fix: make eslint/typescript happy

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

 ## Features
@@ -66,6 +66,7 @@ checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 name = "leaf"
 version = "0.1.0"
 dependencies = [
+ "glam",
 "nodarium_macros",
 "nodarium_utils",
 ]
@@ -117,6 +118,7 @@ dependencies = [
 name = "noise"
 version = "0.1.0"
 dependencies = [
+ "glam",
 "nodarium_macros",
 "nodarium_utils",
 "noise 0.9.0",
@@ -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,7 +1,7 @@
 {
  "name": "@nodarium/app",
  "private": true,
-  "version": "0.0.5",
+  "version": "0.0.6",
  "type": "module",
  "scripts": {
    "dev": "vite dev",
@@ -1,10 +1,12 @@
 <script lang="ts">
  import { appSettings } from '$lib/settings/app-settings.svelte';
-  import { T } from '@threlte/core';
+  import { T, useThrelte } from '@threlte/core';
  import { colors } from '../graph/colors.svelte';
  import BackgroundFrag from './Background.frag';
  import BackgroundVert from './Background.vert';

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

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

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

-  graph: Graph = $state({ 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>();
-  nodeArray = $derived(Array.from(this.nodes.values()));
-
  edges = $state<Edge[]>([]);
+  groups: GroupDefinition[] = $state([]);

-  // Plain array — NOT $state. rootGraph items are plain-serialized (safe for structuredClone).
-  // savedNodes/savedEdges hold live reactive references so reactivity is preserved on exit.
-  graphStack: {
-    rootGraph: Graph;
-    savedNodes: Map<number, NodeInstance>;
-    savedEdges: Edge[];
-    outerGraph: Graph;
-    groupId: number;
-    nodeId: number;
-    cameraPosition: [number, number, number];
-  }[] = [];
+  nodeArray = $derived(Array.from(this.nodes.values()));

  settingTypes: Record<string, NodeInput> = {};
  settings = $state<Record<string, unknown>>();
@@ -104,24 +79,9 @@ export class GraphManager extends EventEmitter<{

  history: HistoryManager = new HistoryManager();

-  public serializeFullGraph(): Graph {
-    if (this.graphStack.length === 0) return this.serialize();
-    let merged = this.serialize();
-    for (let i = this.graphStack.length - 1; i >= 0; i--) {
-      const { rootGraph, groupId } = this.graphStack[i];
-      merged = {
-        ...rootGraph,
-        groups: rootGraph.groups.map(g =>
-          g.id === groupId ? { ...g, nodes: merged.nodes, edges: merged.edges } : g
-        )
-      };
-    }
-    return merged;
-  }
-
  execute = throttle(() => {
    if (this.loaded === false) return;
-    this.emit('result', this.serializeFullGraph());
+    this.emit('result', this.serialize());
  }, 10);

  constructor(public registry: NodeRegistry) {
@@ -129,47 +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;
@@ -233,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;
    }

@@ -339,36 +296,33 @@ export class GraphManager extends EventEmitter<{
    return edges;
  }

-  private _init(graph: Graph) {
-    const nodes = new SvelteMap(
-      graph.nodes.map((node) => {
-        const n = node as NodeInstance;
+  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 };
-        return [node.id, n];
-      })
-    );
+      this.nodes.set(n.id, n);
+    }

-    this.edges = graph.edges.map((edge) => {
-      const from = nodes.get(edge[0]);
-      const to = nodes.get(edge[2]);
+    this.edges = graph.edges.flatMap((edge) => {
+      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');
+        log.warn('Dropping orphaned edge', edge);
+        return [];
      }
      from.state.children = from.state.children || [];
      from.state.children.push(to);
      to.state.parents = to.state.parents || [];
      to.state.parents.push(from);
-      return [from, edge[1], to, edge[3]] as Edge;
+      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();
  }

@@ -377,11 +331,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 }
    );
@@ -396,8 +351,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);

@@ -417,20 +371,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<
@@ -461,18 +402,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);
  }

@@ -492,19 +433,15 @@ export class GraphManager extends EventEmitter<{
    }

    if (node.type === '__internal/group/input') {
-      const groupId = this.graphStack.at(-1)?.groupId;
-      const group = groupId !== undefined ? this.getGroup(groupId) : undefined;
+      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}`,
-            {
+          return [`in_${i}`, {
            ...o,
            external: true
-            }
-          ];
+          }];
        }) || []
      );
      return {
@@ -518,8 +455,7 @@ export class GraphManager extends EventEmitter<{
    }

    if (node.type === '__internal/group/output') {
-      const groupId = this.graphStack.at(-1)?.groupId;
-      const group = groupId !== undefined ? this.getGroup(groupId) : undefined;
+      const group = this.currentGroupId !== null ? this.getGroup(this.currentGroupId) : undefined;
      if (!group) return node.state.type;
      return {
        id: '__internal/group/output' as NodeId,
@@ -539,10 +475,59 @@ export class GraphManager extends EventEmitter<{

    // Construct the group inputs on the fly
    if (node.type === '__internal/group/instance') {
-      const groupDefinition = this.getGroup(node.props?.groupId as number);
+      const groupId = node.props?.groupId as number;

+      let 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);
+      });
+
+      // Handle if multiple groups have the same name, by adding the groupid
+      const groupNames = new SvelteMap<string, number>();
+      for (const o of options) {
+        const value = groupNames.get(o.label) || 0;
+        groupNames.set(o.label, value + 1);
+      }
+      options = options.map(o => {
+        const amount = groupNames.get(o.label) || 0;
+        if (amount > 1) {
+          return {
+            label: `${o.label}#${o.value}`,
+            value: o.value
+          };
+        }
+        return o;
+      });
+
+      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
+            }
+          },
+          outputs: []
+        } as NodeDefinition;
+      }
+
+      const groupDefinition = this.getGroup(node.props?.groupId as number);
      if (!groupDefinition) {
-        logger.error(`Group not found: ${node.props?.groupId}`);
+        log.error(`Group not found: ${node.props?.groupId}`);
        return;
      }

@@ -551,18 +536,15 @@ export class GraphManager extends EventEmitter<{
        ...groupDefinition?.inputs
      };

-      // This is to make sure the the groupId is always first
      delete defaultInputs['groupId'];
+
      const inputs = {
        'groupId': {
          type: 'select',
-          label: 'Group',
+          label: '',
          value: node.props?.groupId,
          internal: true,
-          options: this.graph.groups.map((g, i) => ({
-            value: g.id,
-            label: g.name || `Group ${i + 1}`
-          }))
+          options
        },
        ...defaultInputs
      };
@@ -642,6 +624,7 @@ export class GraphManager extends EventEmitter<{
  }

  removeNode(node: NodeInstance, { restoreEdges = false } = {}) {
+    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]) {
@@ -675,9 +658,9 @@ export class GraphManager extends EventEmitter<{
    const inputs = Object.entries(to.state?.type?.inputs ?? {});
    const outputs = from.state?.type?.outputs ?? [];
    for (let i = 0; i < inputs.length; i++) {
-      const [inputName, input] = inputs[0];
+      const [inputName, input] = inputs[i];
      for (let o = 0; o < outputs.length; o++) {
-        const output = outputs[0];
+        const output = outputs[o];
        if (input.type === output) {
          return this.createEdge(from, o, to, inputName);
        }
@@ -686,82 +669,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 = $state(false);
+  isInsideGroup = $derived(this.currentGroupId !== null);

-  enterGroup(nodeId: number, cameraPosition: [number, number, number]): boolean {
+  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;

-    this.graphStack.push({
-      rootGraph: this.serialize(),
-      savedNodes: new SvelteMap(this.nodes),
-      savedEdges: [...this.edges],
-      outerGraph: this.graph,
-      groupId,
-      nodeId,
-      cameraPosition
+    // 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.graph = { ...this.graph, nodes: group.nodes, edges: group.edges };
-    this._init(this.graph);
+    this.currentGroupId = groupId;
+
+    log.log('entered group', { groupId, depth: this.parentStack.length });
    this.history.reset();
-    this.isInsideGroup = true;
+    this._init(group);
    return true;
  }

-  exitGroup(): { camera: [number, number, number]; nodeId: number } | false {
-    if (!this.graphStack.length) return false;
-    const { savedNodes, savedEdges, outerGraph, groupId, nodeId, cameraPosition } = this.graphStack
-      .pop()!;
-    const internalState = this.serialize();
+  exitGroup() {
+    log.log('exiting group', { depth: this.parentStack.length });
+    if (this.parentStack.length === 0) return;

-    // Clear stale DOM/mesh refs so the remounting components register fresh ones.
-    // The $effect guards in NodeHTML/Node only set these when undefined, so without
-    // this clear they'd keep pointing to the detached elements from before group entry.
-    for (const node of savedNodes.values()) {
-      node.state.ref = undefined;
-      node.state.mesh = undefined;
+    // 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));
    }

-    // Restore live reactive nodes and edges so drag-reactivity is preserved
-    this.nodes.clear();
-    for (const [id, node] of savedNodes) {
-      this.nodes.set(id, node);
-    }
-    this.edges = savedEdges;
-
-    // Patch the group definition with the edited internal graph
-    this.graph = {
-      ...outerGraph,
-      groups: (outerGraph.groups ?? []).map(g =>
-        g.id === groupId ? { ...g, nodes: internalState.nodes, edges: internalState.edges } : g
-      )
-    };
+    const parent = this.parentStack.pop()!;
+    this.currentGroupId = this.parentStack.length === 0 ? null : parent.id;
+    this._init(parent);

    this.history.reset();
-    this.isInsideGroup = this.graphStack.length > 0;
    this.execute();
    this.save();
-    return { camera: cameraPosition, nodeId };
+
+    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;
@@ -771,25 +743,26 @@ export class GraphManager extends EventEmitter<{
    return id;
  }

-  createGraph(nodes: NodeInstance[], edges: [number, number, number, string][]) {
+  createGraph(nodes: SerializedNode[], edges: [number, number, number, string][]) {
    // map old ids to new ids
    const idMap = new SvelteMap<number, number>();

    let startId = this.createNodeId();

-    nodes = nodes.map((node) => {
+    const instances: NodeInstance[] = nodes.map((node) => {
      const id = startId++;
      idMap.set(node.id, id);
      const type = this.registry.getNode(node.type);
      if (!type && !node.type.startsWith('__internal/')) {
        throw new Error(`Node type not found: ${node.type}`);
      }
-      return { ...node, id, tmp: { type } };
+      const registryType = this.registry.getNode(node.type);
+      return { ...node, id, state: { type: registryType } };
    });

    const _edges = edges.map((edge) => {
-      const from = nodes.find((n) => n.id === idMap.get(edge[0]));
-      const to = nodes.find((n) => n.id === idMap.get(edge[2]));
+      const from = instances.find((n) => n.id === idMap.get(edge[0]));
+      const to = instances.find((n) => n.id === idMap.get(edge[2]));

      if (!from || !to) {
        throw new Error('Edge references non-existing node');
@@ -804,22 +777,70 @@ export class GraphManager extends EventEmitter<{
      return [from, edge[1], to, edge[3]] as Edge;
    });

-    for (const node of nodes) {
-      this.nodes.set(node.id, node);
+    for (const node of instances) {
+      const n = $state(node);
+      this.nodes.set(node.id, n);
    }

    this.edges.push(..._edges);

    this.save();
-    return nodes;
+    return instances;
+  }
+
+  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 SvelteSet(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[]) {
@@ -832,7 +853,7 @@ export class GraphManager extends EventEmitter<{

    if (!nodes.length) return;

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

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

@@ -856,17 +877,25 @@ export class GraphManager extends EventEmitter<{

    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 };
@@ -889,8 +918,8 @@ export class GraphManager extends EventEmitter<{
    // Allocate all needed IDs up front so sequential calls never collide.
    const usedIds = new SvelteSet<number>([
      ...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))
    ]);
    const nextId = () => {
      let id = 0;
@@ -937,7 +966,7 @@ export class GraphManager extends EventEmitter<{
    };

    // Push before createNode so createNodeId() inside sees the allocated IDs.
-    this.graph.groups.push(groupDefinition);
+    this.groups.push(groupDefinition);

    const groupNode = this.createNode({
      type: '__internal/group/instance',
@@ -973,6 +1002,124 @@ export class GraphManager extends EventEmitter<{
    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,
@@ -984,7 +1131,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;
    }

@@ -996,6 +1143,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();
@@ -1017,7 +1165,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;
    }

@@ -1034,7 +1182,7 @@ export class GraphManager extends EventEmitter<{
    }

    if (!areSocketsCompatible(fromSocketType, toSocketType)) {
-      logger.error(
+      log.error(
        `Socket types do not match: ${fromSocketType} !== ${toSocketType}`
      );
      return;
@@ -1049,6 +1197,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 || [];
@@ -1065,6 +1214,7 @@ export class GraphManager extends EventEmitter<{
  }

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

  redo() {
+    log.log('redo');
    const nextState = this.history.redo();
    if (nextState) {
      this._init(nextState);
@@ -1089,20 +1240,18 @@ export class GraphManager extends EventEmitter<{
    this.save();
  }

+  private _emitSave = debounce(() => {
+    if (this.nodes.size === 0 && this.edges.length === 0) return;
+    const state = this.serialize();
+    this.emit('save', state);
+    log.log('saving graphs', state);
+  }, 300);
+
  save() {
    if (this.currentUndoGroup) return;
-    const state = this.serialize();
-    this.history.save(state);
-
-    // This is some stupid race condition where the graph-manager emits a save event
-    // when the graph is not fully loaded
-    if (this.nodes.size === 0 && this.edges.length === 0) {
-      return;
-    }
-
-    const fullState = this.graphStack.length > 0 ? this.serializeFullGraph() : state;
-    this.emit('save', fullState);
-    logger.log('saving graphs', fullState);
+    // History snapshot is immediate; the IDB emit is debounced.
+    this.history.save(this.serialize());
+    this._emitSave();
  }

  getParentsOfNode(node: NodeInstance) {
@@ -1110,7 +1259,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();
@@ -1227,6 +1376,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;
@@ -88,7 +88,7 @@ describe('groupSelectedNodes', () => {
    const groupNode = state.groupSelectedNodes();
    assert.isDefined(groupNode);

-    expect(manager.graph.groups.length).toBe(1);
+    expect(manager.groups.length).toBe(1);
  });
 });

@@ -97,7 +97,7 @@ describe('enterGroupNode', () => {
    const { manager, state } = createFixture();
    state.activeNodeId = -1;
    state.enterGroupNode();
-    expect(manager.graphStack.length).toBe(0);
+    expect(manager.parentStack.length).toBe(0);
  });

  it('does nothing when the active node is not a group instance', () => {
@@ -106,7 +106,7 @@ describe('enterGroupNode', () => {
    assert.isDefined(node);
    state.activeNodeId = node!.id;
    state.enterGroupNode();
-    expect(manager.graphStack.length).toBe(0);
+    expect(manager.parentStack.length).toBe(0);
  });

  it('enters the group, pushes graphStack, and clears UI state', () => {
@@ -123,7 +123,7 @@ describe('enterGroupNode', () => {

    state.enterGroupNode();

-    expect(manager.graphStack.length).toBe(1);
+    expect(manager.parentStack.length).toBe(1);
    expect(state.activeNodeId).toBe(-1);
    expect(state.selectedNodes.size).toBe(0);
    expect(manager.isInsideGroup).toBe(true);
@@ -135,30 +135,10 @@ describe('exitGroupNode', () => {
    const { manager, state } = createFixture();
    const before = [...state.cameraPosition];
    state.exitGroupNode();
-    expect(manager.graphStack.length).toBe(0);
+    expect(manager.parentStack.length).toBe(0);
    expect(state.cameraPosition).toEqual(before);
  });

-  it('restores the camera position from before entry', () => {
-    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.cameraPosition = [77, 88, 4];
-
-    state.enterGroupNode();
-    // Simulate camera moving inside the group
-    state.cameraPosition = [0, 0, 1];
-
-    state.exitGroupNode();
-
-    expect(state.cameraPosition).toEqual([77, 88, 4]);
-  });
-
  it('clears activeNodeId and selection after exit', () => {
    const { manager, state } = createFixture();

@@ -1,11 +1,16 @@
-import { animate, lerp } from '$lib/helpers';
-import type { NodeInstance, Socket } from '@nodarium/types';
+import { animate, debounce, lerp } from '$lib/helpers';
+import type { NodeInstance, SerializedEdge, SerializedNode, Socket } from '@nodarium/types';
 import { getContext, setContext } from 'svelte';
 import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import type { OrthographicCamera, Vector3 } from 'three';
 import type { GraphManager } from './graph-manager.svelte';
 import { ColorGenerator } from './graph/colors';
-import { getNodeHeight, getParameterHeight } from './helpers/nodeHelpers';
+import {
+  getNodeHeight,
+  getParameterHeight,
+  serializeEdge,
+  serializeNode
+} from './helpers/nodeHelpers';

 const graphStateKey = Symbol('graph-state');
 export function getGraphState() {
@@ -57,12 +62,20 @@ export class GraphState {
  colors = new ColorGenerator(predefinedColors);

  constructor(private graph: GraphManager) {
-    $effect.root(() => {
-      $effect(() => {
+    const saveCameraPosition = debounce(() => {
      localStorage.setItem(
        'cameraPosition',
        `[${this.cameraPosition[0]},${this.cameraPosition[1]},${this.cameraPosition[2]}]`
      );
+    }, 500);
+
+    $effect.root(() => {
+      $effect(() => {
+        // Read values to subscribe to reactivity, then flush lazily.
+        void this.cameraPosition[0];
+        void this.cameraPosition[1];
+        void this.cameraPosition[2];
+        saveCameraPosition();
      });
    });
    const storedPosition = localStorage.getItem('cameraPosition');
@@ -95,8 +108,8 @@ export class GraphState {
  cameraPosition: [number, number, number] = $state([140, 100, 3.5]);

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

  cameraBounds = $derived([
@@ -152,15 +165,11 @@ export class GraphState {
    this.edges.delete(edgeId);
  }

-  updateNodePosition(node: NodeInstance) {
-    if (
-      node.state.x === node.position[0]
-      && node.state.y === node.position[1]
-    ) {
-      delete node.state.x;
-      delete node.state.y;
-    }
+  private _dirtyPositions = new SvelteSet<NodeInstance>();
+  private _positionFlushPending = false;

+  private _flushPositions() {
+    for (const node of this._dirtyPositions) {
      if (node.state['x'] !== undefined && node.state['y'] !== undefined) {
        if (node.state.ref) {
          node.state.ref.style.setProperty('--nx', `${node.state.x * 10}px`);
@@ -173,6 +182,25 @@ export class GraphState {
        }
      }
    }
+    this._dirtyPositions.clear();
+    this._positionFlushPending = false;
+  }
+
+  updateNodePosition(node: NodeInstance) {
+    if (
+      node.state.x === node.position[0]
+      && node.state.y === node.position[1]
+    ) {
+      delete node.state.x;
+      delete node.state.y;
+    }
+
+    this._dirtyPositions.add(node);
+    if (!this._positionFlushPending) {
+      this._positionFlushPending = true;
+      requestAnimationFrame(() => this._flushPositions());
+    }
+  }

  getSnapLevel() {
    const z = this.cameraPosition[2];
@@ -190,12 +218,10 @@ export class GraphState {
    if (this.activeNodeId === -1 && !this.selectedNodes?.size) {
      return;
    }
-    let nodes = [
-      this.activeNodeId,
-      ...(this.selectedNodes?.values() || [])
-    ]
+    const ids = new SvelteSet([this.activeNodeId, ...(this.selectedNodes?.values() || [])]);
+    let nodes = [...ids]
      .map((id) => this.graph.getNode(id))
-      .filter(b => !!b);
+      .filter((b): b is NodeInstance => !!b);

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

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

+  unGroupSelectedNodes() {
+    return this.graph.ungroupNode(this.activeNodeId);
+  }
+
  groupSelectedNodes() {
    return this.graph.groupNodes([...this.selectedNodes.keys(), this.activeNodeId]);
  }
@@ -251,13 +280,16 @@ export class GraphState {
  pasteNodes() {
    if (!this.clipboard) return;

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

    const newNodes = this.graph.createGraph(nodes, this.clipboard.edges);
    this.selectedNodes.clear();
@@ -365,7 +397,7 @@ export class GraphState {
    if (this.activeNodeId === -1) return;
    const node = this.graph.getNode(this.activeNodeId);
    if (!node || node.type !== '__internal/group/instance') return;
-    const ok = this.graph.enterGroup(this.activeNodeId, [...this.cameraPosition]);
+    const ok = this.graph.enterGroup(this.activeNodeId);
    if (ok) {
      this.activeNodeId = -1;
      this.clearSelection();
@@ -375,7 +407,6 @@ export class GraphState {
  exitGroupNode() {
    const result = this.graph.exitGroup();
    if (!result) return;
-    this.cameraPosition = result.camera;
    this.activeNodeId = result.nodeId;
    this.clearSelection();
  }
@@ -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';
@@ -15,6 +16,7 @@
  import { maxZoom, minZoom } from './constants';
  import { FileDropEventManager } from './drop.events';
  import { MouseEventManager } from './mouse.events';
+  import ZoomIndicator from './ZoomIndicator.svelte';

  const {
    keymap,
@@ -108,14 +110,6 @@

    return nodeType?.outputs?.[index] || 'unknown';
  }
-
-  function getGroupName() {
-    const groupId = graph.graphStack.at(-1)?.groupId;
-    if (groupId !== undefined) {
-      const group = graph.getGroup(groupId);
-      return group?.name || `Group#${groupId}`;
-    }
-  }
 </script>

 <svelte:window
@@ -142,7 +136,6 @@
  oncontextmenu={(ev) => mouseEvents.handleContextMenu(ev)}
  {...fileDropEvents.getEventListenerProps()}
 >
-  <div class="shadow"></div>
  <input
    type="file"
    accept="application/wasm,application/json"
@@ -153,14 +146,7 @@
  />
  <label for="drop-zone"></label>

-  {#if graph.isInsideGroup}
-    <button class="exit-group" onclick={() => graphState.exitGroupNode()}>
-      ↑ Exit Group
-    </button>
-    <p class="group-name absolute">
-      Group <b>{getGroupName()}</b>
-    </p>
-  {/if}
+  <GroupBreadcrumps />

  <Canvas shadows={false} renderMode="on-demand" colorManagementEnabled={false}>
    <Camera
@@ -242,7 +228,7 @@
          style:transform={`scale(${graphState.cameraPosition[2] * 0.1})`}
          class:hovering-sockets={graphState.activeSocket}
        >
-          {#each graph.nodeArray as node, index (node.id)}
+          {#each graph.nodeArray as node, index (node)}
            <NodeEl
              bind:node={graph.nodeArray[index]}
              inView={node ? graphState.isNodeInView(node) : false}
@@ -262,6 +248,8 @@
  <HelpView registry={graph.registry} />
 {/if}

+<ZoomIndicator {safePadding} />
+
 <style>
  .graph-wrapper {
    position: relative;
@@ -270,34 +258,6 @@
    height: 100%;
  }

-  .group-name {
-    position: absolute;
-    left: calc(50% - var(--padding-right) / 2);
-    transition: left 0.3s ease;
-    top: 12px;
-    transform: translateX(-50%);
-    z-index: 1000;
-  }
-
-  .exit-group {
-    position: absolute;
-    top: 12px;
-    left: 12px;
-    z-index: 1000;
-    padding: 4px 12px;
-    background: var(--color-layer-2);
-    border: 1px solid var(--stroke);
-    border-radius: 4px;
-    color: inherit;
-    font-size: 0.85em;
-    cursor: pointer;
-    opacity: 0.85;
-  }
-
-  .exit-group:hover {
-    opacity: 1;
-  }
-
  .wrapper {
    position: absolute;
    z-index: 100;
@@ -309,22 +269,6 @@
    cursor: pointer;
  }

-  .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;
-  }
-
-  .is-inside-group .shadow {
-    box-shadow: 0 0 0px 8px var(--color-layer-2) inset;
-  }
-
  .is-panning {
    cursor: grab;
  }
@@ -1,6 +1,7 @@
 <script lang="ts">
  import { createKeyMap } from '$lib/helpers/createKeyMap';
  import type { Graph, NodeInstance, NodeRegistry } from '@nodarium/types';
+  import { onMount } from 'svelte';
  import { GraphManager } from '../graph-manager.svelte';
  import { GraphState, setGraphManager, setGraphState } from '../graph-state.svelte';
  import { setupKeymaps } from '../keymaps';
@@ -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);
    }
  });
@@ -0,0 +1,52 @@
+<script lang="ts">
+  import { getGraphState } from '../graph-state.svelte';
+
+  const { safePadding }: {
+    safePadding?: { left?: number; right?: number; bottom?: number; top?: number };
+  } = $props();
+
+  const graphState = getGraphState();
+</script>
+
+<div class="zoom-indicator" style:right="calc({safePadding?.right ?? 0}px + 10px)">
+  <button
+    class="fit-btn"
+    title="Fit to view (.)"
+    onclick={() => graphState.centerNode()}
+    aria-label="Fit nodes to view"
+  >
+    ⊡
+  </button>
+  <span>{Math.round(graphState.cameraPosition[2] * 10)}%</span>
+</div>
+
+<style>
+  .zoom-indicator {
+    position: absolute;
+    bottom: 10px;
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    font-family: var(--font-family);
+    font-size: 0.75em;
+    color: var(--color-text);
+    opacity: 0.35;
+    z-index: 10;
+    transition: opacity 0.15s, right 0.2s;
+    pointer-events: auto;
+  }
+
+  .zoom-indicator:hover {
+    opacity: 0.9;
+  }
+
+  .fit-btn {
+    background: none;
+    border: none;
+    color: inherit;
+    cursor: pointer;
+    font-size: 1.1em;
+    line-height: 1;
+    padding: 0;
+  }
+</style>
@@ -2,7 +2,7 @@ type Color = { hue: number; saturation: number; lightness: number };

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

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

+  public getColors() {
+    return Object.fromEntries(
+      this.colors.entries().map(([key, col]) => {
+        return [key, this.colorToHsl(col)];
+      })
+    );
+  }
+
  public getColor(id: string): string {
    if (this.colors.has(id)) {
      return this.colorToHsl(this.colors.get(id)!);
@@ -1,4 +1,5 @@
 import { GraphSchema, type NodeId } from '@nodarium/types';
+import { toast } from '@nodarium/ui';
 import type { GraphManager } from '../graph-manager.svelte';
 import type { GraphState } from '../graph-state.svelte';

@@ -41,6 +42,9 @@ export class FileDropEventManager {
          props,
          position: pos
        });
+      }).catch((e) => {
+        toast(`Failed to load node: ${nodeId}`, 'error');
+        console.error(e);
      });
    } else if (event.dataTransfer.files.length) {
      const file = event.dataTransfer.files[0];
@@ -65,8 +69,13 @@ export class FileDropEventManager {
        reader.onload = (e) => {
          const buffer = e.target?.result as ArrayBuffer;
          if (buffer) {
+            try {
              const state = GraphSchema.parse(JSON.parse(buffer.toString()));
              this.graph.load(state);
+            } catch (e) {
+              toast('Failed to load graph: invalid file', 'error');
+              console.error(e);
+            }
          }
        };
        reader.readAsText(file);
@@ -9,6 +9,7 @@ import { EdgeInteractionManager } from './edge.events';

 export class MouseEventManager {
  edgeInteractionManager: EdgeInteractionManager;
+  private pendingSelectionFrame = false;

  constructor(
    private graph: GraphManager,
@@ -282,6 +283,11 @@ export class MouseEventManager {
    if (this.state.boxSelection) {
      event.preventDefault();
      event.stopPropagation();
+      if (!this.pendingSelectionFrame) {
+        this.pendingSelectionFrame = true;
+        requestAnimationFrame(() => {
+          this.pendingSelectionFrame = false;
+          if (!this.state.mouseDown) return;
          const mouseD = this.state.projectScreenToWorld(
            this.state.mouseDown[0],
            this.state.mouseDown[1]
@@ -301,6 +307,8 @@ export class MouseEventManager {
              this.state.selectedNodes?.delete(node.id);
            }
          }
+        });
+      }
      return;
    }

@@ -1,4 +1,10 @@
-import type { NodeDefinition } 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') {
@@ -27,6 +33,23 @@ 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 ? JSON.parse(JSON.stringify(node.props)) : undefined
+  };
+}
+
+export function serializeEdge(edge: SerializedEdge | Edge): SerializedEdge {
+  if (typeof edge[0] === 'number' && typeof edge[2] === 'number') {
+    return [edge[0], edge[1], edge[2], edge[3]];
+  }
+  const e = edge as Edge;
+  return [e[0].id, e[1], e[2].id, e[3]];
+}
+
 const nodeHeightCache: Record<string, number> = {};
 export function getNodeHeight(node: NodeDefinition) {
  if (!node || !('inputs' in node)) {
@@ -45,3 +68,34 @@ export function getNodeHeight(node: NodeDefinition) {
  nodeHeightCache[node.id] = height;
  return height;
 }
+
+export function areSocketsCompatible(
+  output: string | undefined,
+  inputs: string | (string | undefined)[] | undefined
+) {
+  if (output === '*') return true;
+  if (Array.isArray(inputs) && output) {
+    return inputs.includes('*') || inputs.includes(output);
+  }
+  return inputs === output;
+}
+
+export function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
+  if (firstEdge[0].id !== secondEdge[0].id) {
+    return false;
+  }
+
+  if (firstEdge[1] !== secondEdge[1]) {
+    return false;
+  }
+
+  if (firstEdge[2].id !== secondEdge[2].id) {
+    return false;
+  }
+
+  if (firstEdge[3] !== secondEdge[3]) {
+    return false;
+  }
+
+  return true;
+}
@@ -1,5 +1,6 @@
 import type { createKeyMap } from '$lib/helpers/createKeyMap';
 import { panelState } from '$lib/sidebar/PanelState.svelte';
+import { toast } from '@nodarium/ui';
 import FileSaver from 'file-saver';
 import type { GraphManager } from './graph-manager.svelte';
 import type { GraphState } from './graph-state.svelte';
@@ -66,6 +67,14 @@ 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,
@@ -138,6 +147,7 @@ export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: Gr
        type: 'application/json;charset=utf-8'
      });
      FileSaver.saveAs(blob, 'nodarium-graph.json');
+      toast('Graph downloaded', 'success', 1500);
    }
  });

@@ -26,6 +26,13 @@
  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;

@@ -35,6 +42,7 @@
      height: 34,
      y: 49,
      cornerTop,
+      cornerBottom,
      rightBump,
      aspectRatio
    })
@@ -45,6 +53,7 @@
      height: 40,
      y: 49,
      cornerTop,
+      cornerBottom,
      rightBump,
      aspectRatio
    })
@@ -1,11 +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: []
    }
@@ -136,12 +136,14 @@ export class RemoteNodeRegistry implements NodeRegistry {
  }

  async register(id: string, wasmBuffer: ArrayBuffer) {
-    let wrapper: ReturnType<typeof createWasmWrapper> = null!;
+    const wrapper = (() => {
      try {
-      wrapper = createWasmWrapper(wasmBuffer);
+        return createWasmWrapper(wasmBuffer);
      } catch (error) {
        console.error(`Failed to create node wrapper for node: ${id}`, error);
+        throw error;
      }
+    })();

    const rawDefinition = wrapper.get_definition();
    const definition = NodeDefinitionSchema.safeParse(rawDefinition);
@@ -1,7 +1,7 @@
 <script lang="ts">
  import { defaultPlant, lottaFaces, plant, simple } from '$lib/graph-templates';
  import type { Graph } from '$lib/types';
-  import { InputSelect } from '@nodarium/ui';
+  import { Button, ConfirmDialog, InputSelect, Spinner } from '@nodarium/ui';
  import type { ProjectManager } from './project-manager.svelte';

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

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

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

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

  constructor() {
    this.init();
  }

  async saveGraph(g: Graph) {
-    db.saveGraph(g);
+    await db.saveGraph(g);
  }

  private async init() {
@@ -32,7 +32,7 @@ function writePath(scene: Group, data: Int32Array): Vector3[] {

  // Instanced spheres at points
  if (positions.length > 0) {
-    const sphereGeometry = new SphereGeometry(0.05, 8, 8); // keep low-poly
+    const sphereGeometry = new SphereGeometry(0.02, 8, 8); // keep low-poly
    const sphereMaterial = new MeshBasicMaterial({
      color: 0xff0000,
      depthTest: false
@@ -207,6 +207,7 @@ export function createInstancedGeometryPool(
      existingInstance
      && instanceCount > existingInstance.geometry.userData.count
    ) {
+      existingInstance.geometry.dispose();
      scene.remove(existingInstance);
      instances.splice(instances.indexOf(existingInstance), 1);
      existingInstance = new InstancedMesh(geometry, material, instanceCount);
@@ -1,18 +0,0 @@
-import type { Graph, RuntimeExecutor } from '@nodarium/types';
-
-export class RemoteRuntimeExecutor implements RuntimeExecutor {
-  constructor(private url: string) {}
-
-  async execute(graph: Graph, settings: Record<string, unknown>): Promise<Int32Array> {
-    const res = await fetch(this.url, {
-      method: 'POST',
-      body: JSON.stringify({ graph, settings })
-    });
-
-    if (!res.ok) {
-      throw new Error(`Failed to execute graph`);
-    }
-
-    return new Int32Array(await res.arrayBuffer());
-  }
-}
@@ -21,6 +21,26 @@ log.mute();
 export function expandGroups(graph: Graph): Graph {
  if (!graph.groups || graph.groups.length === 0) return graph;

+  function groupContainsSelf(groupId: number, visited = new Set<number>()): boolean {
+    if (visited.has(groupId)) return true;
+    visited.add(groupId);
+    const group = graph.groups!.find(g => g.id === groupId);
+    if (!group) return false;
+    for (const n of group.nodes) {
+      if (n.type === '__internal/group/instance') {
+        const nestedId = n.props?.groupId as number | undefined;
+        if (nestedId !== undefined && groupContainsSelf(nestedId, visited)) return true;
+      }
+    }
+    return false;
+  }
+
+  for (const group of graph.groups) {
+    if (groupContainsSelf(group.id)) {
+      throw new Error(`Circular group reference: group ${group.id} contains itself`);
+    }
+  }
+
  const nodes = [...graph.nodes];
  let edges = [...graph.edges];

@@ -57,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]]);
          }
@@ -108,6 +134,15 @@ function getValue(input: NodeInput, value?: unknown) {
    return encodeFloat(value as number);
  }

+  if (input.type === 'select' && typeof value !== 'number') {
+    const index = input.options?.indexOf(value as string);
+    if (index === undefined || index < 0) {
+      // Defaultl to the first option
+      return 0;
+    }
+    return index;
+  }
+
  if (Array.isArray(value)) {
    if (input.type === 'vec3' || input.type === 'shape') {
      return [
@@ -133,6 +168,8 @@ function getValue(input: NodeInput, value?: unknown) {
    return value;
  }

+  console.log({ input, value });
+
  throw new Error(`Unknown input type ${input.type}`);
 }

@@ -147,9 +184,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
  constructor(
    private registry: NodeRegistry,
    public cache?: SyncCache<Int32Array>
-  ) {
-    this.cache = undefined;
-  }
+  ) {}

  private async getNodeDefinitions(graph: Graph) {
    if (this.registry.status !== 'ready') {
@@ -373,7 +408,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
        log.groupEnd();
      } catch (e) {
        log.groupEnd();
-        log.error(`Error executing node ${node_type.id || node.id}`, e);
+        throw e;
      }
    }

@@ -2,6 +2,7 @@ import { debugNode } from '$lib/node-registry/debugNode';
 import { IndexDBCache, RemoteNodeRegistry } from '$lib/node-registry/index';
 import type { Graph } from '@nodarium/types';
 import { createPerformanceStore } from '@nodarium/utils';
+import * as Comlink from 'comlink';
 import { MemoryRuntimeExecutor } from './runtime-executor';
 import { MemoryRuntimeCache } from './runtime-executor-cache';

@@ -38,6 +39,9 @@ export async function executeGraph(
  performanceStore.startRun();
  const res = await executor.execute(graph, settings);
  performanceStore.stopRun();
+  if (res?.buffer) {
+    return Comlink.transfer(res, [res.buffer]);
+  }
  return res;
 }

@@ -12,8 +12,8 @@ export class WorkerRuntimeExecutor implements RuntimeExecutor {
  getPerformanceData() {
    return this.worker.getPerformanceData();
  }
-  getDebugData() {
-    return this.worker.getDebugData();
+  async getDebugData() {
+    return await this.worker.getDebugData();
  }
  set useRuntimeCache(useCache: boolean) {
    this.worker.setUseRuntimeCache(useCache);
@@ -1,7 +1,7 @@
 <script lang="ts">
  import { localState } from '$lib/helpers/localState.svelte';
  import type { NodeInput } from '@nodarium/types';
-  import Input from '@nodarium/ui';
+  import Input, { Button as UiButton } from '@nodarium/ui';
  import { onMount } from 'svelte';
  import NestedSettings from './NestedSettings.svelte';

@@ -126,9 +126,9 @@
  {@const inputType = type[key]}
  <div class="input input-{inputType.type}" class:first-level={depth === 1}>
    {#if inputType.type === 'button'}
-      <button onclick={() => onButtonClick?.(id)}>
+      <UiButton onclick={() => onButtonClick?.(id)}>
        {inputType.label || key}
-      </button>
+      </UiButton>
    {:else}
      {#if inputType.label !== ''}
        <label for={id}>{inputType.label || key}</label>
@@ -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 {
@@ -217,13 +224,6 @@
    gap: 10px;
  }

-  button {
-    cursor: pointer;
-    background: var(--color-layer-2);
-    padding-block: 5px;
-    border-radius: 4px;
-  }
-
  hr {
    margin: 0;
    left: 0;
@@ -1,99 +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}
-  />
-{/if}
@@ -1,21 +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 node && !isGroupInstance}
+{#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>
-  <ActiveNodeSelected {manager} bind:node />
+  <NestedSettings
+    id="activeNodeSettings"
+    bind:value={store}
+    type={nodeDefinition}
+  />
 {/if}
@@ -8,7 +8,7 @@
  import { humanizeDuration } from '$lib/helpers';
  import { localState } from '$lib/helpers/localState.svelte';
  import Monitor from '$lib/performance/Monitor.svelte';
-  import { InputNumber } from '@nodarium/ui';
+  import { Button, InputNumber } from '@nodarium/ui';
  import { writable } from 'svelte/store';

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

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

-<div class="p-4">
-  <button onclick={exportObj}>export obj</button>
-  <button onclick={exportGltf}>export gltf</button>
+<div class="p-4 flex gap-2">
+  <Button onclick={exportObj}>export obj</Button>
+  <Button onclick={exportGltf}>export gltf</Button>
 </div>
@@ -8,7 +8,7 @@
    graph
      ? {
        ...graph,
-        nodes: graph.nodes.map((n: object) => ({ ...n, tmp: undefined, state: undefined }))
+        nodes: graph.nodes.map((n: object) => ({ ...n, state: undefined }))
      }
      : null
  );
@@ -1,26 +1,26 @@
 <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, node = $bindable() }: Props = $props();
+  const { manager, graphState, node = $bindable() }: Props = $props();

  const activeGroup = $derived.by(() => {
-    console.log('isInsideGroup', manager?.isInsideGroup);
-    if (manager?.isInsideGroup) {
-      const activeGroupId = manager.graphStack?.at(-1)?.groupId;
-      console.log('activeGroupId', activeGroupId);
-      if (activeGroupId !== undefined) {
-        return manager.getGroup(activeGroupId);
-      }
+    if (node?.type === '__internal/group/instance') {
+      let group = manager.getGroup(node.props?.groupId as number);
+      if (group) return group;
    }

-    if (node?.type === '__internal/group/instance') {
-      return manager.getGroup(node.props?.groupId as number);
+    if (manager?.isInsideGroup && manager.currentGroupId !== null) {
+      return manager.getGroup(manager.currentGroupId);
    }
  });

@@ -30,17 +30,49 @@
    if (activeGroup) manager.renameGroup(activeGroup.id, name);
  }

-  const hasUnusedGroups = $derived.by(() => {
-    if (!manager) return false;
-    if (manager.isInsideGroup) return false;
-    if (manager.graph.groups.length === 0) return false;
-    return manager.graph.groups.filter(g => {
-      return !manager.graph.nodes.find(n => n.props?.groupId === g.id);
-    }).length;
+  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 || hasUnusedGroups}
+{#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>
@@ -48,7 +80,7 @@

 {#if activeGroup}
  {#key activeGroup.id}
-    <div class="group-settings">
+    <div class="p-4 group-settings">
      <label for="group-name">Group name</label>
      <input
        id="group-name"
@@ -57,16 +89,43 @@
        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 hasUnusedGroups}
-  <div class="group-actions">
-    <button onclick={() => manager.removeUnusedGroups()}>
-      Remove ({hasUnusedGroups}) orphaned groups
-    </button>
-  </div>
+{#if manager && !manager.isInsideGroup}
+  <UnusedGroupsPanel {manager} />
 {/if}

 <style>
@@ -74,10 +133,9 @@
    display: flex;
    flex-direction: column;
    gap: 0.4em;
-    padding: 1em;
  }

-  .group-settings label {
+  label {
    font-size: 0.8em;
    opacity: 0.7;
  }
@@ -95,26 +153,4 @@
  .group-settings input:focus {
    outline: 1px solid var(--color-active);
  }
-
-  .group-actions {
-    padding: 0.75em 1em;
-    border-bottom: 1px solid var(--color-outline);
-    margin-top: auto;
-  }
-
-  .group-actions button {
-    width: 100%;
-    padding: 0.4em 0.8em;
-    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.85em;
-    cursor: pointer;
-  }
-
-  .group-actions button:hover {
-    border-color: var(--color-active);
-  }
 </style>
@@ -0,0 +1,122 @@
+<script lang="ts">
+  import type { GraphManager } from '$lib/graph-interface/graph-manager.svelte';
+  import type { GroupDefinition } from '@nodarium/types';
+  import { Button } from '@nodarium/ui';
+  import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+
+  type Props = { manager: GraphManager };
+  const { manager }: Props = $props();
+
+  type GroupNode = { group: GroupDefinition; children: GroupNode[] };
+
+  const unusedTree = $derived.by((): GroupNode[] => {
+    const unused = manager.getUnusedGroups();
+    if (!unused.length) return [];
+
+    const unusedIds = new Set(unused.map(g => g.id));
+
+    // Build child map: which unused groups reference which other unused groups
+    const childrenOf = new SvelteMap<number, number[]>();
+    const referencedBy = new SvelteSet<number>();
+
+    for (const group of unused) {
+      const refs: number[] = [];
+      for (const node of group.nodes) {
+        if (node.type === '__internal/group/instance' && node.props?.groupId !== undefined) {
+          const childId = node.props.groupId as number;
+          if (unusedIds.has(childId)) {
+            refs.push(childId);
+            referencedBy.add(childId);
+          }
+        }
+      }
+      childrenOf.set(group.id, refs);
+    }
+
+    const byId = new Map(unused.map(g => [g.id, g]));
+
+    function buildNode(g: GroupDefinition): GroupNode {
+      return {
+        group: g,
+        children: (childrenOf.get(g.id) ?? []).map(id => buildNode(byId.get(id)!))
+      };
+    }
+
+    return unused
+      .filter(g => !referencedBy.has(g.id))
+      .map(buildNode);
+  });
+</script>
+
+{#if unusedTree.length}
+  <div class="panel p-4">
+    <div class="header">
+      <span>Unused groups</span>
+      <Button size="sm" variant="destructive" onclick={() => manager.removeUnusedGroups()}>
+        Remove all
+      </Button>
+    </div>
+
+    <ul class="tree">
+      {#snippet treeNode(node: GroupNode)}
+        <li>
+          <span class="group-name">{node.group.name || `Group #${node.group.id}`}</span>
+          {#if node.children.length}
+            <ul>
+              {#each node.children as child (child.group.id)}
+                {@render treeNode(child)}
+              {/each}
+            </ul>
+          {/if}
+        </li>
+      {/snippet}
+      {#each unusedTree as node (node.group.id)}
+        {@render treeNode(node)}
+      {/each}
+    </ul>
+  </div>
+{/if}
+
+<style>
+  .panel {
+    border-top: 1px solid var(--color-outline);
+    margin-top: -1px;
+    border-bottom: 1px solid var(--color-outline);
+  }
+
+  .header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 0.5em;
+    font-size: 0.8em;
+    opacity: 0.7;
+  }
+
+
+  .tree {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .tree ul {
+    list-style: none;
+    margin: 0;
+    padding-left: 1.2em;
+    border-left: 1px solid var(--color-outline);
+  }
+
+  .tree li {
+    padding: 0.15em 0;
+  }
+
+  .group-name {
+    font-size: 0.85em;
+  }
+
+  .tree ul .group-name::before {
+    content: '└ ';
+    opacity: 0.4;
+  }
+</style>
@@ -5,8 +5,9 @@
  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';
  import { ProjectManager } from '$lib/project-manager/project-manager.svelte';
  import ProjectManagerEl from '$lib/project-manager/ProjectManager.svelte';
@@ -28,17 +29,19 @@
  import { tutorialConfig } from '$lib/tutorial/tutorial-config';
  import { Planty } from '@nodarium/planty';
  import type { Graph, NodeInstance } from '@nodarium/types';
+  import { Spinner, Toast, toast } from '@nodarium/ui';
  import { createPerformanceStore } from '@nodarium/utils';
  import type { Group } from 'three';

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

  const { data } = $props();

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

-  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [debugNode]);
+  const nodeRegistry = new RemoteNodeRegistry('', registryCache, [debugNode, groupNode]);
  const workerRuntime = new WorkerRuntimeExecutor();
  const runtimeCache = new MemoryRuntimeCache();
  const memoryRuntime = new MemoryRuntimeExecutor(nodeRegistry, runtimeCache);
@@ -50,8 +53,8 @@
  );

  $effect(() => {
-    workerRuntime.useRegistryCache = appSettings.value.debug.cache.useRuntimeCache;
-    workerRuntime.useRuntimeCache = appSettings.value.debug.cache.useRegistryCache;
+    workerRuntime.useRegistryCache = appSettings.value.debug.cache.useRegistryCache;
+    workerRuntime.useRuntimeCache = appSettings.value.debug.cache.useRuntimeCache;

    if (appSettings.value.debug.cache.useRegistryCache) {
      nodeRegistry.cache = registryCache;
@@ -66,8 +69,19 @@
    }
  });

+  $effect(() => {
+    const handler = (e: BeforeUnloadEvent) => {
+      if (pendingSave) {
+        e.preventDefault();
+      }
+    };
+    window.addEventListener('beforeunload', handler);
+    return () => window.removeEventListener('beforeunload', handler);
+  });
+
  let activeNode = $state<NodeInstance | undefined>(undefined);
  let scene = $state<Group>(null!);
+  let isExecuting = $state(false);

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

+  let timeout: ReturnType<typeof setTimeout>;
+
  async function update(
    g: Graph,
    s: Record<string, unknown> = $state.snapshot(graphSettings)
  ) {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      isExecuting = true;
+    }, 100);
    performanceStore.startRun();
    try {
      let a = performance.now();
@@ -126,8 +146,11 @@
      }
      viewerComponent?.update(graphResult);
    } catch (error) {
-      console.log('errors', error);
+      const msg = error instanceof Error ? error.message : String(error);
+      toast(`Execution failed: ${msg}`, 'error');
    } finally {
+      clearTimeout(timeout);
+      isExecuting = false;
      performanceStore.stopRun();
    }
  }
@@ -171,6 +194,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,
@@ -178,15 +202,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'
@@ -245,6 +270,7 @@
  <header></header>
  <Grid.Row>
    <Grid.Cell>
+      <div class="viewer-cell">
        <Viewer
          bind:scene
          bind:this={viewerComponent}
@@ -252,23 +278,35 @@
          debugData={debugData}
          centerCamera={appSettings.value.centerCamera}
        />
+        {#if isExecuting}
+          <div class="viewer-spinner" aria-label="Executing graph">
+            <Spinner size={28} />
+          </div>
+        {/if}
+      </div>
    </Grid.Cell>
    <Grid.Cell>
      {#if pm.graph}
+        {#key pm.graph.id}
          <GraphInterface
            graph={pm.graph}
            bind:this={graphInterface}
            registry={nodeRegistry}
-          safePadding={{ right: sidebarOpen ? 320 : undefined }}
+            safePadding={{ right: sidebarOpen ? 321 : undefined }}
            backgroundType={appSettings.value.nodeInterface.backgroundType}
            snapToGrid={appSettings.value.nodeInterface.snapToGrid}
            bind:activeNode
            bind:showHelp={appSettings.value.nodeInterface.showHelp}
            bind:settings={graphSettings}
            bind:settingTypes={graphSettingTypes}
-          onsave={(g) => pm.saveGraph(g)}
+            onsave={async (g) => {
+              pendingSave = true;
+              await pm.saveGraph(g);
+              pendingSave = false;
+            }}
            onresult={(result) => handleUpdate(result as Graph)}
          />
+        {/key}
      {/if}
      <Sidebar bind:open={sidebarOpen}>
        <Panel id="general" title="General" icon="i-[tabler--settings]">
@@ -294,15 +332,7 @@
        <Panel id="exports" title="Exporter" icon="i-[tabler--package-export]">
          <ExportSettings {scene} />
        </Panel>
-        {#if 0 > 1}
-          <Panel
-            id="node-store"
-            title="Node Store"
-            icon="i-[tabler--database] bg-green-400"
-          >
-            <NodeStore registry={nodeRegistry} />
-          </Panel>
-        {/if}
+
        <Panel
          id="performance"
          title="Performance"
@@ -322,7 +352,9 @@
          hidden={!appSettings.value.debug.advancedMode}
          icon="i-[tabler--code]"
        >
-          <GraphSource graph={manager?.serializeFullGraph()} />
+          {#if manager?.status === 'idle'}
+            <GraphSource graph={manager.serialize()} />
+          {/if}
        </Panel>
        <Panel
          id="benchmark"
@@ -343,8 +375,10 @@
            type={graphSettingTypes}
            bind:value={graphSettings}
          />
+          {#key activeNode}
            <ActiveNodeSettings {manager} bind:node={activeNode} />
-          <GroupSettings {manager} bind:node={activeNode} />
+            <GroupSettings graphState={graphInterface?.state} {manager} bind:node={activeNode} />
+          {/key}
        </Panel>
        <Panel
          id="changelog"
@@ -358,6 +392,8 @@
  </Grid.Row>
 </div>

+<Toast />
+
 <style>
  header {
    background-color: var(--color-layer-1);
@@ -390,6 +426,20 @@
    grid-template-rows: 0px 1fr;
  }

+  .viewer-cell {
+    position: relative;
+    height: 100%;
+  }
+
+  .viewer-spinner {
+    position: absolute;
+    bottom: 12px;
+    right: 12px;
+    color: var(--color-text, #cecece);
+    opacity: 0.6;
+    pointer-events: none;
+  }
+
  .wrapper :global(canvas) {
    transition: opacity 0.3s ease;
    opacity: 1;
@@ -0,0 +1,645 @@
+# Comprehensive UX Practices for Web Applications
+
+## Introduction
+
+This document consolidates many of the most important practical UX principles for modern web applications.
+
+---
+
+# 1. Core UX Principles
+
+## 1.1 Visibility of System Status
+
+Users should always understand:
+
+- What the system is doing
+- Whether an action succeeded
+- Whether work is still in progress
+- Whether an error occurred
+
+### Good Practices
+
+- Show loading indicators immediately
+- Show success confirmations after important actions
+- Show inline validation messages
+- Display progress for long-running tasks
+- Use skeleton loading states instead of blank screens
+- Prevent silent failures
+- Avoid ambiguous UI states
+
+### Bad Practices
+
+- Buttons with no feedback after clicking
+- Infinite spinners without explanation
+- Hidden background operations
+- Saving without visible confirmation
+
+---
+
+## 1.2 Predictability and Consistency
+
+Users build mental models quickly.
+
+Breaking established expectations increases cognitive load and causes mistakes.
+
+### Good Practices
+
+- Use consistent layouts
+- Keep interaction patterns stable
+- Reuse common UI conventions
+- Keep naming and terminology consistent
+- Use standard keyboard shortcuts
+- Make similar components behave similarly
+
+### Bad Practices
+
+- Different button styles for identical actions
+- Inconsistent navigation behavior
+- Custom controls that ignore platform conventions
+- Unexpected modal behavior
+
+---
+
+## 1.3 Recognition Over Recall
+
+Interfaces should minimize memory requirements.
+
+Users should recognize options instead of remembering information.
+
+### Good Practices
+
+- Show recent searches
+- Use autocomplete
+- Display contextual hints
+- Preserve previously entered values
+- Use visible labels
+- Keep important actions visible
+
+### Bad Practices
+
+- Placeholder-only labels
+- Hidden functionality
+- Requiring users to remember previous state
+- Removing useful context during workflows
+
+---
+
+## 1.4 Error Prevention
+
+Preventing mistakes is better than handling mistakes.
+
+### Good Practices
+
+- Disable impossible actions
+- Validate input early
+- Warn before destructive operations
+- Use constrained input formats
+- Use safe defaults
+- Prefer undo over confirmation dialogs
+
+### Bad Practices
+
+- Destructive actions near common actions
+- Easy accidental deletion
+- Poor validation timing
+- Irreversible operations without recovery
+
+---
+
+# 2. Input and Form UX
+
+Forms are one of the most important and failure-prone areas in web applications.
+
+---
+
+## 2.1 Input Focus Behavior
+
+### Good Practices
+
+- Autofocus the primary field when appropriate
+- Preserve focus during rerenders
+- Preserve cursor position
+- Support keyboard-first workflows
+- Use logical tab ordering
+
+### Auto-Selecting Input Text
+
+Auto-selecting text on focus is context-dependent.
+
+### Good Use Cases
+
+- Quantity fields
+- Rename dialogs
+- Editable defaults
+- Quick replacement workflows
+- Temporary values users often replace entirely
+
+### Bad Use Cases
+
+- Long textareas
+- Complex text editing
+- Fields users commonly partially edit
+- Rich text editing
+
+### Principle
+
+Only auto-select when full replacement is more likely than partial editing.
+
+---
+
+## 2.2 Labels and Placeholders
+
+### Good Practices
+
+- Always use visible labels
+- Use placeholders only as supplementary examples
+- Keep labels visible after typing
+- Associate labels correctly for accessibility
+
+### Bad Practices
+
+- Placeholder-only forms
+- Ambiguous labels
+- Labels that disappear during editing
+
+---
+
+## 2.3 Validation
+
+### Recommended Validation Timing
+
+| Validation Type     | Timing    |
+| ------------------- | --------- |
+| Format validation   | Immediate |
+| Semantic validation | On blur   |
+| Server validation   | On submit |
+
+### Good Practices
+
+- Show errors near the relevant field
+- Explain how to fix issues
+- Preserve entered values after errors
+- Validate incrementally
+- Use clear language
+
+### Bad Practices
+
+- Generic “Invalid input” messages
+- Clearing form data after errors
+- Delayed validation surprises
+- Validation that interrupts typing
+
+---
+
+## 2.4 Input Types
+
+### Good Practices
+
+Use appropriate HTML input types:
+
+- `email`
+- `tel`
+- `number`
+- `date`
+- `password`
+- `search`
+
+### Benefits
+
+- Better mobile keyboards
+- Native validation
+- Improved accessibility
+- Better autofill support
+
+---
+
+## 2.5 Form Submission
+
+### Good Practices
+
+- Enter submits forms when expected
+- Escape cancels dialogs
+- Show loading states during submission
+- Prevent duplicate submissions
+- Preserve draft state
+- Allow keyboard submission
+
+### Bad Practices
+
+- Disabled submit buttons without explanation
+- Hidden validation failures
+- Silent submission failures
+
+---
+
+## 2.6 Dropdowns and Selection UX
+
+### Good Practices
+
+- Use radio buttons for small option sets
+- Use searchable selects for large datasets
+- Prefer autocomplete for many options
+- Show selected state clearly
+
+### Bad Practices
+
+- Massive unsearchable dropdowns
+- Nested dropdown hierarchies
+- Multi-select controls without search
+
+---
+
+# 3. Navigation UX
+
+---
+
+## 3.1 Orientation
+
+Users should always know:
+
+- Where they are
+- How they got there
+- What they can do next
+- How to go back
+
+### Good Practices
+
+- Highlight active navigation
+- Use breadcrumbs when helpful
+- Use meaningful page titles
+- Preserve navigation consistency
+
+---
+
+## 3.2 Navigation Structure
+
+### Good Practices
+
+- Keep hierarchy shallow
+- Group related actions
+- Use descriptive names
+- Keep primary actions stable
+
+### Bad Practices
+
+- Deep nesting
+- Ambiguous navigation labels
+- Constantly moving actions
+
+---
+
+## 3.3 URL Design
+
+### Good Practices
+
+- Use readable URLs
+- Make URLs shareable
+- Preserve app state in URLs when useful
+- Support browser history correctly
+
+### Bad Practices
+
+- Opaque generated URLs
+- Broken back button behavior
+- Losing state during navigation
+
+---
+
+# 4. Interaction Design
+
+---
+
+## 4.1 Click Targets
+
+### Good Practices
+
+- Large clickable areas
+- Adequate spacing between actions
+- Clear hover/focus states
+- Touch-friendly sizing
+
+### Bad Practices
+
+- Tiny clickable regions
+- Overlapping interactive elements
+- Hidden hit areas
+
+---
+
+## 4.2 Feedback
+
+Every interaction should produce feedback.
+
+### Good Practices
+
+- Hover states
+- Active states
+- Loading indicators
+- Success states
+- Error states
+- Optimistic updates when appropriate
+
+### Bad Practices
+
+- Dead-feeling interfaces
+- Invisible processing
+- Delayed reactions
+
+---
+
+## 4.3 Destructive Actions
+
+### Good Practices
+
+- Require confirmation for dangerous actions
+- Prefer undo systems
+- Visually distinguish destructive buttons
+- Separate destructive actions spatially
+
+### Bad Practices
+
+- Immediate irreversible deletion
+- Dangerous actions near common actions
+- Ambiguous destructive wording
+
+---
+
+## 4.4 Modal UX
+
+### Good Practices
+
+- Trap keyboard focus
+- Support Escape to close
+- Restore focus after closing
+- Prevent background interaction
+- Keep modal purpose focused
+
+### Bad Practices
+
+- Nested modals
+- Full workflows inside modals
+- Losing unsaved work accidentally
+
+---
+
+# 5. Performance UX
+
+Performance is a UX feature.
+
+Users interpret slowness as unreliability.
+
+---
+
+## 5.1 Perceived Performance
+
+### Good Practices
+
+- Show immediate visual response
+- Use optimistic UI updates
+- Preload likely next content
+- Stream content progressively
+- Use skeleton loaders
+
+### Bad Practices
+
+- Blank screens during loading
+- Long blocking operations
+- Frozen interfaces
+
+---
+
+## 5.2 Layout Stability
+
+### Good Practices
+
+- Prevent layout shift
+- Reserve image dimensions
+- Avoid moving buttons during loading
+- Keep skeletons aligned with final layout
+
+### Bad Practices
+
+- Jumping content
+- Shifting controls
+- Reflow-heavy rendering
+
+---
+
+## 5.3 Responsiveness
+
+### Good Practices
+
+- Keep UI interactive during async operations
+- Avoid blocking the main thread
+- Debounce expensive operations
+- Virtualize large lists
+
+### Bad Practices
+
+- UI freezes
+- Excessive rerenders
+- Laggy typing experiences
+
+---
+
+# 6. Accessibility
+
+Accessibility improves usability for everyone.
+
+---
+
+## 6.1 Keyboard Accessibility
+
+### Good Practices
+
+- Full keyboard navigation
+- Visible focus indicators
+- Logical tab order
+- Keyboard shortcuts for power users
+
+### Bad Practices
+
+- Mouse-only workflows
+- Hidden focus state
+- Keyboard traps
+
+---
+
+## 6.2 Semantic HTML
+
+### Good Practices
+
+- Use proper semantic elements
+- Use buttons for actions
+- Use links for navigation
+- Use headings correctly
+
+### Bad Practices
+
+- Clickable divs without accessibility support
+- Fake buttons
+- Missing semantic structure
+
+---
+
+## 6.3 Visual Accessibility
+
+### Good Practices
+
+- Sufficient color contrast
+- Support reduced motion
+- Avoid color-only communication
+- Use scalable typography
+
+### Bad Practices
+
+- Tiny text
+- Low contrast interfaces
+- Flashing animations
+
+---
+
+## 6.4 Screen Reader Support
+
+### Good Practices
+
+- Proper labels
+- Meaningful alt text
+- ARIA only when necessary
+- Correct live regions for updates
+
+### Bad Practices
+
+- Unlabeled controls
+- Excessive ARIA misuse
+- Non-announced state changes
+
+---
+
+# 7. Enterprise Application UX
+
+Enterprise UX differs significantly from marketing-oriented consumer interfaces.
+
+Power users often prioritize efficiency over visual minimalism.
+
+---
+
+## 7.1 Dense Information Design
+
+### Good Practices
+
+- Efficient data density
+- Resizable tables
+- Sticky headers
+- Multi-column layouts
+- High information throughput
+
+### Bad Practices
+
+- Excessive whitespace
+- Oversimplified dashboards
+- Hidden operational controls
+
+---
+
+## 7.2 Table UX
+
+### Good Practices
+
+- Sorting
+- Filtering
+- Column resizing
+- Pagination or virtualization
+- Keyboard navigation
+- Export functionality
+- Persistent user preferences
+
+### Bad Practices
+
+- Non-sortable enterprise tables
+- Horizontal scrolling nightmares
+- Missing filtering
+
+---
+
+## 7.3 Power User Workflows
+
+### Good Practices
+
+- Keyboard shortcuts
+- Bulk actions
+- Batch editing
+- Command palettes
+- State persistence
+- Fast navigation
+
+### Bad Practices
+
+- Forced wizard workflows
+- Excessive confirmations
+- Repetitive manual work
+
+---
+
+# 8. Mobile UX
+
+---
+
+## 8.1 Touch Design
+
+### Good Practices
+
+- Large touch targets
+- Thumb-friendly layouts
+- Avoid hover dependencies
+- Mobile-friendly spacing
+
+### Bad Practices
+
+- Tiny controls
+- Hover-only interactions
+- Precision-dependent gestures
+
+---
+
+## 8.2 Mobile Forms
+
+### Good Practices
+
+- Mobile keyboard optimization
+- Minimal typing
+- Autofill support
+- Step-by-step flows when necessary
+
+### Bad Practices
+
+- Long complex forms
+- Tiny input fields
+- Excessive required typing
+
+---
+
+# 9. Cognitive Psychology and UX
+
+---
+
+## 9.1 Hick’s Law
+
+More choices increase decision time.
+
+### Applications
+
+- Reduce unnecessary options
+- Group related actions
+- Prioritize primary actions
+
+---
+
+## 9.2 Fitts’s Law
+
+Closer and larger targets are easier to use.
+
+### Applications
+
+- Large primary buttons
+- Edge/corner placement for important actions
@@ -83,6 +83,14 @@
      "min": 0,
      "max": 360,
      "step": 0.01,
+      "value": 137.5
+    },
+    "angle": {
+      "type": "float",
+      "description": "Upward tilt of branches. 0 = horizontal, positive = upward, negative = drooping.",
+      "min": -90,
+      "max": 90,
+      "step": 1,
      "value": 0
    }
  }
@@ -78,7 +78,9 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
                continue;
            }

-            let branch_direction = rotate_vector_by_angle(orthogonal, direction, rotation_angle);
+            let up_angle = evaluate_float(args[10]) * PI / 180.0;
+            let tilted = (orthogonal * up_angle.cos() + direction * up_angle.sin()).normalize();
+            let branch_direction = rotate_vector_by_angle(tilted, direction, rotation_angle);

            log!(
                "BRANCH depth: {}, branch_origin: {:?}, direction_at: {:?}, branch_direction: {:?}",
@@ -13,19 +13,28 @@
      "max": 1,
      "value": 1
    },
-    "curviness": {
-      "type": "float",
-      "hidden": true,
-      "min": 0,
-      "max": 1,
-      "value": 0.5
-    },
    "depth": {
      "type": "integer",
      "min": 1,
      "max": 10,
      "hidden": true,
      "value": 1
+    },
+    "elasticity": {
+      "type": "float",
+      "description": "How rigid the stem is. 0 = rope (uniform droop), 1 = stiff rod (only the tip bends).",
+      "min": 0,
+      "max": 1,
+      "step": 0.05,
+      "value": 0.3
+    },
+    "mode": {
+      "type": "select",
+      "internal": true,
+      "label": "Mode",
+      "options": ["closed-form", "chain"],
+      "hidden": true,
+      "description": "closed-form lerps each segment toward gravity; chain is a forward-kinematic cantilever where each segment rotates by an angle that grows along the stem."
    }
  }
 }
@@ -20,7 +20,11 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
    let args = split_args(input);

    let plants = split_args(args[0]);
-    let depth = evaluate_int(args[3]);
+    let depth = evaluate_int(args[2]);
+    let elasticity = evaluate_float(args[3]).clamp(0.0, 1.0);
+    let mode = evaluate_int(args[4]); // 0 = closed-form, 1 = verlet
+    // 0 → sqrt (rope), 1 → ~4.5 (only the tip droops)
+    let bend_exponent = 0.5 + elasticity * 4.0;

    let mut max_depth = 0;
    for path_data in plants.iter() {
@@ -42,6 +46,77 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
            let mut output_data = path_data.clone();
            let output = wrap_path_mut(&mut output_data);

+            if mode == 1 {
+                // Forward-kinematic cantilever chain. Each segment rotates around
+                // an axis perpendicular to (rest_dir, gravity) by an angle that
+                // grows with alpha along the stem. Positions are built from the
+                // anchored base outward, so segment lengths are preserved by
+                // construction (no iteration, no rescaling, no oscillation).
+
+                let raw_strength = evaluate_float(args[1]);
+                let gravity_dir = Vec3::new(0.0, -1.0, 0.0);
+
+                // Tip bend angle in radians. PI/2 = horizontal tip at strength=1.
+                let max_angle = raw_strength * std::f32::consts::FRAC_PI_2;
+
+                let original: Vec<Vec3> = (0..path.length)
+                    .map(|i| {
+                        let s = i * 4;
+                        Vec3::from_slice(&path.points[s..s + 3])
+                    })
+                    .collect();
+
+                let seg_lens: Vec<f32> = (0..path.length - 1)
+                    .map(|i| (original[i + 1] - original[i]).length())
+                    .collect();
+                let rest_dirs: Vec<Vec3> = (0..path.length - 1)
+                    .map(|i| {
+                        let d = original[i + 1] - original[i];
+                        let l = d.length();
+                        if l > 0.0001 { d / l } else { Vec3::Y }
+                    })
+                    .collect();
+
+                let mut cur = vec![Vec3::ZERO; path.length];
+                cur[0] = original[0];
+
+                for i in 1..path.length {
+                    let seg_idx = i - 1;
+                    let alpha = if path.length > 2 {
+                        seg_idx as f32 / (path.length - 2) as f32
+                    } else {
+                        1.0
+                    };
+                    let bend_angle = max_angle * alpha.powf(bend_exponent);
+
+                    let rest_dir = rest_dirs[seg_idx];
+                    let mut bend_axis = rest_dir.cross(gravity_dir);
+                    let axis_len = bend_axis.length();
+                    bend_axis = if axis_len > 0.0001 {
+                        bend_axis / axis_len
+                    } else {
+                        // rest_dir parallel to gravity — pick an arbitrary
+                        // perpendicular axis to break symmetry.
+                        Vec3::X
+                    };
+
+                    // Rodrigues' rotation formula
+                    let (sin_a, cos_a) = bend_angle.sin_cos();
+                    let bent_dir = rest_dir * cos_a
+                        + bend_axis.cross(rest_dir) * sin_a
+                        + bend_axis * bend_axis.dot(rest_dir) * (1.0 - cos_a);
+
+                    cur[i] = cur[i - 1] + bent_dir * seg_lens[seg_idx];
+                }
+
+                for i in 0..path.length {
+                    let s = i * 4;
+                    output.points[s] = cur[i].x;
+                    output.points[s + 1] = cur[i].y;
+                    output.points[s + 2] = cur[i].z;
+                }
+            } else {
+                // Closed-form: per-segment lerp toward a downward vector
                let mut offset_vec = Vec3::ZERO;

                for i in 0..path.length - 1 {
@@ -49,15 +124,16 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
                    let start_index = i * 4;

                    let start_point = Vec3::from_slice(&path.points[start_index..start_index + 3]);
-                let end_point = Vec3::from_slice(&path.points[start_index + 4..start_index + 7]);
+                    let end_point =
+                        Vec3::from_slice(&path.points[start_index + 4..start_index + 7]);

                    let direction = end_point - start_point;

                    let length = direction.length();

-                let curviness = evaluate_float(args[2]);
-                let strength =
-                    evaluate_float(args[1]) / curviness.max(0.0001) * evaluate_float(args[1]);
+                    let curviness = elasticity.max(0.0001);
+                    let strength_arg = evaluate_float(args[1]) * 10.0;
+                    let strength = strength_arg / curviness * strength_arg;

                    log!(
                        "length: {}, curviness: {}, strength: {}",
@@ -68,7 +144,8 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

                    let down_point = Vec3::new(0.0, -length * strength, 0.0);

-                let mut mid_point = lerp_vec3(direction, down_point, curviness * alpha.sqrt());
+                    let mut mid_point =
+                        lerp_vec3(direction, down_point, curviness * alpha.powf(bend_exponent));

                    if mid_point[0] == 0.0 && mid_point[2] == 0.0 {
                        mid_point[0] += 0.0001;
@@ -87,6 +164,7 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

                    offset_vec += final_end_point - end_point;
                }
+            }
            output_data
        })
        .collect();
@@ -8,5 +8,6 @@ edition = "2018"
 crate-type = ["cdylib", "rlib"]

 [dependencies]
+glam = "0.30.10"
 nodarium_macros = { version = "0.1.0", path = "../../../../packages/macros" }
 nodarium_utils = { version = "0.1.0", path = "../../../../packages/utils" }
@@ -19,6 +19,33 @@
      "max": 64,
      "value": 1,
      "hidden": true
+    },
+    "yCurve": {
+      "type": "float",
+      "description": "Curl the leaf upward along its length (radians). 0 = flat, ~1.57 = 90° tip curl.",
+      "min": -3.14,
+      "max": 3.14,
+      "step": 0.05,
+      "value": 0,
+      "hidden": true
+    },
+    "yTwist": {
+      "type": "float",
+      "description": "Twist around the leaf's spine. Combined with yCurve, produces a 3D spiral.",
+      "min": -6.28,
+      "max": 6.28,
+      "step": 0.05,
+      "value": 0,
+      "hidden": true
+    },
+    "xCurve": {
+      "type": "float",
+      "description": "Curl each cross-section into an arc, mirrored around the midrib. 0 = flat, ~1.57 = U-shape.",
+      "min": -3.14,
+      "max": 3.14,
+      "step": 0.05,
+      "value": 0,
+      "hidden": true
    }
  }
 }
@@ -1,6 +1,7 @@
 use std::convert::TryInto;
 use std::f32::consts::PI;

+use glam::Vec3;
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
 use nodarium_utils::encode_float;
@@ -42,6 +43,9 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
    let input_path = split_args(args[0])[0];
    let size = evaluate_float(args[1]);
    let width_resolution = evaluate_int(args[2]).max(3) as usize;
+    let y_curve = evaluate_float(args[3]);
+    let y_twist = evaluate_float(args[4]);
+    let x_curve = evaluate_float(args[5]);
    let path_length = (input_path.len() - 4) / 2;

    let slice_count = path_length;
@@ -93,27 +97,97 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

    // Writing Positions
    let width = 50.0;
+    let leaf_length: f32 = 100.0;
    let mut positions = vec![[0.0f32; 3]; position_amount];
+
+    // Pre-compute a local frame (center, normal=local-Y, binormal=local-X) for
+    // each slice by walking the FK chain. At each step we bend around the
+    // current binormal (curls the leaf) and twist around the current tangent
+    // (rotates the bend plane → spiral).
+    let segs = (slice_count - 1).max(1) as f32;
+    let bend_per_step = y_curve / segs;
+    let twist_per_step = y_twist / segs;
+
+    let mut centers: Vec<Vec3> = Vec::with_capacity(slice_count);
+    let mut frame_n: Vec<Vec3> = Vec::with_capacity(slice_count);
+    let mut frame_b: Vec<Vec3> = Vec::with_capacity(slice_count);
+
+    let mut tangent = Vec3::new(0.0, 0.0, 1.0);
+    let mut normal = Vec3::new(0.0, 1.0, 0.0);
+    let mut binormal = Vec3::new(1.0, 0.0, 0.0);
+
+    let pz_first = decode_float(input_path[2 + 1]);
+    let mut center = Vec3::new(0.0, 0.0, pz_first - leaf_length);
+
    for i in 0..slice_count {
-        let ax = i as f32 / (slice_count -1) as f32;
+        centers.push(center);
+        frame_n.push(normal);
+        frame_b.push(binormal);

+        if i + 1 < slice_count {
+            let pz_curr = decode_float(input_path[2 + i * 2 + 1]);
+            let pz_next = decode_float(input_path[2 + (i + 1) * 2 + 1]);
+            let seg_len = pz_next - pz_curr;
+
+            center = center + tangent * seg_len;
+
+            // Bend around binormal — tilts tangent toward normal
+            let (sin_b, cos_b) = bend_per_step.sin_cos();
+            let new_t = tangent * cos_b + normal * sin_b;
+            let new_n = -tangent * sin_b + normal * cos_b;
+            tangent = new_t;
+            normal = new_n;
+
+            // Twist around tangent — rotates normal/binormal so the next bend
+            // happens in a rotated plane
+            let (sin_tw, cos_tw) = twist_per_step.sin_cos();
+            let new_n2 = normal * cos_tw + binormal * sin_tw;
+            let new_b = -normal * sin_tw + binormal * cos_tw;
+            normal = new_n2;
+            binormal = new_b;
+        }
+    }
+
+    for i in 0..slice_count {
+        let ax = i as f32 / segs;
        let px = decode_float(input_path[2 + i * 2 + 0]);
-        let pz = decode_float(input_path[2 + i * 2 + 1]);
+        let hw = width - px; // half-width at this slice

+        let c = centers[i];
+        let n = frame_n[i];
+        let b = frame_b[i];

        for j in 0..width_resolution {
            let alpha = j as f32 / (width_resolution - 1) as f32;
-            let x = 2.0 * (-px * (alpha - 0.5) + alpha * width);
-            let py = calculate_y(alpha-0.5)*5.0*(ax*PI).sin();
-            let pz_val = pz - 100.0;
+            // Signed cross-section parameter, -1 (left edge) → +1 (right edge)
+            let t = 2.0 * alpha - 1.0;
+            let py_local = calculate_y(alpha - 0.5) * 5.0 * (ax * PI).sin();
+
+            // X-curl: each cross-section traces a circular arc with curvature
+            // x_curve / hw. Because theta = x_curve * t is signed around the
+            // midrib, sin/cos give a mirrored arc (left and right edges curl
+            // the same direction).
+            let theta = x_curve * t;
+            let (sin_t, cos_t) = theta.sin_cos();
+            let (b_arc, n_arc) = if x_curve.abs() < 0.0001 {
+                (t * hw, 0.0)
+            } else {
+                let r = hw / x_curve;
+                (r * sin_t, r * (1.0 - cos_t))
+            };
+            // Cross-section bulge follows the rotated local frame
+            let b_total = b_arc - py_local * sin_t;
+            let n_total = n_arc + py_local * cos_t;
+
+            let world = c + b * b_total + n * n_total;

            let pos_idx = i * width_resolution + j;
-            positions[pos_idx] = [x - width, py, pz_val];
+            positions[pos_idx] = [world.x, world.y, world.z];

            let flat_idx = offset + pos_idx * 3;
-            out[flat_idx + 0] = encode_float((x - width) * size);
-            out[flat_idx + 1] = encode_float(py * size);
-            out[flat_idx + 2] = encode_float(pz_val * size);
+            out[flat_idx + 0] = encode_float(world.x * size);
+            out[flat_idx + 1] = encode_float(world.y * size);
+            out[flat_idx + 2] = encode_float(world.z * size);
        }
    }

@@ -8,6 +8,7 @@ edition = "2018"
 crate-type = ["cdylib", "rlib"]

 [dependencies]
+glam = "0.30.10"
 nodarium_macros = { version = "0.1.0", path = "../../../../packages/macros" }
 nodarium_utils = { version = "0.1.0", path = "../../../../packages/utils" }
 noise = "0.9.0"
@@ -15,9 +15,9 @@
    },
    "strength": {
      "type": "float",
-      "min": 0.1,
-      "max": 10,
-      "value": 2
+      "min": 0,
+      "max": 1,
+      "value": 0.5
    },
    "fixBottom": {
      "type": "float",
@@ -52,6 +52,12 @@
      "max": 5,
      "value": 1,
      "hidden": true
+    },
+    "preserveLength": {
+      "type": "boolean",
+      "label": "Preserve length",
+      "value": true,
+      "hidden": true
    }
  }
 }
@@ -1,3 +1,4 @@
+use glam::Vec3;
 use nodarium_macros::nodarium_definition_file;
 use nodarium_macros::nodarium_execute;
 use nodarium_utils::{
@@ -30,6 +31,7 @@ pub fn execute(input: &[i32]) -> Vec<i32> {
    let depth = evaluate_int(args[6]);

    let octaves = evaluate_int(args[7]);
+    let preserve_length = evaluate_int(args[8]) != 0;

    let noise_x: HybridMulti<OpenSimplex> =
        HybridMulti::new(seed as u32 + 1).set_octaves(octaves as usize);
@@ -65,24 +67,82 @@ pub fn execute(input: &[i32]) -> Vec<i32> {

            let length = path.get_length() as f64;

-            for i in 0..path.length {
-                let a = i as f64 / (path.length - 1) as f64;
+            if preserve_length {
+                // Snapshot original positions so we can derive each segment's original
+                // direction even after we've modified earlier points.
+                let orig: Vec<f32> = path.points[..path.length * 4].to_vec();

+                // Anchor the base (fix_bottom=1 → scale=0, no displacement at root)
+                let scale0 = lerp(1.0, 0.0, fix_bottom);
+                path.points[0] += noise_x.get([j as f64, 0.0]) as f32
+                    * directional_strength[0]
+                    * strength
+                    * scale0;
+                path.points[1] += noise_y.get([j as f64, 0.0]) as f32
+                    * directional_strength[1]
+                    * strength
+                    * scale0;
+                path.points[2] += noise_z.get([j as f64, 0.0]) as f32
+                    * directional_strength[2]
+                    * strength
+                    * scale0;
+                let mut prev = Vec3::new(path.points[0], path.points[1], path.points[2]);
+
+                for i in 1..path.length {
+                    let a = i as f64 / (path.length - 1) as f64;
                    let px = j as f64 + a * length * scale;
                    let py = a * scale as f64;
+                    let sf = lerp(1.0, a as f32, fix_bottom);
+
+                    let orig_dir = Vec3::new(
+                        orig[i * 4] - orig[(i - 1) * 4],
+                        orig[i * 4 + 1] - orig[(i - 1) * 4 + 1],
+                        orig[i * 4 + 2] - orig[(i - 1) * 4 + 2],
+                    );
+                    let orig_len = orig_dir.length();
+
+                    let perturb = Vec3::new(
+                        noise_x.get([px, py]) as f32 * directional_strength[0] * strength * sf,
+                        noise_y.get([px, py]) as f32 * directional_strength[1] * strength * sf,
+                        noise_z.get([px, py]) as f32 * directional_strength[2] * strength * sf,
+                    );
+
+                    // Perturb the original direction and rescale to original length.
+                    // Biasing toward orig_dir prevents the segment from folding back.
+                    let mut new_dir = orig_dir + perturb;
+                    let nd_len = new_dir.length();
+                    if nd_len > 0.0001 && orig_len > 0.0001 {
+                        new_dir *= orig_len / nd_len;
+                    } else {
+                        new_dir = orig_dir;
+                    }
+
+                    let cur = prev + new_dir;
+                    path.points[i * 4] = cur.x;
+                    path.points[i * 4 + 1] = cur.y;
+                    path.points[i * 4 + 2] = cur.z;
+                    prev = cur;
+                }
+            } else {
+                for i in 0..path.length {
+                    let a = i as f64 / (path.length - 1) as f64;
+                    let px = j as f64 + a * length * scale;
+                    let py = a * scale as f64;
+                    let sf = lerp(1.0, a as f32, fix_bottom);

                    path.points[i * 4] += noise_x.get([px, py]) as f32
                        * directional_strength[0]
                        * strength
-                    * lerp(1.0, a as f32, fix_bottom);
+                        * sf;
                    path.points[i * 4 + 1] += noise_y.get([px, py]) as f32
                        * directional_strength[1]
                        * strength
-                    * lerp(1.0, a as f32, fix_bottom);
+                        * sf;
                    path.points[i * 4 + 2] += noise_z.get([px, py]) as f32
                        * directional_strength[2]
                        * strength
-                    * lerp(1.0, a as f32, fix_bottom);
+                        * sf;
+                }
            }
            path_data
        })
@@ -29,7 +29,7 @@
      "type": "boolean",
      "internal": true,
      "hidden": true,
-      "value": true,
+      "value": false,
      "description": "If multiple objects are connected, should we rotate them as one or spread them?"
    }
  }
@@ -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",
@@ -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",
@@ -8,6 +8,7 @@ export type {
  NodeDefinition,
  NodeId,
  NodeInstance,
+  SerializedEdge,
  SerializedNode,
  Socket
 } from './types';
@@ -105,7 +105,6 @@ export const NodeInputSchema = z.union([
  NodeInputIntegerSchema,
  NodeInputShapeSchema,
  NodeInputSelectSchema,
-  NodeInputSeedSchema,
  NodeInputVec3Schema,
  NodeInputGeometrySchema,
  NodeInputPathSchema,
@@ -76,6 +76,10 @@ 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(),
@@ -100,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",
@@ -41,6 +41,7 @@
    "@sveltejs/vite-plugin-svelte": "^7.0.0",
    "@testing-library/svelte": "^5.3.1",
    "@types/eslint": "^9.6.1",
+    "@types/node": "^25.6.0",
    "@types/three": "^0.184.0",
    "@typescript-eslint/eslint-plugin": "^8.59.1",
    "@typescript-eslint/parser": "^8.59.1",
@@ -0,0 +1,55 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+
+  interface Props {
+    variant?: 'default' | 'primary' | 'destructive' | 'ghost';
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+    class?: string;
+    onclick?: (e: MouseEvent) => void;
+    children?: Snippet;
+    type?: 'button' | 'submit' | 'reset';
+  }
+
+  let {
+    variant = 'default',
+    size = 'md',
+    disabled = false,
+    class: _class = '',
+    onclick,
+    children,
+    type = 'button'
+  }: Props = $props();
+
+  const variantClasses = {
+    default: 'bg-layer-2 border border-outline text-text hover:opacity-85',
+    primary: 'bg-selected text-white border border-transparent hover:opacity-88',
+    destructive: 'bg-red-600 text-white border border-transparent hover:opacity-88',
+    ghost: 'bg-layer-2 border border-transparent text-text opacity-75 hover:opacity-100'
+  };
+
+  const sizeClasses = {
+    sm: 'px-2 py-0.5 text-xs',
+    md: 'px-3 py-1 text-sm'
+  };
+</script>
+
+<button
+  {type}
+  {disabled}
+  class:py-1={size === 'sm'}
+  class:px-1={size === 'sm'}
+  class:py-2={size !== 'sm'}
+  class="
+    inline-flex items-center gap-1.5 rounded cursor-pointer
+    font-(--font-family) leading-none whitespace-nowrap
+    transition-opacity duration-100
+    disabled:opacity-40 disabled:cursor-not-allowed
+    {variantClasses[variant]}
+    {sizeClasses[size]}
+    {_class}
+  "
+  {onclick}
+>
+  {@render children?.()}
+</button>
@@ -0,0 +1,95 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import Button from './Button.svelte';
+
+  interface Props {
+    open?: boolean;
+    title?: string;
+    message?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    onconfirm?: () => void;
+    oncancel?: () => void;
+    children?: Snippet;
+  }
+
+  let {
+    open = $bindable(false),
+    title = 'Are you sure?',
+    message,
+    confirmLabel = 'Confirm',
+    cancelLabel = 'Cancel',
+    onconfirm,
+    oncancel,
+    children
+  }: Props = $props();
+
+  let dialogEl: HTMLDialogElement;
+
+  $effect(() => {
+    if (!dialogEl) return;
+    if (open) {
+      dialogEl.showModal();
+    } else {
+      dialogEl.close();
+    }
+  });
+
+  function confirm() {
+    open = false;
+    onconfirm?.();
+  }
+
+  function cancel() {
+    open = false;
+    oncancel?.();
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      confirm();
+    }
+  }
+
+  function handleCancel(e: Event) {
+    e.preventDefault();
+    cancel();
+  }
+</script>
+
+<dialog
+  bind:this={dialogEl}
+  class="m-auto bg-layer-1 border border-outline rounded-md p-0 text-text max-w-md w-full backdrop:bg-black/50"
+  oncancel={handleCancel}
+  onkeydown={handleKeydown}
+  onclick={(e) => {
+    if (e.target === dialogEl) cancel();
+  }}
+>
+  <div class="px-6 py-5 flex flex-col gap-3">
+    <h3 class="m-0 text-sm font-semibold">{title}</h3>
+    {#if message}
+      <p class="m-0 text-xs opacity-75 leading-relaxed">{message}</p>
+    {/if}
+    {#if children}
+      <div class="text-xs">
+        {@render children()}
+      </div>
+    {/if}
+    <div class="flex justify-end gap-2 mt-1">
+      <Button onclick={cancel}>{cancelLabel}</Button>
+      <Button variant="primary" onclick={confirm}>{confirmLabel}</Button>
+    </div>
+  </div>
+</dialog>
+
+<style>
+  dialog {
+    font-family: var(--font-family);
+  }
+
+  dialog::backdrop {
+    background: rgba(0, 0, 0, 0.5);
+  }
+</style>
@@ -33,6 +33,7 @@
 <script lang="ts">
  import { browser } from '$app/environment';
  import JsonViewer from './JsonViewer.svelte';
+  import { toast } from './toast.svelte';

  let {
    value,
@@ -70,6 +71,11 @@
  let prevJson = '';
  let flashTimeout: ReturnType<typeof setTimeout> | null = null;

+  function copyValue() {
+    navigator.clipboard.writeText(JSON.stringify(key ? { [key]: value } : value, null, 2));
+    toast('Value copied to clipboard', 'success');
+  }
+
  $effect(() => {
    const json = JSON.stringify(value);
    if (prevJson && json !== prevJson) {
@@ -92,7 +98,7 @@
    <button
      class="text-text hover:bg-layer-3 cursor-pointer"
      title="Copy value"
-      onclick={() => navigator.clipboard.writeText(JSON.stringify({ [key]: value }, null, 2))}
+      onclick={() => copyValue()}
    >
      {key}
    </button><span class="text-text/40">: </span>
@@ -0,0 +1,27 @@
+<script lang="ts">
+  interface Props {
+    size?: number;
+    class?: string;
+  }
+  let { size = 20, class: _class = '' }: Props = $props();
+</script>
+
+<svg
+  class="animate-spin text-text shrink-0 {_class}"
+  width={size}
+  height={size}
+  viewBox="0 0 24 24"
+  fill="none"
+  aria-label="Loading"
+  role="status"
+>
+  <circle
+    cx="12"
+    cy="12"
+    r="10"
+    stroke="currentColor"
+    stroke-width="2.5"
+    stroke-linecap="round"
+    stroke-dasharray="40 20"
+  />
+</svg>
@@ -0,0 +1,31 @@
+<script lang="ts">
+  import { fly, slide } from 'svelte/transition';
+  import { toasts } from './toast.svelte';
+
+  const typeClasses: Record<string, string> = {
+    success: 'border-l-green-500',
+    error: 'border-l-red-500',
+    info: 'border-l-active'
+  };
+</script>
+
+<div
+  class="fixed bottom-4 right-4 flex flex-col items-end gap-2 z-9999 pointer-events-none"
+  role="status"
+  aria-live="polite"
+  aria-atomic="false"
+>
+  {#each toasts.value as item (item.id)}
+    <div
+      in:slide={{ duration: 250 }}
+      out:fly={{ x: 100, duration: 250 }}
+      class="
+        bg-layer-2 text-text border border-outline rounded
+        px-3.5 py-2 text-sm min-w-45 max-w-xs w-fit
+        border-l-3 {typeClasses[item.type] ?? 'border-l-outline'}
+      "
+    >
+      {item.message}
+    </div>
+  {/each}
+</div>
@@ -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");

@@ -2,13 +2,20 @@ export { default as Input } from './Input.svelte';
 export { default as InputCheckbox } from './inputs/InputCheckbox.svelte';
 export { default as InputColor } from './inputs/InputColor.svelte';
 export { default as InputNumber } from './inputs/InputNumber.svelte';
+export { default as InputSearch } from './inputs/InputSearch.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 Button } from './Button.svelte';
+export { default as ConfirmDialog } from './ConfirmDialog.svelte';
 export { default as Details } from './Details.svelte';
 export { default as JsonViewer } from './JsonViewer.svelte';
 export { default as ShortCut } from './ShortCut.svelte';
+export { default as Spinner } from './Spinner.svelte';
+export { default as Toast } from './Toast.svelte';
+export { toast } from './toast.svelte';

 import Input from './Input.svelte';
 export default Input;
@@ -46,7 +46,7 @@
      class="h-full w-8 cursor-pointer appearance-none p-0"
    />
  </label>
-  <div class="flex items-center gap-1 px-2 py-1">
+  <div class="flex items-center gap-1 px-2 py-1 border-l border-outline">
    <span class="pointer-events-none text-text opacity-30">#</span>
    <input
      type="text"
@@ -64,5 +64,6 @@
    margin-top: -1px;
    margin-right: -1px;
    height: calc(100% + 2px);
+    width: calc(100% + 2px);
  }
 </style>
@@ -1 +1,99 @@
+<script lang="ts">
+  type SelectOption = string | { value: number; label: string };

+  interface Props {
+    options?: SelectOption[];
+    value?: number;
+    id?: string;
+    placeholder?: string;
+  }
+
+  let {
+    options = [],
+    value = $bindable(0),
+    id = '',
+    placeholder = 'Search…'
+  }: Props = $props();
+
+  const normalized = $derived(
+    options.map((opt, i) => typeof opt === 'string' ? { value: i, label: opt } : opt)
+  );
+
+  const selected = $derived(normalized.find((o) => o.value === value));
+
+  let query = $state('');
+  let open = $state(false);
+  let container: HTMLDivElement;
+
+  const filtered = $derived(
+    query === ''
+      ? normalized
+      : normalized.filter((o) => o.label.toLowerCase().includes(query.toLowerCase()))
+  );
+
+  function select(val: number) {
+    value = val;
+    query = '';
+    open = false;
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape') {
+      open = false;
+      query = '';
+    }
+    if (e.key === 'ArrowDown' && filtered.length) {
+      const idx = filtered.findIndex((o) => o.value === value);
+      value = filtered[(idx + 1) % filtered.length].value;
+    }
+    if (e.key === 'ArrowUp' && filtered.length) {
+      const idx = filtered.findIndex((o) => o.value === value);
+      value = filtered[(idx - 1 + filtered.length) % filtered.length].value;
+    }
+    if (e.key === 'Enter' && filtered.length) {
+      const match = filtered.find((o) => o.value === value) ?? filtered[0];
+      select(match.value);
+    }
+  }
+
+  function handleBlur(e: FocusEvent) {
+    if (!container.contains(e.relatedTarget as Node)) {
+      open = false;
+      query = '';
+    }
+  }
+</script>
+
+<div class="relative w-full" bind:this={container} onblur={handleBlur}>
+  <input
+    {id}
+    type="text"
+    class:rounded-b-none!={open}
+    class="w-full bg-layer-2 text-text outline outline-outline px-3 py-2 rounded-md border-none font-(--font-family) text-sm box-border focus:outline-2 focus:outline-active"
+    placeholder={open ? placeholder : (selected?.label ?? placeholder)}
+    bind:value={query}
+    onfocus={() => (open = true)}
+    onkeydown={handleKeydown}
+    autocomplete="off"
+  />
+  {#if open}
+    <div
+      class="absolute w-[calc(100%+2px)] -ml-px top-[calc(100%+2px)] left-0 right-0 bg-layer-1 border border-outline rounded-b-md max-h-50 overflow-y-auto z-100"
+      role="listbox"
+    >
+      {#each filtered as opt (opt.value)}
+        <div
+          class="px-3 py-2 text-sm text-text cursor-pointer font-(--font-family) {opt.value === value ? 'bg-layer-2' : 'hover:bg-layer-2'}"
+          role="option"
+          aria-selected={opt.value === value}
+          tabindex="-1"
+          onmousedown={() => select(opt.value)}
+        >
+          {opt.label}
+        </div>
+      {:else}
+        <div class="px-3 py-2 text-xs text-text opacity-45 italic">No results</div>
+      {/each}
+    </div>
+  {/if}
+</div>
@@ -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>
@@ -0,0 +1,24 @@
+export type ToastType = 'info' | 'success' | 'error';
+
+export type ToastItem = {
+  id: number;
+  message: string;
+  type: ToastType;
+};
+
+let _toasts = $state<ToastItem[]>([]);
+let _nextId = 0;
+
+export const toasts = {
+  get value() {
+    return _toasts;
+  }
+};
+
+export function toast(message: string, type: ToastType = 'info', duration = 3000) {
+  const id = _nextId++;
+  _toasts.push({ id, message, type });
+  setTimeout(() => {
+    _toasts = _toasts.filter((t) => t.id !== id);
+  }, duration);
+}
@@ -1,16 +1,24 @@
 <script lang="ts">
+  import type { NodeInput } from '@nodarium/types';
  import '$lib/app.css';
  import {
+    Button,
+    ConfirmDialog,
    Details,
    InputCheckbox,
    InputColor,
    InputNumber,
+    InputSearch,
    InputSelect,
    InputShape,
    InputVec3,
    JsonViewer,
-    ShortCut
+    ShortCut,
+    Spinner,
+    Toast,
+    toast
  } from '$lib';
+  import SocketTable from '$lib/inputs/SocketTable.svelte';
  import Section from './Section.svelte';
  import Theme from './Theme.svelte';
  import ThemeSelector from './ThemeSelector.svelte';
@@ -38,6 +46,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) {
@@ -55,6 +74,7 @@

  let points = $state([]);
  let theme = $state('dark');
+  let confirmOpen = $state(false);
 </script>

 <main class="flex flex-col gap-8 py-8">
@@ -63,6 +83,17 @@
    <ThemeSelector bind:theme />
  </div>

+  <Section title="Button">
+    <div class="flex flex-wrap gap-3 items-center">
+      <Button>Default</Button>
+      <Button variant="primary">Primary</Button>
+      <Button variant="destructive">Destructive</Button>
+      <Button variant="ghost">Ghost</Button>
+      <Button disabled>Disabled</Button>
+      <Button size="sm">Small</Button>
+    </div>
+  </Section>
+
  <Section title="InputNumber">
    <Theme />
  </Section>
@@ -82,6 +113,13 @@
    <InputVec3 bind:value={vecValue} />
  </Section>

+  <Section title="InputSearch" value={options[selectValue]}>
+    <div class="flex flex-col gap-2">
+      <p>Searchable select — type to filter</p>
+      <InputSearch bind:value={selectValue} {options} />
+    </div>
+  </Section>
+
  <Section title="Select">
    <p>
      Select with simple values
@@ -135,12 +173,12 @@

  <Section title="JsonViewer">
    {#snippet header()}
-      <button
+      <Button
        onclick={() => randomlyUpdateJson()}
        class="-mt-1 bg-layer-2 p-1 px-2 rounded-sm cursor-pointer"
      >
        update
-      </button>
+      </Button>
    {/snippet}
    <div class="w-64 bg-layer-1 p-2 rounded">
      <JsonViewer
@@ -150,6 +188,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" />
@@ -157,8 +207,46 @@
      <ShortCut alt ctrl key="delete" />
    </div>
  </Section>
+
+  <Section title="Spinner">
+    <div class="flex gap-6 items-center">
+      <Spinner size={16} />
+      <Spinner size={24} />
+      <Spinner size={36} />
+    </div>
+  </Section>
+
+  <Section title="Toast">
+    <div class="flex gap-3">
+      <Button onclick={() => toast('Project saved successfully', 'success')}>
+        Success toast
+      </Button>
+      <Button onclick={() => toast('Something went wrong', 'error')}>
+        Error toast
+      </Button>
+      <Button onclick={() => toast('Graph is executing…', 'info')}>
+        Info toast
+      </Button>
+    </div>
+  </Section>
+
+  <Section title="ConfirmDialog">
+    <Button onclick={() => (confirmOpen = true)}>
+      Open dialog
+    </Button>
+    <ConfirmDialog
+      bind:open={confirmOpen}
+      title="Delete project?"
+      message="This action cannot be undone. The project and all its data will be permanently removed."
+      confirmLabel="Delete"
+      cancelLabel="Cancel"
+      onconfirm={() => toast('Project deleted', 'error')}
+    />
+  </Section>
 </main>

+<Toast />
+
 <style>
  main {
    max-width: 800px;
@@ -1,6 +1,6 @@
 {
  "name": "@nodarium/utils",
-  "version": "0.0.5",
+  "version": "0.0.6",
  "description": "",
  "main": "./src/index.ts",
  "type": "module",
@@ -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;
@@ -290,6 +290,9 @@ importers:
      '@types/eslint':
        specifier: ^9.6.1
        version: 9.6.1
+      '@types/node':
+        specifier: ^25.6.0
+        version: 25.6.0
      '@types/three':
        specifier: ^0.184.0
        version: 0.184.0
Author	SHA1	Message	Date
max	4dd5f633d4	fix: make eslint/typescript happy 📊 Benchmark the Runtime / benchmark (push) Successful in 1m10s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m0s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 32s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m46s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 1m48s Details	2026-05-08 10:32:03 +02:00
max	e6c368afaa	feat: update some nodes a bit 📊 Benchmark the Runtime / benchmark (push) Failing after 1m12s Details 🚀 Lint & Test & Deploy / quality (push) Failing after 58s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 33s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m37s Details 🚀 Lint & Test & Deploy / deploy (push) Has been skipped Details	2026-05-08 01:49:29 +02:00
max	581daa1be7	feat(noise): add preserveLength toggle When enabled (default), perturbs each segment's direction vector and rescales to original length — bends the path without stretching it or causing fold-back artifacts. When disabled, the original direct point displacement is used. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-05-08 01:18:44 +02:00
max	f652b712df	fix: remove redundant schema from union	2026-05-08 01:18:38 +02:00
max	68ae62527f	feat(noise): preserve segment lengths during displacement The noise node previously displaced each path point's XYZ independently, which stretched/compressed segments and produced kinked edges. After displacement, re-project each point onto the sphere of radius seg_lens[i-1] centered at the previous point — same pattern used by the gravity node. Total path length is now preserved; noise bends the path rather than stretching it. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-05-07 23:43:44 +02:00
max	49746c6079	feat(branch): phyllotactic spiral and upward angle Default rotation to the golden angle (137.5°) so successive branches spiral naturally around the stem. Add an `angle` input (-90..90°) that tilts branches between horizontal and along-stem before rotating around the stem axis. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-05-07 23:43:17 +02:00
max	e5df19b6d8	feat(ui): animate toasts	2026-05-07 21:12:53 +02:00
max	415be50ae0	feat(ui): show toast after copying jsontree node	2026-05-07 21:12:43 +02:00
max	f0f4c00137	feat: use beforeunload to make sure graph is saved	2026-05-07 21:12:23 +02:00
max	3c5f897b26	feat: bunch of small fixes	2026-05-07 21:12:10 +02:00
max	ed0c47068a	fix: dispose unused geometry	2026-05-07 21:11:48 +02:00
max	a039bddba1	feat: debounce cameraPosition saving	2026-05-07 21:11:33 +02:00
max	5fa9d36b34	feat: debounce box selection for performance	2026-05-07 21:10:52 +02:00
max	7d788f7e19	feat: surface error when dropping wasm node	2026-05-07 21:10:31 +02:00
max	bd6dfeb466	fix: remove unused svelte-ignore comment 📊 Benchmark the Runtime / benchmark (push) Successful in 1m33s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m21s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 43s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 2m2s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 2m0s Details	2026-05-07 17:44:02 +02:00
max	36f02cabd3	chore: format 📊 Benchmark the Runtime / benchmark (push) Successful in 1m21s Details 🚀 Lint & Test & Deploy / quality (push) Failing after 54s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 30s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m52s Details 🚀 Lint & Test & Deploy / deploy (push) Has been skipped Details	2026-05-07 17:40:41 +02:00
max	3a78ad5ee3	docs: add ux guidelines	2026-05-07 17:40:30 +02:00
max	9a7a7166b7	fix: pasting nodes	2026-05-07 17:39:58 +02:00
max	4aff3874d3	feat: show toast on some errors	2026-05-07 17:19:08 +02:00
max	f415edab57	fix: automatically update graph background on theme swtich	2026-05-07 17:03:02 +02:00
max	743959639f	feat: no results state in add menu	2026-05-07 17:02:47 +02:00
max	d9b8b36686	feat: update some inputs	2026-05-07 17:02:38 +02:00
max	ebf13967a4	feat: use new button component everyhwerre	2026-05-07 17:02:17 +02:00
max	a4f51efead	feat: add spinning icon	2026-05-07 17:01:54 +02:00
max	308626bcdc	feat: add toast component	2026-05-07 17:01:36 +02:00
max	73155dcb46	feat: show confirm when deleting project	2026-05-07 17:01:22 +02:00
max	84afd15746	feat: add #id to group name when duplicates exist	2026-05-07 17:00:57 +02:00
max	af40db3386	feat: add ZoomIndicator to graph	2026-05-07 17:00:30 +02:00
nodarium-bot	091c0f0a83	chore(release): v0.0.6	2026-05-05 21:15:25 +00:00
max	82c2f08a56	chore: cleanup changelog 📊 Benchmark the Runtime / benchmark (push) Successful in 1m34s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 2m7s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 47s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m28s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m59s Details	2026-05-05 22:58:42 +02:00
max	a00db400bb	fix: dont crash when no groups exist 📊 Benchmark the Runtime / benchmark (push) Successful in 1m24s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 48s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m24s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m59s Details 🚀 Lint & Test & Deploy / deploy (push) Has been cancelled Details	2026-05-05 22:52:24 +02:00
max	2d9eb0c087	fix: make planty work 📊 Benchmark the Runtime / benchmark (push) Successful in 1m18s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m9s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 33s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 1m54s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 2m4s Details	2026-05-05 22:45:20 +02:00
nodarium-bot	1e28ded99b	chore(release): v0.0.6	2026-05-05 20:33:26 +00:00
nodarium-bot	5fae518392	chore(release): v0.0.6	2026-05-05 20:23:21 +00:00
max	954f5726c3	Merge pull request 'feat: initial node groups' (#44 ) from feat/group-node-own into main 📊 Benchmark the Runtime / benchmark (push) Successful in 1m11s Details 🚀 Lint & Test & Deploy / quality (push) Successful in 2m14s Details 🚀 Lint & Test & Deploy / test-unit (push) Successful in 49s Details 🚀 Lint & Test & Deploy / test-e2e (push) Successful in 2m3s Details 🚀 Lint & Test & Deploy / deploy (push) Successful in 3m4s Details Reviewed-on: #44	2026-05-05 22:08:17 +02:00
max	63d5b8079d	chore: pnpm format 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m39s Details 🚀 Lint & Test & Deploy / quality (pull_request) Successful in 2m21s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 48s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 1m51s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Successful in 2m1s Details	2026-05-05 21:55:32 +02:00
max	3e32ca419a	feat: ungroup nodes 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m45s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m7s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Successful in 35s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 2m4s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-05 21:51:17 +02:00
max	f0cb12a088	chore: fix some type issues	2026-05-05 21:28:03 +02:00
max	1d60090ffe	chore: fixup graph manager tests	2026-05-05 21:27:53 +02:00
max	5b55056fc1	chore: remove graph element in graphManager	2026-05-05 21:27:42 +02:00
max	e2c2b1a4d7	chore: remove e2e test screenshots (too flaky)	2026-05-05 21:27:23 +02:00
max	7f082ad8f6	feat: implement node sockets ui 📊 Benchmark the Runtime / benchmark (pull_request) Successful in 1m22s Details 🚀 Lint & Test & Deploy / quality (pull_request) Failing after 1m6s Details 🚀 Lint & Test & Deploy / test-unit (pull_request) Failing after 43s Details 🚀 Lint & Test & Deploy / test-e2e (pull_request) Successful in 2m5s Details 🚀 Lint & Test & Deploy / deploy (pull_request) Has been skipped Details	2026-05-05 21:07:57 +02:00
max	ed11195327	chore: refactor graphStack to be simpler	2026-05-05 18:45:54 +02:00
max	8ad62cfc8e	feat: add node group breadcrumbs	2026-05-05 12:44:44 +02:00
max	bff140a764	feat: show different ui when inside group	2026-05-05 11:11:33 +02:00
max	85e2fd1a71	fix: use correct id for debug node	2026-05-04 23:54:43 +02:00
max	5beb03196d	fix: broken format command for @nodarium/planty	2026-05-04 23:47:29 +02:00
max	83e0e47082	refactor: only show group/node panel when selected	2026-05-04 23:47:03 +02:00