feat: make it work

.gitea/actions/setup/action.yml

@@ -1,28 +0,0 @@
-name: Setup
-description: Restore caches and install pnpm dependencies (run after checkout)
-
-runs:
-  using: composite
-  steps:
-    - name: 💾 Setup pnpm Cache
-      uses: actions/cache@v4
-      with:
-        path: .pnpm-store
-        key: ${{ runner.os }}-pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}
-        restore-keys: |
-          ${{ runner.os }}-pnpm-
-
-    - name: 🦀 Cache Cargo
-      uses: actions/cache@v4
-      with:
-        path: |
-          ~/.cargo/registry
-          ~/.cargo/git
-          target
-        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-cargo-
-
-    - name: 📦 Install Dependencies
-      shell: bash
-      run: pnpm install --frozen-lockfile --store-dir .pnpm-store

.gitea/workflows/benchmark.yaml

@@ -12,7 +12,7 @@ env:
   CARGO_TARGET_DIR: target
 
 jobs:
-  benchmark:
+  release:
     runs-on: ubuntu-latest
     container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
 
@@ -23,10 +23,29 @@ jobs:
           fetch-depth: 0
           token: ${{ secrets.GITEA_TOKEN }}
 
-      - name: 🔧 Setup
-        uses: ./.gitea/actions/setup
+      - 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: 🛠️ Build Nodes
+      - 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
@@ -37,12 +56,6 @@ jobs:
           mkdir -p ~/.ssh
           echo "${{ secrets.GIT_SSH_PRIVATE_KEY }}" > ~/.ssh/id_ed25519
           chmod 600 ~/.ssh/id_ed25519
-          cat >> ~/.ssh/config <<'EOF'
-          Host git.max-richter.dev
-            Port 2222
-            IdentityFile ~/.ssh/id_ed25519
-            IdentitiesOnly yes
-          EOF
           ssh-keyscan -p 2222 -H git.max-richter.dev >> ~/.ssh/known_hosts
 
       - name: 📤 Push Results
@@ -52,16 +65,22 @@ jobs:
           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 -p 2222 -i ~/.ssh/id_ed25519 -o IdentitiesOnly=yes"
           git clone git@git.max-richter.dev:max/nodarium-benchmarks.git target_bench_repo
           
-          BRANCH="${GITHUB_HEAD_REF:-$GITHUB_REF_NAME}"
-          SAFE_PR_NAME=$(printf "%s" "$BRANCH" | tr '/' '-')
+          # 3. Create a directory structure based on the branch
+          # This allows the UI to "switch between branches"
+          SAFE_PR_NAME=$(printf "%s" "$GITHUB_HEAD_REF" | tr '/' '-')
           DEST_DIR="target_bench_repo/data/$SAFE_PR_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 $SAFE_PR_NAME: ${{ gitea.sha }}"
+          git commit -m "Update benchmarks for $SAFE_PR_NAME: ${{ github.sha }}"
           git push origin main

.gitea/workflows/release.yaml

@@ -13,7 +13,7 @@ env:
   CARGO_TARGET_DIR: target
 
 jobs:
-  quality:
+  release:
     runs-on: ubuntu-latest
     container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
 
@@ -24,8 +24,27 @@ jobs:
           fetch-depth: 0
           token: ${{ secrets.GITEA_TOKEN }}
 
-      - name: 🔧 Setup
-        uses: ./.gitea/actions/setup
+      - 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: 🧹 Quality Control
         run: |
@@ -33,61 +52,7 @@ jobs:
           pnpm format:check
           pnpm check
           pnpm build
-
-  test-unit:
-    runs-on: ubuntu-latest
-    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
-
-    steps:
-      - name: 📑 Checkout Code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITEA_TOKEN }}
-
-      - name: 🔧 Setup
-        uses: ./.gitea/actions/setup
-
-      - name: 🧪 Run Tests
-        run: xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test:unit
-
-  test-e2e:
-    runs-on: ubuntu-latest
-    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
-
-    steps:
-      - name: 📑 Checkout Code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITEA_TOKEN }}
-
-      - name: 🔧 Setup
-        uses: ./.gitea/actions/setup
-
-      - name: 🏗️ Build Web Assets
-        run: pnpm build
-
-      - name: 🧪 Run Tests
-        run: xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test:e2e
-
-  deploy:
-    runs-on: ubuntu-latest
-    needs: [quality, test-e2e, test-unit]
-    container: git.max-richter.dev/max/nodarium-ci:a56e8f445edb6064ae7a7b3b783fb7445f1b4e69
-
-    steps:
-      - name: 📑 Checkout Code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITEA_TOKEN }}
-
-      - name: 🔧 Setup
-        uses: ./.gitea/actions/setup
-
-      - name: 🏗️ Build Web Assets
-        run: pnpm build
+          xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test
 
       - name: 🚀 Create Release Commit
         if: gitea.ref_type == 'tag'

Dockerfile.ci

@@ -5,7 +5,6 @@ ENV RUSTUP_HOME=/usr/local/rustup \
   PATH=/usr/local/cargo/bin:$PATH
 
 RUN apt-get update && apt-get install -y \
-  openssh-client \
   ca-certificates=20230311+deb12u1 \
   gpg=2.2.40-1.1+deb12u2 \
   gpg-agent=2.2.40-1.1+deb12u2 \

app/benchmark/index.ts

@@ -1,59 +1,35 @@
 import type { Graph, Graph as GraphType, NodeId } from '@nodarium/types';
 import { createLogger, createPerformanceStore, splitNestedArray } from '@nodarium/utils';
-
 import { mkdir, writeFile } from 'node:fs/promises';
-import { freemem, loadavg, totalmem } from 'node:os';
 import { resolve } from 'node:path';
-
 import { MemoryRuntimeExecutor } from '../src/lib/runtime/runtime-executor.ts';
 import { BenchmarkRegistry } from './benchmarkRegistry.ts';
-
-import {
-  getMachineInfo,
-  measureCpuUsage,
-  readCgroupCpuStat,
-  readCpuSnapshot,
-  readProcMemInfo,
-  SystemSample
-} from './systemStats.ts';
 import defaultPlantTemplate from './templates/default.json' assert { type: 'json' };
 import lottaFacesTemplate from './templates/lotta-faces.json' assert { type: 'json' };
 import plantTemplate from './templates/plant.json' assert { type: 'json' };
 
 const registry = new BenchmarkRegistry();
 const r = new MemoryRuntimeExecutor(registry);
+const perfStore = createPerformanceStore();
 
 const log = createLogger('bench');
 
 const templates: Record<string, Graph> = {
-  plant: plantTemplate as unknown as GraphType,
+  'plant': plantTemplate as unknown as GraphType,
   'lotta-faces': lottaFacesTemplate as unknown as GraphType,
-  default: defaultPlantTemplate as unknown as GraphType
+  'default': defaultPlantTemplate as unknown as GraphType
 };
 
-function average(values: number[]) {
-  if (values.length === 0) return 0;
-  return values.reduce((a, b) => a + b, 0) / values.length;
-}
-
-function countGeometry(result: Int32Array): {
-  totalVertices: number;
-  totalFaces: number;
-} {
+function countGeometry(result: Int32Array): { totalVertices: number; totalFaces: number } {
   const parts = splitNestedArray(result);
-
   let totalVertices = 0;
   let totalFaces = 0;
-
   for (const part of parts) {
     const type = part[0];
-
-    const vertexCount = part[1] >>> 0;
-    const faceCount = part[2] >>> 0;
-
+    const vertexCount = part[1];
+    const faceCount = part[2];
     if (type === 2) {
-      const instanceCount = part[3] >>> 0;
-
+      const instanceCount = part[3];
       totalVertices += vertexCount * instanceCount;
       totalFaces += faceCount * instanceCount;
     } else {
@@ -61,144 +37,42 @@ function countGeometry(result: Int32Array): {
       totalFaces += faceCount;
     }
   }
-
-  return {
-    totalVertices,
-    totalFaces
-  };
+  return { totalVertices, totalFaces };
 }
 
 async function run(g: GraphType, amount: number) {
-  await registry.load(g.nodes.map(n => n.type) as NodeId[]);
-
+  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 });
   }
 
-  const systemSamples: SystemSample[] = [];
-
-  let previousCpuSnapshot = await readCpuSnapshot();
-
-  const sampler = setInterval(async () => {
-    try {
-      const cpu = await measureCpuUsage(previousCpuSnapshot);
-
-      previousCpuSnapshot = cpu.snapshot;
-
-      const [l1, l5, l15] = loadavg();
-
-      systemSamples.push({
-        timestamp: Date.now(),
-
-        cpuUsagePercent: cpu.usagePercent,
-        cpuStealPercent: cpu.stealPercent,
-
-        load1: l1,
-        load5: l5,
-        load15: l15,
-
-        freeMemory: freemem(),
-        totalMemory: totalmem()
-      });
-    } catch (err) {
-      console.error(err);
-    }
-  }, 1000);
-
   log.log('executing');
-
-  const perfStore = createPerformanceStore();
-
   r.perf = perfStore;
-
-  let res: Int32Array | undefined;
-
-  const cgroupBefore = await readCgroupCpuStat();
-
+  let res;
   for (let i = 0; i < amount; i++) {
     r.perf?.startRun();
-
     res = await r.execute(g, { randomSeed: true });
-
     r.perf?.stopRun();
-
     const { totalVertices, totalFaces } = countGeometry(res!);
-
     r.perf?.addToLastRun('total-vertices', totalVertices);
     r.perf?.addToLastRun('total-faces', totalFaces);
   }
-
-  const cgroupAfter = await readCgroupCpuStat();
-
-  clearInterval(sampler);
-
   log.log('finished');
-
-  return {
-    data: r.perf.get(),
-    metadata: {
-      timestamp: new Date().toISOString(),
-
-      machine: getMachineInfo(),
-
-      process: {
-        pid: process.pid,
-        uptime: process.uptime(),
-
-        memoryUsage: process.memoryUsage()
-      },
-
-      system: {
-        averages: {
-          cpuUsagePercent: average(
-            systemSamples.map(s => s.cpuUsagePercent)
-          ),
-
-          cpuStealPercent: average(
-            systemSamples.map(s => s.cpuStealPercent)
-          ),
-
-          load1: average(systemSamples.map(s => s.load1)),
-          load5: average(systemSamples.map(s => s.load5)),
-          load15: average(systemSamples.map(s => s.load15)),
-
-          freeMemory: average(
-            systemSamples.map(s => s.freeMemory)
-          )
-        },
-
-        samples: systemSamples,
-
-        meminfo: await readProcMemInfo()
-      },
-
-      cgroup: {
-        before: cgroupBefore,
-        after: cgroupAfter
-      }
-    }
-  };
+  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, null, 2)
-    );
-
+    await writeFile(resolve(outPath, key + '.json'), JSON.stringify(perfData));
     await new Promise(res => setTimeout(res, 200));
   }
 }

app/benchmark/systemStats.ts

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

app/e2e/main.test.ts

@@ -8,6 +8,9 @@ test('test', async ({ page }) => {
 
   await page.goto('http://localhost:4173', { waitUntil: 'load' });
 
+  // await expect(page).toHaveScreenshot();
+  await expect(page.locator('.graph-wrapper')).toHaveScreenshot();
+
   await page.getByRole('button', { name: 'projects' }).click();
   await page.getByRole('button', { name: 'New', exact: true }).click();
   await page.getByRole('combobox').selectOption('2');

app/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nodarium/app",
   "private": true,
-  "version": "0.0.6",
+  "version": "0.0.5",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
     "predev": "rm static/CHANGELOG.md && ln -s ../../CHANGELOG.md static/CHANGELOG.md",
     "build": "svelte-kit sync && vite build",
-    "test:unit": "vitest --browser=false",
+    "test:unit": "vitest",
     "test": "npm run test:unit -- --run && npm run test:e2e",
     "test:e2e": "playwright test",
     "preview": "vite preview",
@@ -18,49 +18,49 @@
     "bench": "tsx ./benchmark/index.ts"
   },
   "dependencies": {
-    "@nodarium/planty": "workspace:*",
     "@nodarium/ui": "workspace:*",
     "@nodarium/utils": "workspace:*",
-    "@sveltejs/kit": "^2.59.0",
-    "@tailwindcss/vite": "^4.2.4",
-    "@threlte/core": "8.5.11",
-    "@threlte/extras": "9.15.1",
+    "@nodarium/planty": "workspace:*",
+    "@sveltejs/kit": "^2.50.2",
+    "@tailwindcss/vite": "^4.1.18",
+    "@threlte/core": "8.3.1",
+    "@threlte/extras": "9.7.1",
     "comlink": "^4.4.2",
     "file-saver": "^2.0.5",
     "idb": "^8.0.3",
     "jsondiffpatch": "^0.7.3",
     "micromark": "^4.0.2",
-    "tailwindcss": "^4.2.4",
-    "three": "^0.184.0"
+    "tailwindcss": "^4.1.18",
+    "three": "^0.182.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^2.0.5",
-    "@eslint/js": "^10.0.1",
-    "@iconify-json/tabler": "^1.2.33",
-    "@iconify/tailwind4": "^1.2.3",
+    "@eslint/compat": "^2.0.2",
+    "@eslint/js": "^9.39.2",
+    "@iconify-json/tabler": "^1.2.26",
+    "@iconify/tailwind4": "^1.2.1",
     "@nodarium/types": "workspace:^",
-    "@playwright/test": "^1.59.1",
+    "@playwright/test": "^1.58.1",
     "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/vite-plugin-svelte": "^7.0.0",
-    "@tsconfig/svelte": "^5.0.8",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@tsconfig/svelte": "^5.0.7",
     "@types/file-saver": "^2.0.7",
-    "@types/three": "^0.184.0",
-    "@vitest/browser-playwright": "^4.1.5",
-    "dprint": "^0.54.0",
-    "eslint": "^10.3.0",
-    "eslint-plugin-svelte": "^3.17.1",
-    "globals": "^17.6.0",
-    "svelte": "^5.55.5",
-    "svelte-check": "^4.4.7",
+    "@types/three": "^0.182.0",
+    "@vitest/browser-playwright": "^4.0.18",
+    "dprint": "^0.51.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-svelte": "^3.14.0",
+    "globals": "^17.3.0",
+    "svelte": "^5.49.2",
+    "svelte-check": "^4.3.6",
     "tslib": "^2.8.1",
     "tsx": "^4.21.0",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.1",
-    "vite": "^8.0.10",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "vite": "^7.3.1",
     "vite-plugin-comlink": "^5.3.0",
-    "vite-plugin-glsl": "^1.6.0",
-    "vite-plugin-wasm": "^3.6.0",
-    "vitest": "^4.1.5",
-    "vitest-browser-svelte": "^2.1.1"
+    "vite-plugin-glsl": "^1.5.5",
+    "vite-plugin-wasm": "^3.5.0",
+    "vitest": "^4.0.18",
+    "vitest-browser-svelte": "^2.0.2"
   }
 }

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

@@ -1,75 +0,0 @@
-<script lang="ts">
-  import { getGraphManager } from '../graph-state.svelte';
-  const graph = getGraphManager();
-
-  function getGroupName(groupId: number) {
-    const group = graph.getGroup(groupId);
-    return group?.name || `Group#${groupId}`;
-  }
-
-  function exitToGroup(targetId?: number) {
-    while (graph.currentGroupId !== (targetId ?? null)) {
-      graph.exitGroup();
-    }
-  }
-
-  // Intermediate groups: parent stack entries that are groups (not the root graph).
-  const intermediateGroups = $derived(
-    graph.parentStack.filter(e => e.id !== graph.id)
-  );
-</script>
-
-<div class="shadow" class:is-inside-group={graph.isInsideGroup}></div>
-
-{#if graph.isInsideGroup}
-  <div class="group-name flex gap-1 items-center">
-    <button
-      class="bg-layer-2 opacity-75 hover:opacity-100 cursor-pointer rounded-sm p-1 px-2"
-      onclick={() => exitToGroup()}
-    >
-      Root
-    </button>
-
-    {#each intermediateGroups as entry (entry.id)}
-      <span class="i-[tabler--arrow-right]"></span>
-      <button
-        class="bg-layer-2 opacity-75 hover:opacity-100 cursor-pointer rounded-sm p-1 px-2"
-        onclick={() => exitToGroup(entry.id)}
-      >
-        {getGroupName(entry.id)}
-      </button>
-    {/each}
-
-    <span class="i-[tabler--arrow-right]"></span>
-    <button class="bg-layer-2 opacity-100 cursor-pointer rounded-sm p-1 px-2">
-      {getGroupName(graph.currentGroupId!)}
-    </button>
-  </div>
-{/if}
-
-<style>
-  .shadow {
-    position: absolute;
-    top: -5px;
-    left: -5px;
-    right: calc(var(--padding-right) - 5px);
-    bottom: -5px;
-    z-index: 1;
-    transition: box-shadow 0.3s ease;
-    box-shadow: 0 0 0px 0px var(--color-layer-2) inset;
-    pointer-events: none;
-  }
-
-  .shadow.is-inside-group  {
-    box-shadow: 0 0 0px 8px var(--color-layer-2) inset;
-  }
-
-  .group-name {
-    position: absolute;
-    left: calc(50% - var(--padding-right) / 2);
-    transition: left 0.3s ease;
-    top: 12px;
-    transform: translateX(-50%);
-    z-index: 1000;
-  }
-</style>

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

@@ -1,4 +1,4 @@
-import { assert, describe, expect, it } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { GraphManager } from './graph-manager.svelte';
 import {
   createMockNodeRegistry,
@@ -9,151 +9,8 @@ import {
   mockVec3OutputNode
 } from './test-utils';
 
-describe('groupNodes', () => {
-  it('should not do anything if no nodes are selected', () => {
-    const registry = createMockNodeRegistry([
-      mockFloatOutputNode,
-      mockFloatInputNode,
-      mockGeometryOutputNode,
-      mockPathInputNode
-    ]);
-
-    const manager = new GraphManager(registry);
-
-    const floatInputNode = manager.createNode({
-      type: 'test/node/input',
-      position: [100, 100],
-      props: {}
-    });
-
-    assert.isDefined(floatInputNode);
-
-    const floatOutputNode = manager.createNode({
-      type: 'test/node/output',
-      position: [0, 0],
-      props: {}
-    });
-    assert.isDefined(floatOutputNode);
-
-    const edge = manager.createEdge(floatInputNode, 0, floatOutputNode, 'input');
-    assert.isDefined(edge);
-    manager.save();
-
-    manager.groupNodes([]);
-
-    const graph = manager.serialize();
-    expect(graph.nodes.length).toBe(2);
-    expect(graph.edges.length).toBe(1);
-    expect(graph.groups.length).toBe(0);
-  });
-
-  it('should group selected nodes and create a group node', () => {
-    const registry = createMockNodeRegistry([
-      mockFloatOutputNode,
-      mockFloatInputNode,
-      mockGeometryOutputNode,
-      mockPathInputNode
-    ]);
-
-    const manager = new GraphManager(registry);
-
-    const floatInputNode = manager.createNode({
-      type: 'test/node/input',
-      position: [100, 100],
-      props: {}
-    });
-
-    assert.isDefined(floatInputNode);
-
-    const floatOutputNode = manager.createNode({
-      type: 'test/node/output',
-      position: [0, 0],
-      props: {}
-    });
-    assert.isDefined(floatOutputNode);
-
-    const edge = manager.createEdge(floatInputNode, 0, floatOutputNode, 'input');
-    assert.isDefined(edge);
-    manager.save();
-
-    const groupNode = manager.groupNodes([floatInputNode.id]);
-    assert.isDefined(groupNode);
-
-    const graph = manager.serialize();
-
-    expect(graph.nodes.map(n => n.id), 'graph to contain group node').to.contain(groupNode.id);
-    expect(graph.groups[0].nodes.map(n => n.id), 'group graph to contain float node').to.contain(
-      floatInputNode.id
-    );
-    expect(graph.nodes.map(n => n.id)).not.to.contain(floatInputNode.id);
-
-    expect(graph.nodes.length).toBe(2);
-    expect(graph.edges.length).toBe(1);
-    expect(graph.groups.length).toBe(1);
-  });
-
-  it('should rewire external edges when grouping a middle node in a chain', () => {
-    const registry = createMockNodeRegistry([mockFloatOutputNode, mockFloatInputNode]);
-    const manager = new GraphManager(registry);
-
-    // A → B → C  (float chain: output → middle → input)
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    const nodeB = manager.createNode({ type: 'test/node/output', position: [100, 0], props: {} });
-    const nodeC = manager.createNode({ type: 'test/node/input', position: [200, 0], props: {} });
-
-    assert.isDefined(nodeA);
-    assert.isDefined(nodeB);
-    assert.isDefined(nodeC);
-
-    manager.createEdge(nodeA, 0, nodeB, 'input');
-    manager.createEdge(nodeB, 0, nodeC, 'value');
-
-    const groupNode = manager.groupNodes([nodeB.id]);
-    assert.isDefined(groupNode);
-
-    const graph = manager.serialize();
-
-    // Top-level: A, C, groupNode — B is gone
-    expect(graph.nodes.length, 'top-level node count').toBe(3);
-    const topLevelIds = graph.nodes.map(n => n.id);
-    expect(topLevelIds).toContain(nodeA.id);
-    expect(topLevelIds).toContain(nodeC.id);
-    expect(topLevelIds).toContain(groupNode.id);
-    expect(topLevelIds).not.toContain(nodeB.id);
-
-    // Both original edges survive, now routing through the group node
-    expect(graph.edges.length, 'edge count unchanged').toBe(2);
-    const edgeSources = graph.edges.map(e => e[0]);
-    const edgeTargets = graph.edges.map(e => e[2]);
-    expect(edgeTargets).toContain(groupNode.id); // A → groupNode
-    expect(edgeSources).toContain(groupNode.id); // groupNode → C
-
-    // One group definition was created
-    expect(graph.groups.length).toBe(1);
-    const group = graph.groups[0];
-
-    // Group contains B plus the two boundary nodes
-    const groupNodeIds = group.nodes.map(n => n.id);
-    expect(groupNodeIds).toContain(nodeB.id);
-    const inputBoundary = group.nodes.find(n => n.type === '__internal/group/input');
-    const outputBoundary = group.nodes.find(n => n.type === '__internal/group/output');
-    expect(inputBoundary, 'group input boundary node').toBeDefined();
-    expect(outputBoundary, 'group output boundary node').toBeDefined();
-
-    // Group declares one input slot and one output slot
-    expect(Object.keys(group.inputs ?? {}).length, 'group input count').toBe(1);
-    expect(group.outputs?.length, 'group output count').toBe(1);
-
-    // Internal edges wire: inputBoundary → B → outputBoundary
-    expect(group.edges.length, 'internal edge count').toBe(2);
-    const internalSources = group.edges.map(e => e[0]);
-    const internalTargets = group.edges.map(e => e[2]);
-    expect(internalTargets).toContain(nodeB.id);
-    expect(internalSources).toContain(nodeB.id);
-  });
-});
-
-describe('getPossibleSockets', () => {
+describe('GraphManager', () => {
+  describe('getPossibleSockets', () => {
     describe('when dragging an output socket', () => {
       it('should return compatible input sockets based on type', () => {
         const registry = createMockNodeRegistry([
@@ -404,4 +261,5 @@ describe('getPossibleSockets', () => {
         expect(possibleSocketsForFloat.map(([n]) => n.id)).toContain(floatInputNode!.id);
       });
     });
+  });
 });

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

@@ -1,262 +0,0 @@
-import { assert, describe, expect, it } from 'vitest';
-import { GraphManager } from './graph-manager.svelte';
-import { GraphState } from './graph-state.svelte';
-import { createMockNodeRegistry, mockFloatInputNode, mockFloatOutputNode } from './test-utils';
-
-// GraphState constructor reads localStorage synchronously — mock before any instantiation
-Object.defineProperty(globalThis, 'localStorage', {
-  value: {
-    getItem: () => null,
-    setItem: () => {},
-    removeItem: () => {},
-    clear: () => {},
-    length: 0,
-    key: () => null
-  } as Storage,
-  writable: true,
-  configurable: true
-});
-
-function createFixture() {
-  const registry = createMockNodeRegistry([mockFloatOutputNode, mockFloatInputNode]);
-  const manager = new GraphManager(registry);
-  const state = new GraphState(manager);
-  return { manager, state };
-}
-
-describe('clearSelection', () => {
-  it('empties selectedNodes', () => {
-    const { state } = createFixture();
-    state.selectedNodes.add(1);
-    state.selectedNodes.add(2);
-    state.clearSelection();
-    expect(state.selectedNodes.size).toBe(0);
-  });
-});
-
-describe('projectScreenToWorld', () => {
-  it('maps the viewport centre to the camera position', () => {
-    const { state } = createFixture();
-    // cameraPosition default: [140, 100, 3.5], width=100, height=100
-    state.width = 100;
-    state.height = 100;
-    state.cameraPosition = [140, 100, 3.5];
-    const [wx, wy] = state.projectScreenToWorld(50, 50);
-    expect(wx).toBeCloseTo(140);
-    expect(wy).toBeCloseTo(100);
-  });
-
-  it('offsets correctly for a point not at centre', () => {
-    const { state } = createFixture();
-    state.width = 100;
-    state.height = 100;
-    state.cameraPosition = [0, 0, 2];
-    const [wx, wy] = state.projectScreenToWorld(100, 50);
-    // x: 0 + (100 - 50) / 2 = 25
-    expect(wx).toBeCloseTo(25);
-    expect(wy).toBeCloseTo(0);
-  });
-});
-
-describe('groupSelectedNodes', () => {
-  it('delegates to graph.groupNodes with selected IDs and activeNodeId', () => {
-    const { manager, state } = createFixture();
-
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    const nodeB = manager.createNode({ type: 'test/node/input', position: [100, 0], props: {} });
-    assert.isDefined(nodeA);
-    assert.isDefined(nodeB);
-
-    state.selectedNodes.add(nodeA!.id);
-    state.activeNodeId = nodeB!.id;
-
-    const groupNode = state.groupSelectedNodes();
-    assert.isDefined(groupNode);
-
-    const graph = manager.serialize();
-    expect(graph.groups.length).toBe(1);
-    expect(graph.nodes.map(n => n.id)).toContain(groupNode!.id);
-  });
-
-  it('works when only activeNodeId is set with no extra selection', () => {
-    const { manager, state } = createFixture();
-
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    assert.isDefined(nodeA);
-
-    state.activeNodeId = nodeA!.id;
-    const groupNode = state.groupSelectedNodes();
-    assert.isDefined(groupNode);
-
-    expect(manager.groups.length).toBe(1);
-  });
-});
-
-describe('enterGroupNode', () => {
-  it('does nothing when activeNodeId is -1', () => {
-    const { manager, state } = createFixture();
-    state.activeNodeId = -1;
-    state.enterGroupNode();
-    expect(manager.parentStack.length).toBe(0);
-  });
-
-  it('does nothing when the active node is not a group instance', () => {
-    const { manager, state } = createFixture();
-    const node = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    assert.isDefined(node);
-    state.activeNodeId = node!.id;
-    state.enterGroupNode();
-    expect(manager.parentStack.length).toBe(0);
-  });
-
-  it('enters the group, pushes graphStack, and clears UI state', () => {
-    const { manager, state } = createFixture();
-
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    assert.isDefined(nodeA);
-    const groupNode = manager.groupNodes([nodeA!.id]);
-    assert.isDefined(groupNode);
-
-    state.selectedNodes.add(nodeA!.id);
-    state.activeNodeId = groupNode!.id;
-    state.cameraPosition = [10, 20, 5];
-
-    state.enterGroupNode();
-
-    expect(manager.parentStack.length).toBe(1);
-    expect(state.activeNodeId).toBe(-1);
-    expect(state.selectedNodes.size).toBe(0);
-    expect(manager.isInsideGroup).toBe(true);
-  });
-});
-
-describe('exitGroupNode', () => {
-  it('does nothing when not inside a group', () => {
-    const { manager, state } = createFixture();
-    const before = [...state.cameraPosition];
-    state.exitGroupNode();
-    expect(manager.parentStack.length).toBe(0);
-    expect(state.cameraPosition).toEqual(before);
-  });
-
-  it('clears activeNodeId and selection after exit', () => {
-    const { manager, state } = createFixture();
-
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    assert.isDefined(nodeA);
-    const groupNode = manager.groupNodes([nodeA!.id]);
-    assert.isDefined(groupNode);
-
-    state.activeNodeId = groupNode!.id;
-    state.enterGroupNode();
-    state.activeNodeId = 99;
-    state.selectedNodes.add(99);
-
-    state.exitGroupNode();
-
-    // Group instance node is re-selected on exit; internal selection is cleared
-    expect(state.activeNodeId).toBe(groupNode!.id);
-    expect(state.selectedNodes.size).toBe(0);
-  });
-
-  it('restores outer nodes to manager after exit', () => {
-    const { manager, state } = createFixture();
-
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    const nodeB = manager.createNode({ type: 'test/node/input', position: [100, 0], props: {} });
-    assert.isDefined(nodeA);
-    assert.isDefined(nodeB);
-
-    manager.createEdge(nodeA!, 0, nodeB!, 'value');
-    const groupNode = manager.groupNodes([nodeA!.id]);
-    assert.isDefined(groupNode);
-
-    state.activeNodeId = groupNode!.id;
-    state.enterGroupNode();
-
-    // Inside the group: nodeA is an internal node so it IS active; the outer
-    // nodes (nodeB, groupNode) are saved and no longer in the active Map.
-    expect(manager.nodes.has(nodeA!.id)).toBe(true);
-    expect(manager.nodes.has(nodeB!.id)).toBe(false);
-
-    state.exitGroupNode();
-
-    // After exit: outer nodes are restored
-    expect(manager.nodes.has(nodeB!.id)).toBe(true);
-    expect(manager.nodes.has(groupNode!.id)).toBe(true);
-    expect(manager.isInsideGroup).toBe(false);
-  });
-
-  it('isInsideGroup is false after exiting the only group level', () => {
-    const { manager, state } = createFixture();
-
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    assert.isDefined(nodeA);
-    const groupNode = manager.groupNodes([nodeA!.id]);
-    assert.isDefined(groupNode);
-
-    state.activeNodeId = groupNode!.id;
-    state.enterGroupNode();
-    expect(manager.isInsideGroup).toBe(true);
-
-    state.exitGroupNode();
-    expect(manager.isInsideGroup).toBe(false);
-  });
-});
-
-describe('copyNodes / pasteNodes', () => {
-  it('copies the active node into the clipboard', () => {
-    const { manager, state } = createFixture();
-    const node = manager.createNode({ type: 'test/node/output', position: [10, 20], props: {} });
-    assert.isDefined(node);
-
-    state.activeNodeId = node!.id;
-    state.mousePosition = [0, 0];
-    state.copyNodes();
-
-    assert.isNotNull(state.clipboard);
-    expect(state.clipboard!.nodes.map(n => n.id)).toContain(node!.id);
-  });
-
-  it('includes edges between copied nodes', () => {
-    const { manager, state } = createFixture();
-    const nodeA = manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    const nodeB = manager.createNode({ type: 'test/node/input', position: [100, 0], props: {} });
-    assert.isDefined(nodeA);
-    assert.isDefined(nodeB);
-
-    manager.createEdge(nodeA!, 0, nodeB!, 'value');
-
-    state.activeNodeId = nodeA!.id;
-    state.selectedNodes.add(nodeB!.id);
-    state.mousePosition = [0, 0];
-    state.copyNodes();
-
-    assert.isNotNull(state.clipboard);
-    expect(state.clipboard!.edges.length).toBe(1);
-  });
-
-  it('pastes nodes and adds them to the graph', () => {
-    const { manager, state } = createFixture();
-    const node = manager.createNode({ type: 'test/node/output', position: [10, 20], props: {} });
-    assert.isDefined(node);
-
-    state.activeNodeId = node!.id;
-    state.mousePosition = [0, 0];
-    state.copyNodes();
-
-    const countBefore = manager.nodes.size;
-    state.mousePosition = [50, 50];
-    state.pasteNodes();
-
-    expect(manager.nodes.size).toBe(countBefore + 1);
-  });
-
-  it('does nothing when clipboard is empty', () => {
-    const { manager, state } = createFixture();
-    manager.createNode({ type: 'test/node/output', position: [0, 0], props: {} });
-    const countBefore = manager.nodes.size;
-    state.pasteNodes();
-    expect(manager.nodes.size).toBe(countBefore);
-  });
-});

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

@@ -5,7 +5,7 @@ import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import type { OrthographicCamera, Vector3 } from 'three';
 import type { GraphManager } from './graph-manager.svelte';
 import { ColorGenerator } from './graph/colors';
-import { getNodeHeight, getParameterHeight } from './helpers/nodeHelpers';
+import { getNodeHeight, getSocketPosition } from './helpers/nodeHelpers';
 
 const graphStateKey = Symbol('graph-state');
 export function getGraphState() {
@@ -99,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,
@@ -152,6 +155,10 @@ export class GraphState {
     this.edges.delete(edgeId);
   }
 
+  getEdgeData() {
+    return this.edges;
+  }
+
   updateNodePosition(node: NodeInstance) {
     if (
       node.state.x === node.position[0]
@@ -186,6 +193,29 @@ export class GraphState {
     return 1;
   }
 
+  tryConnectToDebugNode(nodeId: number) {
+    const node = this.graph.nodes.get(nodeId);
+    if (!node) return;
+    if (node.type.endsWith('/debug')) return;
+    if (!node.state.type?.outputs?.length) return;
+    for (const _node of this.graph.nodes.values()) {
+      if (_node.type.endsWith('/debug')) {
+        this.graph.createEdge(node, 0, _node, 'input');
+        return;
+      }
+    }
+
+    const debugNode = this.graph.createNode({
+      type: 'max/plantarium/debug',
+      position: [node.position[0] + 30, node.position[1]],
+      props: {}
+    });
+
+    if (debugNode) {
+      this.graph.createEdge(node, 0, debugNode, 'input');
+    }
+  }
+
   copyNodes() {
     if (this.activeNodeId === -1 && !this.selectedNodes?.size) {
       return;
@@ -213,14 +243,6 @@ export class GraphState {
     };
   }
 
-  unGroupSelectedNodes() {
-    return this.graph.ungroupNode(this.activeNodeId);
-  }
-
-  groupSelectedNodes() {
-    return this.graph.groupNodes([...this.selectedNodes.keys(), this.activeNodeId]);
-  }
-
   centerNode(node?: NodeInstance) {
     const average = [0, 0, 4];
     if (node) {
@@ -282,7 +304,7 @@ export class GraphState {
         if (edge[3] === index) {
           node = edge[0];
           index = edge[1];
-          position = this.getSocketPosition(node, index);
+          position = getSocketPosition(node, index);
           this.graph.removeEdge(edge);
           break;
         }
@@ -302,7 +324,7 @@ export class GraphState {
         return {
           node,
           index,
-          position: this.getSocketPosition(node, index)
+          position: getSocketPosition(node, index)
         };
       });
   }
@@ -339,8 +361,7 @@ export class GraphState {
         for (const node of this.graph.nodes.values()) {
           const x = node.position[0];
           const y = node.position[1];
-          const nodeType = this.graph.getNodeType(node);
-          const height = nodeType ? getNodeHeight(nodeType) : 20;
+          const height = getNodeHeight(node.state.type!);
           if (downX > x && downX < x + 20 && downY > y && downY < y + height) {
             clickedNodeId = node.id;
             break;
@@ -352,8 +373,7 @@ export class GraphState {
   }
 
   isNodeInView(node: NodeInstance) {
-    if (!node) return false;
-    const height = getNodeHeight(this.graph.getNodeType(node)!);
+    const height = getNodeHeight(node.state.type!);
     const width = 20;
     return node.position[0] > this.cameraBounds[0] - width
       && node.position[0] < this.cameraBounds[1]
@@ -364,57 +384,4 @@ export class GraphState {
   openNodePalette() {
     this.addMenuPosition = [this.mousePosition[0], this.mousePosition[1]];
   }
-
-  enterGroupNode() {
-    if (this.activeNodeId === -1) return;
-    const node = this.graph.getNode(this.activeNodeId);
-    if (!node || node.type !== '__internal/group/instance') return;
-    const ok = this.graph.enterGroup(this.activeNodeId);
-    if (ok) {
-      this.activeNodeId = -1;
-      this.clearSelection();
-    }
-  }
-
-  exitGroupNode() {
-    const result = this.graph.exitGroup();
-    if (!result) return;
-    this.activeNodeId = result.nodeId;
-    this.clearSelection();
-  }
-
-  getSocketPosition(
-    node: NodeInstance,
-    index: string | number
-  ): [number, number] {
-    if (node.type === '__internal/group/input' && typeof index === 'number') {
-      return [
-        (node?.state?.x ?? node.position[0]) + 20,
-        (node?.state?.y ?? node.position[1]) + 2.5 + 5 * index + 5
-      ];
-    }
-
-    if (typeof index === 'number') {
-      return [
-        (node?.state?.x ?? node.position[0]) + 20,
-        (node?.state?.y ?? node.position[1]) + 2.5 + 10 * index
-      ];
-    } else {
-      let height = 5;
-      const nodeType = this.graph.getNodeType(node)!;
-      const inputs = nodeType.inputs || {};
-      for (const inputKey in inputs) {
-        const h = getParameterHeight(nodeType, inputKey) / 10;
-        if (inputKey === index) {
-          height += h / 2;
-          break;
-        }
-        height += h;
-      }
-      return [
-        node?.state?.x ?? node.position[0],
-        (node?.state?.y ?? node.position[1]) + height
-      ];
-    }
-  }
 }

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

@@ -7,11 +7,11 @@
   import AddMenu from '../components/AddMenu.svelte';
   import BoxSelection from '../components/BoxSelection.svelte';
   import Camera from '../components/Camera.svelte';
-  import GroupBreadcrumps from '../components/GroupBreadcrumps.svelte';
   import HelpView from '../components/HelpView.svelte';
   import Debug from '../debug/Debug.svelte';
   import EdgeEl from '../edges/Edge.svelte';
   import { getGraphManager, getGraphState } from '../graph-state.svelte';
+  import { getSocketPosition } from '../helpers/nodeHelpers';
   import NodeEl from '../node/Node.svelte';
   import { maxZoom, minZoom } from './constants';
   import { FileDropEventManager } from './drop.events';
@@ -39,8 +39,8 @@
       return [0, 0, 0, 0];
     }
 
-    const pos1 = graphState.getSocketPosition(fromNode, edge[1]);
-    const pos2 = graphState.getSocketPosition(toNode, edge[3]);
+    const pos1 = getSocketPosition(fromNode, edge[1]);
+    const pos2 = getSocketPosition(toNode, edge[3]);
     return [pos1[0], pos1[1], pos2[0], pos2[1]];
   }
 
@@ -97,17 +97,13 @@
   }
 
   function getSocketType(node: NodeInstance, index: number | string): string {
-    const nodeType = graph.getNodeType(node);
     if (typeof index === 'string') {
-      return nodeType?.inputs?.[index].type || 'unknown';
+      return node.state.type?.inputs?.[index].type || 'unknown';
     }
-
-    if (node.type === '__internal/group/input') {
-      const key = Object.keys(nodeType?.inputs || {})[index];
-      return nodeType?.inputs?.[key].type || 'unknown';
+    if (node.type === '__virtual/group/instance') {
+      index += 1;
     }
-
-    return nodeType?.outputs?.[index] || 'unknown';
+    return node.state.type?.outputs?.[index] || 'unknown';
   }
 </script>
 
@@ -121,7 +117,6 @@
   bind:this={graphState.wrapper}
   class="graph-wrapper"
   style="height: 100%"
-  class:is-inside-group={graph.isInsideGroup}
   class:is-panning={graphState.isPanning}
   class:is-hovering={graphState.hoveredNodeId !== -1}
   aria-label="Graph"
@@ -129,7 +124,6 @@
   tabindex="0"
   bind:clientWidth={graphState.width}
   bind:clientHeight={graphState.height}
-  style:--padding-right="{safePadding?.right || 0}px"
   onkeydown={(ev) => keymap.handleKeyboardEvent(ev)}
   onmousedown={(ev) => mouseEvents.handleMouseDown(ev)}
   oncontextmenu={(ev) => mouseEvents.handleContextMenu(ev)}
@@ -145,8 +139,6 @@
   />
   <label for="drop-zone"></label>
 
-  <GroupBreadcrumps />
-
   <Canvas shadows={false} renderMode="on-demand" colorManagementEnabled={false}>
     <Camera
       bind:camera={graphState.camera}
@@ -227,10 +219,10 @@
           style:transform={`scale(${graphState.cameraPosition[2] * 0.1})`}
           class:hovering-sockets={graphState.activeSocket}
         >
-          {#each graph.nodeArray as node, index (node.id)}
+          {#each graph.nodes.values() as node (node.id)}
             <NodeEl
-              bind:node={graph.nodeArray[index]}
-              inView={node ? graphState.isNodeInView(node) : false}
+              {node}
+              inView={graphState.isNodeInView(node)}
             />
           {/each}
         </div>

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

@@ -1,7 +1,6 @@
 <script lang="ts">
   import { createKeyMap } from '$lib/helpers/createKeyMap';
   import type { Graph, NodeInstance, NodeRegistry } from '@nodarium/types';
-  import { onMount } from 'svelte';
   import { GraphManager } from '../graph-manager.svelte';
   import { GraphState, setGraphManager, setGraphState } from '../graph-state.svelte';
   import { setupKeymaps } from '../keymaps';
@@ -29,7 +28,6 @@
     graph,
     registry,
     safePadding,
-    // eslint-disable-next-line no-useless-assignment
     settings = $bindable(),
     activeNode = $bindable(),
     backgroundType = $bindable('grid'),
@@ -84,11 +82,102 @@
 
   manager.on('save', (save) => onsave?.(save));
 
-  onMount(() => {
+  $effect(() => {
     if (graph) {
       manager.load(graph);
     }
   });
+
+  function navigateToBreadcrumb(index: number) {
+    const crumbs = manager.breadcrumbs;
+    const depth = crumbs.length - 1 - index;
+    let result: { camera: [number, number, number]; nodeId: 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]);
+      }
+      result = manager.exitGroup();
+    }
+    if (result !== false) {
+      state.activeNodeId = result.nodeId;
+      state.clearSelection();
+      state.cameraPosition[0] = result.camera[0];
+      state.cameraPosition[1] = result.camera[1];
+      state.cameraPosition[2] = result.camera[2];
+    } else {
+      state.activeNodeId = -1;
+      state.clearSelection();
+      state.centerNode();
+    }
+  }
 </script>
 
+{#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/graph/colors.ts

@@ -2,7 +2,7 @@ type Color = { hue: number; saturation: number; lightness: number };
 
 export class ColorGenerator {
   private colors: Map<string, Color> = new Map();
-  // private lightnessLevels = [10, 60];
+  private lightnessLevels = [10, 60];
 
   constructor(predefined: Record<string, Color>) {
     for (const [id, colorStr] of Object.entries(predefined)) {
@@ -10,14 +10,6 @@ export class ColorGenerator {
     }
   }
 
-  public getColors() {
-    return Object.fromEntries(
-      this.colors.entries().map(([key, col]) => {
-        return [key, this.colorToHsl(col)];
-      })
-    );
-  }
-
   public getColor(id: string): string {
     if (this.colors.has(id)) {
       return this.colorToHsl(this.colors.get(id)!);

app/src/lib/graph-interface/graph/mouse.events.ts

@@ -190,7 +190,7 @@ export class MouseEventManager {
     // if we clicked on a node
     if (clickedNodeId !== -1) {
       if (event.ctrlKey && event.shiftKey) {
-        this.graph.tryConnectToDebugNode(clickedNodeId);
+        this.state.tryConnectToDebugNode(clickedNodeId);
         return;
       }
       if (this.state.activeNodeId === -1) {

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

@@ -1,18 +1,11 @@
-import type {
-  Edge,
-  NodeDefinition,
-  NodeInstance,
-  SerializedEdge,
-  SerializedNode
-} from '@nodarium/types';
+import type { NodeDefinition, NodeInstance } from '@nodarium/types';
 
 export function getParameterHeight(node: NodeDefinition, inputKey: string) {
-  if (node.id === '__internal/group/input') {
-    return 50;
-  }
-
   const input = node.inputs?.[inputKey];
   if (!input) {
+    if (inputKey.startsWith('__virtual')) {
+      return 50;
+    }
     return 0;
   }
 
@@ -33,31 +26,58 @@ export function getParameterHeight(node: NodeDefinition, inputKey: string) {
   return 50;
 }
 
-export function serializeNode(node: SerializedNode | NodeInstance): SerializedNode {
-  return {
-    id: node.id,
-    position: [...node.position],
-    type: node.type,
-    props: node.props
-  };
-}
-
-export function serializeEdge(edge: SerializedEdge | Edge): SerializedEdge {
-  if (typeof edge[0] === 'number' && typeof edge[2] === 'number') {
-    return [edge[0], edge[1], edge[2], edge[3]];
+export function getSocketPosition(
+  node: NodeInstance,
+  index: string | number
+): [number, number] {
+  if (typeof index === 'number') {
+    if (node.type === '__virtual/group/input') {
+      const nodeType = node.state.type;
+      const keys = Object.keys(nodeType?.inputs || {});
+      let height = 5;
+      for (let i = 0; i < keys.length; i++) {
+        const h = getParameterHeight(nodeType!, keys[i]) / 10;
+        if (i === index) { height += h / 2; break; }
+        height += h;
+      }
+      return [
+        (node?.state?.x ?? node.position[0]) + 20,
+        (node?.state?.y ?? node.position[1]) + height
+      ];
+    }
+    return [
+      (node?.state?.x ?? node.position[0]) + 20,
+      (node?.state?.y ?? node.position[1]) + 2.5 + 10 * index
+    ];
+  } else {
+    let height = 5;
+    const nodeType = node.state.type!;
+    const inputs = nodeType.inputs || {};
+    for (const inputKey in inputs) {
+      const h = getParameterHeight(nodeType, inputKey) / 10;
+      if (inputKey === index) {
+        height += h / 2;
+        break;
+      }
+      height += h;
+    }
+    return [
+      node?.state?.x ?? node.position[0],
+      (node?.state?.y ?? node.position[1]) + height
+    ];
   }
-  const e = edge as Edge;
-  return [e[0].id, e[1], e[2].id, e[3]];
 }
 
 const nodeHeightCache: Record<string, number> = {};
 export function getNodeHeight(node: NodeDefinition) {
-  if (!node || !('inputs' in node)) {
-    return 5;
-  }
-  if (node.id in nodeHeightCache) {
+  // 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) {
+    return 5;
+  }
   let height = 5;
 
   for (const key in node.inputs) {
@@ -65,37 +85,8 @@ export function getNodeHeight(node: NodeDefinition) {
     height += h;
   }
 
+  if (!isVirtual) {
     nodeHeightCache[node.id] = height;
+  }
   return height;
 }
-
-export function areSocketsCompatible(
-  output: string | undefined,
-  inputs: string | (string | undefined)[] | undefined
-) {
-  if (output === '*') return true;
-  if (Array.isArray(inputs) && output) {
-    return inputs.includes('*') || inputs.includes(output);
-  }
-  return inputs === output;
-}
-
-export function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
-  if (firstEdge[0].id !== secondEdge[0].id) {
-    return false;
-  }
-
-  if (firstEdge[1] !== secondEdge[1]) {
-    return false;
-  }
-
-  if (firstEdge[2].id !== secondEdge[2].id) {
-    return false;
-  }
-
-  if (firstEdge[3] !== secondEdge[3]) {
-    return false;
-  }
-
-  return true;
-}

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

@@ -45,12 +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) {
-        graphState.exitGroupNode();
+        const groupId = graph.currentGroupContext;
+        if (groupId) {
+          graphState.groupCameras.set(
+            groupId,
+            [...graphState.cameraPosition] as [number, number, number]
+          );
+        }
+        const result = graph.exitGroup();
+        if (result !== false) {
+          graphState.activeNodeId = result.nodeId;
+          graphState.clearSelection();
+          graphState.cameraPosition[0] = result.camera[0];
+          graphState.cameraPosition[1] = result.camera[1];
+          graphState.cameraPosition[2] = result.camera[2];
           return;
         }
+      }
       graphState.activeNodeId = -1;
       graphState.clearSelection();
       graphState.edgeEndPosition = null;
@@ -58,29 +72,6 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
     }
   });
 
-  keymap.addShortcut({
-    key: 'g',
-    ctrl: true,
-    preventDefault: true,
-    description: 'Group selected nodes',
-    callback: () => graphState.groupSelectedNodes()
-  });
-
-  keymap.addShortcut({
-    key: 'g',
-    alt: true,
-    preventDefault: true,
-    description: 'Ungroup selected nodes',
-    callback: () => graphState.unGroupSelectedNodes()
-  });
-
-  keymap.addShortcut({
-    key: 'Tab',
-    preventDefault: true,
-    description: 'Enter selected node group',
-    callback: () => graphState.enterGroupNode()
-  });
-
   keymap.addShortcut({
     key: 'A',
     shift: true,
@@ -186,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/Node.svelte

@@ -3,14 +3,13 @@
   import type { NodeInstance } from '@nodarium/types';
   import { T } from '@threlte/core';
   import { type Mesh } from 'three';
-  import { getGraphManager, getGraphState } from '../graph-state.svelte';
+  import { getGraphState } from '../graph-state.svelte';
   import { colors } from '../graph/colors.svelte';
   import { getNodeHeight, getParameterHeight } from '../helpers/nodeHelpers';
   import NodeFrag from './Node.frag';
   import NodeVert from './Node.vert';
   import NodeHtml from './NodeHTML.svelte';
 
-  const graph = getGraphManager();
   const graphState = getGraphState();
 
   type Props = {
@@ -19,7 +18,7 @@
   };
   let { node = $bindable(), inView }: Props = $props();
 
-  const nodeType = $derived(node ? graph.getNodeType(node) : undefined);
+  const nodeType = $derived(node.state.type!);
 
   const isActive = $derived(graphState.activeNodeId === node.id);
   const isSelected = $derived(graphState.selectedNodes.has(node.id));
@@ -33,17 +32,15 @@
   );
 
   const sectionHeights = $derived(
-    nodeType
-      ? Object
-        .keys(nodeType?.inputs || {})
+    Object
+      .keys(nodeType.inputs || {})
       .map(key => getParameterHeight(nodeType, key) / 10)
       .filter(b => !!b)
-      : [5]
   );
 
   let meshRef: Mesh | undefined = $state();
 
-  const height = $derived(nodeType ? getNodeHeight(nodeType) : 20);
+  const height = $derived(getNodeHeight(node.state.type!));
 
   const zoom = $derived(graphState.cameraPosition[2]);
 

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

@@ -1,13 +1,13 @@
 <script lang="ts">
-  import type { NodeInstance } from '@nodarium/types';
+  import type { NodeDefinition, NodeInstance } from '@nodarium/types';
   import { getGraphManager, getGraphState } from '../graph-state.svelte';
   import NodeHeader from './NodeHeader.svelte';
   import NodeParameter from './NodeParameter.svelte';
 
   let ref: HTMLDivElement;
 
-  const graph = getGraphManager();
   const graphState = getGraphState();
+  const manager = getGraphManager();
 
   type Props = {
     node: NodeInstance;
@@ -31,14 +31,60 @@
   const zOffset = Math.random() - 0.5;
   const zLimit = 2 - zOffset;
 
-  const nodeType = $derived(graph.getNodeType(node));
-
-  const parameters = $derived(
-    Object.entries(nodeType?.inputs || {}).filter(
+  function buildParameters(node: NodeInstance, inputs: NodeDefinition['inputs']) {
+    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') {
+      const groupOptions = [...(manager?.groups?.entries() ?? [])].map(([id, g]) => ({
+        label: g.name,
+        value: id
+      }));
+      // Remove the static placeholder from the definition (height-only) and replace
+      // with a fully dynamic version that carries current names + value.
+      parameters = parameters.filter(([key]) => key !== '__virtual/groupId');
+      parameters = [['__virtual/groupId', {
+        type: 'select',
+        value: node.props?.groupId as string,
+        options: groupOptions
+      }], ...parameters];
+    }
+
+    return parameters;
+  }
+
+  $effect(() => {
+    const props = node.props as Record<string, unknown> | undefined;
+    const virtualGroupId = props?.['__virtual/groupId'] as string | undefined;
+    if (!virtualGroupId) return;
+    const activeGroupId = props?.groupId as string | undefined;
+    if (virtualGroupId === activeGroupId) return;
+    const newGroupDef = manager?.groupNodeDefinitions.get(`__virtual/group/${virtualGroupId}`);
+    if (!newGroupDef) return;
+    const { children, parents, ref } = node.state;
+    node.props = { ...props, groupId: virtualGroupId, '__virtual/groupId': virtualGroupId };
+    node.state = { type: newGroupDef, children, parents, ref };
+    manager?.execute();
+    manager?.save();
+  });
+
+  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) {
       node.state.ref = ref;
@@ -60,17 +106,52 @@
 >
   <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
       id={key}
       input={value}
       isLast={i == parameters.length - 1}
+      outputIndex={node.type === '__virtual/group/input' ? i : undefined}
     />
   {/each}
 </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

@@ -1,11 +1,11 @@
 <script lang="ts">
   import { appSettings } from '$lib/settings/app-settings.svelte';
   import type { NodeInstance, Socket } from '@nodarium/types';
-  import { getGraphManager, getGraphState } from '../graph-state.svelte';
+  import { getGraphState } from '../graph-state.svelte';
   import { createNodePath } from '../helpers/index.js';
+  import { getSocketPosition } from '../helpers/nodeHelpers';
 
   const graphState = getGraphState();
-  const graph = getGraphManager();
 
   const { node }: { node: NodeInstance } = $props();
 
@@ -16,24 +16,13 @@
       graphState.setDownSocket?.({
         node,
         index: 0,
-        position: graphState.getSocketPosition?.(node, 0)
+        position: getSocketPosition?.(node, 0)
       });
     }
   }
 
   const cornerTop = 10;
-  const nodeType = $derived(graph.getNodeType(node));
-  const rightBump = $derived(
-    !!nodeType?.outputs?.length && node.type !== '__internal/group/input'
-  );
-  const cornerBottom = $derived(
-    node.type === '__internal/group/input'
-      ? (Object.keys(nodeType?.inputs ?? {}).length ? 0 : 10)
-      : node.type === '__internal/group/output'
-      ? (nodeType?.outputs?.length ? 0 : 10)
-      : 0
-  );
-
+  const rightBump = $derived(!!node?.state?.type?.outputs?.length && node.type !== '__virtual/group/input');
   const aspectRatio = 0.25;
 
   const path = $derived(
@@ -42,7 +31,6 @@
       height: 34,
       y: 49,
       cornerTop,
-      cornerBottom,
       rightBump,
       aspectRatio
     })
@@ -53,7 +41,6 @@
       height: 40,
       y: 49,
       cornerTop,
-      cornerBottom,
       rightBump,
       aspectRatio
     })
@@ -83,9 +70,9 @@
     {#if appSettings.value.debug.advancedMode}
       <span class="bg-white text-black! mr-2 px-1 rounded-sm opacity-30">{node.id}</span>
     {/if}
-    {nodeType?.meta?.title || node.type?.split('/').pop()}
+    {node.state?.type?.meta?.title ?? node.type.split('/').pop()}
   </div>
-  {#if rightBump}
+  {#if node.type !== '__virtual/group/input'}
     <div
       class="target"
       role="button"

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

@@ -2,7 +2,7 @@
   import type { NodeInput, NodeInstance, Socket } from '@nodarium/types';
   import { getGraphManager, getGraphState } from '../graph-state.svelte';
   import { createNodePath } from '../helpers';
-  import { getParameterHeight } from '../helpers/nodeHelpers';
+  import { getParameterHeight, getSocketPosition } from '../helpers/nodeHelpers';
   import NodeInputEl from './NodeInput.svelte';
 
   type Props = {
@@ -10,6 +10,7 @@
     input: NodeInput;
     id: string;
     isLast?: boolean;
+    outputIndex?: number;
   };
 
   const graph = getGraphManager();
@@ -17,39 +18,39 @@
   const graphId = graph?.id;
   const elementId = `input-${Math.random().toString(36).substring(7)}`;
 
-  let { node = $bindable(), input, id, isLast }: Props = $props();
+  let { node = $bindable(), input, id, isLast, outputIndex = undefined }: Props = $props();
 
-  let nodeType = $derived(graph.getNodeType(node)!);
+  const nodeType = $derived(node.state.type!);
 
   const inputType = $derived(nodeType.inputs?.[id]);
 
   const socketId = $derived(`${node.id}-${id}`);
+  const outputSocketId = $derived(outputIndex !== undefined ? `${node.id}-${outputIndex}` : '');
   const height = $derived(getParameterHeight(nodeType, id));
 
   function handleMouseDown(ev: MouseEvent) {
     ev.preventDefault();
     ev.stopPropagation();
-
-    if (node.type === '__internal/group/input') {
-      const outputIndex = Object.entries(nodeType?.inputs ?? {}).findIndex(([key]) => key === id);
-      graphState.setDownSocket({
-        node,
-        index: outputIndex,
-        position: graphState.getSocketPosition(node, outputIndex)
-      });
-    } else {
     graphState.setDownSocket({
       node,
       index: id,
-        position: graphState.getSocketPosition(node, id)
+      position: getSocketPosition(node, id)
     });
   }
+
+  function handleOutputMouseDown(ev: MouseEvent) {
+    ev.preventDefault();
+    ev.stopPropagation();
+    if (outputIndex === undefined) return;
+    graphState.setDownSocket({
+      node,
+      index: outputIndex,
+      position: getSocketPosition(node, outputIndex)
+    });
   }
 
-  const leftBump = $derived(
-    nodeType.inputs?.[id].internal !== true && node.type !== '__internal/group/input'
-  );
-  const rightBump = $derived(node.type === '__internal/group/input');
+  const leftBump = $derived(!id.startsWith('__virtual') && nodeType.inputs?.[id].internal !== true && outputIndex === undefined);
+  const rightBump = $derived(outputIndex !== undefined);
   const cornerBottom = $derived(isLast ? 5 : 0);
   const aspectRatio = 0.5;
 
@@ -59,8 +60,8 @@
       height: 2000 / height,
       y: 50.5,
       cornerBottom,
-      rightBump,
       leftBump,
+      rightBump,
       aspectRatio
     })
   );
@@ -69,9 +70,9 @@
       depth: 7,
       height: 2200 / height,
       y: 50.5,
-      rightBump,
       cornerBottom,
       leftBump,
+      rightBump,
       aspectRatio
     })
   );
@@ -91,15 +92,16 @@
 <div
   class="wrapper"
   data-node-type={node.type}
-  class:is-group-input={node.type === '__internal/group/input'}
   data-node-input={id}
   style:height="{height}px"
   style:--socket-color={hoverColor}
-  class:possible-socket={graphState?.possibleSocketIds.has(socketId)}
+  class:possible-socket={outputIndex !== undefined
+    ? graphState?.possibleSocketIds.has(outputSocketId)
+    : graphState?.possibleSocketIds.has(socketId)}
 >
   {#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}
@@ -107,7 +109,7 @@
       {/if}
     </div>
 
-    {#if node?.state?.type?.inputs?.[id]?.internal !== true}
+    {#if outputIndex === undefined && node?.state?.type?.inputs?.[id]?.internal !== true}
       <div
         data-node-socket
         class="target"
@@ -119,6 +121,17 @@
     {/if}
   {/key}
 
+  {#if outputIndex !== undefined}
+    <div
+      data-node-socket
+      class="target target-right"
+      onmousedown={handleOutputMouseDown}
+      role="button"
+      tabindex="0"
+    >
+    </div>
+  {/if}
+
   <svg
     xmlns="http://www.w3.org/2000/svg"
     viewBox="0 0 100 100"
@@ -146,11 +159,16 @@
     transform: translateY(-50%) translateX(-50%);
   }
 
-  .is-group-input .target {
-    right: 0px;
+  .target-right {
+    right: 0;
+    left: auto;
     transform: translateY(-50%) translateX(50%);
   }
 
+  .target-right:hover ~ svg path {
+    d: var(--hover-path);
+  }
+
   .possible-socket .target::before {
     content: "";
     position: absolute;

app/src/lib/graph-interface/test-utils.ts

@@ -23,11 +23,7 @@ export function createMockNodeRegistry(nodes: NodeDefinition[]): NodeRegistry {
 
 export const mockFloatOutputNode: NodeDefinition = {
   id: 'test/node/output',
-  inputs: {
-    'input': {
-      type: 'float'
-    }
-  },
+  inputs: {},
   outputs: ['float'],
   meta: { title: 'Float Output' },
   execute: () => new Int32Array()
@@ -36,7 +32,7 @@ export const mockFloatOutputNode: NodeDefinition = {
 export const mockFloatInputNode: NodeDefinition = {
   id: 'test/node/input',
   inputs: { value: { type: 'float' } },
-  outputs: ['float'],
+  outputs: [],
   meta: { title: 'Float Input' },
   execute: () => new Int32Array()
 };

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

@@ -4,8 +4,7 @@ export function grid(width: number, height: number) {
   const graph: Graph = {
     id: Math.floor(Math.random() * 100000),
     edges: [],
-    nodes: [],
-    groups: []
+    nodes: []
   };
 
   const amount = width * height;

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

@@ -47,7 +47,6 @@ export function tree(depth: number): Graph {
   return {
     id: Math.floor(Math.random() * 100000),
     nodes,
-    edges,
-    groups: []
+    edges
   };
 }

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

@@ -1,12 +1,8 @@
 export const debugNode = {
-  id: '__internal/node/debug',
-  meta: {
-    title: 'Debug'
-  },
+  id: 'max/plantarium/debug',
   inputs: {
     input: {
-      type: '*',
-      label: ''
+      type: '*'
     }
   },
   execute(_data: Int32Array): Int32Array {

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

@@ -1,14 +0,0 @@
-export const groupNode = {
-  id: '__internal/group/instance',
-  meta: { title: 'Group' },
-  inputs: {
-    groupId: {
-      label: '',
-      type: 'select',
-      values: []
-    }
-  },
-  execute(_data: Int32Array): Int32Array {
-    return _data;
-  }
-} as const;

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/node-registry/node-registry-client.ts

@@ -88,7 +88,6 @@ export class RemoteNodeRegistry implements NodeRegistry {
   }
 
   async fetchNodeDefinition(nodeId: `${string}/${string}/${string}`) {
-    if (nodeId.startsWith('__internal/')) return;
     return this.fetchJson(`nodes/${nodeId}.json`);
   }
 
@@ -110,8 +109,6 @@ export class RemoteNodeRegistry implements NodeRegistry {
           return this.nodes.get(id)!;
         }
 
-        if (id.startsWith('__internal/')) return;
-
         const wasmBuffer = await this.fetchNodeWasm(id);
 
         try {

app/src/lib/result-viewer/geometryPool.ts

@@ -80,6 +80,7 @@ export function createGeometryPool(parentScene: Group, material: Material) {
     }
 
     const normals = new Float32Array(data.buffer, index * 4, vertexCount * 3);
+    index = index + vertexCount * 3;
 
     if (
       geometry.userData?.faceCount !== faceCount

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

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

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,
@@ -18,113 +154,6 @@ import type { RuntimeNode } from './types';
 const log = createLogger('runtime-executor');
 log.mute();
 
-export function expandGroups(graph: Graph): Graph {
-  if (!graph.groups || graph.groups.length === 0) return graph;
-
-  function groupContainsSelf(groupId: number, visited = new Set<number>()): boolean {
-    if (visited.has(groupId)) return true;
-    visited.add(groupId);
-    const group = graph.groups!.find(g => g.id === groupId);
-    if (!group) return false;
-    for (const n of group.nodes) {
-      if (n.type === '__internal/group/instance') {
-        const nestedId = n.props?.groupId as number | undefined;
-        if (nestedId !== undefined && groupContainsSelf(nestedId, visited)) return true;
-      }
-    }
-    return false;
-  }
-
-  for (const group of graph.groups) {
-    if (groupContainsSelf(group.id)) {
-      throw new Error(`Circular group reference: group ${group.id} contains itself`);
-    }
-  }
-
-  const nodes = [...graph.nodes];
-  let edges = [...graph.edges];
-
-  let changed = true;
-  while (changed) {
-    changed = false;
-
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      if (node.type !== '__internal/group/instance') continue;
-
-      const groupId = node.props?.groupId as number | undefined;
-      if (groupId === undefined) continue;
-
-      const group = graph.groups.find(g => g.id === groupId);
-      if (!group) continue;
-
-      changed = true;
-
-      const ID_OFFSET = (node.id + 1) * 1_000_000;
-      const idMap = new Map<number, number>();
-
-      const inputBoundary = group.nodes.find(n => n.type === '__internal/group/input');
-      const outputBoundary = group.nodes.find(n => n.type === '__internal/group/output');
-
-      const realNodes = group.nodes.filter(
-        n => n.type !== '__internal/group/input' && n.type !== '__internal/group/output'
-      );
-
-      for (const n of realNodes) idMap.set(n.id, ID_OFFSET + n.id);
-
-      const incomingExternal = edges.filter(e => e[2] === node.id);
-      const outgoingExternal = edges.filter(e => e[0] === node.id);
-      const newEdges: Graph['edges'] = [];
-
-      // external_source → [inputBoundary →] internal_target
-      //
-      // External socket names are "input_N" where N equals the input boundary's
-      // output index. Match each external edge only to the internal edges that
-      // originate from that specific output slot — not a cartesian product of all.
-      if (inputBoundary) {
-        const fromInput = group.edges.filter(e => e[0] === inputBoundary.id);
-        for (const extEdge of incomingExternal) {
-          const inputIndex = parseInt((extEdge[3] as string).replace('input_', ''), 10);
-          const matchingIntEdges = fromInput.filter(e => e[1] === inputIndex);
-          for (const intEdge of matchingIntEdges) {
-            const toId = idMap.get(intEdge[2]);
-            if (toId !== undefined) newEdges.push([extEdge[0], extEdge[1], toId, intEdge[3]]);
-          }
-        }
-      }
-
-      // internal_source → [outputBoundary →] external_target
-      if (outputBoundary) {
-        const toOutput = group.edges.filter(e => e[2] === outputBoundary.id);
-        for (const extEdge of outgoingExternal) {
-          for (const intEdge of toOutput) {
-            const fromId = idMap.get(intEdge[0]);
-            if (fromId !== undefined) newEdges.push([fromId, intEdge[1], extEdge[2], extEdge[3]]);
-          }
-        }
-      }
-
-      // internal-to-internal edges (skip boundary edges)
-      for (const e of group.edges) {
-        if (e[0] === inputBoundary?.id || e[2] === outputBoundary?.id) continue;
-        const fromId = idMap.get(e[0]);
-        const toId = idMap.get(e[2]);
-        if (fromId !== undefined && toId !== undefined) newEdges.push([fromId, e[1], toId, e[3]]);
-      }
-
-      nodes.splice(i, 1);
-      for (const n of realNodes) nodes.push({ ...n, id: idMap.get(n.id)! });
-
-      edges = edges.filter(e => e[0] !== node.id && e[2] !== node.id);
-      edges.push(...newEdges);
-
-      break;
-    }
-  }
-
-  return { ...graph, nodes, edges };
-}
-
 function getValue(input: NodeInput, value?: unknown) {
   if (value === undefined && 'value' in input) {
     value = input.value;
@@ -185,8 +214,8 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
     // Only load non-virtual types (virtual nodes are resolved locally)
     const nonVirtualTypes = graph.nodes
       .map(node => node.type)
-      .filter(t => !t.startsWith('__internal/'));
-    await this.registry.load(nonVirtualTypes);
+      .filter(t => !t.startsWith('__virtual/'));
+    await this.registry.load(nonVirtualTypes as any);
 
     const typeMap = new Map<string, NodeDefinition>();
     for (const node of graph.nodes) {
@@ -333,7 +362,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
           if (inputNode) {
             if (results[inputNode.id] === undefined) {
               throw new Error(
-                `Node ${node.type} is missing input from node ${inputNode.type}#${inputNode.id}`
+                `Node ${node.type} is missing input from node ${inputNode.type}`
               );
             }
             return results[inputNode.id];

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

@@ -52,7 +52,7 @@
     // select input: use index into options
     if ('options' in node && Array.isArray(node.options)) {
       if (typeof inputValue === 'string') {
-        return node.options.indexOf(inputValue);
+        return (node.options as string[]).indexOf(inputValue);
       }
       return 0;
     }
@@ -204,13 +204,6 @@
 
   .input-boolean > label {
     order: 2;
-    font-size: 1em;
-    opacity: 0.9;
-  }
-
-  label {
-    font-size: 0.8em;
-    opacity: 0.7;
   }
 
   .first-level.input {

app/src/lib/sidebar/Sidebar.svelte

@@ -2,7 +2,6 @@
   import { type Snippet } from 'svelte';
   import { panelState as state } from './PanelState.svelte';
 
-  // eslint-disable-next-line no-useless-assignment
   let { children, open = $bindable(false) } = $props<{ children?: Snippet; open?: boolean }>();
 
   $effect(() => {

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

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

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

@@ -1,103 +1,31 @@
 <script lang="ts">
   import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
-  import NestedSettings from '$lib/settings/NestedSettings.svelte';
-  import type { NodeId, NodeInput, NodeInstance } from '@nodarium/types';
-
-  type InternalNodeInput = NodeInput & {
-    __node_type?: NodeId;
-    __node_input: string;
-  };
+  import type { NodeInstance } from '@nodarium/types';
+  import ActiveNodeSelected from './ActiveNodeSelected.svelte';
 
   type Props = {
     manager: GraphManager;
-    node: NodeInstance | undefined;
+    node: NodeInstance;
   };
 
-  const { manager, node = $bindable() }: Props = $props();
+  let { manager, node = $bindable() }: Props = $props();
 
-  function filterInputs(inputs?: Record<string, NodeInput>) {
-    if (!node) return {};
-    return Object.fromEntries(
-      Object.entries(inputs ?? {})
-        .filter(([, value]) => {
-          return value.hidden === true;
-        })
-        .map(([key, value]) => {
-          const v = value as InternalNodeInput;
-          v.__node_type = node.state.type?.id;
-          v.__node_input = key;
-          return [key, v];
-        })
+  const inputs = $derived(node?.state?.type?.inputs || {});
+
+  const hasSettings = $derived(
+    Object.values(inputs).find(entry => {
+      return entry.hidden === true;
+    }) !== undefined
   );
-  }
-  const nodeDefinition = node ? filterInputs(node.state.type?.inputs) : {};
 
-  type Store = Record<string, number | number[]>;
-  let store = $state<Store>(createStore(node?.props, nodeDefinition));
-  function createStore(
-    props: NodeInstance['props'],
-    inputs: Record<string, NodeInput>
-  ): Store {
-    const store: Store = {};
-    Object.keys(inputs).forEach((key) => {
-      if (props) {
-        const value = props[key] !== undefined ? props[key] : inputs[key].value;
-        if (Array.isArray(value) || typeof value === 'number') {
-          store[key] = value;
-        } else if (typeof value === 'boolean') {
-          store[key] = value ? 1 : 0;
-        } else {
-          console.error('Wrong error', { value });
-        }
-      }
-    });
-    return store;
-  }
-
-  let lastPropsHash = '';
-  function updateNode() {
-    if (!node || !store) return;
-    let needsUpdate = false;
-    Object.keys(store).forEach((_key: string) => {
-      node.props = node.props || {};
-      const key = _key as keyof typeof store;
-      if (node && store) {
-        needsUpdate = true;
-        const value = store[key];
-        if (value !== undefined) {
-          node.props[key] = value;
-        }
-      }
-    });
-
-    let propsHash = JSON.stringify(node.props);
-    if (propsHash === lastPropsHash) {
-      return;
-    }
-    lastPropsHash = propsHash;
-
-    if (needsUpdate) {
-      manager.save();
-      manager.execute();
-    }
-  }
-
-  const isGroupInstance = $derived(node?.type === '__internal/group/instance');
-
-  $effect(() => {
-    if (store) {
-      updateNode();
-    }
-  });
+  $inspect({ inputs, hasSettings });
 </script>
 
-{#if !isGroupInstance && Object.keys(nodeDefinition).length}
-  <div class='{node?"border-l-2 pl-3.5!":""} bg-layer-2 flex items-center h-[70px] border-b-1 border-l-selected border-b-outline pl-4'>
+{#key node.id}
+  {#if node && hasSettings}
+    <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>
     </div>
-  <NestedSettings
-    id="activeNodeSettings"
-    bind:value={store}
-    type={nodeDefinition}
-  />
-{/if}
+    <ActiveNodeSelected {manager} bind:node />
+  {/if}
+{/key}

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

@@ -1,23 +1,20 @@
 <script lang="ts">
   import type { Graph } from '$lib/types';
-  import { JsonViewer } from '@nodarium/ui';
 
   const { graph }: { graph?: Graph } = $props();
 
-  const data = $derived(
-    graph
-      ? {
-        ...graph,
-        nodes: graph.nodes.map((n: object) => ({ ...n, tmp: undefined, state: undefined }))
-      }
-      : null
+  function convert(g: Graph): string {
+    return JSON.stringify(
+      {
+        ...g,
+        nodes: g.nodes.map((n: object) => ({ ...n, tmp: undefined, state: undefined }))
+      },
+      null,
+      2
     );
+  }
 </script>
 
-<div class="overflow-auto p-2">
-  {#if data}
-    <JsonViewer value={data} path="graph" />
-  {:else}
-    <span class="font-mono text-xs text-neutral-500">No graph loaded</span>
-  {/if}
-</div>
+<pre>
+  {graph ? convert(graph) : "No graph loaded"}
+</pre>

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

@@ -0,0 +1,175 @@
+<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();
+
+  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);
+  }
+
+  function prune() {
+    manager.pruneUnusedGroups();
+  }
+</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 class="flex flex-col gap-1.5">
+    <span class="section-label">Maintenance</span>
+    <button class="danger-btn" onclick={prune}>Prune unused groups</button>
+  </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);
+  }
+
+  .danger-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;
+    font-family: var(--font-family);
+    opacity: 0.7;
+    width: 100%;
+    text-align: left;
+  }
+
+  .danger-btn:hover {
+    outline-color: #e05050;
+    opacity: 1;
+  }
+</style>

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

@@ -1,156 +0,0 @@
-<script lang="ts">
-  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
-  import { GraphState } from '$lib/graph-interface/graph-state.svelte';
-  import type { NodeInstance } from '@nodarium/types';
-  import { SocketTable } from '@nodarium/ui';
-  import UnusedGroupsPanel from './UnusedGroupsPanel.svelte';
-
-  type Props = {
-    manager: GraphManager;
-    graphState: GraphState;
-    node?: NodeInstance;
-  };
-
-  const { manager, graphState, node = $bindable() }: Props = $props();
-
-  const activeGroup = $derived.by(() => {
-    if (node?.type === '__internal/group/instance') {
-      let group = manager.getGroup(node.props?.groupId as number);
-      if (group) return group;
-    }
-
-    if (manager?.isInsideGroup && manager.currentGroupId !== null) {
-      return manager.getGroup(manager.currentGroupId);
-    }
-  });
-
-  const groupName = $derived(activeGroup?.name ?? '');
-  function handleRename(e: Event) {
-    const name = (e.target as HTMLInputElement).value;
-    if (activeGroup) manager.renameGroup(activeGroup.id, name);
-  }
-
-  function handleRemoveInput(key: string) {
-    if (!activeGroup) return;
-    const group = manager.getGroup(activeGroup?.id);
-    const inputs = $state.snapshot(group?.inputs ?? {});
-    delete inputs[key];
-    activeGroup.inputs = inputs;
-    manager.nodes = manager.nodes;
-    manager.save();
-  }
-
-  const types = $derived(
-    Array.from(
-      new Set(
-        manager?.registry
-          ? manager.registry.getAllNodes()
-            .flatMap(n =>
-              Object.values(n.inputs ?? {})
-                .map(v => v.type)
-            )
-          : []
-      )
-    )
-  );
-
-  let outputType = $derived(activeGroup?.outputs?.[0]?.type ?? 'unknown');
-
-  $effect(() => {
-    if (!activeGroup) return;
-    const group = manager.getGroup(activeGroup?.id);
-    const outputs = $state.snapshot(group?.outputs ?? []);
-    if (outputs?.[0]?.type === outputType) return;
-    activeGroup.outputs = [
-      {
-        label: outputs[0]?.label ?? 'Output',
-        type: outputType
-      }
-    ];
-    manager.nodes = manager.nodes;
-    manager.save();
-  });
-</script>
-
-{#if activeGroup}
-  <div class='{node?"border-l-2 pl-3.5!":""} bg-layer-2 flex items-center h-[70px] border-b-1 border-l-selected border-b-outline pl-4'>
-    <h3>Group Settings</h3>
-  </div>
-{/if}
-
-{#if activeGroup}
-  {#key activeGroup.id}
-    <div class="p-4 group-settings">
-      <label for="group-name">Group name</label>
-      <input
-        id="group-name"
-        type="text"
-        placeholder="Group {activeGroup.id}"
-        value={groupName}
-        oninput={handleRename}
-      />
-
-      <label for="group-name">Group Inputs</label>
-      <div>
-        <SocketTable
-          {types}
-          onremove={handleRemoveInput}
-          bind:inputs={activeGroup.inputs}
-          colors={graphState?.colors?.getColors()}
-        />
-      </div>
-
-      <label for="group-name mb-2">Group output</label>
-      <div class="flex bg-layer-2 rounded-sm outline outline-outline w-min">
-        <span
-          style:background={graphState?.colors?.getColor(outputType)}
-          class="block opacity-50 min-w-2 ml-2 w-2 h-2 my-auto rounded-sm"
-        ></span>
-        <select
-          class="text-[0.9em] shrink-0 px-2 py-1 border-outline"
-          bind:value={outputType}
-        >
-          {#each types as type (type)}
-            <option>
-              <span
-                style="background: {graphState?.colors?.getColor(type)}; width: 5px; height: 5px; border-radius: 5px;"
-              ></span>
-              {type}
-            </option>
-          {/each}
-        </select>
-      </div>
-    </div>
-  {/key}
-{/if}
-
-{#if manager && !manager.isInsideGroup}
-  <UnusedGroupsPanel {manager} />
-{/if}
-
-<style>
-  .group-settings {
-    display: flex;
-    flex-direction: column;
-    gap: 0.4em;
-  }
-
-  label {
-    font-size: 0.8em;
-    opacity: 0.7;
-  }
-
-  .group-settings input {
-    background: var(--color-layer-1);
-    border: 1px solid var(--color-outline);
-    border-radius: 4px;
-    color: var(--color-text);
-    font-family: var(--font-family);
-    font-size: 0.9em;
-    padding: 0.4em 0.6em;
-  }
-
-  .group-settings input:focus {
-    outline: 1px solid var(--color-active);
-  }
-</style>

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

@@ -1,135 +0,0 @@
-<script lang="ts">
-  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
-  import type { GroupDefinition } from '@nodarium/types';
-  import { SvelteMap, SvelteSet } from 'svelte/reactivity';
-
-  type Props = { manager: GraphManager };
-  const { manager }: Props = $props();
-
-  type GroupNode = { group: GroupDefinition; children: GroupNode[] };
-
-  const unusedTree = $derived.by((): GroupNode[] => {
-    const unused = manager.getUnusedGroups();
-    if (!unused.length) return [];
-
-    const unusedIds = new Set(unused.map(g => g.id));
-
-    // Build child map: which unused groups reference which other unused groups
-    const childrenOf = new SvelteMap<number, number[]>();
-    const referencedBy = new SvelteSet<number>();
-
-    for (const group of unused) {
-      const refs: number[] = [];
-      for (const node of group.nodes) {
-        if (node.type === '__internal/group/instance' && node.props?.groupId !== undefined) {
-          const childId = node.props.groupId as number;
-          if (unusedIds.has(childId)) {
-            refs.push(childId);
-            referencedBy.add(childId);
-          }
-        }
-      }
-      childrenOf.set(group.id, refs);
-    }
-
-    const byId = new Map(unused.map(g => [g.id, g]));
-
-    function buildNode(g: GroupDefinition): GroupNode {
-      return {
-        group: g,
-        children: (childrenOf.get(g.id) ?? []).map(id => buildNode(byId.get(id)!))
-      };
-    }
-
-    return unused
-      .filter(g => !referencedBy.has(g.id))
-      .map(buildNode);
-  });
-</script>
-
-{#if unusedTree.length}
-  <div class="panel p-4">
-    <div class="header">
-      <span>Unused groups</span>
-      <button class="remove-all" onclick={() => manager.removeUnusedGroups()}>
-        Remove all
-      </button>
-    </div>
-
-    <ul class="tree">
-      {#snippet treeNode(node: GroupNode)}
-        <li>
-          <span class="group-name">{node.group.name || `Group #${node.group.id}`}</span>
-          {#if node.children.length}
-            <ul>
-              {#each node.children as child (child.group.id)}
-                {@render treeNode(child)}
-              {/each}
-            </ul>
-          {/if}
-        </li>
-      {/snippet}
-      {#each unusedTree as node (node.group.id)}
-        {@render treeNode(node)}
-      {/each}
-    </ul>
-  </div>
-{/if}
-
-<style>
-  .panel {
-    border-top: 1px solid var(--color-outline);
-    margin-top: -1px;
-    border-bottom: 1px solid var(--color-outline);
-  }
-
-  .header {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    margin-bottom: 0.5em;
-    font-size: 0.8em;
-    opacity: 0.7;
-  }
-
-  .remove-all {
-    background: none;
-    border: 1px solid var(--color-outline);
-    border-radius: 4px;
-    color: var(--color-text);
-    cursor: pointer;
-    font-family: var(--font-family);
-    font-size: 0.85em;
-    padding: 0.2em 0.5em;
-  }
-
-  .remove-all:hover {
-    border-color: var(--color-active);
-  }
-
-  .tree {
-    list-style: none;
-    margin: 0;
-    padding: 0;
-  }
-
-  .tree ul {
-    list-style: none;
-    margin: 0;
-    padding-left: 1.2em;
-    border-left: 1px solid var(--color-outline);
-  }
-
-  .tree li {
-    padding: 0.15em 0;
-  }
-
-  .group-name {
-    font-size: 0.85em;
-  }
-
-  .tree ul .group-name::before {
-    content: '└ ';
-    opacity: 0.4;
-  }
-</style>

app/src/routes/+page.svelte

@@ -4,8 +4,8 @@
   import Grid from '$lib/grid';
   import { debounceAsyncFunction } from '$lib/helpers';
   import { createKeyMap } from '$lib/helpers/createKeyMap';
-  import { debugNode } from '$lib/node-registry/debugNode';
-  import { groupNode } from '$lib/node-registry/groupNode.js';
+  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';
@@ -22,7 +22,7 @@
   import Changelog from '$lib/sidebar/panels/Changelog.svelte';
   import ExportSettings from '$lib/sidebar/panels/ExportSettings.svelte';
   import GraphSource from '$lib/sidebar/panels/GraphSource.svelte';
-  import GroupSettings from '$lib/sidebar/panels/GroupSettings.svelte';
+  import 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';
@@ -39,7 +39,12 @@
 
   const registryCache = new IndexDBCache('node-registry');
 
-  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [debugNode, groupNode]);
+  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [
+    debugNode,
+    groupInputNode,
+    groupOutputNode,
+    groupNode
+  ]);
   const workerRuntime = new WorkerRuntimeExecutor();
   const runtimeCache = new MemoryRuntimeCache();
   const memoryRuntime = new MemoryRuntimeExecutor(nodeRegistry, runtimeCache);
@@ -96,7 +101,7 @@
     randomSeed: { type: 'boolean', value: false }
   });
   $effect(() => {
-    if (graphSettings && graphSettingTypes && manager?.loaded) {
+    if (graphSettings && graphSettingTypes) {
       manager?.setSettings($state.snapshot(graphSettings));
     }
   });
@@ -172,7 +177,6 @@
   config={tutorialConfig}
   actions={{
     'setup-default': () => {
-      console.log('setup-default');
       const ts = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
       pm.handleCreateProject(
         structuredClone(templates.defaultPlant) as unknown as Graph,
@@ -180,16 +184,15 @@
       );
     },
     'load-tutorial-template': () => {
-      console.log('load-tutorial-template');
       if (!pm.graph) return;
       const g = structuredClone(templates.tutorial) as unknown as Graph;
       g.id = pm.graph.id;
       g.meta = { ...pm.graph.meta };
-      manager.load(g);
+      pm.graph = g;
+      pm.saveGraph(g);
       graphInterface.state.centerNode(graphInterface.manager.getAllNodes()[0]);
     },
     'open-github-nodes': () => {
-      console.log('open-github-nodes');
       window.open(
         'https://github.com/jim-fx/nodarium/tree/main/nodes/max/plantarium',
         '__blank'
@@ -258,12 +261,11 @@
     </Grid.Cell>
     <Grid.Cell>
       {#if pm.graph}
-        {#key pm.graph.id}
         <GraphInterface
           graph={pm.graph}
           bind:this={graphInterface}
           registry={nodeRegistry}
-            safePadding={{ right: sidebarOpen ? 321 : undefined }}
+          safePadding={{ right: sidebarOpen ? 330 : undefined }}
           backgroundType={appSettings.value.nodeInterface.backgroundType}
           snapToGrid={appSettings.value.nodeInterface.snapToGrid}
           bind:activeNode
@@ -273,7 +275,6 @@
           onsave={(g) => pm.saveGraph(g)}
           onresult={(result) => handleUpdate(result as Graph)}
         />
-        {/key}
       {/if}
       <Sidebar bind:open={sidebarOpen}>
         <Panel id="general" title="General" icon="i-[tabler--settings]">
@@ -327,9 +328,7 @@
           hidden={!appSettings.value.debug.advancedMode}
           icon="i-[tabler--code]"
         >
-          {#if manager?.status === 'idle'}
-            <GraphSource graph={manager.serialize()} />
-          {/if}
+          <GraphSource graph={pm.graph ?? manager?.serialize()} />
         </Panel>
         <Panel
           id="benchmark"
@@ -344,16 +343,25 @@
           title="Graph Settings"
           icon="i-[custom--graph] bg-blue-400"
         >
-          <span class="block h-[1px]"></span>
           <NestedSettings
             id="graph-settings"
             type={graphSettingTypes}
             bind:value={graphSettings}
           />
-          {#key activeNode}
+          {#if activeNode?.id}
             <ActiveNodeSettings {manager} bind:node={activeNode} />
-            <GroupSettings graphState={graphInterface?.state} {manager} bind:node={activeNode} />
-          {/key}
+          {/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"

docs/LLM.md

@@ -1,216 +1,312 @@
-# Nodarium — LLM Reference
+# Nodarium - LLM Documentation
 
-## What It Is
+## Overview
 
-Nodarium is a **node-based visual programming editor**. Users wire together nodes on a 2D canvas; each node is a WebAssembly module that receives typed inputs and produces typed outputs. A live Three.js viewer renders the resulting 3D geometry/paths/instances.
+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
 
-## Repository Layout
+### Core Components
 
-```
-/
-├── app/                        # SvelteKit web app
-│   └── src/
-│       ├── routes/+page.svelte # App entry point
-│       └── lib/
-│           ├── graph-interface/  # Canvas editor (UI + state)
-│           ├── runtime/          # WASM execution engine
-│           ├── node-registry/    # Fetch & cache node definitions
-│           ├── project-manager/  # IndexDB persistence
-│           ├── result-viewer/    # Three.js 3D output
-│           ├── sidebar/          # UI panels
-│           └── settings/         # App + graph settings
-├── packages/
-│   ├── types/    # Shared TypeScript types + Zod schemas
-│   ├── utils/    # Logging, hashing, WASM wrapping, perf
-│   ├── ui/       # Reusable Svelte UI components
-│   ├── planty/   # Tutorial system
-│   └── macros/   # Build-time macros
-└── docs/
-```
+#### 1. Node System (`app/static/nodes/`)
 
----
+WASM-based nodes that perform computations. All nodes must implement the NodeDefinition interface.
 
-## Core Architecture
+- **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
 
-```
-User Interaction
-  └── GraphInterface
-        ├── GraphState   ← UI: selection, camera, mouse, clipboard
-        └── GraphManager ← Logic: nodes, edges, history, serialization
-              ├── NodeRegistry   ← fetches WASM definitions (remote API + IndexDB cache)
-              ├── HistoryManager ← undo/redo (jsondiffpatch deltas)
-              └── emit('result') → RuntimeExecutor
-                                      └── node.execute(Int32Array) per node
-                                            └── ResultViewer (Three.js/Threlte)
-```
+- **Node Registry**: `app/src/lib/node-registry.ts`
+  - Loads and manages WASM nodes
+  - `getNodeWasm()` - Creates WASM wrapper from bytes
+  - `getNode()` - Retrieves node definition
 
-**Event flow:**
+- **Debug Node**: `app/src/lib/node-registry/debugNode.js`
+  - Special debug node with wildcard inputs
+  - Variable-height nodes and parameters
+  - Quick-connect shortcut
 
-1. User edits graph → GraphManager mutates state
-2. GraphManager emits `save` → ProjectManager persists to IndexDB
-3. GraphManager emits `result` → Runtime executes graph → Viewer updates
+#### 2. Graph Interface
 
----
+Visual node editor built with Svelte 5.
 
-## Critical Files
+- **Main Wrapper**: `app/src/lib/graph-interface/graph/Wrapper.svelte`
+  - Entry point for graph interface
+  - Manages GraphManager and GraphState
 
-| File                                                   | Role                                                                  |
-| ------------------------------------------------------ | --------------------------------------------------------------------- |
-| `app/src/routes/+page.svelte`                          | Wires all systems; creates GraphManager, runtime, registry            |
-| `app/src/lib/graph-interface/graph-manager.svelte.ts`  | Central graph logic: createNode, createEdge, serialize, load, history |
-| `app/src/lib/graph-interface/graph-state.svelte.ts`    | UI state: camera, selection, mouse, clipboard, groupSelectedNodes     |
-| `app/src/lib/graph-interface/graph/Graph.svelte`       | Canvas renderer                                                       |
-| `app/src/lib/graph-interface/node/Node.svelte`         | 3D mesh node (Three.js shader)                                        |
-| `app/src/lib/graph-interface/node/NodeHTML.svelte`     | HTML overlay: labels + parameters                                     |
-| `app/src/lib/graph-interface/node/NodeHeader.svelte`   | Node title bar                                                        |
-| `app/src/lib/graph-interface/keymaps.ts`               | Keyboard shortcuts                                                    |
-| `app/src/lib/graph-interface/helpers/nodeHelpers.ts`   | Node height calculations                                              |
-| `app/src/lib/graph-interface/graph/colors.svelte.ts`   | Socket type → color mapping                                           |
-| `app/src/lib/runtime/runtime-executor.ts`              | Executes nodes in DAG order; expandGroups()                           |
-| `app/src/lib/node-registry/index.ts`                   | RemoteNodeRegistry entry                                              |
-| `app/src/lib/node-registry/groupNode.ts`               | Built-in group node definition                                        |
-| `app/src/lib/node-registry/debugNode.ts`               | Built-in debug node                                                   |
-| `app/src/lib/sidebar/panels/ActiveNodeSettings.svelte` | Per-node settings panel                                               |
-| `packages/types/src/types.ts`                          | Graph, NodeInstance, NodeDefinition, Edge, GroupDefinition            |
-| `packages/types/src/inputs.ts`                         | NodeInput union types (float, vec3, geometry, path, …)                |
-| `packages/utils/src/wasm.ts`                           | createWasmWrapper() — wraps WASM bytes into a NodeDefinition          |
+- **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)
 
-## Key Types
+- **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
-// packages/types/src/types.ts
+interface NodeDefinition {
+  id: string;
+  name: string;
+  inputs: Socket[];
+  outputs: Socket[];
+  parameters: Parameter[];
+  execute: (inputs: any[], parameters: any[]) => any[];
+}
 
-type NodeId = `${string}/${string}/${string}`; // e.g. "max/plantarium/stem"
+interface Socket {
+  id: string;
+  name: string;
+  type: string; // datatype (e.g., "number", "vec3", "*")
+  defaultValue?: any;
+  optional?: boolean;
+}
 
-type NodeInstance = {
-  id: number;
-  type: NodeId;
-  position: [number, number];
-  props?: Record<string, number | number[]>; // current parameter values
-  meta?: { title?: string; lastModified?: string };
-  state: NodeRuntimeState; // runtime-only, NOT serialized
-};
+interface Parameter {
+  id: string;
+  name: string;
+  type: string;
+  defaultValue: any;
+  min?: number;
+  max?: number;
+  options?: string[];
+}
 
-type NodeRuntimeState = {
-  type?: NodeDefinition; // resolved definition
-  parents?: NodeInstance[];
-  children?: NodeInstance[];
-  x?: number;
-  y?: number; // interpolated position
-  mesh?: Mesh; // Three.js mesh reference
-  ref?: HTMLElement;
-};
-
-type NodeDefinition = {
-  id: NodeId;
-  inputs?: Record<string, NodeInput>;
-  outputs?: string[]; // output type names
-  meta?: { title?: string; description?: string };
-  execute(input: Int32Array): Int32Array; // WASM function
-};
-
-// Edge: [fromNode, outputIndex, toNode, inputSocketName]
-type Edge = [NodeInstance, number, NodeInstance, string];
-
-type Graph = {
-  nodes: NodeInstance[];
-  edges: [number, number, number, string][]; // serialized (IDs, not refs)
-  settings: Record<string, unknown>;
-  groups: GroupDefinition[];
-};
-
-type GroupDefinition = {
-  id: number;
+interface Graph {
   nodes: NodeInstance[];
   edges: Edge[];
-  inputs?: Record<string, NodeInput>;
-  outputs?: string[];
-};
+}
+
+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;
+}
 ```
 
-### NodeInput socket types
+## Development Workflow
 
-`float` | `integer` | `boolean` | `select` | `seed` | `vec3` | `geometry` | `path` | `shape` | `color` | `*` (wildcard)
+### Prerequisites
 
-Each input can have: `value` (default), `label`, `hidden`, `external`, `setting` (link to graph setting), `accepts` (extra compatible types).
+- Node.js
+- pnpm
+- Rust
+- wasm-pack
 
----
-
-## Patterns & Conventions
-
-### Svelte 5 reactivity
-
-The codebase uses Svelte 5 runes throughout — `$state`, `$derived`, `$effect`. Collections use `SvelteMap<K,V>` and `SvelteSet<T>` (from `svelte/reactivity`) instead of plain Map/Set so that mutations trigger reactive updates.
-
-### Context API
-
-`GraphManager` and `GraphState` are provided via Svelte context (`setContext` / `getContext`) inside `GraphInterface`. All child components (Node, Edge, etc.) consume them via context rather than props.
-
-### Edge representation
-
-In memory, edges are `[NodeInstance, outputIndex, NodeInstance, inputSocketName]` — direct object references for fast traversal. On serialization (`Graph.edges`), they become `[nodeId, outputIndex, nodeId, inputSocketName]` (plain IDs).
-
-### Socket compatibility
-
-```typescript
-areSocketsCompatible(outputType: string, inputType: string | string[]): boolean
-// '*' wildcard matches any type; 'geometry' accepts ['geometry', 'instances']
-```
-
-### WASM execution interface
-
-Every node exposes a single function: `execute(input: Int32Array): Int32Array`.
-Data encoding (Plantarium):
-
-- `[0, stemDepth, ...x,y,z,thickness]` — path
-- `[1, vertexCount, faceCount, ...faces, ...vertices, ...normals]` — geometry
-- `[2, vertexCount, faceCount, instanceCount, stemDepth, ...]` — instances
-
-### Event emitter
-
-`GraphManager extends EventEmitter<{ save, result, settings }>`. Subscribe with `manager.on('result', cb)`. Used to decouple the editor UI from runtime execution and persistence.
-
-### History
-
-Every mutation goes through `HistoryManager`. Call `this.history.save(this.serialize())` before mutations; undo/redo replays jsondiffpatch deltas.
-
-### Internal node IDs
-
-Built-in nodes use the `__internal/` namespace: `__internal/group/instance`, `__internal/node/debug`. Virtual boundary nodes use `__virtual/`: `__virtual/group/input`, `__virtual/group/output`.
-
----
-
-## In-Progress: Node Groups (`feat/group-node-own`)
-
-Group selected nodes with **Ctrl+G**. A `GroupDefinition` is stored in `Graph.groups[]`; a group instance node (`__internal/group/instance`) referencing it by `props.groupId` replaces the selected nodes.
-
-**Known gaps as of 2026-05-03:**
-
-| Issue                                                                                     | Location                                                           |
-| ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
-| `createGroupNode()` called but not defined                                                | `graph-state.svelte.ts:334` → missing in `graph-manager.svelte.ts` |
-| Runtime expects `group.graph.nodes/edges`; schema has flat `nodes/edges`                  | `runtime-executor.ts` vs `types.ts`                                |
-| Runtime expects `group.inputs` as array; schema defines it as `Record<string, NodeInput>` | Same mismatch                                                      |
-| `enterGroupNode()` is a stub — no group navigation                                        | `graph-state.svelte.ts`                                            |
-| `serialize()` writes parent-graph edges into group instead of group-internal edges        | `graph-manager.svelte.ts`                                          |
-
----
-
-## Dev Commands
-
-Run from `app/`:
+### Build Commands
 
 ```bash
-npm run dev          # start dev server (Vite)
-npm run build        # production build
-npm run check        # svelte-check + tsc
-npm run lint         # eslint
-npm run test         # unit (vitest) + e2e (playwright)
-npm run test:unit    # vitest only
-npm run test:e2e     # playwright only
-npm run bench        # benchmark runner
+# 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

package.json

@@ -6,8 +6,7 @@
     "qa": "pnpm lint && pnpm check && pnpm test",
     "format": "pnpm dprint fmt",
     "format:check": "pnpm dprint check",
-    "test:e2e": "pnpm run -r --parallel test:e2e",
-    "test:unit": "pnpm run -r --parallel test:unit",
+    "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",
@@ -20,6 +19,6 @@
   "packageManager": "pnpm@10.28.1+sha512.7d7dbbca9e99447b7c3bf7a73286afaaf6be99251eb9498baefa7d406892f67b879adb3a1d7e687fc4ccc1a388c7175fbaae567a26ab44d1067b54fcb0d6a316",
   "devDependencies": {
     "chokidar-cli": "catalog:",
-    "dprint": "^0.54.0"
+    "dprint": "^0.51.1"
   }
 }

packages/planty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodarium/planty",
-  "version": "0.0.6",
+  "version": "0.0.1",
   "scripts": {
     "dev": "vite dev",
     "build": "vite build",
@@ -10,8 +10,8 @@
     "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' ."
+    "format": "dprint fmt -c '../.dprint.jsonc' .",
+    "format:check": "dprint check -c '../.dprint.jsonc' ."
   },
   "files": [
     "dist",
@@ -34,29 +34,29 @@
     "svelte": "^5.0.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^2.0.5",
-    "@eslint/js": "^10.0.1",
     "@nodarium/ui": "workspace:*",
+    "@eslint/compat": "^2.0.4",
+    "@eslint/js": "^10.0.1",
     "@sveltejs/adapter-auto": "^7.0.1",
-    "@sveltejs/kit": "^2.59.0",
+    "@sveltejs/kit": "^2.57.0",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
-    "@tailwindcss/vite": "^4.2.4",
-    "@types/node": "^25.6.0",
-    "eslint": "^10.3.0",
+    "@tailwindcss/vite": "^4.2.2",
+    "@types/node": "^24",
+    "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-svelte": "^3.17.1",
-    "globals": "^17.6.0",
-    "prettier": "^3.8.3",
+    "eslint-plugin-svelte": "^3.17.0",
+    "globals": "^17.4.0",
+    "prettier": "^3.8.1",
     "prettier-plugin-svelte": "^3.5.1",
-    "prettier-plugin-tailwindcss": "^0.8.0",
+    "prettier-plugin-tailwindcss": "^0.7.2",
     "publint": "^0.3.18",
-    "svelte": "^5.55.5",
-    "svelte-check": "^4.4.7",
-    "tailwindcss": "^4.2.4",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.1",
-    "vite": "^8.0.10"
+    "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/tsconfig.json

@@ -9,6 +9,7 @@
     "skipLibCheck": true,
     "sourceMap": true,
     "strict": true,
+    "module": "NodeNext",
     "moduleResolution": "bundler"
   }
 }

packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodarium/types",
-  "version": "0.0.6",
+  "version": "0.0.5",
   "description": "",
   "type": "module",
   "main": "src/index.ts",
@@ -18,9 +18,9 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "zod": "^4.4.3"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "dprint": "^0.54.0"
+    "dprint": "^0.51.1"
   }
 }

packages/types/src/index.ts

@@ -4,13 +4,13 @@ export type {
   Box,
   Edge,
   Graph,
-  GroupDefinition,
+  GroupSocket,
   NodeDefinition,
+  NodeGroupDefinition,
   NodeId,
   NodeInstance,
-  SerializedEdge,
   SerializedNode,
   Socket
 } from './types';
-export { GraphSchema, GroupSchema, NodeSchema } from './types';
+export { GraphSchema, NodeSchema } from './types';
 export { NodeDefinitionSchema } from './types';

packages/types/src/inputs.ts

@@ -61,10 +61,11 @@ export const NodeInputBooleanSchema = z.object({
 export const NodeInputSelectSchema = z.object({
   ...DefaultOptionsSchema.shape,
   type: z.literal('select'),
-  options: z.array(
-    z.union([z.string(), z.object({ value: z.number(), label: z.string() })])
-  ).optional(),
-  value: z.union([z.string(), z.number()]).optional()
+  options: z.union([
+    z.array(z.string()),
+    z.array(z.object({ label: z.string(), value: z.string() }))
+  ]).optional(),
+  value: z.string().optional()
 });
 
 export const NodeInputSeedSchema = z.object({

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,24 +76,33 @@ export type Socket = {
 
 export type Edge = [NodeInstance, number, NodeInstance, string];
 
-const SerializedEdgeSchema = z.tuple([z.number(), z.number(), z.number(), z.string()]);
+export type GroupSocket = {
+  name: string;
+  type: string;
+};
 
-export type SerializedEdge = z.infer<typeof SerializedEdgeSchema>;
+export type NodeGroupDefinition = {
+  id: string;
+  name: string;
+  inputs: GroupSocket[];
+  outputs: GroupSocket[];
+  graph: {
+    nodes: SerializedNode[];
+    edges: [number, number, number, string][];
+  };
+};
 
-export const GroupSchema = z.object({
-  id: z.number(),
-  name: z.string().optional(),
+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()])),
-  inputs: z.record(z.string(), NodeInputSchema).optional(),
-  outputs: z.array(z.object({
-    type: z.string(),
-    label: z.string().optional()
-  })).optional()
+    edges: z.array(z.tuple([z.number(), z.number(), z.number(), z.string()]))
+  })
 });
 
-export type GroupDefinition = z.infer<typeof GroupSchema>;
-
 export const GraphSchema = z.object({
   id: z.number(),
   meta: z
@@ -104,8 +113,8 @@ export const GraphSchema = z.object({
     .optional(),
   settings: z.record(z.string(), z.any()).optional(),
   nodes: z.array(NodeSchema),
-  edges: z.array(SerializedEdgeSchema),
-  groups: z.array(GroupSchema)
+  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,6 +1,6 @@
 {
   "name": "@nodarium/ui",
-  "version": "0.0.6",
+  "version": "0.0.5",
   "scripts": {
     "dev": "vite",
     "build": "vite build",
@@ -30,47 +30,46 @@
     "svelte": "^4.0.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^2.0.5",
-    "@eslint/eslintrc": "^3.3.5",
-    "@eslint/js": "^10.0.1",
+    "@eslint/compat": "^2.0.2",
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.2",
     "@nodarium/types": "workspace:^",
-    "@playwright/test": "^1.59.1",
+    "@playwright/test": "^1.58.1",
     "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/kit": "^2.59.0",
+    "@sveltejs/kit": "^2.50.2",
     "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "@testing-library/svelte": "^5.3.1",
     "@types/eslint": "^9.6.1",
-    "@types/node": "^25.6.0",
-    "@types/three": "^0.184.0",
-    "@typescript-eslint/eslint-plugin": "^8.59.1",
-    "@typescript-eslint/parser": "^8.59.1",
-    "@vitest/browser-playwright": "^4.1.5",
-    "dprint": "^0.54.0",
-    "eslint": "^10.3.0",
-    "eslint-plugin-svelte": "^3.17.1",
-    "globals": "^17.6.0",
-    "publint": "^0.3.18",
-    "svelte": "^5.55.5",
-    "svelte-check": "^4.4.7",
-    "svelte-eslint-parser": "^1.6.0",
+    "@types/three": "^0.182.0",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "@vitest/browser-playwright": "^4.0.18",
+    "dprint": "^0.51.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-svelte": "^3.14.0",
+    "globals": "^17.3.0",
+    "publint": "^0.3.17",
+    "svelte": "^5.49.2",
+    "svelte-check": "^4.3.6",
+    "svelte-eslint-parser": "^1.4.1",
     "tslib": "^2.8.1",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.1",
-    "vite": "^8.0.10",
-    "vitest": "^4.1.5",
-    "vitest-browser-svelte": "^2.1.1"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18",
+    "vitest-browser-svelte": "^2.0.2"
   },
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "dependencies": {
-    "@iconify-json/tabler": "^1.2.33",
-    "@iconify/tailwind4": "^1.2.3",
     "@nodarium/ui": "workspace:*",
-    "@tailwindcss/vite": "^4.2.4",
-    "@threlte/core": "^8.5.11",
-    "@threlte/extras": "^9.15.1",
-    "tailwindcss": "^4.2.4"
+    "@iconify-json/tabler": "^1.2.26",
+    "@iconify/tailwind4": "^1.2.1",
+    "@tailwindcss/vite": "^4.1.18",
+    "@threlte/core": "^8.3.1",
+    "@threlte/extras": "^9.7.1",
+    "tailwindcss": "^4.1.18"
   }
 }

packages/ui/src/lib/Input.svelte

@@ -40,7 +40,7 @@
 {:else if input.type === 'boolean'}
   <InputCheckbox bind:value={value as boolean} {id} />
 {:else if input.type === 'select'}
-  <InputSelect bind:value={value as number} options={input.options} {id} />
+  <InputSelect bind:value={value as number | string} options={input.options} {id} />
 {:else if input.type === 'vec3'}
   <InputVec3 bind:value={value as [number, number, number]} {id} />
 {/if}

packages/ui/src/lib/JsonViewer.svelte

@@ -1,144 +0,0 @@
-<script module lang="ts">
-  // eslint-disable-next-line svelte/prefer-svelte-reactivity
-  const cache = new Map<string, Record<string, boolean>>();
-
-  function getStore(root: string): Record<string, boolean> {
-    if (!cache.has(root)) {
-      try {
-        const raw = localStorage.getItem(`json_viewer:${root}`);
-        cache.set(root, raw ? JSON.parse(raw) : {});
-      } catch {
-        cache.set(root, {});
-      }
-    }
-    return cache.get(root)!;
-  }
-
-  function readOpen(path: string, fallback: boolean): boolean {
-    const root = path.split('/')[0];
-    const store = getStore(root);
-    return path in store ? store[path] : fallback;
-  }
-
-  function writeOpen(path: string, value: boolean) {
-    const root = path.split('/')[0];
-    const store = getStore(root);
-    store[path] = value;
-    try {
-      localStorage.setItem(`json_viewer:${root}`, JSON.stringify(store));
-    } catch { /* quota exceeded etc */ }
-  }
-</script>
-
-<script lang="ts">
-  import { browser } from '$app/environment';
-  import JsonViewer from './JsonViewer.svelte';
-
-  let {
-    value,
-    key,
-    depth = 0,
-    path = ''
-  }: { value: unknown; key?: string; depth?: number; path?: string } = $props();
-
-  const defaultOpen = $derived(depth < 4);
-  let open = $derived(browser && path ? readOpen(path, defaultOpen) : defaultOpen);
-  let flashing = $state(false);
-
-  const isArr = $derived(Array.isArray(value));
-  const isExpandable = $derived(value !== null && typeof value === 'object');
-  const open_bracket = $derived(isArr ? '[' : '{');
-  const close_bracket = $derived(isArr ? ']' : '}');
-  const items = $derived.by(() => {
-    if (isArr) {
-      return (value as unknown[]).map((v, i) => [String(i), v] as [string, unknown]);
-    }
-    if (value !== null && typeof value === 'object') {
-      return Object.entries(value as Record<string, unknown>).filter(
-        ([, v]) => v !== undefined
-      );
-    }
-    return [] as [string, unknown][];
-  });
-  const showKeys = $derived(!isArr || typeof items[0]?.[1] === 'object');
-
-  function toggle(next: boolean) {
-    open = next;
-    if (browser && path) writeOpen(path, next);
-  }
-
-  let prevJson = '';
-  let flashTimeout: ReturnType<typeof setTimeout> | null = null;
-
-  $effect(() => {
-    const json = JSON.stringify(value);
-    if (prevJson && json !== prevJson) {
-      if (flashTimeout) clearTimeout(flashTimeout);
-      flashing = true;
-      flashTimeout = setTimeout(() => {
-        flashing = false;
-        flashTimeout = null;
-      }, 500);
-    }
-    prevJson = json;
-  });
-</script>
-
-<span
-  class="font-mono text-xs leading-[1.6] rounded transition-[background-color] duration-500"
-  class:bg-layer-3={flashing}
->
-  {#if key !== undefined}
-    <button
-      class="text-text hover:bg-layer-3 cursor-pointer"
-      title="Copy value"
-      onclick={() => navigator.clipboard.writeText(JSON.stringify({ [key]: value }, null, 2))}
-    >
-      {key}
-    </button><span class="text-text/40">: </span>
-  {/if}
-
-  {#if isExpandable}
-    {#if items.length === 0}
-      <span class="text-text/50">{open_bracket}{close_bracket}</span>
-    {:else if open}
-      {#if depth > 0}
-        <button class="w-3 text-text/50 hover:text-text" onclick={() => toggle(false)}>
-          ▼
-        </button>
-      {/if}
-      <span class="text-text/50">{open_bracket}</span>
-      <div class="pl-4 border-l border-outline">
-        {#each items as [k, v], i (k)}
-          <div>
-            <JsonViewer
-              value={v}
-              key={showKeys ? k : undefined}
-              depth={depth + 1}
-              path={path ? `${path}/${k}` : k}
-            />{#if i < items.length - 1}<span class="text-text/20">,</span>{/if}
-          </div>
-        {/each}
-      </div>
-      <span class="text-text/50">{close_bracket}</span>
-    {:else}
-      <button
-        class="inline text-text/50 hover:text-text"
-        onclick={() => toggle(true)}
-      >
-        <span class="w-3 inline-block">▶</span>
-        {open_bracket}<span class="text-text/40 mx-1">{items.length}</span>{close_bracket}
-      </button>
-    {/if}
-  {:else if value === null}
-    <span class="text-emerald-500!">null</span>
-  {:else if typeof value === 'boolean'}
-    <span class="text-blue-500!">{value}</span>
-  {:else if typeof value === 'number'}
-    <span class="text-orange-400!">{value}</span>
-  {:else if typeof value === 'string'}
-    <span class="text-emerald-500!">"{value}"</span>
-  {:else}
-    <span class="text-text/70">{String(value)}</span>
-  {/if}
-</span>

packages/ui/src/lib/app.css

@@ -9,7 +9,7 @@
 @source inline("{hover:,}{bg-,outline-,text-,}layer-3{/30,/50,}");
 @source inline("{hover:,}{bg-,outline-,text-,}active");
 @source inline("{hover:,}{bg-,outline-,text-,}selected");
-@source inline("{hover:,}{bg-,outline-,text-,border-,divide-}outline{!,}");
+@source inline("{hover:,}{bg-,outline-,text-,}outline{!,}");
 @source inline("{hover:,}{bg-,outline-,text-,}connection");
 @source inline("{hover:,}{bg-,outline-,text-,}text");
 

packages/ui/src/lib/index.ts

@@ -5,10 +5,8 @@ export { default as InputNumber } from './inputs/InputNumber.svelte';
 export { default as InputSelect } from './inputs/InputSelect.svelte';
 export { default as InputShape } from './inputs/InputShape.svelte';
 export { default as InputVec3 } from './inputs/InputVec3.svelte';
-export { default as SocketTable } from './inputs/SocketTable.svelte';
 
 export { default as Details } from './Details.svelte';
-export { default as JsonViewer } from './JsonViewer.svelte';
 export { default as ShortCut } from './ShortCut.svelte';
 
 import Input from './Input.svelte';

packages/ui/src/lib/inputs/InputSelect.svelte

@@ -1,23 +1,28 @@
 <script lang="ts">
-  type SelectOption = string | { value: number; label: string };
+  type StringOption = string;
+  type LabeledOption = { label: string; value: string };
 
   interface Props {
-    options?: SelectOption[];
-    value?: number;
+    options?: StringOption[] | LabeledOption[];
+    value?: number | string;
     id?: string;
   }
 
-  let { options = [], value = $bindable(0), id = '' }: Props = $props();
+  let { options = [], value = $bindable<number | string>(0), id = '' }: Props = $props();
 
-  const normalized = $derived(
-    options.map((opt, i) => typeof opt === 'string' ? { value: i, label: opt } : opt)
-  );
+  const isLabeled = $derived(options.length > 0 && typeof options[0] === 'object');
 </script>
 
 <select {id} bind:value class="bg-layer-2 text-text">
-  {#each normalized as opt (opt.value)}
-    <option value={opt.value}>{opt.label}</option>
+  {#if isLabeled}
+    {#each options as opt ((opt as LabeledOption).value)}
+      <option value={(opt as LabeledOption).value}>{(opt as LabeledOption).label}</option>
     {/each}
+  {:else}
+    {#each options as label, i (label)}
+      <option value={i}>{label as string}</option>
+    {/each}
+  {/if}
 </select>
 
 <style>

packages/ui/src/lib/inputs/SocketTable.svelte

@@ -1,118 +0,0 @@
-<script lang="ts">
-  import type { NodeInput } from '@nodarium/types';
-  type Props = {
-    inputs?: Record<string, NodeInput>;
-    colors: Record<string, string>;
-    onremove?: (key: string) => void;
-    types: string[];
-  };
-  let { inputs = $bindable(), onremove, colors = {}, types = ['seed', 'float', 'path'] }: Props =
-    $props();
-
-  let potentialRow = $state<
-    {
-      type: string;
-      label: string;
-    } | undefined
-  >();
-
-  function showPotentialRow() {
-    potentialRow = {
-      type: types[0],
-      label: 'Input ' + Object.keys(inputs ?? {}).length
-    };
-  }
-
-  function realizePotentialRow() {
-    if (inputs) inputs[`input_${Object.keys(inputs).length}`] = potentialRow as NodeInput;
-    potentialRow = undefined;
-  }
-
-  function removeRow(key?: string) {
-    if (!key) {
-      potentialRow = undefined;
-    } else if (inputs) {
-      onremove?.(key);
-    }
-  }
-
-  function getColor(type: string) {
-    if (type in colors) {
-      return colors[type];
-    }
-
-    return '#f00';
-  }
-</script>
-
-{#snippet row(input: { type: string; label?: string }, remove: () => void, add?: () => void)}
-  <div class="flex min-w-0">
-    <span
-      style:background={getColor(input.type)}
-      data-type={input.type}
-      class="block opacity-50 min-w-2 ml-2 w-2 h-2 my-auto rounded-sm"
-    ></span>
-    <select
-      class="text-[0.9em] border-r w-19 shrink-0 px-2 py-1 border-outline"
-      bind:value={input.type}
-    >
-      {#each types as type (type)}
-        <option>
-          <span
-            style="background: {getColor(type)}; width: 5px; height: 5px; border-radius: 5px;"
-          ></span>
-          {type}
-        </option>
-      {/each}
-    </select>
-    <input
-      class="px-2 grow min-w-30 border-r border-outline text-[0.9em]"
-      type="text"
-      bind:value={input.label}
-    />
-    <button
-      class="px-2 cursor-pointer opacity-50 hover:opacity-100 hover:bg-red-400"
-      onclick={remove}
-      aria-label="remove"
-    >
-      {#if add}
-        <span class="py-1 block i-[tabler--cancel]"></span>
-      {:else}
-        <span class="py-1 block i-[tabler--trash]"></span>
-      {/if}
-    </button>
-    {#if add}
-      <button
-        class="px-2 border-l hover:bg-green-300 opacity-50 hover:opacity-100 hover:text-layer-1 border-outline cursor-pointer"
-        onclick={add}
-        aria-label="add"
-      >
-        <span class="py-1 block i-[tabler--circle-plus]"></span>
-      </button>
-    {/if}
-  </div>
-{/snippet}
-
-<div class="rounded-sm overflow-hidden bg-layer-2 divide-y divide-outline outline-1 outline-outline">
-  {#each Object.entries(inputs ?? {}) as [key, input] (key)}
-    {@render row(input, () => removeRow(key))}
-  {/each}
-  {#if potentialRow}
-    <div class="opacity-80">
-      {@render row(potentialRow, () => removeRow(), () => realizePotentialRow())}
-    </div>
-  {:else}
-    <div class="opacity-40">
-      <div class="flex h-[27px]">
-        <div class="flex-1"></div>
-        <button
-          class="border-l hover:bg-green-300 hover:text-layer-1 border-outline py-1 px-2 cursor-pointer"
-          onclick={() => showPotentialRow()}
-          aria-label="remove"
-        >
-          <span class="block i-[tabler--circle-plus]"></span>
-        </button>
-      </div>
-    </div>
-  {/if}
-</div>

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

@@ -1,5 +1,4 @@
 <script lang="ts">
-  import type { NodeInput } from '@nodarium/types';
   import '$lib/app.css';
   import {
     Details,
@@ -9,10 +8,8 @@
     InputSelect,
     InputShape,
     InputVec3,
-    JsonViewer,
     ShortCut
   } from '$lib';
-  import SocketTable from '$lib/inputs/SocketTable.svelte';
   import Section from './Section.svelte';
   import Theme from './Theme.svelte';
   import ThemeSelector from './ThemeSelector.svelte';
@@ -23,48 +20,11 @@
   let vecValue = $state([0.2, 0.3, 0.4]);
   const options = ['strawberry', 'raspberry', 'chickpeas'];
   let selectValue = $state(0);
-  let selectValue2 = $state(0);
+  const d = $derived(options[selectValue]);
   let checked = $state(false);
   let colorValue = $state<[number, number, number]>([59, 130, 246]);
   let mirrorShape = $state(true);
   let detailsOpen = $state(false);
-  let jsonValue = $state({
-    id: 1,
-    nodes: [{ id: 0, type: 'max/test/node', position: [0, 0] }, {
-      id: 1,
-      type: 'max/test/other',
-      position: [100, 50]
-    }],
-    edges: [[0, 0, 1, 'input']],
-    groups: [],
-    settings: { seed: 42, enabled: true }
-  });
-
-  let socketTypes: Record<string, NodeInput> = $state({
-    input_0: {
-      'label': 'Input 0',
-      'type': 'path'
-    },
-    input_1: {
-      'label': 'Input 1',
-      'type': 'float'
-    }
-  });
-
-  function randomlyUpdateJson() {
-    const rand = Math.floor(Math.random() * 5);
-    if (rand === 0) {
-      jsonValue.nodes[0].position[0] += 1;
-    } else if (rand === 1) {
-      jsonValue.nodes[0].position[1] += 1;
-    } else if (rand === 2) {
-      jsonValue.settings.seed += 1;
-    } else if (rand === 3) {
-      jsonValue.settings.enabled = !jsonValue.settings.enabled;
-    } else if (rand === 4) {
-      jsonValue.id += Math.floor(Math.random() * 10 - 5);
-    }
-  }
 
   let points = $state([]);
   let theme = $state('dark');
@@ -95,28 +55,8 @@
     <InputVec3 bind:value={vecValue} />
   </Section>
 
-  <Section title="Select">
-    <p>
-      Select with simple values
-      <br>
-      <b>value={options[selectValue]}</b>
-    </p>
+  <Section title="Select" value={d}>
     <InputSelect bind:value={selectValue} {options} />
-    <br>
-    <br>
-    <p>
-      Select with <i>&lbrace;option: number, label: string&rbrace;[]</i>
-      <br>
-      <b>value={selectValue2}</b>
-    </p>
-    <InputSelect
-      bind:value={selectValue2}
-      options={[
-        { value: 0, label: 'Zero' },
-        { value: 1, label: 'One' },
-        { value: 2, label: 'Two' }
-      ]}
-    />
   </Section>
 
   <Section title="Checkbox" value={checked}>
@@ -146,35 +86,6 @@
     </Details>
   </Section>
 
-  <Section title="JsonViewer">
-    {#snippet header()}
-      <button
-        onclick={() => randomlyUpdateJson()}
-        class="-mt-1 bg-layer-2 p-1 px-2 rounded-sm cursor-pointer"
-      >
-        update
-      </button>
-    {/snippet}
-    <div class="w-64 bg-layer-1 p-2 rounded">
-      <JsonViewer
-        value={jsonValue}
-        path="demo"
-      />
-    </div>
-  </Section>
-
-  <Section title="Socket Table">
-    <SocketTable
-      colors={{
-        seed: '#f00',
-        float: '#0f0',
-        path: '#00f'
-      }}
-      types={['seed', 'float', 'path']}
-      bind:inputs={socketTypes}
-    />
-  </Section>
-
   <Section title="Shortcut">
     <div class="flex gap-4">
       <ShortCut ctrl key="S" />

packages/ui/src/routes/ThemeSelector.svelte

@@ -12,7 +12,6 @@
     'custom'
   ];
 
-  // eslint-disable-next-line no-useless-assignment
   let { theme = $bindable() } = $props();
 
   let themeIndex = $state(0);

packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodarium/utils",
-  "version": "0.0.6",
+  "version": "0.0.5",
   "description": "",
   "main": "./src/index.ts",
   "type": "module",
@@ -16,8 +16,8 @@
     "@nodarium/types": "workspace:^"
   },
   "devDependencies": {
-    "dprint": "^0.54.0",
-    "vite": "^8.0.10",
-    "vitest": "^4.1.5"
+    "dprint": "^0.51.1",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
   }
 }

packages/utils/src/logger.ts

@@ -1,60 +1,3 @@
-interface LogEntry {
-  time: string;
-  scope: string;
-  level: string;
-  args: unknown[];
-}
-
-const logBuffer: LogEntry[] = [];
-const startTime = Date.now();
-
-function formatTime(): string {
-  const ms = Date.now() - startTime;
-  const h = Math.floor(ms / 3600000).toString().padStart(2, '0');
-  const m = Math.floor((ms % 3600000) / 60000).toString().padStart(2, '0');
-  const s = Math.floor((ms % 60000) / 1000).toString().padStart(2, '0');
-  const mss = (ms % 1000).toString().padStart(3, '0');
-  return `${h}:${m}:${s}.${mss}`;
-}
-
-function serialize(arg: unknown): string {
-  if (typeof arg === 'string') return arg;
-  try {
-    return JSON.stringify(arg);
-  } catch {
-    return String(arg);
-  }
-}
-
-function formatEntry(entry: LogEntry, scopeWidth: number): string {
-  const scope = `[${entry.scope}]`.padEnd(scopeWidth + 2);
-  const level = entry.level.toUpperCase().padEnd(5);
-  const msg = entry.args.map(serialize).join(' ');
-  return `${entry.time} ${scope} ${level} ${msg}`;
-}
-
-(globalThis as Record<string, unknown>).copyLogs = () => {
-  if (logBuffer.length === 0) {
-    console.log('%c[logger] No log entries to copy', 'color: #888');
-    return;
-  }
-  const scopeWidth = logBuffer.reduce((max, e) => Math.max(max, e.scope.length), 0);
-  const lines = [
-    `=== Log Export (${logBuffer.length} entries) ===`,
-    '',
-    ...logBuffer.map(e => formatEntry(e, scopeWidth))
-  ].join('\n');
-
-  navigator.clipboard.writeText(lines).then(() => {
-    console.log(`%c[logger] Copied ${logBuffer.length} entries to clipboard`, 'color: #4f4');
-  });
-};
-
-(globalThis as Record<string, unknown>).clearLogs = () => {
-  logBuffer.length = 0;
-  console.log('%c[logger] Log buffer cleared', 'color: #888');
-};
-
 export const createLogger = (() => {
   let maxLength = 5;
   return (scope: string) => {
@@ -63,35 +6,18 @@ export const createLogger = (() => {
 
     let isGrouped = false;
 
-    function s(color: string, ...args: unknown[]) {
+    function s(color: string, ...args: any) {
       return isGrouped
         ? [...args]
         : [`[%c${scope.padEnd(maxLength, ' ')}]:`, `color: ${color}`, ...args];
     }
 
-    function record(level: string, args: unknown[]) {
-      logBuffer.push({ time: formatTime(), scope, level, args });
-    }
-
     return {
-      log: (...args: unknown[]) => {
-        record('log', args);
-        !muted && console.log(...s('#888', ...args));
-      },
-      info: (...args: unknown[]) => {
-        record('info', args);
-        !muted && console.info(...s('#888', ...args));
-      },
-      warn: (...args: unknown[]) => {
-        record('warn', args);
-        !muted && console.warn(...s('#888', ...args));
-      },
-      error: (...args: unknown[]) => {
-        record('error', args);
-        console.error(...s('#f88', ...args));
-      },
-      group: (...args: unknown[]) => {
-        record('group', args);
+      log: (...args: any[]) => !muted && console.log(...s('#888', ...args)),
+      info: (...args: any[]) => !muted && console.info(...s('#888', ...args)),
+      warn: (...args: any[]) => !muted && console.warn(...s('#888', ...args)),
+      error: (...args: any[]) => console.error(...s('#f88', ...args)),
+      group: (...args: any[]) => {
         if (!muted) {
           console.groupCollapsed(...s('#888', ...args));
           isGrouped = true;

pnpm-workspace.yaml

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