chore: cleanup changelog

fix: dont crash when no groups exist
fix: make planty work
2026-05-05 22:58:42 +02:00 · 2026-05-05 22:52:24 +02:00 · 2026-05-05 22:45:20 +02:00 · 2026-05-05 20:33:26 +00:00 · 2026-05-05 20:23:21 +00:00 · 2026-05-05 22:08:17 +02:00
53 changed files with 3277 additions and 2625 deletions
@@ -65,6 +65,9 @@ jobs:
      - 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

@@ -1,35 +1,59 @@
 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 countGeometry(result: Int32Array): { totalVertices: number; totalFaces: number } {
+function average(values: number[]) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+
+function countGeometry(result: Int32Array): {
+  totalVertices: number;
+  totalFaces: number;
+} {
  const parts = splitNestedArray(result);
+
  let totalVertices = 0;
  let totalFaces = 0;
+
  for (const part of parts) {
    const type = part[0];
-    const vertexCount = part[1];
-    const faceCount = part[2];
+
+    const vertexCount = part[1] >>> 0;
+    const faceCount = part[2] >>> 0;
+
    if (type === 2) {
-      const instanceCount = part[3];
+      const instanceCount = part[3] >>> 0;
+
      totalVertices += vertexCount * instanceCount;
      totalFaces += faceCount * instanceCount;
    } else {
@@ -37,42 +61,144 @@ function countGeometry(result: Int32Array): { totalVertices: number; totalFaces:
      totalFaces += faceCount;
    }
  }
-  return { totalVertices, totalFaces };
+
+  return {
+    totalVertices,
+    totalFaces
+  };
 }

 async function run(g: GraphType, amount: number) {
-  await registry.load(plantTemplate.nodes.map(n => n.type) as NodeId[]);
+  await registry.load(g.nodes.map(n => n.type) as NodeId[]);
+
  log.log('loaded ' + g.nodes.length + ' nodes');

  log.log('warming up');

-  // Warm up the runtime? maybe this does something?
  for (let index = 0; index < 10; index++) {
    await r.execute(g, { randomSeed: true });
  }

+  const systemSamples: SystemSample[] = [];
+
+  let previousCpuSnapshot = await readCpuSnapshot();
+
+  const sampler = setInterval(async () => {
+    try {
+      const cpu = await measureCpuUsage(previousCpuSnapshot);
+
+      previousCpuSnapshot = cpu.snapshot;
+
+      const [l1, l5, l15] = loadavg();
+
+      systemSamples.push({
+        timestamp: Date.now(),
+
+        cpuUsagePercent: cpu.usagePercent,
+        cpuStealPercent: cpu.stealPercent,
+
+        load1: l1,
+        load5: l5,
+        load15: l15,
+
+        freeMemory: freemem(),
+        totalMemory: totalmem()
+      });
+    } catch (err) {
+      console.error(err);
+    }
+  }, 1000);
+
  log.log('executing');
+
+  const perfStore = createPerformanceStore();
+
  r.perf = perfStore;
-  let res;
+
+  let res: Int32Array | undefined;
+
+  const cgroupBefore = await readCgroupCpuStat();
+
  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 r.perf.get();
+
+  return {
+    data: r.perf.get(),
+    metadata: {
+      timestamp: new Date().toISOString(),
+
+      machine: getMachineInfo(),
+
+      process: {
+        pid: process.pid,
+        uptime: process.uptime(),
+
+        memoryUsage: process.memoryUsage()
+      },
+
+      system: {
+        averages: {
+          cpuUsagePercent: average(
+            systemSamples.map(s => s.cpuUsagePercent)
+          ),
+
+          cpuStealPercent: average(
+            systemSamples.map(s => s.cpuStealPercent)
+          ),
+
+          load1: average(systemSamples.map(s => s.load1)),
+          load5: average(systemSamples.map(s => s.load5)),
+          load15: average(systemSamples.map(s => s.load15)),
+
+          freeMemory: average(
+            systemSamples.map(s => s.freeMemory)
+          )
+        },
+
+        samples: systemSamples,
+
+        meminfo: await readProcMemInfo()
+      },
+
+      cgroup: {
+        before: cgroupBefore,
+        after: cgroupAfter
+      }
+    }
+  };
 }

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

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

-  // await expect(page).toHaveScreenshot();
-  await expect(page.locator('.graph-wrapper')).toHaveScreenshot();
-
  await page.getByRole('button', { name: 'projects' }).click();
  await page.getByRole('button', { name: 'New', exact: true }).click();
  await page.getByRole('combobox').selectOption('2');
@@ -1,13 +1,13 @@
 {
  "name": "@nodarium/app",
  "private": true,
-  "version": "0.0.5",
+  "version": "0.0.6",
  "type": "module",
  "scripts": {
    "dev": "vite dev",
    "predev": "rm static/CHANGELOG.md && ln -s ../../CHANGELOG.md static/CHANGELOG.md",
    "build": "svelte-kit sync && vite build",
-    "test:unit": "vitest",
+    "test:unit": "vitest --browser=false",
    "test": "npm run test:unit -- --run && npm run test:e2e",
    "test:e2e": "playwright test",
    "preview": "vite preview",
@@ -18,49 +18,49 @@
    "bench": "tsx ./benchmark/index.ts"
  },
  "dependencies": {
+    "@nodarium/planty": "workspace:*",
    "@nodarium/ui": "workspace:*",
    "@nodarium/utils": "workspace:*",
-    "@nodarium/planty": "workspace:*",
-    "@sveltejs/kit": "^2.50.2",
-    "@tailwindcss/vite": "^4.1.18",
-    "@threlte/core": "8.3.1",
-    "@threlte/extras": "9.7.1",
+    "@sveltejs/kit": "^2.59.0",
+    "@tailwindcss/vite": "^4.2.4",
+    "@threlte/core": "8.5.11",
+    "@threlte/extras": "9.15.1",
    "comlink": "^4.4.2",
    "file-saver": "^2.0.5",
    "idb": "^8.0.3",
    "jsondiffpatch": "^0.7.3",
    "micromark": "^4.0.2",
-    "tailwindcss": "^4.1.18",
-    "three": "^0.182.0"
+    "tailwindcss": "^4.2.4",
+    "three": "^0.184.0"
  },
  "devDependencies": {
-    "@eslint/compat": "^2.0.2",
-    "@eslint/js": "^9.39.2",
-    "@iconify-json/tabler": "^1.2.26",
-    "@iconify/tailwind4": "^1.2.1",
+    "@eslint/compat": "^2.0.5",
+    "@eslint/js": "^10.0.1",
+    "@iconify-json/tabler": "^1.2.33",
+    "@iconify/tailwind4": "^1.2.3",
    "@nodarium/types": "workspace:^",
-    "@playwright/test": "^1.58.1",
+    "@playwright/test": "^1.59.1",
    "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/vite-plugin-svelte": "^6.2.4",
-    "@tsconfig/svelte": "^5.0.7",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@tsconfig/svelte": "^5.0.8",
    "@types/file-saver": "^2.0.7",
-    "@types/three": "^0.182.0",
-    "@vitest/browser-playwright": "^4.0.18",
-    "dprint": "^0.51.1",
-    "eslint": "^9.39.2",
-    "eslint-plugin-svelte": "^3.14.0",
-    "globals": "^17.3.0",
-    "svelte": "^5.49.2",
-    "svelte-check": "^4.3.6",
+    "@types/three": "^0.184.0",
+    "@vitest/browser-playwright": "^4.1.5",
+    "dprint": "^0.54.0",
+    "eslint": "^10.3.0",
+    "eslint-plugin-svelte": "^3.17.1",
+    "globals": "^17.6.0",
+    "svelte": "^5.55.5",
+    "svelte-check": "^4.4.7",
    "tslib": "^2.8.1",
    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
-    "vite": "^7.3.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.1",
+    "vite": "^8.0.10",
    "vite-plugin-comlink": "^5.3.0",
-    "vite-plugin-glsl": "^1.5.5",
-    "vite-plugin-wasm": "^3.5.0",
-    "vitest": "^4.0.18",
-    "vitest-browser-svelte": "^2.0.2"
+    "vite-plugin-glsl": "^1.6.0",
+    "vite-plugin-wasm": "^3.6.0",
+    "vitest": "^4.1.5",
+    "vitest-browser-svelte": "^2.1.1"
  }
 }
@@ -0,0 +1,75 @@
+<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>
@@ -1,3 +1,4 @@
+import { clone } from '$lib/helpers';
 import throttle from '$lib/helpers/throttle';
 import { RemoteNodeRegistry } from '$lib/node-registry/index';
 import type {
@@ -10,54 +11,27 @@ import type {
  NodeInput,
  NodeInstance,
  NodeRegistry,
+  SerializedEdge,
+  SerializedNode,
  Socket
 } from '@nodarium/types';
 import { fastHashString } from '@nodarium/utils';
 import { createLogger } from '@nodarium/utils';
 import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import EventEmitter from './helpers/EventEmitter';
+import {
+  areEdgesEqual,
+  areSocketsCompatible,
+  serializeEdge,
+  serializeNode
+} from './helpers/nodeHelpers';
 import { HistoryManager } from './history-manager';

-const logger = createLogger('graph-manager');
-logger.mute();
+const log = createLogger('graph-manager');
+log.mute();

 const remoteRegistry = new RemoteNodeRegistry('');

-const clone = 'structuredClone' in self
-  ? self.structuredClone
-  : (args: unknown) => JSON.parse(JSON.stringify(args));
-
-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;
-}
-
-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;
-}
-
 export class GraphManager extends EventEmitter<{
  save: Graph;
  result: unknown;
@@ -69,12 +43,26 @@ export class GraphManager extends EventEmitter<{
  status = $state<'loading' | 'idle' | 'error'>();
  loaded = false;

-  graph: Graph = { id: 0, nodes: [], edges: [], groups: [] };
+  // Snapshots of parent levels we navigated away from. Empty at root.
+  // Entry i has the saved state of depth i (0 = root graph, 1 = first group, …).
+  parentStack: {
+    id: number;
+    nodes: SerializedNode[];
+    edges: SerializedEdge[];
+    nodeId: number; // group instance node id that was entered to reach the next level
+  }[] = $state([]);
+
+  // ID of the currently active group, or null when at the root graph.
+  currentGroupId = $state<number | null>(null);
+
+  // Graph Data
  id = $state(0);
-
+  meta = $state<Graph['meta']>({});
  nodes = new SvelteMap<number, NodeInstance>();
-
  edges = $state<Edge[]>([]);
+  groups: GroupDefinition[] = $state([]);
+
+  nodeArray = $derived(Array.from(this.nodes.values()));

  settingTypes: Record<string, NodeInput> = {};
  settings = $state<Record<string, unknown>>();
@@ -90,6 +78,7 @@ export class GraphManager extends EventEmitter<{
  });

  history: HistoryManager = new HistoryManager();
+
  execute = throttle(() => {
    if (this.loaded === false) return;
    this.emit('result', this.serialize());
@@ -100,46 +89,44 @@ export class GraphManager extends EventEmitter<{
  }

  serialize(): Graph {
-    const nodes = Array.from(this.nodes.values()).map((node) => ({
-      id: node.id,
-      position: [...node.position],
-      type: node.type,
-      props: node.props
-    })) as NodeInstance[];
-    const edges = this.edges.map((edge) => [
-      edge[0].id,
-      edge[1],
-      edge[2].id,
-      edge[3]
-    ]) as Graph['edges'];
-
-    const groups = this.graph.groups?.map((group) => {
-      const groupNodes = group.nodes.map((node) => ({
-        id: node.id,
-        position: [...node.position],
-        type: node.type,
-        props: node.props
-      })) as NodeInstance[];
+    const nodes =
+      (this.parentStack.length === 0 ? Array.from(this.nodes.values()) : this.parentStack[0].nodes)
+        .map(n => serializeNode(n));
+    const edges =
+      (this.parentStack.length === 0 ? Array.from(this.edges.values()) : this.parentStack[0].edges)
+        .map(e => serializeEdge(e));

+    const groups = this.groups?.map((group) => {
+      const isCurrentActive = this.currentGroupId === group.id;
+      const stackState = this.parentStack.find((s) => s.id === group.id);
+      const groupNodes =
+        (isCurrentActive ? [...this.nodes.values()] : stackState?.nodes ?? group.nodes).map(
+          n => serializeNode(n)
+        );
+      const groupEdges =
+        (isCurrentActive ? [...this.edges.values()] : stackState?.edges ?? group.edges).map(
+          e => serializeEdge(e)
+        );
      return {
        id: group.id,
+        name: group.name,
        inputs: group.inputs,
        outputs: group.outputs,
        nodes: groupNodes,
-        edges: group.edges
+        edges: groupEdges
      };
    });

-    const serialized = {
-      id: this.graph.id,
-      settings: $state.snapshot(this.settings),
-      meta: $state.snapshot(this.graph.meta),
+    const serialized = $state.snapshot({
+      id: this.id,
+      settings: this.settings,
+      meta: this.meta,
      groups,
      nodes,
      edges
-    };
-    logger.log('serializing graph', serialized);
-    return clone($state.snapshot(serialized));
+    });
+    log.log('serializing graph', serialized);
+    return clone(serialized);
  }

  private lastSettingsHash = 0;
@@ -203,7 +190,7 @@ export class GraphManager extends EventEmitter<{
    );

    if (!bestInputEntry || bestOutputIdx === -1) {
-      logger.error('Could not find compatible sockets for drop');
+      log.error('Could not find compatible sockets for drop');
      return;
    }

@@ -263,6 +250,28 @@ export class GraphManager extends EventEmitter<{
    });
  }

+  tryConnectToDebugNode(nodeId: number) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return;
+    if (node.type.endsWith('/debug')) return;
+    if (!node.state.type?.outputs?.length) return;
+    let debugNode = this.nodes.values().find(n => n.type.endsWith('/debug'));
+
+    if (!debugNode) {
+      debugNode = this.createNode({
+        type: '__internal/node/debug',
+        position: [node.position[0] + 30, node.position[1]],
+        props: {}
+      });
+    }
+
+    if (debugNode) {
+      this.createEdge(node, 0, debugNode, 'input');
+    }
+
+    return debugNode;
+  }
+
  getEdgesBetweenNodes(nodes: NodeInstance[]): [number, number, number, string][] {
    const edges = [];
    for (const node of nodes) {
@@ -287,23 +296,22 @@ export class GraphManager extends EventEmitter<{
    return edges;
  }

-  private _init(graph: Graph) {
-    const nodes = new SvelteMap(
-      graph.nodes.map((node) => {
-        const nodeType = this.registry.getNode(node.type);
-        const n = node as NodeInstance;
-        if (nodeType) {
-          n.state = {
-            type: nodeType
-          };
+  private _init(
+    graph: { nodes: SerializedNode[]; edges: SerializedEdge[] }
+  ) {
+    this.nodes.clear();
+    for (const node of graph.nodes) {
+      const n = $state(node) as NodeInstance;
+      const registryType = this.registry.getNode(node.type);
+      n.state = registryType ? { type: registryType } : {};
+      const resolvedType = this.getNodeType(n);
+      if (resolvedType) n.state = { type: resolvedType };
+      this.nodes.set(n.id, n);
    }
-        return [node.id, n];
-      })
-    );

    this.edges = graph.edges.map((edge) => {
-      const from = nodes.get(edge[0]);
-      const to = nodes.get(edge[2]);
+      const from = this.nodes.get(edge[0]);
+      const to = this.nodes.get(edge[2]);
      if (!from || !to) {
        throw new Error('Edge references non-existing node');
      }
@@ -314,11 +322,6 @@ export class GraphManager extends EventEmitter<{
      return [from, edge[1], to, edge[3]] as Edge;
    });

-    this.nodes.clear();
-    for (const [id, node] of nodes) {
-      this.nodes.set(id, node);
-    }
-
    this.execute();
  }

@@ -327,11 +330,12 @@ export class GraphManager extends EventEmitter<{

    this.loaded = false;
    graph.groups ??= [];
-    this.graph = graph;
+    this.meta = graph.meta;
+    this.groups = graph.groups;
    this.status = 'loading';
    this.id = graph.id;

-    logger.info(
+    log.info(
      'loading graph',
      { nodes: graph.nodes, edges: graph.edges, id: graph.id }
    );
@@ -346,8 +350,7 @@ export class GraphManager extends EventEmitter<{
            .filter(n => n && 'type' in n)
            .map((n) => n.type)
        )
-      )
-      .filter(n => !n.startsWith('__internal/'));
+      );

    await this.registry.load(nodeIds);

@@ -367,20 +370,7 @@ export class GraphManager extends EventEmitter<{
        });
    }

-    logger.info('loaded node types', this.registry.getAllNodes());
-
-    for (const node of this.graph.nodes) {
-      const nodeType = this.registry.getNode(node.type);
-      if (!nodeType && !node.type.startsWith('__internal/')) {
-        logger.error(`Node type not found: ${node.type}`);
-        this.status = 'error';
-        return;
-      }
-      // Turn into runtime node
-      const n = node as NodeInstance;
-      n.state = {};
-      n.state.type = nodeType;
-    }
+    log.info('loaded node types', this.registry.getAllNodes());

    // load settings
    const settingTypes: Record<
@@ -411,18 +401,18 @@ export class GraphManager extends EventEmitter<{
      }
    }

+    this.parentStack = [];
+    this.currentGroupId = null;
+
    this.settings = settingValues;
    this.emit('settings', { types: settingTypes, values: settingValues });

    this.history.reset();
-    this._init(this.graph);
-
+    this._init(graph);
    this.save();
-
    this.status = 'idle';
-
    this.loaded = true;
-    logger.log(`Graph loaded in ${performance.now() - a}ms`);
+    log.log(`Graph loaded in ${performance.now() - a}ms`);
    setTimeout(() => this.execute(), 100);
  }

@@ -436,29 +426,123 @@ export class GraphManager extends EventEmitter<{
  }

  getNodeType(node: NodeInstance) {
-    // Construct the group inputs on the fly
-    if (node.type === '__internal/group/instance') {
-      const groupDefinition = this.getGroup(node.props?.groupId as number);
-
-      if (!groupDefinition) {
-        logger.error(`Group not found: ${node.props?.groupId}`);
+    if (!node) {
+      console.trace('failed to get node type', { node });
      return;
    }

+    if (node.type === '__internal/group/input') {
+      const group = this.currentGroupId !== null ? this.getGroup(this.currentGroupId) : undefined;
+      if (!group) return node.state.type;
+
+      const groupInputs: NodeDefinition['inputs'] = Object.fromEntries(
+        Object.values(group?.inputs || {}).map((o, i) => {
+          return [`in_${i}`, {
+            ...o,
+            external: true
+          }];
+        }) || []
+      );
+      return {
+        id: '__internal/group/input' as NodeId,
+        meta: {
+          title: 'Group Input'
+        },
+        inputs: groupInputs,
+        execute: (x: Int32Array) => x
+      } as NodeDefinition;
+    }
+
+    if (node.type === '__internal/group/output') {
+      const group = this.currentGroupId !== null ? this.getGroup(this.currentGroupId) : undefined;
+      if (!group) return node.state.type;
+      return {
+        id: '__internal/group/output' as NodeId,
+        inputs: Object.fromEntries(
+          (group.outputs ?? []).map((
+            o,
+            i
+          ) => [`out_${i}`, { type: o.type, label: o.label, external: true }])
+        ),
+        meta: {
+          title: 'Group Output'
+        },
+        outputs: [],
+        execute: (x: Int32Array) => x
+      } as NodeDefinition;
+    }
+
+    // Construct the group inputs on the fly
+    if (node.type === '__internal/group/instance') {
+      const groupId = node.props?.groupId as number;
+      if (!groupId) {
+        return {
+          ...node.state.type,
+          meta: {
+            title: 'Group',
+            ...node?.state?.type?.meta || {}
+          },
+          inputs: {
+            'groupId': {
+              type: 'select',
+              label: '',
+              value: this.groups?.[0]?.id,
+              internal: true,
+              options: this.groups.map((g) => ({
+                value: g.id,
+                label: g.name || `Group#${g.id}`
+              })).filter((g) => {
+                const activeIds = new SvelteSet([
+                  ...this.parentStack.filter(e => e.id !== this.id).map(e => e.id),
+                  ...(this.currentGroupId !== null ? [this.currentGroupId] : [])
+                ]);
+                return !activeIds.has(g.value);
+              })
+            }
+          },
+          outputs: []
+        } as NodeDefinition;
+      }
+
+      const groupDefinition = this.getGroup(node.props?.groupId as number);
+      if (!groupDefinition) {
+        log.error(`Group not found: ${node.props?.groupId}`);
+        return;
+      }
+
+      const defaultInputs = {
+        ...(node.state.type?.inputs || {}),
+        ...groupDefinition?.inputs
+      };
+
+      delete defaultInputs['groupId'];
+
      const inputs = {
        'groupId': {
          type: 'select',
          label: '',
          value: node.props?.groupId,
          internal: true,
-          options: this.graph.groups.map(g => g.id)
+          options: this.groups.map((g) => ({
+            value: g.id,
+            label: g.name || `Group#${g.id}`
+          })).filter((g) => {
+            const activeIds = new SvelteSet([
+              ...this.parentStack.filter(e => e.id !== this.id).map(e => e.id),
+              ...(this.currentGroupId !== null ? [this.currentGroupId] : [])
+            ]);
+            return !activeIds.has(g.value);
+          })
        },
-        ...(node.state.type?.inputs || {}),
-        ...groupDefinition?.inputs
+        ...defaultInputs
      };

      const groupType = {
        ...node.state.type,
+        meta: {
+          title: 'Group',
+          ...node?.state?.type?.meta || {}
+        },
        inputs,
        outputs: groupDefinition?.outputs?.map(o => o.type)
      } as NodeDefinition;
@@ -528,7 +612,7 @@ export class GraphManager extends EventEmitter<{
  }

  removeNode(node: NodeInstance, { restoreEdges = false } = {}) {
-    console.log('REMOVING NODE', $state.snapshot({ node }));
+    log.log('removing node', { id: node.id, type: node.type, restoreEdges });
    const edgesToNode = this.edges.filter((edge) => edge[2].id === node.id);
    const edgesFromNode = this.edges.filter((edge) => edge[0].id === node.id);
    for (const edge of [...edgesToNode, ...edgesFromNode]) {
@@ -573,14 +657,71 @@ export class GraphManager extends EventEmitter<{
  }

  getGroup(id: number) {
-    return this.graph.groups.find(g => g.id === id);
+    return this.groups.find(g => g.id === id);
+  }
+
+  renameGroup(groupId: number, name: string) {
+    log.log('renaming group', { groupId, name });
+    const group = this.getGroup(groupId);
+    if (!group) return;
+    group.name = name;
+    this.save();
+  }
+
+  isInsideGroup = $derived(this.currentGroupId !== null);
+
+  enterGroup(nodeId: number): boolean {
+    const groupNode = this.getNode(nodeId);
+    if (!groupNode || groupNode.type !== '__internal/group/instance') return false;
+
+    log.log('entering group', { nodeId });
+
+    const groupId = groupNode.props?.groupId as number;
+    const group = this.getGroup(groupId);
+    if (!group) return false;
+
+    // Snapshot current level and push it onto the parent stack.
+    this.parentStack.push({
+      id: this.currentGroupId ?? this.id,
+      nodes: [...this.nodes.values()].map(n => serializeNode(n)),
+      edges: [...this.edges.values()].map(e => serializeEdge(e)),
+      nodeId
+    });
+    this.currentGroupId = groupId;
+
+    log.log('entered group', { groupId, depth: this.parentStack.length });
+    this.history.reset();
+    this._init(group);
+    return true;
+  }
+
+  exitGroup() {
+    log.log('exiting group', { depth: this.parentStack.length });
+    if (this.parentStack.length === 0) return;
+
+    // Persist live edits back to the GroupDefinition.
+    const group = this.getGroup(this.currentGroupId!);
+    if (group) {
+      group.nodes = [...this.nodes.values()].map(n => serializeNode(n));
+      group.edges = [...this.edges.values()].map(e => serializeEdge(e));
+    }
+
+    const parent = this.parentStack.pop()!;
+    this.currentGroupId = this.parentStack.length === 0 ? null : parent.id;
+    this._init(parent);
+
+    this.history.reset();
+    this.execute();
+    this.save();
+
+    return { nodeId: parent.nodeId };
  }

  createNodeId() {
    const ids = [
      ...this.nodes.keys(),
-      ...this.graph.groups.map(g => g.id),
-      ...this.graph.groups.flatMap(g => g.nodes.map(n => n.id))
+      ...this.groups.map(g => g.id),
+      ...this.groups.flatMap(g => g.nodes.map(n => n.id))
    ];

    let id = 0;
@@ -633,12 +774,59 @@ export class GraphManager extends EventEmitter<{
    return nodes;
  }

+  getUnusedGroups() {
+    const usedGroupIds = new SvelteSet<number>();
+    const queue: number[] = [];
+
+    // Seed from root-level nodes so outer groups aren't treated as unused when inside a group.
+    const rootNodes = this.parentStack.length > 0
+      ? this.parentStack[0].nodes
+      : [...this.nodes.values()];
+
+    for (const node of rootNodes) {
+      if (node.type === '__internal/group/instance' && node.props?.groupId !== undefined) {
+        queue.push(node.props.groupId as number);
+      }
+    }
+
+    // Also seed from live nodes (may contain new group instances created inside a group).
+    if (this.currentGroupId !== null) {
+      for (const node of this.nodes.values()) {
+        if (node.type === '__internal/group/instance' && node.props?.groupId !== undefined) {
+          queue.push(node.props.groupId as number);
+        }
+      }
+    }
+
+    // Every group on the navigation path is used by definition.
+    for (const entry of this.parentStack) {
+      if (entry.id !== this.id) usedGroupIds.add(entry.id);
+    }
+    if (this.currentGroupId !== null) usedGroupIds.add(this.currentGroupId);
+
+    while (queue.length) {
+      const groupId = queue.pop()!;
+      if (usedGroupIds.has(groupId)) continue;
+      usedGroupIds.add(groupId);
+      const group = this.getGroup(groupId);
+      if (!group) continue;
+      for (const node of group.nodes) {
+        if (node.type === '__internal/group/instance' && node.props?.groupId !== undefined) {
+          const childId = node.props.groupId as number;
+          if (!usedGroupIds.has(childId)) queue.push(childId);
+        }
+      }
+    }
+
+    return this.groups.filter(g => !usedGroupIds.has(g.id));
+  }
+
  removeUnusedGroups() {
-    const usedGroups = new Set(this.getAllNodes().map(n => n.props?.groupId));
-    const unusedGroupAmount = this.graph.groups.length - usedGroups.size;
-    this.graph.groups = this.graph.groups.filter(g => usedGroups.has(g.id));
+    const unused = this.getUnusedGroups();
+    const unusedIds = new SvelteSet(unused.map(g => g.id));
+    this.groups = this.groups.filter(g => !unusedIds.has(g.id));
    this.save();
-    return unusedGroupAmount;
+    return unused.length;
  }

  groupNodes(nodeIds: number[]) {
@@ -646,14 +834,14 @@ export class GraphManager extends EventEmitter<{
    this.removeUnusedGroups();

    const nodes = [
-      ...new Set(nodeIds).values().map(id => this.getNode(id)).filter(Boolean)
+      ...new SvelteSet(nodeIds).values().map(id => this.getNode(id)).filter(Boolean)
    ] as NodeInstance[];

    if (!nodes.length) return;

-    logger.log(`Grouping ${nodes.length} nodes`, { nodes });
+    log.log(`Grouping ${nodes.length} nodes`, { nodes });

-    const ids = new Set(nodes.map(n => n.id));
+    const ids = new SvelteSet(nodes.map(n => n.id));

    // We use the map to dedupe when one external node is connected to multiple internal nodes
    //           ┌──internal_a
@@ -661,31 +849,39 @@ export class GraphManager extends EventEmitter<{
    //           └──internal_b
    // This should only result in one group input not two
    const incomingEdges = this.edges.filter((edge) => ids.has(edge[2].id) && !ids.has(edge[0].id));
-    const groupInputs = new Map<string, Edge>();
+    const groupInputs = new SvelteMap<string, Edge>();
    for (const edge of incomingEdges) {
      groupInputs.set(`${edge[0].id}-${edge[1]}`, edge);
    }

    // And the same for the outputs
    const outgoingEdges = this.edges.filter((edge) => ids.has(edge[0].id) && !ids.has(edge[2].id));
-    const groupOutputs = new Map<string, Edge>();
+    const groupOutputs = new SvelteMap<string, Edge>();
    for (const edge of outgoingEdges) {
      groupOutputs.set(`${edge[2].id}-${edge[3]}`, edge);
    }

    const inputs: Record<string, NodeInput> = {};
    [...groupInputs.values()].forEach((edge, i) => {
+      const internalInputDef = edge[2].state.type?.inputs?.[edge[3]];
      const input = {
-        label: `Input ${i}`,
+        label: internalInputDef?.label ?? edge[3],
        type: edge[0].state.type?.outputs?.[edge[1]] || '*'
      };
      inputs[`input_${i}`] = input as NodeInput;
    });

-    const outputs = [...groupOutputs.values()].map((edge, i) => ({
-      label: `Output ${i}`,
+    const outputs = [];
+    if (groupOutputs.size) {
+      const edge = groupOutputs.values().next().value!;
+      const outputType = edge[0].state.type?.outputs?.[edge[1]] || '*';
+      outputs.push({
+        label: outputType === '*'
+          ? 'Output'
+          : outputType.charAt(0).toUpperCase() + outputType.slice(1),
        type: edge[2].state.type?.inputs?.[edge[3]].type || '*'
-    }));
+      });
+    }

    const groupPosition = [0, 0] as [number, number];
    const bounds: Box = { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity };
@@ -700,35 +896,53 @@ export class GraphManager extends EventEmitter<{
    groupPosition[0] /= nodes.length;
    groupPosition[1] /= nodes.length;

+    // Map from deduped edge source key → group input index, used for both
+    // internal edge wiring and external edge socket naming.
+    const inputIndexByEdgeKey = new SvelteMap<string, number>();
+    [...groupInputs.keys()].forEach((key, i) => inputIndexByEdgeKey.set(key, i));
+
+    // Allocate all needed IDs up front so sequential calls never collide.
+    const usedIds = new SvelteSet<number>([
+      ...this.nodes.keys(),
+      ...this.groups.map(g => g.id),
+      ...this.groups.flatMap(g => g.nodes.map(n => n.id))
+    ]);
+    const nextId = () => {
+      let id = 0;
+      while (usedIds.has(id)) id++;
+      usedIds.add(id);
+      return id;
+    };
+
    const groupInputNode: NodeInstance = {
-      id: this.createNodeId(),
+      id: nextId(),
      type: '__internal/group/input',
      position: [bounds.minX - 50, (bounds.minY + bounds.maxY) / 2],
      state: {}
    };

    const groupOutputNode: NodeInstance = {
-      id: this.createNodeId(),
+      id: nextId(),
      type: '__internal/group/output',
      position: [bounds.maxX + 25, (bounds.minY + bounds.maxY) / 2],
      state: {}
    };

-    // Edges that are inside the group
+    // Edges that are inside the group, routed through boundary nodes at
+    // the correct input/output index for each unique external connection.
    const internalEdges = this.edges.filter((edge) => {
      return ids.has(edge[0].id) || ids.has(edge[2].id);
    }).map((edge) => {
-      // Going in from the group
      if (!ids.has(edge[0].id)) {
-        return [groupInputNode.id, 0, edge[2].id, edge[3]];
-        // Going out to the group
+        const idx = inputIndexByEdgeKey.get(`${edge[0].id}-${edge[1]}`) ?? 0;
+        return [groupInputNode.id, idx, edge[2].id, edge[3]];
      } else if (!ids.has(edge[2].id)) {
-        return [edge[0].id, edge[1], groupOutputNode.id, 'Out'];
+        return [edge[0].id, edge[1], groupOutputNode.id, 'out_0'];
      }
      return [edge[0].id, edge[1], edge[2].id, edge[3]];
    }) as [number, number, number, string][];

-    const groupId = this.createNodeId();
+    const groupId = nextId();
    const groupDefinition: GroupDefinition = {
      id: groupId,
      inputs: inputs,
@@ -737,6 +951,9 @@ export class GraphManager extends EventEmitter<{
      nodes: [groupInputNode, ...nodes, groupOutputNode]
    };

+    // Push before createNode so createNodeId() inside sees the allocated IDs.
+    this.groups.push(groupDefinition);
+
    const groupNode = this.createNode({
      type: '__internal/group/instance',
      position: [groupPosition[0], groupPosition[1]],
@@ -747,20 +964,17 @@ export class GraphManager extends EventEmitter<{

    if (!groupNode) throw new Error('Failed to create group node');

-    // Update the edges that are now inside
-    // the group to be connected to that group node
+    // Rewire external edges to/from the group node using the correct input socket.
    const externalEdges = this.edges.map((edge) => {
      if (ids.has(edge[2].id)) {
-        // Edge going into the group
-        return [edge[0], edge[1], groupNode, 'input_0'] as Edge;
+        const idx = inputIndexByEdgeKey.get(`${edge[0].id}-${edge[1]}`) ?? 0;
+        return [edge[0], edge[1], groupNode, `input_${idx}`] as Edge;
      } else if (ids.has(edge[0].id)) {
-        // Edge going out of the group
        return [groupNode, 0, edge[2], edge[3]] as Edge;
      }
      return edge;
    });

-    this.graph.groups.push(groupDefinition);
    this.nodes.set(groupNode.id, groupNode);
    this.edges = externalEdges;

@@ -769,12 +983,129 @@ export class GraphManager extends EventEmitter<{
      this.removeNode(node);
    }

-    console.log('FINISHED', this.serialize());
    this.saveUndoGroup();

    return groupNode;
  }

+  ungroupNode(nodeId: number) {
+    const groupNode = this.getNode(nodeId);
+    if (!groupNode || groupNode.type !== '__internal/group/instance') return false;
+
+    const groupId = groupNode.props?.groupId as number;
+    const group = this.getGroup(groupId);
+    if (!group) return false;
+
+    log.log('ungrouping node', { groupId, group });
+
+    this.startUndoGroup();
+
+    const edgesToGroup = this.edges.filter(e => e[2].id === nodeId);
+    const edgesFromGroup = this.edges.filter(e => e[0].id === nodeId);
+
+    const groupInputNode = group.nodes.find(n => n.type === '__internal/group/input');
+    const groupOutputNode = group.nodes.find(n => n.type === '__internal/group/output');
+    const internalNodes = group.nodes.filter(
+      n => n.type !== '__internal/group/input' && n.type !== '__internal/group/output'
+    );
+
+    // Offset internal nodes so their average position matches the group node's position
+    let centerX = 0, centerY = 0;
+    for (const n of internalNodes) {
+      centerX += n.position[0];
+      centerY += n.position[1];
+    }
+    const offsetX = internalNodes.length
+      ? groupNode.position[0] - centerX / internalNodes.length
+      : 0;
+    const offsetY = internalNodes.length
+      ? groupNode.position[1] - centerY / internalNodes.length
+      : 0;
+
+    // Allocate new IDs that don't collide with anything in the current graph
+    const usedIds = new SvelteSet<number>([
+      ...this.nodes.keys(),
+      ...this.groups.map(g => g.id),
+      ...this.groups.flatMap(g => g.nodes.map(n => n.id))
+    ]);
+    const nextId = () => {
+      let id = 0;
+      while (usedIds.has(id)) id++;
+      usedIds.add(id);
+      return id;
+    };
+
+    // Map old internal IDs (including boundary nodes) to fresh IDs
+    const idMap = new SvelteMap<number, number>();
+    for (const n of group.nodes) {
+      idMap.set(n.id, nextId());
+    }
+
+    // Instantiate internal nodes and add them to the graph
+    const newNodes: NodeInstance[] = internalNodes.map(n => {
+      const nodeType = this.registry.getNode(n.type);
+      const node: NodeInstance = $state({
+        id: idMap.get(n.id)!,
+        type: n.type,
+        position: [n.position[0] + offsetX, n.position[1] + offsetY] as [number, number],
+        state: { type: nodeType },
+        props: n.props || {}
+      });
+      return node;
+    });
+
+    for (const node of newNodes) {
+      this.nodes.set(node.id, node);
+    }
+
+    // input_X socket on the group node → the external source that was feeding it
+    const inputIdxToExternal = new SvelteMap<number, { node: NodeInstance; socket: number }>();
+    for (const edge of edgesToGroup) {
+      const match = (edge[3] as string).match(/^input_(\d+)$/);
+      if (match) inputIdxToExternal.set(parseInt(match[1]), { node: edge[0], socket: edge[1] });
+    }
+
+    // All external nodes that received output from the group node
+    const externalOutputTargets = edgesFromGroup.map(e => ({ toNode: e[2], toSocket: e[3] }));
+
+    // Recreate internal edges, substituting boundary nodes with the real external peers
+    for (const [fromId, fromSocketIdx, toId, toSocketKey] of group.edges) {
+      let fromNode: NodeInstance | undefined;
+      let resolvedFromSocket = fromSocketIdx;
+
+      if (groupInputNode && fromId === groupInputNode.id) {
+        const ext = inputIdxToExternal.get(fromSocketIdx);
+        if (!ext) continue;
+        fromNode = ext.node;
+        resolvedFromSocket = ext.socket;
+      } else {
+        const newId = idMap.get(fromId);
+        if (newId !== undefined) fromNode = this.nodes.get(newId);
+      }
+
+      if (!fromNode) continue;
+
+      if (groupOutputNode && toId === groupOutputNode.id) {
+        for (const { toNode, toSocket } of externalOutputTargets) {
+          this.createEdge(fromNode, resolvedFromSocket, toNode, toSocket, { applyUpdate: false });
+        }
+      } else {
+        const newToId = idMap.get(toId);
+        if (newToId === undefined) continue;
+        const toNode = this.nodes.get(newToId);
+        if (!toNode) continue;
+        this.createEdge(fromNode, resolvedFromSocket, toNode, toSocketKey, { applyUpdate: false });
+      }
+    }
+
+    // Remove the group instance node (also cleans up its edges)
+    this.removeNode(groupNode);
+
+    this.saveUndoGroup();
+
+    return newNodes;
+  }
+
  createNode({
    type,
    position,
@@ -786,7 +1117,7 @@ export class GraphManager extends EventEmitter<{
  }) {
    const nodeType = this.registry.getNode(type);
    if (!nodeType && !type.startsWith('__internal/')) {
-      logger.error(`Node type not found: ${type}`);
+      log.error(`Node type not found: ${type}`);
      return;
    }

@@ -798,6 +1129,7 @@ export class GraphManager extends EventEmitter<{
      props
    });

+    log.log('creating node', { id: node.id, type, position, props });
    this.nodes.set(node.id, node);

    this.save();
@@ -819,7 +1151,7 @@ export class GraphManager extends EventEmitter<{
      (e) => e[0].id === from.id && e[1] === fromSocket && e[3] === toSocket
    );
    if (existingEdge) {
-      logger.error('Edge already exists', existingEdge);
+      log.error('Edge already exists', existingEdge);
      return;
    }

@@ -827,14 +1159,16 @@ export class GraphManager extends EventEmitter<{
    const toType = this.getNodeType(to);

    // check if socket types match
-    const fromSocketType = fromType?.outputs?.[fromSocket];
+    const fromSocketType = from.type === '__internal/group/input'
+      ? fromType?.inputs?.[Object.keys(fromType?.inputs || {})[fromSocket]].type
+      : fromType?.outputs?.[fromSocket];
    const toSocketType = [toType?.inputs?.[toSocket]?.type];
    if (toType?.inputs?.[toSocket]?.accepts) {
      toSocketType.push(...(toType?.inputs?.[toSocket]?.accepts || []));
    }

    if (!areSocketsCompatible(fromSocketType, toSocketType)) {
-      logger.error(
+      log.error(
        `Socket types do not match: ${fromSocketType} !== ${toSocketType}`
      );
      return;
@@ -849,6 +1183,7 @@ export class GraphManager extends EventEmitter<{

    const edge = [from, fromSocket, to, toSocket] as Edge;

+    log.log('creating edge', { from: from.id, fromSocket, to: to.id, toSocket });
    this.edges.push(edge);

    from.state.children = from.state.children || [];
@@ -865,6 +1200,7 @@ export class GraphManager extends EventEmitter<{
  }

  undo() {
+    log.log('undo');
    const nextState = this.history.undo();
    if (nextState) {
      this._init(nextState);
@@ -873,6 +1209,7 @@ export class GraphManager extends EventEmitter<{
  }

  redo() {
+    log.log('redo');
    const nextState = this.history.redo();
    if (nextState) {
      this._init(nextState);
@@ -900,8 +1237,9 @@ export class GraphManager extends EventEmitter<{
      return;
    }

-    this.emit('save', state);
-    logger.log('saving graphs', state);
+    const fullState = this.serialize();
+    this.emit('save', fullState);
+    log.log('saving graphs', fullState);
  }

  getParentsOfNode(node: NodeInstance) {
@@ -909,7 +1247,7 @@ export class GraphManager extends EventEmitter<{
    const stack = node.state?.parents?.slice(0);
    while (stack?.length) {
      if (parents.length > 1000000) {
-        logger.warn('Infinite loop detected');
+        log.warn('Infinite loop detected');
        break;
      }
      const parent = stack.pop();
@@ -998,7 +1336,9 @@ export class GraphManager extends EventEmitter<{
          }
        });

-      const ownType = nodeType.outputs?.[index];
+      const ownType = node.type === '__internal/group/input'
+        ? nodeType.inputs?.[Object.keys(nodeType?.inputs || {})[index]].type
+        : nodeType.outputs?.[index];

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

-  getEdgeData() {
-    return this.edges;
-  }
-
  updateNodePosition(node: NodeInstance) {
    if (
      node.state.x === node.position[0]
@@ -190,29 +186,6 @@ 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: '__internal/node/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;
@@ -240,6 +213,10 @@ export class GraphState {
    };
  }

+  unGroupSelectedNodes() {
+    return this.graph.ungroupNode(this.activeNodeId);
+  }
+
  groupSelectedNodes() {
    return this.graph.groupNodes([...this.selectedNodes.keys(), this.activeNodeId]);
  }
@@ -362,7 +339,8 @@ export class GraphState {
        for (const node of this.graph.nodes.values()) {
          const x = node.position[0];
          const y = node.position[1];
-          const height = getNodeHeight(this.graph.getNodeType(node)!);
+          const nodeType = this.graph.getNodeType(node);
+          const height = nodeType ? getNodeHeight(nodeType) : 20;
          if (downX > x && downX < x + 20 && downY > y && downY < y + height) {
            clickedNodeId = node.id;
            break;
@@ -374,6 +352,7 @@ export class GraphState {
  }

  isNodeInView(node: NodeInstance) {
+    if (!node) return false;
    const height = getNodeHeight(this.graph.getNodeType(node)!);
    const width = 20;
    return node.position[0] > this.cameraBounds[0] - width
@@ -388,14 +367,33 @@ export class GraphState {

  enterGroupNode() {
    if (this.activeNodeId === -1) return;
-    const selectedNode = this.graph.getNode(this.activeNodeId);
-    if (!selectedNode || selectedNode.type.startsWith('__internal/group/instance')) 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,
@@ -7,6 +7,7 @@
  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';
@@ -95,11 +96,17 @@
    graphState.addMenuPosition = null;
  }

-  function getSocketType(node: NodeInstance, index: number | string, e: unknown): string {
+  function getSocketType(node: NodeInstance, index: number | string): string {
    const nodeType = graph.getNodeType(node);
    if (typeof index === 'string') {
      return nodeType?.inputs?.[index].type || 'unknown';
    }
+
+    if (node.type === '__internal/group/input') {
+      const key = Object.keys(nodeType?.inputs || {})[index];
+      return nodeType?.inputs?.[key].type || 'unknown';
+    }
+
    return nodeType?.outputs?.[index] || 'unknown';
  }
 </script>
@@ -114,6 +121,7 @@
  bind:this={graphState.wrapper}
  class="graph-wrapper"
  style="height: 100%"
+  class:is-inside-group={graph.isInsideGroup}
  class:is-panning={graphState.isPanning}
  class:is-hovering={graphState.hoveredNodeId !== -1}
  aria-label="Graph"
@@ -121,6 +129,7 @@
  tabindex="0"
  bind:clientWidth={graphState.width}
  bind:clientHeight={graphState.height}
+  style:--padding-right="{safePadding?.right || 0}px"
  onkeydown={(ev) => keymap.handleKeyboardEvent(ev)}
  onmousedown={(ev) => mouseEvents.handleMouseDown(ev)}
  oncontextmenu={(ev) => mouseEvents.handleContextMenu(ev)}
@@ -136,6 +145,8 @@
  />
  <label for="drop-zone"></label>

+  <GroupBreadcrumps />
+
  <Canvas shadows={false} renderMode="on-demand" colorManagementEnabled={false}>
    <Camera
      bind:camera={graphState.camera}
@@ -182,8 +193,8 @@
      {#if graphState.activeSocket}
        <EdgeEl
          z={graphState.cameraPosition[2]}
-          inputType={getSocketType(graphState.activeSocket.node, graphState.activeSocket.index, 'c')}
-          outputType={getSocketType(graphState.activeSocket.node, graphState.activeSocket.index, 'd')}
+          inputType={getSocketType(graphState.activeSocket.node, graphState.activeSocket.index)}
+          outputType={getSocketType(graphState.activeSocket.node, graphState.activeSocket.index)}
          x1={graphState.activeSocket.position[0]}
          y1={graphState.activeSocket.position[1]}
          x2={graphState.edgeEndPosition?.[0] ?? graphState.mousePosition[0]}
@@ -196,8 +207,8 @@
        <EdgeEl
          id={graph.getEdgeId(edge)}
          z={graphState.cameraPosition[2]}
-          inputType={getSocketType(edge[0], edge[1], 'a')}
-          outputType={getSocketType(edge[2], edge[3], 'b')}
+          inputType={getSocketType(edge[0], edge[1])}
+          outputType={getSocketType(edge[2], edge[3])}
          {x1}
          {y1}
          {x2}
@@ -216,10 +227,10 @@
          style:transform={`scale(${graphState.cameraPosition[2] * 0.1})`}
          class:hovering-sockets={graphState.activeSocket}
        >
-          {#each graph.getAllNodes() as node (node.id)}
+          {#each graph.nodeArray as node, index (node.id)}
            <NodeEl
-              {node}
-              inView={graphState.isNodeInView(node)}
+              bind:node={graph.nodeArray[index]}
+              inView={node ? graphState.isNodeInView(node) : false}
            />
          {/each}
        </div>
@@ -29,6 +29,7 @@
    graph,
    registry,
    safePadding,
+    // eslint-disable-next-line no-useless-assignment
    settings = $bindable(),
    activeNode = $bindable(),
    backgroundType = $bindable('grid'),
@@ -83,8 +84,8 @@

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

-  $effect(() => {
-    if (graph && (manager.status !== 'idle' || manager.graph.id !== graph.id)) {
+  onMount(() => {
+    if (graph) {
      manager.load(graph);
    }
  });
@@ -2,7 +2,7 @@ type Color = { hue: number; saturation: number; lightness: number };

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

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

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

 export function getParameterHeight(node: NodeDefinition, inputKey: string) {
+  if (node.id === '__internal/group/input') {
+    return 50;
+  }
+
  const input = node.inputs?.[inputKey];
  if (!input) {
    return 0;
@@ -23,17 +33,31 @@ 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]];
+  }
+  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) {
-    console.trace('Node is undefined', node);
+  if (!node || !('inputs' in node)) {
+    return 5;
  }
  if (node.id in nodeHeightCache) {
    return nodeHeightCache[node.id];
  }
-  if (!node?.inputs) {
-    return 5;
-  }
  let height = 5;

  for (const key in node.inputs) {
@@ -44,3 +68,34 @@ export function getNodeHeight(node: NodeDefinition) {
  nodeHeightCache[node.id] = height;
  return height;
 }
+
+export function areSocketsCompatible(
+  output: string | undefined,
+  inputs: string | (string | undefined)[] | undefined
+) {
+  if (output === '*') return true;
+  if (Array.isArray(inputs) && output) {
+    return inputs.includes('*') || inputs.includes(output);
+  }
+  return inputs === output;
+}
+
+export function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
+  if (firstEdge[0].id !== secondEdge[0].id) {
+    return false;
+  }
+
+  if (firstEdge[1] !== secondEdge[1]) {
+    return false;
+  }
+
+  if (firstEdge[2].id !== secondEdge[2].id) {
+    return false;
+  }
+
+  if (firstEdge[3] !== secondEdge[3]) {
+    return false;
+  }
+
+  return true;
+}
@@ -47,6 +47,10 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
    key: 'Escape',
    description: 'Deselect nodes',
    callback: () => {
+      if (graph.isInsideGroup) {
+        graphState.exitGroupNode();
+        return;
+      }
      graphState.activeNodeId = -1;
      graphState.clearSelection();
      graphState.edgeEndPosition = null;
@@ -62,8 +66,17 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
    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()
  });
@@ -19,7 +19,7 @@
  };
  let { node = $bindable(), inView }: Props = $props();

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

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

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

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

-  const height = $derived(getNodeHeight(nodeType));
+  const height = $derived(nodeType ? getNodeHeight(nodeType) : 20);

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

@@ -23,7 +23,17 @@

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

  const path = $derived(
@@ -32,6 +42,7 @@
      height: 34,
      y: 49,
      cornerTop,
+      cornerBottom,
      rightBump,
      aspectRatio
    })
@@ -42,6 +53,7 @@
      height: 40,
      y: 49,
      cornerTop,
+      cornerBottom,
      rightBump,
      aspectRatio
    })
@@ -71,8 +83,9 @@
    {#if appSettings.value.debug.advancedMode}
      <span class="bg-white text-black! mr-2 px-1 rounded-sm opacity-30">{node.id}</span>
    {/if}
-    {node.type.split('/').pop()}
+    {nodeType?.meta?.title || node.type?.split('/').pop()}
  </div>
+  {#if rightBump}
    <div
      class="target"
      role="button"
@@ -80,6 +93,7 @@
      onmousedown={handleMouseDown}
    >
    </div>
+  {/if}
  <svg
    xmlns="http://www.w3.org/2000/svg"
    viewBox="0 0 100 100"
@@ -19,7 +19,7 @@

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

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

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

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

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

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

+  .is-group-input .target {
+    right: 0px;
+    transform: translateY(-50%) translateX(50%);
+  }
+
  .possible-socket .target::before {
    content: "";
    position: absolute;
@@ -4,7 +4,8 @@ export function grid(width: number, height: number) {
  const graph: Graph = {
    id: Math.floor(Math.random() * 100000),
    edges: [],
-    nodes: []
+    nodes: [],
+    groups: []
  };

  const amount = width * height;
@@ -47,6 +47,7 @@ export function tree(depth: number): Graph {
  return {
    id: Math.floor(Math.random() * 100000),
    nodes,
-    edges
+    edges,
+    groups: []
  };
 }
@@ -1,8 +1,12 @@
 export const debugNode = {
-  id: '__internal/debug/instance',
+  id: '__internal/node/debug',
+  meta: {
+    title: 'Debug'
+  },
  inputs: {
    input: {
-      type: '*'
+      type: '*',
+      label: ''
    }
  },
  execute(_data: Int32Array): Int32Array {
@@ -2,7 +2,8 @@ export const groupNode = {
  id: '__internal/group/instance',
  meta: { title: 'Group' },
  inputs: {
-    input: {
+    groupId: {
+      label: '',
      type: 'select',
      values: []
    }
@@ -80,7 +80,6 @@ export function createGeometryPool(parentScene: Group, material: Material) {
    }

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

    if (
      geometry.userData?.faceCount !== faceCount
@@ -1,13 +1,23 @@
+import type { Graph } from '@nodarium/types';
 import { describe, expect, it } from 'vitest';
 import { expandGroups } from './runtime-executor';
-import type { Graph } from '@nodarium/types';

 // 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 } : {}) };
+  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] {
+function edge(
+  from: number,
+  fromSocket: number,
+  to: number,
+  toSocket: string
+): [number, number, number, string] {
  return [from, fromSocket, to, toSocket];
 }

@@ -6,11 +6,42 @@ import type {
  RuntimeExecutor,
  SyncCache
 } from '@nodarium/types';
+import {
+  concatEncodedArrays,
+  createLogger,
+  encodeFloat,
+  fastHashArrayBuffer,
+  type PerformanceStore
+} from '@nodarium/utils';
+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;

-  let nodes = [...graph.nodes];
+  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;
@@ -46,10 +77,16 @@ export function expandGroups(graph: Graph): Graph {
      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) {
-          for (const intEdge of fromInput) {
+          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]]);
          }
@@ -87,17 +124,6 @@ export function expandGroups(graph: Graph): Graph {

  return { ...graph, nodes, edges };
 }
-import {
-  concatEncodedArrays,
-  createLogger,
-  encodeFloat,
-  fastHashArrayBuffer,
-  type PerformanceStore
-} from '@nodarium/utils';
-import type { RuntimeNode } from './types';
-
-const log = createLogger('runtime-executor');
-log.mute();

 function getValue(input: NodeInput, value?: unknown) {
  if (value === undefined && 'value' in input) {
@@ -159,8 +185,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('__virtual/'));
-    await this.registry.load(nonVirtualTypes as any);
+      .filter(t => !t.startsWith('__internal/'));
+    await this.registry.load(nonVirtualTypes);

    const typeMap = new Map<string, NodeDefinition>();
    for (const node of graph.nodes) {
@@ -204,6 +204,13 @@

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

  .first-level.input {
@@ -2,6 +2,7 @@
  import { type Snippet } from 'svelte';
  import { panelState as state } from './PanelState.svelte';

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

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

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

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

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

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

-  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [debugNode]);
+  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [debugNode, groupNode]);
  const workerRuntime = new WorkerRuntimeExecutor();
  const runtimeCache = new MemoryRuntimeCache();
  const memoryRuntime = new MemoryRuntimeExecutor(nodeRegistry, runtimeCache);
@@ -94,7 +96,7 @@
    randomSeed: { type: 'boolean', value: false }
  });
  $effect(() => {
-    if (graphSettings && graphSettingTypes) {
+    if (graphSettings && graphSettingTypes && manager?.loaded) {
      manager?.setSettings($state.snapshot(graphSettings));
    }
  });
@@ -170,6 +172,7 @@
  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,
@@ -177,15 +180,16 @@
      );
    },
    '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 };
-      pm.graph = g;
-      pm.saveGraph(g);
+      manager.load(g);
      graphInterface.state.centerNode(graphInterface.manager.getAllNodes()[0]);
    },
    'open-github-nodes': () => {
+      console.log('open-github-nodes');
      window.open(
        'https://github.com/jim-fx/nodarium/tree/main/nodes/max/plantarium',
        '__blank'
@@ -254,11 +258,12 @@
    </Grid.Cell>
    <Grid.Cell>
      {#if pm.graph}
+        {#key pm.graph.id}
          <GraphInterface
            graph={pm.graph}
            bind:this={graphInterface}
            registry={nodeRegistry}
-          safePadding={{ right: sidebarOpen ? 330 : undefined }}
+            safePadding={{ right: sidebarOpen ? 321 : undefined }}
            backgroundType={appSettings.value.nodeInterface.backgroundType}
            snapToGrid={appSettings.value.nodeInterface.snapToGrid}
            bind:activeNode
@@ -268,6 +273,7 @@
            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]">
@@ -321,7 +327,9 @@
          hidden={!appSettings.value.debug.advancedMode}
          icon="i-[tabler--code]"
        >
-          <GraphSource graph={manager?.serialize()} />
+          {#if manager?.status === 'idle'}
+            <GraphSource graph={manager.serialize()} />
+          {/if}
        </Panel>
        <Panel
          id="benchmark"
@@ -336,12 +344,16 @@
          title="Graph Settings"
          icon="i-[custom--graph] bg-blue-400"
        >
+          <span class="block h-[1px]"></span>
          <NestedSettings
            id="graph-settings"
            type={graphSettingTypes}
            bind:value={graphSettings}
          />
+          {#key activeNode}
            <ActiveNodeSettings {manager} bind:node={activeNode} />
+            <GroupSettings graphState={graphInterface?.state} {manager} bind:node={activeNode} />
+          {/key}
        </Panel>
        <Panel
          id="changelog"
@@ -47,6 +47,7 @@ User Interaction
 ```

 **Event flow:**
+
 1. User edits graph → GraphManager mutates state
 2. GraphManager emits `save` → ProjectManager persists to IndexDB
 3. GraphManager emits `result` → Runtime executes graph → Viewer updates
@@ -56,7 +57,7 @@ User Interaction
 ## Critical Files

 | File                                                   | Role                                                                  |
-|------|------|
+| ------------------------------------------------------ | --------------------------------------------------------------------- |
 | `app/src/routes/+page.svelte`                          | Wires all systems; creates GraphManager, runtime, registry            |
 | `app/src/lib/graph-interface/graph-manager.svelte.ts`  | Central graph logic: createNode, createEdge, serialize, load, history |
 | `app/src/lib/graph-interface/graph-state.svelte.ts`    | UI state: camera, selection, mouse, clipboard, groupSelectedNodes     |
@@ -83,54 +84,56 @@ User Interaction
 ```typescript
 // packages/types/src/types.ts

-type NodeId = `${string}/${string}/${string}` // e.g. "max/plantarium/stem"
+type NodeId = `${string}/${string}/${string}`; // e.g. "max/plantarium/stem"

 type NodeInstance = {
-  id: number
-  type: NodeId
-  position: [number, number]
-  props?: Record<string, number | number[]>  // current parameter values
-  meta?: { title?: string; lastModified?: string }
-  state: NodeRuntimeState   // runtime-only, NOT serialized
-}
+  id: number;
+  type: NodeId;
+  position: [number, number];
+  props?: Record<string, number | number[]>; // current parameter values
+  meta?: { title?: string; lastModified?: string };
+  state: NodeRuntimeState; // runtime-only, NOT serialized
+};

 type NodeRuntimeState = {
-  type?: NodeDefinition     // resolved definition
-  parents?: NodeInstance[]
-  children?: NodeInstance[]
-  x?: number; y?: number    // interpolated position
-  mesh?: Mesh               // Three.js mesh reference
-  ref?: HTMLElement
-}
+  type?: NodeDefinition; // 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
-}
+  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 Edge = [NodeInstance, number, NodeInstance, string];

 type Graph = {
-  nodes: NodeInstance[]
-  edges: [number, number, number, string][]  // serialized (IDs, not refs)
-  settings: Record<string, unknown>
-  groups: GroupDefinition[]
-}
+  nodes: NodeInstance[];
+  edges: [number, number, number, string][]; // serialized (IDs, not refs)
+  settings: Record<string, unknown>;
+  groups: GroupDefinition[];
+};

 type GroupDefinition = {
-  id: number
-  nodes: NodeInstance[]
-  edges: Edge[]
-  inputs?: Record<string, NodeInput>
-  outputs?: string[]
-}
+  id: number;
+  nodes: NodeInstance[];
+  edges: Edge[];
+  inputs?: Record<string, NodeInput>;
+  outputs?: string[];
+};
 ```

 ### NodeInput socket types
+
 `float` | `integer` | `boolean` | `select` | `seed` | `vec3` | `geometry` | `path` | `shape` | `color` | `*` (wildcard)

 Each input can have: `value` (default), `label`, `hidden`, `external`, `setting` (link to graph setting), `accepts` (extra compatible types).
@@ -140,34 +143,43 @@ Each input can have: `value` (default), `label`, `hidden`, `external`, `setting`
 ## 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`.

 ---
@@ -179,7 +191,7 @@ Group selected nodes with **Ctrl+G**. A `GroupDefinition` is stored in `Graph.gr
 **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                                                      |
@@ -20,6 +20,6 @@
  "packageManager": "pnpm@10.28.1+sha512.7d7dbbca9e99447b7c3bf7a73286afaaf6be99251eb9498baefa7d406892f67b879adb3a1d7e687fc4ccc1a388c7175fbaae567a26ab44d1067b54fcb0d6a316",
  "devDependencies": {
    "chokidar-cli": "catalog:",
-    "dprint": "^0.51.1"
+    "dprint": "^0.54.0"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@nodarium/planty",
-  "version": "0.0.1",
+  "version": "0.0.6",
  "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": {
-    "@nodarium/ui": "workspace:*",
-    "@eslint/compat": "^2.0.4",
+    "@eslint/compat": "^2.0.5",
    "@eslint/js": "^10.0.1",
+    "@nodarium/ui": "workspace:*",
    "@sveltejs/adapter-auto": "^7.0.1",
-    "@sveltejs/kit": "^2.57.0",
+    "@sveltejs/kit": "^2.59.0",
    "@sveltejs/package": "^2.5.7",
    "@sveltejs/vite-plugin-svelte": "^7.0.0",
-    "@tailwindcss/vite": "^4.2.2",
-    "@types/node": "^24",
-    "eslint": "^10.2.0",
+    "@tailwindcss/vite": "^4.2.4",
+    "@types/node": "^25.6.0",
+    "eslint": "^10.3.0",
    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-svelte": "^3.17.0",
-    "globals": "^17.4.0",
-    "prettier": "^3.8.1",
+    "eslint-plugin-svelte": "^3.17.1",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.3",
    "prettier-plugin-svelte": "^3.5.1",
-    "prettier-plugin-tailwindcss": "^0.7.2",
+    "prettier-plugin-tailwindcss": "^0.8.0",
    "publint": "^0.3.18",
-    "svelte": "^5.55.2",
-    "svelte-check": "^4.4.6",
-    "tailwindcss": "^4.2.2",
-    "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.1",
-    "vite": "^8.0.7"
+    "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"
  },
  "keywords": [
    "svelte"
@@ -9,7 +9,6 @@
    "skipLibCheck": true,
    "sourceMap": true,
    "strict": true,
-    "module": "NodeNext",
    "moduleResolution": "bundler"
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "@nodarium/types",
-  "version": "0.0.5",
+  "version": "0.0.6",
  "description": "",
  "type": "module",
  "main": "src/index.ts",
@@ -18,9 +18,9 @@
  "author": "",
  "license": "ISC",
  "dependencies": {
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
  },
  "devDependencies": {
-    "dprint": "^0.51.1"
+    "dprint": "^0.54.0"
  }
 }
@@ -8,6 +8,7 @@ export type {
  NodeDefinition,
  NodeId,
  NodeInstance,
+  SerializedEdge,
  SerializedNode,
  Socket
 } from './types';
@@ -61,8 +61,10 @@ export const NodeInputBooleanSchema = z.object({
 export const NodeInputSelectSchema = z.object({
  ...DefaultOptionsSchema.shape,
  type: z.literal('select'),
-  options: z.array(z.string()).optional(),
-  value: z.string().optional()
+  options: z.array(
+    z.union([z.string(), z.object({ value: z.number(), label: z.string() })])
+  ).optional(),
+  value: z.union([z.string(), z.number()]).optional()
 });

 export const NodeInputSeedSchema = z.object({
@@ -76,8 +76,13 @@ export type Socket = {

 export type Edge = [NodeInstance, number, NodeInstance, string];

+const SerializedEdgeSchema = z.tuple([z.number(), z.number(), z.number(), z.string()]);
+
+export type SerializedEdge = z.infer<typeof SerializedEdgeSchema>;
+
 export const GroupSchema = z.object({
  id: z.number(),
+  name: z.string().optional(),
  nodes: z.array(NodeSchema),
  edges: z.array(z.tuple([z.number(), z.number(), z.number(), z.string()])),
  inputs: z.record(z.string(), NodeInputSchema).optional(),
@@ -99,7 +104,7 @@ export const GraphSchema = z.object({
    .optional(),
  settings: z.record(z.string(), z.any()).optional(),
  nodes: z.array(NodeSchema),
-  edges: z.array(z.tuple([z.number(), z.number(), z.number(), z.string()])),
+  edges: z.array(SerializedEdgeSchema),
  groups: z.array(GroupSchema)
 });

@@ -1,6 +1,6 @@
 {
  "name": "@nodarium/ui",
-  "version": "0.0.5",
+  "version": "0.0.6",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
@@ -30,46 +30,47 @@
    "svelte": "^4.0.0"
  },
  "devDependencies": {
-    "@eslint/compat": "^2.0.2",
-    "@eslint/eslintrc": "^3.3.3",
-    "@eslint/js": "^9.39.2",
+    "@eslint/compat": "^2.0.5",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^10.0.1",
    "@nodarium/types": "workspace:^",
-    "@playwright/test": "^1.58.1",
+    "@playwright/test": "^1.59.1",
    "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/kit": "^2.50.2",
+    "@sveltejs/kit": "^2.59.0",
    "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
    "@testing-library/svelte": "^5.3.1",
    "@types/eslint": "^9.6.1",
-    "@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",
+    "@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",
    "tslib": "^2.8.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18",
-    "vitest-browser-svelte": "^2.0.2"
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.1",
+    "vite": "^8.0.10",
+    "vitest": "^4.1.5",
+    "vitest-browser-svelte": "^2.1.1"
  },
  "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:*",
-    "@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"
+    "@tailwindcss/vite": "^4.2.4",
+    "@threlte/core": "^8.5.11",
+    "@threlte/extras": "^9.15.1",
+    "tailwindcss": "^4.2.4"
  }
 }
@@ -1,4 +1,5 @@
-<script module>
+<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> {
@@ -59,7 +60,7 @@
    }
    return [] as [string, unknown][];
  });
-  const showKeys = $derived(!isArr || typeof items[0]?.[1] === "object")
+  const showKeys = $derived(!isArr || typeof items[0]?.[1] === 'object');

  function toggle(next: boolean) {
    open = next;
@@ -88,7 +89,13 @@
  class:bg-layer-3={flashing}
 >
  {#if key !== undefined}
-    <span class="text-text">{key}</span><span class="text-text/40">: </span>
+    <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}
@@ -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-,}outline{!,}");
+@source inline("{hover:,}{bg-,outline-,text-,border-,divide-}outline{!,}");
@source inline("{hover:,}{bg-,outline-,text-,}connection");
@source inline("{hover:,}{bg-,outline-,text-,}text");

@@ -5,6 +5,7 @@ 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';
@@ -1,16 +1,22 @@
 <script lang="ts">
+  type SelectOption = string | { value: number; label: string };
+
  interface Props {
-    options?: string[];
+    options?: SelectOption[];
    value?: number;
    id?: string;
  }

  let { options = [], value = $bindable(0), id = '' }: Props = $props();
+
+  const normalized = $derived(
+    options.map((opt, i) => typeof opt === 'string' ? { value: i, label: opt } : opt)
+  );
 </script>

 <select {id} bind:value class="bg-layer-2 text-text">
-  {#each options as label, i (label)}
-    <option value={i}>{label}</option>
+  {#each normalized as opt (opt.value)}
+    <option value={opt.value}>{opt.label}</option>
  {/each}
 </select>

@@ -0,0 +1,118 @@
+<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>
@@ -1,4 +1,5 @@
 <script lang="ts">
+  import type { NodeInput } from '@nodarium/types';
  import '$lib/app.css';
  import {
    Details,
@@ -11,6 +12,7 @@
    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';
@@ -21,7 +23,7 @@
  let vecValue = $state([0.2, 0.3, 0.4]);
  const options = ['strawberry', 'raspberry', 'chickpeas'];
  let selectValue = $state(0);
-  const d = $derived(options[selectValue]);
+  let selectValue2 = $state(0);
  let checked = $state(false);
  let colorValue = $state<[number, number, number]>([59, 130, 246]);
  let mirrorShape = $state(true);
@@ -38,6 +40,17 @@
    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) {
@@ -82,9 +95,28 @@
    <InputVec3 bind:value={vecValue} />
  </Section>

-  <Section title="Select" value={d}>
-    <i>Select with simple values</i>
+  <Section title="Select">
+    <p>
+      Select with simple values
+      <br>
+      <b>value={options[selectValue]}</b>
+    </p>
    <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}>
@@ -131,6 +163,18 @@
    </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" />
@@ -12,6 +12,7 @@
    'custom'
  ];

+  // eslint-disable-next-line no-useless-assignment
  let { theme = $bindable() } = $props();

  let themeIndex = $state(0);
@@ -1,6 +1,6 @@
 {
  "name": "@nodarium/utils",
-  "version": "0.0.5",
+  "version": "0.0.6",
  "description": "",
  "main": "./src/index.ts",
  "type": "module",
@@ -16,8 +16,8 @@
    "@nodarium/types": "workspace:^"
  },
  "devDependencies": {
-    "dprint": "^0.51.1",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18"
+    "dprint": "^0.54.0",
+    "vite": "^8.0.10",
+    "vitest": "^4.1.5"
  }
 }
@@ -1,3 +1,60 @@
+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) => {
@@ -6,18 +63,35 @@ export const createLogger = (() => {

    let isGrouped = false;

-    function s(color: string, ...args: any) {
+    function s(color: string, ...args: unknown[]) {
      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: 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[]) => {
+      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);
        if (!muted) {
          console.groupCollapsed(...s('#888', ...args));
          isGrouped = true;
@@ -7,6 +7,7 @@ packages:

 catalog:
  chokidar-cli: github:open-cli-tools/chokidar-cli#semver:v4.0.0
+
 onlyBuiltDependencies:
  - "@tailwindcss/oxide"
  - esbuild
Author	SHA1	Message	Date
max	82c2f08a56	chore: cleanup changelog 📊 Benchmark the Runtime / benchmark (push) Successful in 1m34s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 2m7s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 47s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m28s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m59s Details	2026-05-05 22:58:42 +02:00
max	a00db400bb	fix: dont crash when no groups exist 📊 Benchmark the Runtime / benchmark (push) Successful in 1m24s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m24s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 48s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m59s Details 🚀 Lint & Test & Deploy / deploy (push) Has been cancelled Details	2026-05-05 22:52:24 +02:00
max	2d9eb0c087	fix: make planty work 📊 Benchmark the Runtime / benchmark (push) Successful in 1m18s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m9s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 33s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m54s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 2m4s Details	2026-05-05 22:45:20 +02:00
nodarium-bot	1e28ded99b	chore(release): v0.0.6	2026-05-05 20:33:26 +00:00
nodarium-bot	5fae518392	chore(release): v0.0.6	2026-05-05 20:23:21 +00:00
max	954f5726c3	Merge pull request 'feat: initial node groups' (#44 ) from feat/group-node-own into main 📊 Benchmark the Runtime / benchmark (push) Successful in 1m11s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 49s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 2m3s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m14s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 3m4s Details Reviewed-on: #44	2026-05-05 22:08:17 +02:00
max	63d5b8079d	chore: pnpm format 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m39s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m21s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 48s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m51s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Successful in 2m1s Details	2026-05-05 21:55:32 +02:00
max	3e32ca419a	feat: ungroup nodes 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m45s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m7s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 35s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 2m4s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-05 21:51:17 +02:00
max	f0cb12a088	chore: fix some type issues	2026-05-05 21:28:03 +02:00
max	1d60090ffe	chore: fixup graph manager tests	2026-05-05 21:27:53 +02:00
max	5b55056fc1	chore: remove graph element in graphManager	2026-05-05 21:27:42 +02:00
max	e2c2b1a4d7	chore: remove e2e test screenshots (too flaky)	2026-05-05 21:27:23 +02:00
max	7f082ad8f6	feat: implement node sockets ui 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m22s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m6s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Failing after 43s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 2m5s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-05 21:07:57 +02:00
max	ed11195327	chore: refactor graphStack to be simpler	2026-05-05 18:45:54 +02:00
max	8ad62cfc8e	feat: add node group breadcrumbs	2026-05-05 12:44:44 +02:00
max	bff140a764	feat: show different ui when inside group	2026-05-05 11:11:33 +02:00
max	85e2fd1a71	fix: use correct id for debug node	2026-05-04 23:54:43 +02:00
max	5beb03196d	fix: broken format command for @nodarium/planty	2026-05-04 23:47:29 +02:00
max	83e0e47082	refactor: only show group/node panel when selected	2026-05-04 23:47:03 +02:00
max	106797de32	feat: make group input/output node work 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m11s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m7s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 32s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m50s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Successful in 1m56s Details	2026-05-04 19:11:52 +02:00
max	1a56ba986d	damn dude 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m17s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m16s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 49s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m57s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Successful in 2m1s Details	2026-05-04 16:14:20 +02:00
max	703f531cd3	chore: make eslint and playwright happy 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m6s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m0s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 36s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m57s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 16:11:21 +02:00
max	0ed22f20b9	chore: pnpm upgrade 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m42s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 45s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 31s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 1m49s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 16:01:21 +02:00
max	733b0a2ceb	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m4s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m25s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 38s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 2m1s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:49:55 +02:00
max	8f60816c78	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m4s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m30s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 44s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 47s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:43:38 +02:00
max	cd7b51d86a	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m8s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m24s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 41s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 45s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:37:52 +02:00
max	6c9cd1505d	chore: sync sveltekit app before e2e 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m2s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m42s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 32s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 0s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:30:42 +02:00
max	db5ee8ba29	fix: make eslint happy 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m4s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m24s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 30s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 32s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:19:18 +02:00
max	a6b9ca4315	feat: capture system stats in benchmark 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m3s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 52s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 31s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 33s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:12:51 +02:00
max	d4910aba8c	chore: pnpm format 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m2s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m30s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 32s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 33s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 15:00:40 +02:00
max	e695c76490	chore: make eslint happy 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m6s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m7s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 31s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 32s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 14:50:11 +02:00
max	2a54fa7590	feat: add name to groups 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m8s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 45s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Failing after 29s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 34s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 14:12:30 +02:00
max	6d5cac65e8	feat(ui): click-to-copy on node values in jsonviewer	2026-05-04 14:12:17 +02:00
max	3ee074b11c	feat(ui): make inputselect also handle value+label options	2026-05-04 14:12:03 +02:00
max	59a1e63396	feat: add unit tests for graph state	2026-05-04 12:49:30 +02:00
max	317d1552ce	fix: graph correctly restore html refs after exiting node group	2026-05-04 12:49:23 +02:00
max	78439b19e9	fix: make benchmark work	2026-05-04 12:45:06 +02:00
max	ef217b1c40	feat: some updates 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m13s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 44s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Failing after 29s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Failing after 33s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-04 11:27:21 +02:00