fix(ci): still trying to get gpg to work

Closes #34

.dprint.jsonc

@@ -0,0 +1,59 @@
+{
+  "$schema": "https://dprint.dev/schemas/v0.json",
+  "indentWidth": 2,
+  "lineWidth": 100,
+  "typescript": {
+    // https://dprint.dev/plugins/typescript/config/
+    "quoteStyle": "preferSingle",
+    "trailingCommas": "never",
+  },
+  "json": {
+    // https://dprint.dev/plugins/json/config/
+  },
+  "markdown": {},
+  "toml": {},
+  "dockerfile": {},
+  "markup": {
+    // https://dprint.dev/plugins/markup_fmt/config/
+    "scriptIndent": true,
+    "styleIndent": true,
+  },
+  "yaml": {},
+  "exec": {
+    "cwd": "${configDir}",
+    "commands": [
+      {
+        "command": "rustfmt",
+        "exts": [
+          "rs",
+        ],
+        "cacheKeyFiles": [
+          "rustfmt.toml",
+          "rust-toolchain.toml",
+        ],
+      },
+    ],
+  },
+  "excludes": [
+    "**/node_modules",
+    "**/build",
+    "**/.svelte-kit",
+    "**/package",
+    "**/*-lock.yaml",
+    "**/yaml.lock",
+    "**/.DS_Store",
+    "**/.pnpm-store",
+    "**/.cargo",
+    "**/target",
+  ],
+  "plugins": [
+    "https://plugins.dprint.dev/typescript-0.95.15.wasm",
+    "https://plugins.dprint.dev/json-0.21.1.wasm",
+    "https://plugins.dprint.dev/markdown-0.21.1.wasm",
+    "https://plugins.dprint.dev/toml-0.7.0.wasm",
+    "https://plugins.dprint.dev/dockerfile-0.3.3.wasm",
+    "https://plugins.dprint.dev/g-plane/markup_fmt-v0.25.3.wasm",
+    "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.6.0.wasm",
+    "https://plugins.dprint.dev/exec-0.6.0.json@a054130d458f124f9b5c91484833828950723a5af3f8ff2bd1523bd47b83b364",
+  ],
+}

.envrc

@@ -0,0 +1 @@
+use flake

.gitea/scripts/build.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+mkdir -p app/static
+
+cp CHANGELOG.md app/static/CHANGELOG.md
+
+# Derive branch/tag info
+REF_TYPE="${GITHUB_REF_TYPE:-branch}"
+REF_NAME="${GITHUB_REF_NAME:-$(basename "$GITHUB_REF")}"
+BRANCH="${GITHUB_HEAD_REF:-}"
+if [[ -z "$BRANCH" && "$REF_TYPE" == "branch" ]]; then
+  BRANCH="$REF_NAME"
+fi
+
+# Determine last tag and commits since
+LAST_TAG="$(git describe --tags --abbrev=0 2>/dev/null || true)"
+if [[ -n "$LAST_TAG" ]]; then
+  COMMITS_SINCE_LAST_RELEASE="$(git rev-list --count "${LAST_TAG}..HEAD")"
+else
+  COMMITS_SINCE_LAST_RELEASE="0"
+fi
+
+commit_message=$(git log -1 --pretty=%B | tr -d '\n' | sed 's/"/\\"/g')
+
+cat >app/static/git.json <<EOF
+{
+  "ref": "${GITHUB_REF:-}",
+  "ref_name": "${REF_NAME}",
+  "ref_type": "${REF_TYPE}",
+  "sha": "${GITHUB_SHA:-}",
+  "run_number": "${GITHUB_RUN_NUMBER:-}",
+  "event_name": "${GITHUB_EVENT_NAME:-}",
+  "workflow": "${GITHUB_WORKFLOW:-}",
+  "job": "${GITHUB_JOB:-}",
+  "commit_message": "${commit_message}",
+  "commit_timestamp": "$(git log -1 --pretty=%cI)",
+  "branch": "${BRANCH}",
+  "commits_since_last_release": "${COMMITS_SINCE_LAST_RELEASE}"
+}
+EOF
+
+pnpm build
+
+cp -R packages/ui/build app/build/ui

.gitea/scripts/create-release.sh

@@ -0,0 +1,102 @@
+#!/bin/sh
+set -eu
+
+TAG="$GITHUB_REF_NAME"
+VERSION=$(echo "$TAG" | sed 's/^v//')
+DATE=$(date +%Y-%m-%d)
+
+echo "🚀 Creating release for $TAG"
+
+# -------------------------------------------------------------------
+# 1. Extract release notes from annotated tag
+# -------------------------------------------------------------------
+
+# Ensure the local git knows this is an annotated tag with metadata
+git fetch origin "refs/tags/$TAG:refs/tags/$TAG" --force
+
+# %(contents) gets the whole message.
+# If you want ONLY what you typed after the first line, use %(contents:body)
+NOTES=$(git tag -l "$TAG" --format='%(contents)' | sed '/-----BEGIN PGP SIGNATURE-----/,/-----END PGP SIGNATURE-----/d')
+
+if [ -z "$(echo "$NOTES" | tr -d '[:space:]')" ]; then
+  echo "❌ Tag message is empty or tag is not annotated"
+  exit 1
+fi
+
+git checkout main
+
+# -------------------------------------------------------------------
+# 2. Update all package.json versions
+# -------------------------------------------------------------------
+echo "🔧 Updating package.json versions to $VERSION"
+find . -name package.json ! -path "*/node_modules/*" | while read -r file; do
+  tmp_file="$file.tmp"
+  jq --arg v "$VERSION" '.version = $v' "$file" >"$tmp_file"
+  mv "$tmp_file" "$file"
+done
+
+# -------------------------------------------------------------------
+# 3. Generate commit list since last release
+# -------------------------------------------------------------------
+LAST_TAG=$(git tag --sort=-creatordate | grep -v "^$TAG$" | head -n 1 || echo "")
+
+if [ -n "$LAST_TAG" ]; then
+  # Filter out previous 'chore(release)' commits so the list stays clean
+  COMMITS=$(git log "$LAST_TAG"..HEAD --pretty=format:'* [%h](https://git.max-richter.dev/max/nodarium/commit/%H) %s' | grep -v "chore(release)")
+else
+  COMMITS=$(git log HEAD --pretty=format:'* [%h](https://git.max-richter.dev/max/nodarium/commit/%H) %s' | grep -v "chore(release)")
+fi
+
+# -------------------------------------------------------------------
+# 4. Update CHANGELOG.md (prepend)
+# -------------------------------------------------------------------
+tmp_changelog="CHANGELOG.tmp"
+{
+  echo "# $TAG ($DATE)"
+  echo ""
+  echo "$NOTES"
+  echo ""
+  if [ -n "$COMMITS" ]; then
+    echo "---"
+    echo ""
+    echo "$COMMITS"
+    echo ""
+  fi
+  echo ""
+  if [ -f CHANGELOG.md ]; then
+    cat CHANGELOG.md
+  fi
+} >"$tmp_changelog"
+
+mv "$tmp_changelog" CHANGELOG.md
+
+pnpm exec dprint fmt CHANGELOG.md
+
+# -------------------------------------------------------------------
+# 5. Setup GPG signing
+# -------------------------------------------------------------------
+echo "$BOT_PGP_PRIVATE_KEY" | base64 -d | gpg --batch --import
+GPG_KEY_ID=$(gpg --list-secret-keys --keyid-format LONG | grep sec | awk '{print $2}' | cut -d'/' -f2)
+
+export GPG_TTY=$(tty)
+echo "allow-loopback-pinentry" >>~/.gnupg/gpg-agent.conf
+gpg-connect-agent reloadagent /bye
+
+git config user.name "nodarium-bot"
+git config user.email "nodarium-bot@max-richter.dev"
+git config --global user.signingkey "$GPG_KEY_ID"
+git config --global commit.gpgsign true
+
+# -------------------------------------------------------------------
+# 6. Create release commit
+# -------------------------------------------------------------------
+git add CHANGELOG.md $(git ls-files '**/package.json')
+
+if git diff --cached --quiet; then
+  echo "No changes to commit for release $TAG"
+else
+  git commit -m "chore(release): $TAG"
+  git push origin main
+fi
+
+echo "✅ Release process for $TAG complete"

.gitea/scripts/deploy-files.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "Configuring rclone"
+
+KEY_FILE="$(mktemp)"
+echo "${SSH_PRIVATE_KEY}" >"${KEY_FILE}"
+chmod 600 "${KEY_FILE}"
+
+mkdir -p ~/.config/rclone
+cat >~/.config/rclone/rclone.conf <<EOF
+[sftp-remote]
+type = sftp
+host = ${SSH_HOST}
+user = ${SSH_USER}
+port = ${SSH_PORT}
+key_file = ${KEY_FILE}
+EOF
+
+if [[ "${GITHUB_REF_TYPE:-}" == "tag" ]]; then
+  TARGET_DIR="${REMOTE_DIR}"
+elif [[ "${GITHUB_EVENT_NAME:-}" == "pull_request" ]]; then
+  SAFE_PR_NAME="${GITHUB_HEAD_REF//\//-}"
+  TARGET_DIR="${REMOTE_DIR}_${SAFE_PR_NAME}"
+elif [[ "${GITHUB_REF_NAME:-}" == "main" ]]; then
+  TARGET_DIR="${REMOTE_DIR}_main"
+else
+  SAFE_REF="${GITHUB_REF_NAME//\//-}"
+  TARGET_DIR="${REMOTE_DIR}_${SAFE_REF}"
+fi
+
+echo "Deploying to ${TARGET_DIR}"
+
+rclone sync \
+  --update \
+  --verbose \
+  --progress \
+  --exclude _astro/** \
+  --stats 2s \
+  --stats-one-line \
+  --transfers 4 \
+  ./app/build/ \
+  "sftp-remote:${TARGET_DIR}"

.gitea/workflows/build-ci-image.yaml

@@ -0,0 +1,41 @@
+name: Build & Push CI Image
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "Dockerfile.ci"
+      - ".gitea/workflows/build-ci-image.yaml"
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker BuildX
+        uses: docker/setup-buildx-action@v2
+        with:
+          config-inline: |
+            [registry."git.max-richter.dev"]
+              https = true
+              insecure = false
+
+      - name: Login to Gitea Registry
+        uses: docker/login-action@v3
+        with:
+          registry: git.max-richter.dev
+          username: ${{ gitea.actor }}
+          password: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: Build and Push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile.ci
+          push: true
+          tags: |
+            git.max-richter.dev/${{ gitea.repository }}-ci:latest
+            git.max-richter.dev/${{ gitea.repository }}-ci:${{ gitea.sha }}

.gitea/workflows/release.yaml

@@ -0,0 +1,83 @@
+name: 🚀 Lint & Test & Deploy
+
+on:
+  push:
+    branches: ["*"]
+    tags: ["*"]
+  pull_request:
+    branches: ["*"]
+
+env:
+  PNPM_CACHE_FOLDER: .pnpm-store
+  CARGO_HOME: .cargo
+  CARGO_TARGET_DIR: target
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    container: git.max-richter.dev/max/nodarium-ci:bce06da456e3c008851ac006033cfff256015a47
+
+    steps:
+      - name: 📑 Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: 💾 Setup pnpm Cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.PNPM_CACHE_FOLDER }}
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+
+      - name: 🦀 Cache Cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: 📦 Install Dependencies
+        run: pnpm install --frozen-lockfile --store-dir ${{ env.PNPM_CACHE_FOLDER }}
+
+      - name: 🧹 Quality Control
+        run: |
+          pnpm lint
+          pnpm format:check
+          pnpm check
+          pnpm build
+          xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test
+
+      - name: 🚀 Create Release Commit
+        if: gitea.ref_type == 'tag'
+        run: ./.gitea/scripts/create-release.sh
+        env:
+          BOT_PGP_PRIVATE_KEY: ${{ secrets.BOT_PGP_PRIVATE_KEY }}
+
+      - name: 🛠️ Build
+        run: ./.gitea/scripts/build.sh
+
+      - name: 🏷️ Create Gitea Release
+        if: gitea.ref_type == 'tag'
+        uses: akkuman/gitea-release-action@v1
+        with:
+          tag_name: ${{ gitea.ref_name }}
+          release_name: Release ${{ gitea.ref_name }}
+          body_path: CHANGELOG.md
+          draft: false
+          prerelease: false
+
+      - name: 🚀 Deploy Changed Files via rclone
+        run: ./.gitea/scripts/deploy-files.sh
+        env:
+          REMOTE_DIR: ${{ vars.REMOTE_DIR }}
+          SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
+          SSH_HOST: ${{ vars.SSH_HOST }}
+          SSH_PORT: ${{ vars.SSH_PORT }}
+          SSH_USER: ${{ vars.SSH_USER }}

.github/workflows/deploy.yaml

@@ -1,38 +0,0 @@
-name: Deploy to GitHub Pages
-
-on:
-  push:
-    branches: 'main'
-
-jobs:
-  build_site:
-    runs-on: ubuntu-latest
-    container: jimfx/nodes:latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: build
-        run: pnpm run build:deploy
-
-      - name: 🔑 Configure rclone
-        run: |
-          echo "$SSH_PRIVATE_KEY" > /tmp/id_rsa
-          chmod 600 /tmp/id_rsa
-          mkdir -p ~/.config/rclone
-          echo "[sftp-remote]\ntype = sftp\nhost = ${SSH_HOST}\nuser = ${SSH_USER}\nport = ${SSH_PORT}\nkey_file = /tmp/id_rsa" > ~/.config/rclone/rclone.conf
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
-          SSH_HOST: ${{ vars.SSH_HOST }}
-          SSH_PORT: ${{ vars.SSH_PORT }}
-          SSH_USER: ${{ vars.SSH_USER }}
-
-      - name: 🚀 Deploy Changed Files via rclone
-        run: |
-          echo "Uploading the rest"
-          rclone sync --update -v --progress --exclude _astro/** --stats 2s --stats-one-line ./app/build/ sftp-remote:${REMOTE_DIR} --transfers 4
-        env:
-          REMOTE_DIR: ${{ vars.REMOTE_DIR }}

.gitignore

@@ -4,3 +4,6 @@ node_modules/
 # Added by cargo
 
 /target
+.direnv/
+
+.pnpm-store/

CHANGELOG.md

@@ -0,0 +1,133 @@
+# v0.0.4 (2026-02-10)
+
+## Features
+
+- Added shape and leaf nodes, including rotation support.
+- Added high-contrast light theme and improved overall node readability.
+- Enhanced UI with dots background, clearer details, and consistent node coloring.
+- Improved changelog display and parsing robustness.
+
+## Fixes
+
+- Fixed UI issues (backside rendering, missing types, linter errors).
+- Improved CI handling of commit messages and changelog placement.
+
+## Chores
+
+- Simplified CI quality checks.
+- Updated dprint linters.
+- Refactored changelog code.
+
+---
+
+- [51de3ce](https://git.max-richter.dev/max/nodarium/commit/51de3ced133af07b9432e1137068ef43ddfecbc9) fix(ci): update changelog before building
+- [8d403ba](https://git.max-richter.dev/max/nodarium/commit/8d403ba8039a05b687f050993a6afca7fb743e12) Merge pull request 'feat/shape-node' (#36) from feat/shape-node into main
+- [6bb3011](https://git.max-richter.dev/max/nodarium/commit/6bb301153ac13c31511b6b28ae95c6e0d4c03e9e) Merge remote-tracking branch 'origin/main' into feat/shape-node
+- [02eee5f](https://git.max-richter.dev/max/nodarium/commit/02eee5f9bf4b1bc813d5d28673c4d5d77b392a92) fix: disable macro logs in wasm
+- [4f48a51](https://git.max-richter.dev/max/nodarium/commit/4f48a519a950123390530f1b6040e2430a767745) feat(nodes): add rotation to instance node
+- [97199ac](https://git.max-richter.dev/max/nodarium/commit/97199ac20fb079d6c157962d1a998d63670d8797) feat(nodes): implement leaf node
+- [f36f0cb](https://git.max-richter.dev/max/nodarium/commit/f36f0cb2305692c7be60889bcde7f91179e18b81) feat(ui): show circles only when hovering InputShape
+- [ed3d48e](https://git.max-richter.dev/max/nodarium/commit/ed3d48e07fa6db84bbb24db6dbe044cbc36f049f) fix(runtime): correctly encode 2d shape for wasm nodes
+- [c610d6c](https://git.max-richter.dev/max/nodarium/commit/c610d6c99152d8233235064b81503c2b0dc4ada8) fix(app): show backside in three instances
+- [8865b9b](https://git.max-richter.dev/max/nodarium/commit/8865b9b032bdf5a1385b4e9db0b1923f0e224fdd) feat(node): initial leaf / shape nodes
+- [235ee5d](https://git.max-richter.dev/max/nodarium/commit/235ee5d979fbd70b3e0fb6f09a352218c3ff1e6d) fix(app): wrong linter errors in changelog
+- [23a4857](https://git.max-richter.dev/max/nodarium/commit/23a48572f3913d91d839873cc155a16139c286a6) feat(app): dots background for node interface
+- [e89a46e](https://git.max-richter.dev/max/nodarium/commit/e89a46e146e9e95de57ffdf55b05d16d6fe975f4) feat(app): add error page
+- [cefda41](https://git.max-richter.dev/max/nodarium/commit/cefda41fcf3d5d011c9f7598a4f3f37136602dbd) feat(theme): optimize node readability
+- [21d0f0d](https://git.max-richter.dev/max/nodarium/commit/21d0f0da5a26492fa68ad4897a9b1d9e88857030) feat: add high-contrast-light theme
+- [4620245](https://git.max-richter.dev/max/nodarium/commit/46202451ba3eea73bd1bc6ef5129b3e26ee9315c) ci: simplify ci quality checks
+- [0f4239d](https://git.max-richter.dev/max/nodarium/commit/0f4239d179ddedd3d012ca98b5bc3312afbc8f10) ci: simplify ci quality checks
+- [d9c9bb5](https://git.max-richter.dev/max/nodarium/commit/d9c9bb5234bc8776daf26be99ba77a2145c70649) fix(theme): allow raw html in head style
+- [18802fd](https://git.max-richter.dev/max/nodarium/commit/18802fdc10294a58425f052a4fde4bcf4be58caf) fix(ui): add missing types
+- [b1cbd23](https://git.max-richter.dev/max/nodarium/commit/b1cbd235420c99a11154ef6a899cc7e14faf1c37) feat(app): use same color for node outline and header
+- [33f10da](https://git.max-richter.dev/max/nodarium/commit/33f10da396fdc13edcb8faaee212280102b24f3a) feat(ui): make details stand out
+- [af5b3b2](https://git.max-richter.dev/max/nodarium/commit/af5b3b23ba18d73d6abec60949fb0c9edfc25ff8) fix: make sure that CHANGELOG.md is in correct place
+- [64d75b9](https://git.max-richter.dev/max/nodarium/commit/64d75b9686c494075223a0a318297fe59ec99e81) feat(ui): add InputColor and custom theme
+- [2e6466c](https://git.max-richter.dev/max/nodarium/commit/2e6466ceca1d2131581d1862e93c756affdf6cd6) chore: update dprint linters
+- [20d8e2a](https://git.max-richter.dev/max/nodarium/commit/20d8e2abedf0de30299d947575afef9c8ffd61d9) feat(theme): improve light theme a bit
+- [715e1d0](https://git.max-richter.dev/max/nodarium/commit/715e1d095b8a77feb0cf66bbb444baf0f163adcb) feat(theme): merge edge and connection color
+- [07e2826](https://git.max-richter.dev/max/nodarium/commit/07e2826f16dafa6a07377c9fb591168fa5c2abcf) feat(ui): improve colors of input shape
+- [e0ad97b](https://git.max-richter.dev/max/nodarium/commit/e0ad97b003fd8cb4d950c03e5488a5accf6a37d0) feat(ui): highlight circle on hover on InputShape
+- [93df4a1](https://git.max-richter.dev/max/nodarium/commit/93df4a19ff816e2bdfa093594721f0829f84c9e6) fix(ci): handle newline in commit messages for git.json
+- [d661a4e](https://git.max-richter.dev/max/nodarium/commit/d661a4e4a9dfa6c9c73b5e24a3edcf56e1bbf48c) feat(ui): improve InputShape ux
+- [c7f808c](https://git.max-richter.dev/max/nodarium/commit/c7f808ce2d52925425b49f92edf49d9557f8901d) wip
+- [72d6cd6](https://git.max-richter.dev/max/nodarium/commit/72d6cd6ea2886626823e6e86856f19338c7af3c1) feat(ui): add initial InputShape element
+- [615f2d3](https://git.max-richter.dev/max/nodarium/commit/615f2d3c4866a9e85f3eca398f3f02100c4df355) feat(ui): allow custom snippets in ui section header
+- [2fadb68](https://git.max-richter.dev/max/nodarium/commit/2fadb6802de640d692fdab7d654311df0d7b4836) refactor: make changelog code simpler
+- [9271d3a](https://git.max-richter.dev/max/nodarium/commit/9271d3a7e4cb0cc751b635c2adb518de7b4100c7) fix(app): handle error while parsing commit
+- [13c83ef](https://git.max-richter.dev/max/nodarium/commit/13c83efdb962a6578ade59f10cc574fef0e17534) fix(app): handle error while parsing changelog
+- [e44b73b](https://git.max-richter.dev/max/nodarium/commit/e44b73bebfb1cc8e872cd2fa7d8b6ff3565df374) feat: optimize changelog display
+- [979e9fd](https://git.max-richter.dev/max/nodarium/commit/979e9fd92289eba9f77221c563337c00028e4cf5) feat: improve changelog readbility
+- [544500e](https://git.max-richter.dev/max/nodarium/commit/544500e7fe9ee14412cef76f3c7a32ba6f291656) chore: remove pgp from changelog
+- [aaebbc4](https://git.max-richter.dev/max/nodarium/commit/aaebbc4bc082ee93c2317ce45071c9bc61b0b77e) fix: some stuff with ci
+
+# v0.0.3 (2026-02-07)
+
+## Features
+
+- Edge dragging now highlights valid connection sockets, improving graph editing clarity.
+- InputNumber supports snapping to predefined values while holding Alt.
+- Changelog is accessible directly from the sidebar and now includes git metadata and a list of commits.
+
+## Fixes
+
+- Fixed incorrect socket highlighting when an edge already existed.
+- Corrected initialization of `InputNumber` values outside min/max bounds.
+- Fixed initialization of nested vec3 inputs.
+- Multiple CI fixes to ensure reliable builds, correct environment variables, and proper image handling.
+
+## Maintenance / CI
+
+- Significant CI and Dockerfile cleanup and optimization.
+- Improved git metadata generation during builds.
+- Dependency updates, formatting, and test snapshot updates.
+
+---
+
+- [f8a2a95](https://git.max-richter.dev/max/nodarium/commit/f8a2a95bc18fa3c8c1db67dc0c2b66db1ff0d866) chore: clean CHANGELOG.md
+- [c9dd143](https://git.max-richter.dev/max/nodarium/commit/c9dd143916d758991f3ba30723a32c18b6f98bb5) fix(ci): correctly add release notes from tag to changelog
+- [898dd49](https://git.max-richter.dev/max/nodarium/commit/898dd49aee930350af8645382ef5042765a1fac7) fix(ci): correctly copy changelog to build output
+- [9fb69d7](https://git.max-richter.dev/max/nodarium/commit/9fb69d760fdf92ecc2448e468242970ec48443b0) feat: show commits since last release in changelog
+- [bafbcca](https://git.max-richter.dev/max/nodarium/commit/bafbcca2b8a7cd9f76e961349f11ec84d1e4da63) fix: wrong socket was highlighted when dragging node
+- [8ad9e55](https://git.max-richter.dev/max/nodarium/commit/8ad9e5535cd752ef111504226b4dac57b5adcf3d) feat: highlight possible sockets when dragging edge
+- [11eaeb7](https://git.max-richter.dev/max/nodarium/commit/11eaeb719be7f34af8db8b7908008a15308c0cac) feat(app): display some git metadata in changelog
+- [74c2978](https://git.max-richter.dev/max/nodarium/commit/74c2978cd16d2dd95ce1ae8019dfb9098e52b4b6) chore: cleanup git.json a bit
+- [4fdc247](https://git.max-richter.dev/max/nodarium/commit/4fdc24790490d3f13ee94a557159617f4077a2f9) ci: update build.sh to correct git.json
+- [c3f8b4b](https://git.max-richter.dev/max/nodarium/commit/c3f8b4b5aad7a525fb11ab14c9236374cb60442d) ci: debug available env vars
+- [67591c0](https://git.max-richter.dev/max/nodarium/commit/67591c0572b873d8c7cd00db8efb7dac2d6d4de2) chore: pnpm format
+- [de1f9d6](https://git.max-richter.dev/max/nodarium/commit/de1f9d6ab669b8e699d98b8855e125e21030b5b3) feat(ui): change inputnumber to snap to values when alt is pressed
+- [6acce72](https://git.max-richter.dev/max/nodarium/commit/6acce72fb8c416cc7f6eec99c2ae94d6529e960c) fix(ui): correctly initialize InputNumber
+- [cf8943b](https://git.max-richter.dev/max/nodarium/commit/cf8943b2059aa286e41865caf75058d35498daf7) chore: pnpm update
+- [9e03d36](https://git.max-richter.dev/max/nodarium/commit/9e03d36482bb4f972c384b66b2dcf258f0cd18be) chore: use newest ci image
+- [fd7268d](https://git.max-richter.dev/max/nodarium/commit/fd7268d6208aede435e1685817ae6b271c68bd83) ci: make dockerfile work
+- [6358c22](https://git.max-richter.dev/max/nodarium/commit/6358c22a853ec340be5223fabb8289092e4f4afe) ci: use tagged own image for ci
+- [655b6a1](https://git.max-richter.dev/max/nodarium/commit/655b6a18b282f0cddcc750892e575ee6c311036b) ci: make dockerfile work
+- [37b2bdc](https://git.max-richter.dev/max/nodarium/commit/37b2bdc8bdbd8ded6b22b89214b49de46f788351) ci: update ci Dockerfile to work
+- [94e01d4](https://git.max-richter.dev/max/nodarium/commit/94e01d4ea865f15ce06b52827a1ae6906de5be5e) ci: correctly build and push ci image
+- [35f5177](https://git.max-richter.dev/max/nodarium/commit/35f5177884b62bbf119af1bbf4df61dd0291effb) feat: try to optimize the Dockerfile
+- [ac2c61f](https://git.max-richter.dev/max/nodarium/commit/ac2c61f2211ba96bbdbb542179905ca776537cec) ci: use actual git url in ci
+- [ef3d462](https://git.max-richter.dev/max/nodarium/commit/ef3d46279f4ff9c04d80bb2d9a9e7cfec63b224e) fix(ci): build before testing
+- [703da32](https://git.max-richter.dev/max/nodarium/commit/703da324fabbef0e2c017f0f7a925209fa26bd03) ci: automatically build ci image and store locally
+- [1dae472](https://git.max-richter.dev/max/nodarium/commit/1dae472253ccb5e3766f2270adc053b922f46738) ci: add a git.json metadata file during build
+- [09fdfb8](https://git.max-richter.dev/max/nodarium/commit/09fdfb88cd203ace0e36663ebdb2c8c7ba53f190) chore: update test screenshots
+- [04b63cc](https://git.max-richter.dev/max/nodarium/commit/04b63cc7e2fc4fcfa0973cf40592d11457179db3) feat: add changelog to sidebar
+- [cb6a356](https://git.max-richter.dev/max/nodarium/commit/cb6a35606dfda50b0c81b04902d7a6c8e59458d2) feat(ci): also cache cargo stuff
+- [9c9f3ba](https://git.max-richter.dev/max/nodarium/commit/9c9f3ba3b7c94215a86b0a338a5cecdd87b96b28) fix(ci): use GITHUB_instead of GITEA_ for env vars
+- [08dda2b](https://git.max-richter.dev/max/nodarium/commit/08dda2b2cb4d276846abe30bc260127626bb508a) chore: pnpm format
+- [059129a](https://git.max-richter.dev/max/nodarium/commit/059129a738d02b8b313bb301a515697c7c4315ac) fix(ci): deploy prs and main
+- [437c9f4](https://git.max-richter.dev/max/nodarium/commit/437c9f4a252125e1724686edace0f5f006f58439) feat(ci): add list of all commits to changelog entry
+- [48bf447](https://git.max-richter.dev/max/nodarium/commit/48bf447ce12949d7c29a230806d160840b7847e1) docs: straighten up changelog a bit
+- [548fa4f](https://git.max-richter.dev/max/nodarium/commit/548fa4f0a1a14adc40a74da1182fa6da81eab3df) fix(app): correctly initialize vec3 inputs in nestedsettings
+
+# v0.0.2 (2026-02-04)
+
+## Fixes
+
+---
+
+- []() fix(ci): actually deploy on tags
+- []() fix(app): correctly handle false value in settings
+
+# v0.0.1 (2026-02-03)
+
+chore: format

Cargo.lock

@@ -1,176 +1,88 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "autocfg"
-version = "1.2.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "box"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "nodarium_macros",
  "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
 ]
 
 [[package]]
 name = "branch"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
- "glam",
  "nodarium_macros",
  "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "console_error_panic_hook"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
-dependencies = [
- "cfg-if",
- "wasm-bindgen",
 ]
 
 [[package]]
 name = "float"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "nodarium_macros",
  "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
 ]
 
 [[package]]
 name = "glam"
-version = "0.27.0"
+version = "0.30.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e05e7e6723e3455f4818c7b26e855439f7546cf617ef669d1adedb8669e5cb9"
+checksum = "19fc433e8437a212d1b6f1e68c7824af3aed907da60afa994e7f542d18d12aa9"
 
 [[package]]
 name = "gravity"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "glam",
  "nodarium_macros",
  "nodarium_utils",
- "noise",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
+]
+
+[[package]]
+name = "instance"
+version = "0.1.0"
+dependencies = [
+ "glam",
+ "nodarium_macros",
+ "nodarium_utils",
 ]
 
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
-name = "js-sys"
-version = "0.3.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+name = "leaf"
+version = "0.1.0"
 dependencies = [
- "wasm-bindgen",
+ "nodarium_macros",
+ "nodarium_utils",
 ]
 
-[[package]]
-name = "log"
-version = "0.4.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
-
 [[package]]
 name = "math"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "nodarium_macros",
  "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
 ]
 
 [[package]]
-name = "max-plantarium-triangle"
-version = "0.1.0"
-dependencies = [
- "console_error_panic_hook",
- "nodarium_macros",
- "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
-]
-
-[[package]]
-name = "max-plantarium-vec3"
-version = "0.1.0"
-dependencies = [
- "console_error_panic_hook",
- "nodarium_macros",
- "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
-]
-
-[[package]]
-name = "nodarium_instance"
-version = "0.1.0"
-dependencies = [
- "console_error_panic_hook",
- "glam",
- "nodarium_macros",
- "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
-]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "nodarium_macros"
@@ -180,7 +92,7 @@ dependencies = [
  "quote",
  "serde",
  "serde_json",
- "syn 1.0.109",
+ "syn",
 ]
 
 [[package]]
@@ -195,29 +107,19 @@ dependencies = [
 name = "nodarium_utils"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "glam",
- "noise",
+ "noise 0.9.0",
  "serde",
  "serde_json",
- "wasm-bindgen",
- "web-sys",
 ]
 
 [[package]]
-name = "nodes-noise"
+name = "noise"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
- "glam",
  "nodarium_macros",
  "nodarium_utils",
- "noise",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
+ "noise 0.9.0",
 ]
 
 [[package]]
@@ -233,48 +135,35 @@ dependencies = [
 
 [[package]]
 name = "num-traits"
-version = "0.2.18"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "once_cell"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
-
 [[package]]
 name = "output"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
- "glam",
  "nodarium_macros",
  "nodarium_utils",
- "serde",
- "serde_json",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.81"
+version = "1.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
+checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
 dependencies = [
  "proc-macro2",
 ]
@@ -307,103 +196,84 @@ dependencies = [
 name = "random"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "nodarium_macros",
  "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
 ]
 
 [[package]]
 name = "rotate"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "glam",
  "nodarium_macros",
  "nodarium_utils",
  "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
 ]
 
-[[package]]
-name = "ryu"
-version = "1.0.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
-
-[[package]]
-name = "scoped-tls"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
-
 [[package]]
 name = "serde"
-version = "1.0.198"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9846a40c979031340571da2545a4e5b7c4163bdae79b301d5f86d03979451fcc"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
-[[package]]
-name = "serde-wasm-bindgen"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b4c031cd0d9014307d82b8abf653c0290fbdaeb4c02d00c63cf52f728628bf"
-dependencies = [
- "js-sys",
- "serde",
- "wasm-bindgen",
-]
-
 [[package]]
 name = "serde_derive"
-version = "1.0.198"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88edab869b01783ba905e7d0153f9fc1a6505a96e4ad3018011eedb838566d9"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.60",
+ "syn",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.116"
+version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
  "itoa",
- "ryu",
+ "memchr",
  "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "shape"
+version = "0.1.0"
+dependencies = [
+ "nodarium_macros",
+ "nodarium_utils",
 ]
 
 [[package]]
 name = "stem"
 version = "0.1.0"
 dependencies = [
- "console_error_panic_hook",
  "nodarium_macros",
  "nodarium_utils",
- "serde",
- "serde-wasm-bindgen",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
 ]
 
 [[package]]
 name = "syn"
-version = "1.0.109"
+version = "2.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -411,119 +281,30 @@ dependencies = [
 ]
 
 [[package]]
-name = "syn"
-version = "2.0.60"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
+name = "triangle"
+version = "0.1.0"
 dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
+ "nodarium_macros",
+ "nodarium_utils",
 ]
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
-name = "wasm-bindgen"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+name = "vec3"
+version = "0.1.0"
 dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
+ "nodarium_macros",
+ "nodarium_utils",
+ "serde",
 ]
 
 [[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.92"
+name = "zmij"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
-dependencies = [
- "bumpalo",
- "log",
- "once_cell",
- "proc-macro2",
- "quote",
- "syn 2.0.60",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
-dependencies = [
- "cfg-if",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.60",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
-
-[[package]]
-name = "wasm-bindgen-test"
-version = "0.3.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9bf62a58e0780af3e852044583deee40983e5886da43a271dd772379987667b"
-dependencies = [
- "console_error_panic_hook",
- "js-sys",
- "scoped-tls",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-test-macro"
-version = "0.3.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.60",
-]
-
-[[package]]
-name = "web-sys"
-version = "0.3.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
+checksum = "94f63c051f4fe3c1509da62131a678643c5b6fbdc9273b2b79d4378ebda003d2"

Dockerfile

@@ -1,18 +0,0 @@
-FROM node:22
-
-# IMAGE CUSTOMISATIONS
-
-# Install rust
-# https://github.com/rust-lang/rustup/issues/1085
-RUN RUSTUP_URL="https://sh.rustup.rs" \
-  && curl --silent --show-error --location --fail --retry 3 --proto '=https' --tlsv1.2 --output /tmp/rustup-linux-install.sh $RUSTUP_URL \
-  && bash /tmp/rustup-linux-install.sh -y \
-  && curl https://rclone.org/install.sh --output /tmp/rclone-install.sh \
-  && bash /tmp/rclone-install.sh
-
-ENV PATH=/root/.cargo/bin:$PATH
-
-RUN rustup target add wasm32-unknown-unknown \
-  && cargo install wasm-pack \
-  && npm i -g pnpm
-  

Dockerfile.ci

@@ -0,0 +1,32 @@
+FROM node:25-bookworm-slim
+
+ENV RUSTUP_HOME=/usr/local/rustup \
+  CARGO_HOME=/usr/local/cargo \
+  PATH=/usr/local/cargo/bin:$PATH
+
+RUN apt-get update && apt-get install -y \
+  ca-certificates=20230311+deb12u1 \
+  gpg=2.2.40-1.1+deb12u2 \
+  gpg-agent=2.2.40-1.1+deb12u2 \
+  curl=7.88.1-10+deb12u14 \
+  git=1:2.39.5-0+deb12u3 \
+  jq=1.6-2.1+deb12u1 \
+  g++=4:12.2.0-3 \
+  rclone=1.60.1+dfsg-2+b5 \
+  xvfb=2:21.1.7-3+deb12u11 \
+  xauth=1:1.1.2-1 \
+  --no-install-recommends \
+  # Install Rust
+  && curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \
+  --default-toolchain stable \
+  --profile minimal \
+  && rustup target add wasm32-unknown-unknown \
+  # Setup Playwright
+  && npm i -g pnpm \
+  && pnpm dlx playwright install --with-deps firefox \
+  # Final Cleanup
+  && rm -rf /usr/local/rustup/downloads /usr/local/rustup/tmp \ 
+  && rm -rf /usr/local/cargo/registry/index /usr/local/cargo/registry/cache \ 
+  && rm -rf /usr/local/rustup/toolchains/*/share/doc \ 
+  && apt-get purge -y --auto-remove \ 
+  && rm -rf /var/lib/apt/lists/*

README.md

@@ -2,17 +2,17 @@ Nodarium
 
 <div align="center">
 
-  <a href="https://nodes.max-richter.dev/"><h2 align="center">Nodarium</h2></a>
+<a href="https://nodes.max-richter.dev/"><h2 align="center">Nodarium</h2></a>
 
-  <p align="center">
-    Nodarium is a WebAssembly based visual programming language. 
+<p align="center">
+    Nodarium is a WebAssembly based visual programming language.
   </p>
 
-  <img src=".github/graphics/nodes.svg" width="80%"/>
+<img src=".gitea/graphics/nodes.svg" width="80%"/>
 
 </div>
 
-Currently this visual programming language is used to develop https://nodes.max-richter.dev, a procedural modelling tool for 3d-plants.
+Currently this visual programming language is used to develop <https://nodes.max-richter.dev>, a procedural modelling tool for 3d-plants.
 
 # Table of contents
 
@@ -22,7 +22,7 @@ Currently this visual programming language is used to develop https://nodes.max-
 
 # Developing
 
-### Install prerequisites:
+### Install prerequisites
 
 - [Node.js](https://nodejs.org/en/download)
 - [pnpm](https://pnpm.io/installation)
@@ -50,4 +50,29 @@ pnpm dev
 
 ### [Now you can create your first node 🤓](./docs/DEVELOPING_NODES.md)
 
+# Releasing
+
+## Creating a Release
+
+1. **Create an annotated tag** with your release notes:
+
+```bash
+git tag -a v1.0.0 -m "Release notes for this version"
+git push origin v1.0.0
+```
+
+2. **The CI workflow will:**
+   - Run lint, format check, and type check
+   - Build the project
+   - Update all `package.json` versions to match the tag
+   - Generate/update `CHANGELOG.md`
+   - Create a release commit on `main`
+   - Publish a Gitea release
+
+## Version Requirements
+
+- Tag must match pattern `v*` (e.g., `v1.0.0`, `v2.3.1`)
+- Tag message must not be empty (annotated tag required)
+- Tag must be pushed from `main` branch
+
 # Roadmap

app/.env

@@ -0,0 +1 @@
+PUBLIC_ANALYTIC_SCRIPT=""

app/.gitignore

@@ -27,3 +27,5 @@ dist-ssr
 *.sln
 *.sw?
 build/
+
+test-results/

app/Dockerfile

@@ -0,0 +1,32 @@
+FROM jimfx/nodes:latest AS builder
+
+WORKDIR /app
+
+COPY pnpm-lock.yaml pnpm-workspace.yaml package.json Cargo.lock Cargo.toml ./
+
+COPY packages/ ./packages/
+COPY nodes/ ./nodes/
+COPY app/package.json ./app/
+
+RUN --mount=type=cache,id=pnpm-store,target=/root/.local/share/pnpm/store \
+  --mount=type=cache,target=/usr/local/cargo/registry \
+  --mount=type=cache,target=/app/target \
+  pnpm install --frozen-lockfile
+
+COPY . .
+
+RUN --mount=type=cache,id=pnpm-store,target=/root/.local/share/pnpm/store \
+  --mount=type=cache,target=/usr/local/cargo/registry \
+  --mount=type=cache,target=/app/target \
+  pnpm build:nodes && \
+  pnpm --filter @nodarium/app... build
+
+FROM nginx:alpine AS runner
+
+RUN rm /etc/nginx/conf.d/default.conf
+
+COPY app/docker/app.conf /etc/nginx/conf.d/app.conf
+
+COPY --from=builder /app/app/build /app
+
+EXPOSE 80

app/README.md

@@ -1,7 +1 @@
-# Tauri + Svelte + Typescript
-
-This template should help get you started developing with Tauri, Svelte and TypeScript in Vite.
-
-## Recommended IDE Setup
-
-[VS Code](https://code.visualstudio.com/) + [Svelte](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode) + [Tauri](https://marketplace.visualstudio.com/items?itemName=tauri-apps.tauri-vscode) + [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer).
+# Nodarium App

app/docker/app.conf

@@ -0,0 +1,10 @@
+server {
+    listen 80;
+    server_name _;
+    root /app;
+    index index.html;
+
+    location / {
+        try_files \$uri \$uri/ /index.html;
+    }
+}

app/e2e/main.test.ts

@@ -0,0 +1,62 @@
+import { expect, test } from '@playwright/test';
+
+test('test', async ({ page }) => {
+  // Listen for console messages
+  page.on('console', msg => {
+    console.log(`[Browser Console] ${msg.type()}: ${msg.text()}`);
+  });
+
+  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');
+  await page.getByRole('textbox', { name: 'Project name' }).click();
+  await page.getByRole('textbox', { name: 'Project name' }).fill('Test Project');
+  await page.getByRole('button', { name: 'Create' }).click();
+
+  const expectedNodes = [
+    {
+      id: '10',
+      type: 'max/plantarium/stem',
+      props: {
+        amount: 50,
+        length: 4,
+        thickness: 1
+      }
+    },
+    {
+      id: '11',
+      type: 'max/plantarium/noise',
+      props: {
+        scale: 0.5,
+        strength: 5
+      }
+    },
+    {
+      id: '9',
+      type: 'max/plantarium/output'
+    }
+  ];
+
+  for (const node of expectedNodes) {
+    const wrapper = page.locator(
+      `div.wrapper[data-node-id="${node.id}"][data-node-type="${node.type}"]`
+    );
+    await expect(wrapper).toBeVisible();
+    if ('props' in node) {
+      const props = node.props as unknown as Record<string, number>;
+      for (const propId in node.props) {
+        const expectedValue = props[propId];
+        const inputElement = page.locator(
+          `div.wrapper[data-node-type="${node.type}"][data-node-input="${propId}"] input[type="number"]`
+        );
+        const value = parseFloat(await inputElement.inputValue());
+        expect(value).toBe(expectedValue);
+      }
+    }
+  }
+});

app/eslint.config.mjs

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

app/package.json

@@ -1,46 +1,63 @@
 {
-  "name": "@nodes/app",
+  "name": "@nodarium/app",
   "private": true,
-  "version": "0.0.0",
+  "version": "0.0.4",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
+    "predev": "rm static/CHANGELOG.md && ln -s ../../CHANGELOG.md static/CHANGELOG.md",
     "build": "svelte-kit sync && vite build",
-    "test": "vitest",
-    "preview": "vite preview"
+    "test:unit": "vitest",
+    "test": "npm run test:unit -- --run && npm run test:e2e",
+    "test:e2e": "playwright test",
+    "preview": "vite preview",
+    "format": "dprint fmt -c '../.dprint.jsonc' .",
+    "format:check": "dprint check -c '../.dprint.jsonc' .",
+    "lint": "eslint .",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json"
   },
   "dependencies": {
-    "@nodes/registry": "link:../packages/registry",
-    "@nodes/ui": "link:../packages/ui",
-    "@nodes/utils": "link:../packages/utils",
-    "@sveltejs/kit": "^2.12.2",
-    "@threlte/core": "8.0.0-next.23",
-    "@threlte/extras": "9.0.0-next.33",
-    "@types/three": "^0.171.0",
-    "@unocss/reset": "^0.65.2",
+    "@nodarium/ui": "workspace:*",
+    "@nodarium/utils": "workspace:*",
+    "@sveltejs/kit": "^2.50.2",
+    "@tailwindcss/vite": "^4.1.18",
+    "@threlte/core": "8.3.1",
+    "@threlte/extras": "9.7.1",
     "comlink": "^4.4.2",
     "file-saver": "^2.0.5",
-    "idb": "^8.0.1",
-    "jsondiffpatch": "^0.6.0",
-    "three": "^0.171.0"
+    "idb": "^8.0.3",
+    "jsondiffpatch": "^0.7.3",
+    "micromark": "^4.0.2",
+    "tailwindcss": "^4.1.18",
+    "three": "^0.182.0"
   },
   "devDependencies": {
-    "@iconify-json/tabler": "^1.2.13",
-    "@nodes/types": "link:../packages/types",
-    "@sveltejs/adapter-static": "^3.0.6",
-    "@sveltejs/vite-plugin-svelte": "^5.0.3",
-    "@tsconfig/svelte": "^5.0.4",
+    "@eslint/compat": "^2.0.2",
+    "@eslint/js": "^9.39.2",
+    "@iconify-json/tabler": "^1.2.26",
+    "@iconify/tailwind4": "^1.2.1",
+    "@nodarium/types": "workspace:^",
+    "@playwright/test": "^1.58.1",
+    "@sveltejs/adapter-static": "^3.0.10",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@tsconfig/svelte": "^5.0.7",
     "@types/file-saver": "^2.0.7",
-    "@unocss/preset-icons": "^0.65.2",
-    "svelte": "^5.14.4",
-    "svelte-check": "^4.1.1",
+    "@types/three": "^0.182.0",
+    "@vitest/browser-playwright": "^4.0.18",
+    "dprint": "^0.51.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-svelte": "^3.14.0",
+    "globals": "^17.3.0",
+    "svelte": "^5.49.2",
+    "svelte-check": "^4.3.6",
     "tslib": "^2.8.1",
-    "typescript": "^5.7.2",
-    "unocss": "^0.65.2",
-    "vite": "^6.0.4",
-    "vite-plugin-comlink": "^5.1.0",
-    "vite-plugin-glsl": "^1.3.1",
-    "vite-plugin-wasm": "^3.3.0",
-    "vitest": "^2.1.8"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "vite": "^7.3.1",
+    "vite-plugin-comlink": "^5.3.0",
+    "vite-plugin-glsl": "^1.5.5",
+    "vite-plugin-wasm": "^3.5.0",
+    "vitest": "^4.0.18",
+    "vitest-browser-svelte": "^2.0.2"
   }
 }

app/playwright.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  webServer: { command: 'pnpm build && pnpm preview', port: 4173 },
+  testDir: 'e2e',
+  use: {
+    browserName: 'firefox',
+    launchOptions: {
+      firefoxUserPrefs: {
+        // Force WebGL even without a GPU
+        'webgl.force-enabled': true,
+        'webgl.disabled': false,
+        // Use software rendering (Mesa) instead of hardware
+        'layers.acceleration.disabled': true,
+        'gfx.webrender.software': true,
+        'webgl.enable-webgl2': true
+      }
+    }
+  }
+});

app/src/app.css

@@ -0,0 +1,10 @@
+@import "tailwindcss";
+@source "../../packages/ui/**/*.svelte";
+@plugin "@iconify/tailwind4" {
+  prefix: "i";
+  icon-sets: from-folder("custom", "./src/lib/icons");
+}
+
+body * {
+  color: var(--color-text);
+}

app/src/app.d.ts

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

app/src/app.html

@@ -1,29 +1,26 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%sveltekit.assets%/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    %sveltekit.head%
+    <title>Nodes</title>
+    <script>
+      var store = localStorage.getItem('node-settings');
+      if (store) {
+        try {
+          var value = JSON.parse(store);
+          var themes = ['dark', 'light', 'catppuccin'];
+          if (themes[value.theme]) {
+            document.documentElement.classList.add('theme-' + themes[value.theme]);
+          }
+        } catch (e) {}
+      }
+    </script>
+  </head>
 
-<head>
-  <meta charset="utf-8" />
-  <link rel="icon" href="%sveltekit.assets%/svelte.svg" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <script defer src="https://umami.max-richter.dev/script.js" data-website-id="585c442b-0524-4874-8955-f9853b44b17e"></script>
-  %sveltekit.head%
-  <title>Nodes</title>
-  <script>
-    var store = localStorage.getItem("node-settings");
-    if (store) {
-      try {
-        var value = JSON.parse(store);
-        var themes = ["dark", "light", "catppuccin"];
-        if (themes[value.theme]) {
-          document.documentElement.classList.add("theme-" + themes[value.theme]);
-        }
-      } catch (e) { }
-    }
-  </script>
-</head>
-
-<body data-sveltekit-preload-data="hover">
-  <div style="display: contents">%sveltekit.body%</div>
-</body>
-
+  <body data-sveltekit-preload-data="hover">
+    <div style="display: contents">%sveltekit.body%</div>
+  </body>
 </html>

app/src/lib/config.ts

@@ -0,0 +1,2 @@
+import { PUBLIC_ANALYTIC_SCRIPT } from '$env/static/public';
+export const ANALYTIC_SCRIPT = PUBLIC_ANALYTIC_SCRIPT;

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

@@ -1,168 +0,0 @@
-<script lang="ts">
-  import type { GraphManager } from "./graph-manager.js";
-  import { HTML } from "@threlte/extras";
-  import { onMount } from "svelte";
-
-  export let position: [x: number, y: number] | null;
-
-  export let graph: GraphManager;
-
-  let input: HTMLInputElement;
-  let value: string = "";
-  let activeNodeId: string = "";
-
-  const allNodes = graph.getNodeDefinitions();
-
-  function filterNodes() {
-    return allNodes.filter((node) => node.id.includes(value));
-  }
-
-  $: nodes = value === "" ? allNodes : filterNodes();
-  $: if (nodes) {
-    if (activeNodeId === "") {
-      activeNodeId = nodes[0].id;
-    } else if (nodes.length) {
-      const node = nodes.find((node) => node.id === activeNodeId);
-      if (!node) {
-        activeNodeId = nodes[0].id;
-      }
-    }
-  }
-
-  function handleKeyDown(event: KeyboardEvent) {
-    event.stopImmediatePropagation();
-
-    if (event.key === "Escape") {
-      position = null;
-      return;
-    }
-
-    if (event.key === "ArrowDown") {
-      const index = nodes.findIndex((node) => node.id === activeNodeId);
-      activeNodeId = nodes[(index + 1) % nodes.length].id;
-      return;
-    }
-
-    if (event.key === "ArrowUp") {
-      const index = nodes.findIndex((node) => node.id === activeNodeId);
-      activeNodeId = nodes[(index - 1 + nodes.length) % nodes.length].id;
-      return;
-    }
-
-    if (event.key === "Enter") {
-      if (activeNodeId && position) {
-        graph.createNode({ type: activeNodeId, position });
-        position = null;
-      }
-      return;
-    }
-  }
-
-  onMount(() => {
-    input.disabled = false;
-    setTimeout(() => input.focus(), 50);
-  });
-</script>
-
-<HTML position.x={position?.[0]} position.z={position?.[1]} transform={false}>
-  <div class="add-menu-wrapper">
-    <div class="header">
-      <input
-        id="add-menu"
-        type="text"
-        aria-label="Search for a node type"
-        role="searchbox"
-        placeholder="Search..."
-        disabled={false}
-        on:keydown={handleKeyDown}
-        bind:value
-        bind:this={input}
-      />
-    </div>
-
-    <div class="content">
-      {#each nodes as node}
-        <div
-          class="result"
-          role="treeitem"
-          tabindex="0"
-          aria-selected={node.id === activeNodeId}
-          on:keydown={(event) => {
-            if (event.key === "Enter") {
-              if (position) {
-                graph.createNode({ type: node.id, position, props: {} });
-                position = null;
-              }
-            }
-          }}
-          on:mousedown={() => {
-            if (position) {
-              graph.createNode({ type: node.id, position, props: {} });
-              position = null;
-            }
-          }}
-          on:focus={() => {
-            activeNodeId = node.id;
-          }}
-          class:selected={node.id === activeNodeId}
-          on:mouseover={() => {
-            activeNodeId = node.id;
-          }}
-        >
-          {node.id.split("/").at(-1)}
-        </div>
-      {/each}
-    </div>
-  </div>
-</HTML>
-
-<style>
-  .header {
-    padding: 5px;
-  }
-
-  input {
-    background: var(--layer-0);
-    font-family: var(--font-family);
-    border: none;
-    border-radius: 5px;
-    color: var(--text-color);
-    padding: 0.6em;
-    width: calc(100% - 2px);
-    box-sizing: border-box;
-    font-size: 0.8em;
-    margin-left: 1px;
-    margin-top: 1px;
-  }
-
-  input:focus {
-    outline: solid 2px rgba(255, 255, 255, 0.2);
-  }
-
-  .add-menu-wrapper {
-    position: absolute;
-    background: var(--layer-1);
-    border-radius: 7px;
-    overflow: hidden;
-    border: solid 2px var(--layer-2);
-    width: 150px;
-  }
-  .content {
-    min-height: none;
-    width: 100%;
-    color: var(--text-color);
-  }
-
-  .result {
-    padding: 1em 0.9em;
-    border-bottom: solid 1px var(--layer-2);
-    opacity: 0.7;
-    font-size: 0.9em;
-    cursor: pointer;
-  }
-
-  .result[aria-selected="true"] {
-    background: var(--layer-2);
-    opacity: 1;
-  }
-</style>

app/src/lib/graph-interface/background/Background.frag

@@ -1,4 +1,6 @@
 precision highp float;
+// For WebGL1 make sure this extension is enabled in your material:
+// #extension GL_OES_standard_derivatives : enable
 
 varying vec2 vUv;
 
@@ -9,34 +11,47 @@ uniform vec3 camPos;
 uniform vec2 zoomLimits;
 uniform vec3 backgroundColor;
 uniform vec3 lineColor;
+uniform int gridType; // 0 = grid lines, 1 = dots
+
+// Anti-aliased step: threshold in the same units as `value`
+float aaStep(float threshold, float value, float deriv) {
+    float w = deriv * 0.5; // ~one pixel
+    return smoothstep(threshold - w, threshold + w, value);
+}
 
 float grid(float x, float y, float divisions, float thickness) {
-    x = fract(x * divisions);
-    x = min(x, 1.0 - x);
+    // Continuous grid coordinates
+    float gx = x * divisions;
+    float gy = y * divisions;
 
-    float xdelta = fwidth(x);
-    x = smoothstep(x - xdelta, x + xdelta, thickness);
+    // Distance to nearest grid line (0 at the line)
+    float fx = fract(gx);
+    fx = min(fx, 1.0 - fx);
+    float fy = fract(gy);
+    fy = min(fy, 1.0 - fy);
 
-    y = fract(y * divisions);
-    y = min(y, 1.0 - y);
+    // Derivatives in screen space – use the continuous coords here
+    float dx = fwidth(gx);
+    float dy = fwidth(gy);
 
-    float ydelta = fwidth(y);
-    y = smoothstep(y - ydelta, y + ydelta, thickness);
+    // Keep the original semantics: thickness is the threshold in the [0, 0.5] distance domain
+    float lineX = 1.0 - aaStep(thickness, fx, dx);
+    float lineY = 1.0 - aaStep(thickness, fy, dy);
 
-    return clamp(x + y, 0.0, 1.0);
+    return clamp(lineX + lineY, 0.0, 1.0);
 }
 
 float circle_grid(float x, float y, float divisions, float circleRadius) {
+    float gridX = mod(x + divisions * 0.5, divisions) - divisions * 0.5;
+    float gridY = mod(y + divisions * 0.5, divisions) - divisions * 0.5;
 
-    float gridX = mod(x + divisions/2.0, divisions) - divisions / 2.0;
-    float gridY = mod(y + divisions/2.0, divisions) - divisions / 2.0;
+    vec2 g = vec2(gridX, gridY);
+    float d = length(g);
 
-    // Calculate the distance from the center of the grid
-    float gridDistance = length(vec2(gridX, gridY));
-
-    // Use smoothstep to create a smooth transition at the edges of the circle
-    float circle = 1.0 - smoothstep(circleRadius - 0.5, circleRadius + 0.5, gridDistance);
+    // Screen-space derivative for AA on the circle edge
+    float w = fwidth(d);
 
+    float circle = 1.0 - smoothstep(circleRadius - w, circleRadius + w, d);
     return circle;
 }
 
@@ -56,44 +71,59 @@ void main(void) {
     float minZ = zoomLimits.x;
     float maxZ = zoomLimits.y;
 
-    float divisions = 0.1/cz;
-    float thickness = 0.05/cz;
-    float delta = 0.1 / 2.0;
+    float divisions = 0.1 / cz;
+    float thickness = 0.05 / cz;
 
     float nz = (cz - minZ) / (maxZ - minZ);
 
-    float ux = (vUv.x-0.5) * width + cx*cz;
-    float uy = (vUv.y-0.5) * height - cy*cz;
+    float ux = (vUv.x - 0.5) * width + cx * cz;
+    float uy = (vUv.y - 0.5) * height - cy * cz;
 
+    if(gridType == 0) {
+      // extra small grid
+      float m1 = grid(ux, uy, divisions * 4.0,  thickness * 4.0)  * 0.9;
+      float m2 = grid(ux, uy, divisions * 16.0, thickness * 16.0) * 0.5;
+      float xsmall = max(m1, m2);
+      
+      float s3 = circle_grid(ux, uy, cz / 1.6, 1.0) * 0.5;
+      xsmall = max(xsmall, s3);
 
-    //extra small grid
-    float m1 = grid(ux, uy, divisions*4.0, thickness*4.0) * 0.9;
-    float m2 = grid(ux, uy, divisions*16.0, thickness*16.0) * 0.5;
-    float xsmall = max(m1, m2);
-    
-    float s3 = circle_grid(ux, uy, cz/1.6, 1.0) * 0.5;
-    xsmall = max(xsmall, s3);
+      // small grid
+      float c1 = grid(ux, uy, divisions,        thickness)        * 0.6;
+      float c2 = grid(ux, uy, divisions * 2.0,  thickness * 2.0)  * 0.5;
+      float small = max(c1, c2);
 
-    // small grid
-    float c1 = grid(ux, uy, divisions, thickness) * 0.6;
-    float c2 = grid(ux, uy, divisions*2.0, thickness) * 0.5;
-    float small = max(c1, c2);
+      float s1 = circle_grid(ux, uy, cz * 10.0, 2.0) * 0.5;
+      small = max(small, s1);
 
-    float s1 = circle_grid(ux, uy, cz*10.0, 2.0) * 0.5;
-    small = max(small, s1);
+      // large grid
+      float c3 = grid(ux, uy, divisions / 8.0,  thickness / 8.0)  * 0.5;
+      float c4 = grid(ux, uy, divisions / 2.0,  thickness / 4.0)  * 0.4;
+      float large = max(c3, c4);
 
-    // large grid
-    float c3 = grid(ux, uy, divisions/8.0, thickness/8.0) * 0.5;
-    float c4 = grid(ux, uy, divisions/2.0, thickness/4.0) * 0.4;
-    float large = max(c3, c4);
+      float s2 = circle_grid(ux, uy, cz * 20.0, 1.0) * 0.4;
+      large = max(large, s2);
 
-    float s2 = circle_grid(ux, uy, cz*20.0, 1.0) * 0.4;
-    large = max(large, s2);
+      float c = mix(large, small, min(nz * 2.0 + 0.05, 1.0));
+      c = mix(c, xsmall, clamp((nz - 0.3) / 0.7, 0.0, 1.0));
 
-    float c = mix(large, small, min(nz*2.0+0.05, 1.0));
-    c = mix(c, xsmall, max(min((nz-0.3)/0.7, 1.0), 0.0));
+      vec3 color = mix(backgroundColor, lineColor, c); 
 
-    vec3 color = mix(backgroundColor, lineColor, c); 
+      gl_FragColor = vec4(color, 1.0);
+    } else {
+      float large = circle_grid(ux, uy, cz * 20.0, 1.0) * 0.4;
+
+      float medium = circle_grid(ux, uy, cz * 10.0, 1.0) * 0.6;
+
+      float small = circle_grid(ux, uy, cz * 2.5, 1.0) * 0.8;
+
+      float c = mix(large, medium, min(nz * 2.0 + 0.05, 1.0));
+      c = mix(c, small, clamp((nz - 0.3) / 0.7, 0.0, 1.0));
+
+      vec3 color = mix(backgroundColor, lineColor, c); 
+
+      gl_FragColor = vec4(color, 1.0);
+    }
 
-    gl_FragColor = vec4(color, 1.0);
 }
+

app/src/lib/graph-interface/background/Background.story.svelte

@@ -1,21 +0,0 @@
-<script lang="ts">
-  import type { Hst } from "@histoire/plugin-svelte";
-  export let Hst: Hst;
-  import Background from "./Background.svelte";
-  import { Canvas } from "@threlte/core";
-  import Camera from "../Camera.svelte";
-  let width = globalThis.innerWidth || 100;
-  let height = globalThis.innerHeight || 100;
-
-  let cameraPosition: [number, number, number] = [0, 1, 0];
-</script>
-
-<svelte:window bind:innerWidth={width} bind:innerHeight={height} />
-
-<Hst.Story>
-  <Canvas shadows={false}>
-    <Camera bind:position={cameraPosition} />
-
-    <Background {cameraPosition} {width} {height} />
-  </Canvas>
-</Hst.Story>

app/src/lib/graph-interface/background/Background.svelte

@@ -1,17 +1,17 @@
 <script lang="ts">
-  import { T } from "@threlte/core";
-  import BackgroundVert from "./Background.vert";
-  import BackgroundFrag from "./Background.frag";
-  import { colors } from "../graph/colors.svelte";
-  import { Color } from "three";
-  import { appSettings } from "$lib/settings/app-settings.svelte";
+  import { appSettings } from '$lib/settings/app-settings.svelte';
+  import { T } from '@threlte/core';
+  import { colors } from '../graph/colors.svelte';
+  import BackgroundFrag from './Background.frag';
+  import BackgroundVert from './Background.vert';
 
   type Props = {
-    minZoom: number;
-    maxZoom: number;
-    cameraPosition: [number, number, number];
-    width: number;
-    height: number;
+    minZoom?: number;
+    maxZoom?: number;
+    cameraPosition?: [number, number, number];
+    width?: number;
+    height?: number;
+    type?: 'grid' | 'dots' | 'none';
   };
 
   let {
@@ -20,8 +20,17 @@
     cameraPosition = [0, 1, 0],
     width = globalThis?.innerWidth || 100,
     height = globalThis?.innerHeight || 100,
+    type = 'grid'
   }: Props = $props();
 
+  const typeMap = new Map([
+    ['grid', 0],
+    ['dots', 1],
+    ['none', 2]
+  ]);
+
+  const gridType = $derived(typeMap.get(type) || 0);
+
   let bw = $derived(width / cameraPosition[2]);
   let bh = $derived(height / cameraPosition[2]);
 </script>
@@ -39,27 +48,31 @@
       fragmentShader={BackgroundFrag}
       uniforms={{
         camPos: {
-          value: [0, 1, 0],
+          value: [0, 1, 0]
         },
         backgroundColor: {
-          value: colors["layer-0"].clone(),
+          value: colors['layer-0']
         },
         lineColor: {
-          value: colors["outline"].clone(),
+          value: colors['outline']
         },
         zoomLimits: {
-          value: [2, 50],
+          value: [2, 50]
         },
         dimensions: {
-          value: [100, 100],
+          value: [100, 100]
         },
+        gridType: {
+          value: 0
+        }
       }}
       uniforms.camPos.value={cameraPosition}
-      uniforms.backgroundColor.value={appSettings.theme &&
-        colors["layer-0"].clone()}
-      uniforms.lineColor.value={appSettings.theme && colors["outline"].clone()}
+      uniforms.backgroundColor.value={appSettings.value.theme
+      && colors['layer-0']}
+      uniforms.lineColor.value={appSettings.value.theme && colors['outline']}
       uniforms.zoomLimits.value={[minZoom, maxZoom]}
       uniforms.dimensions.value={[width, height]}
+      uniforms.gridType.value={gridType}
     />
   </T.Mesh>
 </T.Group>

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

@@ -0,0 +1,244 @@
+<script lang="ts">
+  import type { NodeId, NodeInstance } from '@nodarium/types';
+  import { HTML } from '@threlte/extras';
+  import { onMount } from 'svelte';
+  import { getGraphManager, getGraphState } from '../graph-state.svelte';
+
+  type Props = {
+    paddingLeft?: number;
+    paddingRight?: number;
+    paddingTop?: number;
+    paddingBottom?: number;
+    onnode: (n: NodeInstance) => void;
+  };
+
+  const padding = 10;
+
+  const {
+    paddingLeft = padding,
+    paddingRight = padding,
+    paddingTop = padding,
+    paddingBottom = padding,
+    onnode
+  }: Props = $props();
+
+  const graph = getGraphManager();
+  const graphState = getGraphState();
+
+  let input: HTMLInputElement;
+  let value = $state<string>();
+  let activeNodeId = $state<NodeId>();
+
+  const MENU_WIDTH = 150;
+  const MENU_HEIGHT = 350;
+
+  const allNodes = graphState.activeSocket
+    ? graph.getPossibleNodes(graphState.activeSocket)
+    : graph.getNodeDefinitions();
+
+  function filterNodes() {
+    return allNodes.filter((node) => node.id.includes(value ?? ''));
+  }
+
+  const nodes = $derived(value === '' ? allNodes : filterNodes());
+  $effect(() => {
+    if (nodes) {
+      if (activeNodeId === undefined) {
+        activeNodeId = nodes?.[0]?.id;
+      } else if (nodes.length) {
+        const node = nodes.find((node) => node.id === activeNodeId);
+        if (!node) {
+          activeNodeId = nodes[0].id;
+        }
+      }
+    }
+  });
+
+  function handleNodeCreation(nodeType: NodeInstance['type']) {
+    if (!graphState.addMenuPosition) return;
+    onnode?.({
+      id: -1,
+      type: nodeType,
+      position: [...graphState.addMenuPosition],
+      props: {},
+      state: {}
+    });
+  }
+
+  function handleKeyDown(event: KeyboardEvent) {
+    event.stopImmediatePropagation();
+
+    if (event.key === 'Escape') {
+      graphState.addMenuPosition = null;
+      return;
+    }
+
+    if (event.key === 'ArrowDown') {
+      const index = nodes.findIndex((node) => node.id === activeNodeId);
+      activeNodeId = nodes[(index + 1) % nodes.length].id;
+      return;
+    }
+
+    if (event.key === 'ArrowUp') {
+      const index = nodes.findIndex((node) => node.id === activeNodeId);
+      activeNodeId = nodes[(index - 1 + nodes.length) % nodes.length].id;
+      return;
+    }
+
+    if (event.key === 'Enter') {
+      if (activeNodeId && graphState.addMenuPosition) {
+        handleNodeCreation(activeNodeId);
+      }
+      return;
+    }
+  }
+
+  function clampAddMenuPosition() {
+    if (!graphState.addMenuPosition) return;
+
+    const camX = graphState.cameraPosition[0];
+    const camY = graphState.cameraPosition[1];
+    const zoom = graphState.cameraPosition[2];
+
+    const halfViewportWidth = (graphState.width / 2) / zoom;
+    const halfViewportHeight = (graphState.height / 2) / zoom;
+
+    const halfMenuWidth = (MENU_WIDTH / 2) / zoom;
+    const halfMenuHeight = (MENU_HEIGHT / 2) / zoom;
+
+    const minX = camX - halfViewportWidth - halfMenuWidth + paddingLeft / zoom;
+    const maxX = camX + halfViewportWidth - halfMenuWidth - paddingRight / zoom;
+    const minY = camY - halfViewportHeight - halfMenuHeight + paddingTop / zoom;
+    const maxY = camY + halfViewportHeight - halfMenuHeight - paddingBottom / zoom;
+
+    const clampedX = Math.max(
+      minX + halfMenuWidth,
+      Math.min(graphState.addMenuPosition[0], maxX - halfMenuWidth)
+    );
+    const clampedY = Math.max(
+      minY + halfMenuHeight,
+      Math.min(graphState.addMenuPosition[1], maxY - halfMenuHeight)
+    );
+
+    if (clampedX !== graphState.addMenuPosition[0] || clampedY !== graphState.addMenuPosition[1]) {
+      graphState.addMenuPosition = [clampedX, clampedY];
+    }
+  }
+
+  $effect(() => {
+    const pos = graphState.addMenuPosition;
+    const zoom = graphState.cameraPosition[2];
+    const width = graphState.width;
+    const height = graphState.height;
+
+    if (pos && zoom && width && height) {
+      clampAddMenuPosition();
+    }
+  });
+
+  onMount(() => {
+    input.disabled = false;
+    setTimeout(() => input.focus(), 50);
+  });
+</script>
+
+<HTML
+  position.x={graphState.addMenuPosition?.[0]}
+  position.z={graphState.addMenuPosition?.[1]}
+  transform={false}
+>
+  <div class="add-menu-wrapper">
+    <div class="header">
+      <input
+        id="add-menu"
+        type="text"
+        aria-label="Search for a node type"
+        role="searchbox"
+        placeholder="Search..."
+        disabled={false}
+        onkeydown={handleKeyDown}
+        bind:value
+        bind:this={input}
+      />
+    </div>
+
+    <div class="content">
+      {#each nodes as node (node.id)}
+        <div
+          class="result"
+          role="treeitem"
+          tabindex="0"
+          aria-selected={node.id === activeNodeId}
+          onkeydown={(event) => {
+            if (event.key === 'Enter') {
+              handleNodeCreation(node.id);
+            }
+          }}
+          onmousedown={() => handleNodeCreation(node.id)}
+          onfocus={() => {
+            activeNodeId = node.id;
+          }}
+          class:selected={node.id === activeNodeId}
+          onmouseover={() => {
+            activeNodeId = node.id;
+          }}
+        >
+          {node.id.split('/').at(-1)}
+        </div>
+      {/each}
+    </div>
+  </div>
+</HTML>
+
+<style>
+  .header {
+    padding: 5px;
+  }
+
+  input {
+    background: var(--color-layer-0);
+    font-family: var(--font-family);
+    border: none;
+    border-radius: 5px;
+    color: var(--text-color);
+    padding: 0.6em;
+    width: calc(100% - 2px);
+    box-sizing: border-box;
+    font-size: 0.8em;
+    margin-left: 1px;
+    margin-top: 1px;
+  }
+
+  input:focus {
+    outline: solid 2px rgba(255, 255, 255, 0.2);
+  }
+
+  .add-menu-wrapper {
+    position: absolute;
+    background: var(--color-layer-1);
+    border-radius: 7px;
+    overflow: hidden;
+    border: solid 2px var(--color-layer-2);
+    width: 150px;
+  }
+  .content {
+    min-height: none;
+    width: 100%;
+    color: var(--text-color);
+    max-height: 300px;
+    overflow-y: auto;
+  }
+
+  .result {
+    padding: 1em 0.9em;
+    border-bottom: solid 1px var(--color-layer-2);
+    opacity: 0.7;
+    font-size: 0.9em;
+    cursor: pointer;
+  }
+
+  .result[aria-selected="true"] {
+    background: var(--color-layer-2);
+    opacity: 1;
+  }
+</style>

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

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { HTML } from "@threlte/extras";
+  import { HTML } from '@threlte/extras';
 
   type Props = {
     p1: { x: number; y: number };
@@ -10,7 +10,7 @@
   const {
     p1 = { x: 0, y: 0 },
     p2 = { x: 0, y: 0 },
-    cameraPosition = [0, 1, 0],
+    cameraPosition = [0, 1, 0]
   }: Props = $props();
 
   const width = $derived(Math.abs(p1.x - p2.x) * cameraPosition[2]);
@@ -24,14 +24,15 @@
   <div
     class="box-selection"
     style={`width: ${width}px; height: ${height}px;`}
-  ></div>
+  >
+  </div>
 </HTML>
 
 <style>
   .box-selection {
     width: 40px;
     height: 20px;
-    border: solid 2px var(--outline);
+    border: solid 2px var(--color-outline);
     border-style: dashed;
     border-radius: 2px;
   }

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

@@ -1,6 +1,6 @@
 <script lang="ts">
-  import { T } from "@threlte/core";
-  import { type OrthographicCamera } from "three";
+  import { T } from '@threlte/core';
+  import { type OrthographicCamera } from 'three';
   type Props = {
     camera: OrthographicCamera;
     position: [number, number, number];

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

@@ -1,6 +1,6 @@
 <script lang="ts">
-  import type { NodeDefinition, NodeRegistry } from "@nodes/types";
-  import { onDestroy, onMount } from "svelte";
+  import type { NodeDefinition, NodeRegistry } from '@nodarium/types';
+  import { onMount } from 'svelte';
 
   let mx = $state(0);
   let my = $state(0);
@@ -20,15 +20,15 @@
     my = ev.clientY;
     if (!target) return;
 
-    const closest = target?.closest?.("[data-node-type]");
+    const closest = target?.closest?.('[data-node-type]');
 
     if (!closest) {
       node = undefined;
       return;
     }
 
-    let nodeType = closest.getAttribute("data-node-type");
-    let nodeInput = closest.getAttribute("data-node-input");
+    let nodeType = closest.getAttribute('data-node-type');
+    let nodeInput = closest.getAttribute('data-node-input');
 
     if (!nodeType) {
       node = undefined;
@@ -40,9 +40,9 @@
 
   onMount(() => {
     const style = wrapper.parentElement?.style;
-    style?.setProperty("cursor", "help");
+    style?.setProperty('cursor', 'help');
     return () => {
-      style?.removeProperty("cursor");
+      style?.removeProperty('cursor');
     };
   });
 </script>
@@ -53,12 +53,12 @@
   class="help-wrapper p-4"
   class:visible={node}
   bind:clientWidth={width}
-  style="--my:{my}px; --mx:{Math.min(mx, window.innerWidth - width - 20)}px;"
+  style="--my: {my}px; --mx: {Math.min(mx, window.innerWidth - width - 20)}px"
   bind:this={wrapper}
 >
   <p class="m-0 text-light opacity-40 flex items-center gap-3 mb-4">
     <span class="i-tabler-help block w-4 h-4"></span>
-    {node?.id.split("/").at(-1) || "Help"}
+    {node?.id.split('/').at(-1) || 'Help'}
     {#if input}
       <span>> {input}</span>
     {/if}
@@ -77,7 +77,7 @@
     {#if !input}
       <div>
         <span class="i-tabler-arrow-right opacity-30">-></span>
-        {node?.outputs?.map((o) => o).join(", ") ?? "nothing"}
+        {node?.outputs?.map((o) => o).join(', ') ?? 'nothing'}
       </div>
     {/if}
   {/if}
@@ -88,12 +88,12 @@
     position: fixed;
     pointer-events: none;
     transform: translate(var(--mx), var(--my));
-    background: var(--layer-1);
+    background: var(--color-layer-1);
     border-radius: 5px;
     top: 10px;
     left: 10px;
     max-width: 250px;
-    border: 1px solid var(--outline);
+    border: 1px solid var(--color-outline);
     z-index: 10000;
     display: none;
   }

app/src/lib/graph-interface/debug/Debug.svelte

@@ -1,19 +1,65 @@
 <script lang="ts">
-	import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
-	import { points, lines } from './store.js';
-	import { T } from '@threlte/core';
+  import type { Box } from '@nodarium/types';
+  import { T } from '@threlte/core';
+  import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
+  import { Color, Vector3 } from 'three';
+  import { lines, points, rects } from './store.js';
+
+  type Line = {
+    points: Vector3[];
+    color?: Color;
+  };
+
+  function getEachKey(value: Vector3 | Box | Line): string {
+    if ('x' in value) {
+      return [value.x, value.y, value.z].join('-');
+    }
+    if ('minX' in value) {
+      return [value.maxX, value.minX, value.maxY, value.minY].join('-');
+    }
+
+    if ('points' in value) {
+      return getEachKey(value.points[Math.floor(value.points.length / 2)]);
+    }
+
+    return '';
+  }
 </script>
 
-{#each $points as point}
-	<T.Mesh position.x={point.x} position.y={point.y} position.z={point.z} rotation.x={-Math.PI / 2}>
-		<T.CircleGeometry args={[0.2, 32]} />
-		<T.MeshBasicMaterial color="red" />
-	</T.Mesh>
+{#each $points as point (getEachKey(point))}
+  <T.Mesh
+    position.x={point.x}
+    position.y={point.y}
+    position.z={point.z}
+    rotation.x={-Math.PI / 2}
+  >
+    <T.CircleGeometry args={[0.2, 32]} />
+    <T.MeshBasicMaterial color="red" />
+  </T.Mesh>
 {/each}
 
-{#each $lines as line}
-	<T.Mesh>
-		<MeshLineGeometry points={line} />
-		<MeshLineMaterial color="red" linewidth={1} attenuate={false} />
-	</T.Mesh>
+{#each $rects as rect, i (getEachKey(rect))}
+  <T.Mesh
+    position.x={(rect.minX + rect.maxX) / 2}
+    position.y={0}
+    position.z={(rect.minY + rect.maxY) / 2}
+    rotation.x={-Math.PI / 2}
+  >
+    <T.PlaneGeometry args={[rect.maxX - rect.minX, rect.maxY - rect.minY]} />
+    <T.MeshBasicMaterial
+      color={new Color().setHSL((i * 1.77) % 1, 1, 0.5)}
+      opacity={0.9}
+    />
+  </T.Mesh>
+{/each}
+
+{#each $lines as line (getEachKey(line))}
+  <T.Mesh position.y={1}>
+    <MeshLineGeometry points={line.points} />
+    <MeshLineMaterial
+      color={line.color || 'red'}
+      linewidth={1}
+      attenuate={false}
+    />
+  </T.Mesh>
 {/each}

app/src/lib/graph-interface/debug/index.ts

@@ -1,5 +1,8 @@
-import { Vector3 } from "three/src/math/Vector3.js";
-import { lines, points } from "./store";
+import type { Box } from '@nodarium/types';
+import type { Color } from 'three';
+import { Vector3 } from 'three/src/math/Vector3.js';
+import Component from './Debug.svelte';
+import { lines, points, rects } from './store';
 
 export function debugPosition(x: number, y: number) {
   points.update((p) => {
@@ -8,18 +11,27 @@ export function debugPosition(x: number, y: number) {
   });
 }
 
+export function debugRect(rect: Box) {
+  rects.update((r) => {
+    r.push(rect);
+    return r;
+  });
+}
+
 export function clear() {
   points.set([]);
   lines.set([]);
+  rects.set([]);
 }
 
-export function debugLine(line: Vector3[]) {
+export function debugLine(points: Vector3[], color?: Color) {
   lines.update((l) => {
-    l.push(line);
+    l.push({ points, color });
     return l;
   });
 }
 
-import Component from "./Debug.svelte";
-
-export default Component
+export default Component;
+export function clearLines() {
+  lines.set([]);
+}

app/src/lib/graph-interface/debug/store.ts

@@ -1,6 +1,8 @@
-import { writable } from "svelte/store";
-import { Vector3 } from "three/src/math/Vector3.js";
+import type { Box } from '@nodarium/types';
+import { writable } from 'svelte/store';
+import type { Color } from 'three';
+import { Vector3 } from 'three/src/math/Vector3.js';
 
 export const points = writable<Vector3[]>([]);
-
-export const lines = writable<Vector3[][]>([]);
+export const rects = writable<Box[]>([]);
+export const lines = writable<{ points: Vector3[]; color?: Color }[]>([]);

app/src/lib/graph-interface/edges/Edge.svelte

@@ -1,119 +1,149 @@
 <script module lang="ts">
-  import { colors } from "../graph/colors.svelte";
+  import { colors } from '../graph/colors.svelte';
 
   const circleMaterial = new MeshBasicMaterial({
-    color: colors.edge.clone(),
-    toneMapped: false,
-  });
-  $effect.root(() => {
-    $effect(() => {
-      appSettings.theme;
-      circleMaterial.color = colors.edge.clone().convertSRGBToLinear();
-    });
+    color: colors.outline.clone(),
+    toneMapped: false
   });
 
-  const lineCache = new Map<number, BufferGeometry>();
+  $effect.root(() => {
+    $effect(() => {
+      if (appSettings.value.theme === undefined) {
+        return;
+      }
+      circleMaterial.color = colors.outline.clone().convertSRGBToLinear();
+    });
+  });
 
   const curve = new CubicBezierCurve(
     new Vector2(0, 0),
     new Vector2(0, 0),
     new Vector2(0, 0),
-    new Vector2(0, 0),
+    new Vector2(0, 0)
   );
 </script>
 
 <script lang="ts">
-  import { T } from "@threlte/core";
-  import { MeshLineMaterial } from "@threlte/extras";
-  import { BufferGeometry, MeshBasicMaterial, Vector3 } from "three";
-  import { CubicBezierCurve } from "three/src/extras/curves/CubicBezierCurve.js";
-  import { Vector2 } from "three/src/math/Vector2.js";
-  import { createEdgeGeometry } from "./createEdgeGeometry.js";
-  import { appSettings } from "$lib/settings/app-settings.svelte";
+  import { appSettings } from '$lib/settings/app-settings.svelte';
+  import { T } from '@threlte/core';
+  import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
+  import { onDestroy } from 'svelte';
+  import { MeshBasicMaterial, Vector3 } from 'three';
+  import { CubicBezierCurve } from 'three/src/extras/curves/CubicBezierCurve.js';
+  import { Vector2 } from 'three/src/math/Vector2.js';
+  import { getGraphState } from '../graph-state.svelte';
+  import MeshGradientLineMaterial from './MeshGradientLine/MeshGradientLineMaterial.svelte';
+
+  const graphState = getGraphState();
 
   type Props = {
-    from: { x: number; y: number };
-    to: { x: number; y: number };
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
     z: number;
+    id?: string;
+    inputType?: string;
+    outputType?: string;
   };
 
-  const { from, to, z }: Props = $props();
+  const { x1, y1, x2, y2, z, inputType = 'unknown', outputType = 'unknown', id }: Props = $props();
 
-  let geometry: BufferGeometry | null = $state(null);
+  const thickness = $derived(Math.max(0.001, 0.00082 * Math.exp(0.055 * z)));
 
-  const lineColor = $derived(
-    appSettings.theme && colors.edge.clone().convertSRGBToLinear(),
-  );
+  const inputColor = $derived(graphState.colors.getColor(inputType));
+  const outputColor = $derived(graphState.colors.getColor(outputType));
 
-  let lastId: number | null = null;
+  let points = $state<Vector3[]>([]);
 
-  const primeA = 31;
-  const primeB = 37;
+  let lastId: string | null = null;
+  const curveId = $derived(`${x1}-${y1}-${x2}-${y2}`);
 
   function update() {
-    const new_x = to.x - from.x;
-    const new_y = to.y - from.y;
-    const curveId = new_x * primeA + new_y * primeB;
+    const new_x = x2 - x1;
+    const new_y = y2 - y1;
     if (lastId === curveId) {
       return;
     }
-
-    const mid = new Vector2(new_x / 2, new_y / 2);
-
-    if (lineCache.has(curveId)) {
-      geometry = lineCache.get(curveId)!;
-      return;
-    }
+    lastId = curveId;
 
     const length = Math.floor(
-      Math.sqrt(Math.pow(new_x, 2) + Math.pow(new_y, 2)) / 4,
+      Math.sqrt(Math.pow(new_x, 2) + Math.pow(new_y, 2)) / 4
     );
 
     const samples = Math.max(length * 16, 10);
 
     curve.v0.set(0, 0);
-    curve.v1.set(mid.x, 0);
-    curve.v2.set(mid.x, new_y);
+    curve.v1.set(new_x / 2, 0);
+    curve.v2.set(new_x / 2, new_y);
     curve.v3.set(new_x, new_y);
 
-    const points = curve
+    points = curve
       .getPoints(samples)
       .map((p) => new Vector3(p.x, 0, p.y))
       .flat();
 
-    geometry = createEdgeGeometry(points);
-    lineCache.set(curveId, geometry);
+    if (id) {
+      graphState.setEdgeGeometry(
+        id,
+        x1,
+        y1,
+        $state.snapshot(points) as unknown as Vector3[]
+      );
+    }
   }
 
   $effect(() => {
-    if (from || to) {
+    if (x1 || x2 || y1 || y2) {
       update();
     }
   });
+
+  onDestroy(() => {
+    if (id) graphState.removeEdgeGeometry(id);
+  });
 </script>
 
 <T.Mesh
-  position.x={from.x}
-  position.z={from.y}
+  position.x={x1}
+  position.z={y1}
   position.y={0.8}
   rotation.x={-Math.PI / 2}
-  material={circleMaterial}
 >
   <T.CircleGeometry args={[0.5, 16]} />
+  <T.MeshBasicMaterial color={inputColor} toneMapped={false} />
 </T.Mesh>
 
 <T.Mesh
-  position.x={to.x}
-  position.z={to.y}
+  position.x={x2}
+  position.z={y2}
   position.y={0.8}
   rotation.x={-Math.PI / 2}
   material={circleMaterial}
 >
   <T.CircleGeometry args={[0.5, 16]} />
+  <T.MeshBasicMaterial color={outputColor} toneMapped={false} />
 </T.Mesh>
 
-{#if geometry}
-  <T.Mesh position.x={from.x} position.z={from.y} position.y={0.1} {geometry}>
-    <MeshLineMaterial width={Math.max(z * 0.0001, 0.00001)} color={lineColor} />
+{#if graphState.hoveredEdgeId === id}
+  <T.Mesh position.x={x1} position.z={y1} position.y={0.1}>
+    <MeshLineGeometry {points} />
+    <MeshLineMaterial
+      width={thickness * 5}
+      color={inputColor}
+      tonemapped={false}
+      opacity={0.5}
+      transparent
+    />
   </T.Mesh>
 {/if}
+
+<T.Mesh position.x={x1} position.z={y1} position.y={0.1}>
+  <MeshLineGeometry {points} />
+  <MeshGradientLineMaterial
+    width={thickness}
+    colorStart={inputColor}
+    colorEnd={outputColor}
+    tonemapped={false}
+  />
+</T.Mesh>

app/src/lib/graph-interface/edges/FloatingEdge.svelte

@@ -1,12 +0,0 @@
-<script lang="ts">
-  import Edge from "./Edge.svelte";
-
-  type Props = {
-    from: { x: number; y: number };
-    to: { x: number; y: number };
-    z: number;
-  };
-  const { from, to, z }: Props = $props();
-</script>
-
-<Edge {from} {to} {z} />

app/src/lib/graph-interface/edges/MeshGradientLine/MeshGradientLineMaterial.svelte

@@ -0,0 +1,112 @@
+<script lang="ts">
+  import { T, useThrelte } from '@threlte/core';
+  import { Color, ShaderMaterial, Vector2 } from 'three';
+  import fragmentShader from './fragment.frag';
+  import type { MeshLineMaterialProps } from './types';
+  import vertexShader from './vertex.vert';
+
+  let {
+    opacity = 1,
+    colorStart = '#ffffff',
+    colorEnd = '#ffffff',
+    dashOffset = 0,
+    dashArray = 0,
+    dashRatio = 0,
+    attenuate = true,
+    width = 1,
+    scaleDown = 0,
+    alphaMap,
+    ref = $bindable(),
+    children,
+    ...props
+  }: MeshLineMaterialProps = $props();
+
+  let { invalidate, size } = useThrelte();
+
+  // svelte-ignore state_referenced_locally
+  const uniforms = {
+    lineWidth: { value: width },
+    colorStart: { value: new Color(colorStart) },
+    colorEnd: { value: new Color(colorEnd) },
+    opacity: { value: opacity },
+    resolution: { value: new Vector2(1, 1) },
+    sizeAttenuation: { value: attenuate ? 1 : 0 },
+    dashArray: { value: dashArray },
+    useDash: { value: dashArray > 0 ? 1 : 0 },
+    dashOffset: { value: dashOffset },
+    dashRatio: { value: dashRatio },
+    scaleDown: { value: scaleDown / 10 },
+    alphaTest: { value: 0 },
+    alphaMap: { value: alphaMap },
+    useAlphaMap: { value: alphaMap ? 1 : 0 }
+  };
+
+  const material = new ShaderMaterial({ uniforms });
+
+  $effect.pre(() => {
+    uniforms.lineWidth.value = width;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.opacity.value = opacity;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.resolution.value.set($size.width, $size.height);
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.sizeAttenuation.value = attenuate ? 1 : 0;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.dashArray.value = dashArray;
+    uniforms.useDash.value = dashArray > 0 ? 1 : 0;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.dashOffset.value = dashOffset;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.dashRatio.value = dashRatio;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.scaleDown.value = scaleDown / 10;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.alphaMap.value = alphaMap;
+    uniforms.useAlphaMap.value = alphaMap ? 1 : 0;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.colorStart.value.set(colorStart);
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.colorEnd.value.set(colorEnd);
+    invalidate();
+  });
+</script>
+
+<T
+  is={material}
+  bind:ref
+  {fragmentShader}
+  {vertexShader}
+  {...props}
+>
+  {@render children?.({ ref: material })}
+</T>

app/src/lib/graph-interface/edges/MeshGradientLine/fragment.frag

@@ -0,0 +1,30 @@
+uniform vec3 colorStart;
+uniform vec3 colorEnd;
+
+uniform float useDash;
+uniform float dashArray;
+uniform float dashOffset;
+uniform float dashRatio;
+uniform sampler2D alphaMap;
+uniform float useAlphaMap;
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying float vCounters;
+
+vec4 CustomLinearTosRGB( in vec4 value ) {
+	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
+}
+
+void main()	{
+
+  vec4 c = mix(vec4(colorStart,1.0),vec4(colorEnd, 1.0), vCounters);
+
+	if( useAlphaMap == 1. ) c.a *= texture2D( alphaMap, vUV ).r;
+
+	if( useDash == 1. ){
+		c.a *= ceil(mod(vCounters + dashOffset, dashArray) - (dashArray * dashRatio));
+	}
+
+	gl_FragColor = CustomLinearTosRGB(c);
+}

app/src/lib/graph-interface/edges/MeshGradientLine/types.ts

@@ -0,0 +1,68 @@
+import type { Props } from '@threlte/core';
+import type { BufferGeometry, Vector3 } from 'three';
+import type { ColorRepresentation, ShaderMaterial, Texture } from 'three';
+
+export type MeshLineGeometryProps = Props<BufferGeometry> & {
+  /**
+   * @default []
+   */
+  points: Vector3[];
+
+  /**
+   * @default 'none'
+   */
+  shape?: 'none' | 'taper' | 'custom';
+
+  /**
+   * @default () => 1
+   */
+  shapeFunction?: (p: number) => number;
+};
+
+export type MeshLineMaterialProps =
+  & Omit<
+    Props<ShaderMaterial>,
+    'uniforms' | 'fragmentShader' | 'vertexShader'
+  >
+  & {
+    /**
+     * @default 1
+     */
+    opacity?: number;
+
+    /**
+     * @default '#ffffff'
+     */
+    color?: ColorRepresentation;
+
+    /**
+     * @default 0
+     */
+    dashOffset?: number;
+
+    /**
+     * @default 0
+     */
+    dashArray?: number;
+
+    /**
+     * @default 0
+     */
+    dashRatio?: number;
+
+    /**
+     * @default true
+     */
+    attenuate?: boolean;
+
+    /**
+     * @default 1
+     */
+    width?: number;
+
+    /**
+     * @default 0
+     */
+    scaleDown?: number;
+    alphaMap?: Texture | undefined;
+  };

app/src/lib/graph-interface/edges/MeshGradientLine/vertex.vert

@@ -0,0 +1,83 @@
+attribute vec3 previous;
+attribute vec3 next;
+attribute float side;
+attribute float width;
+attribute float counters;
+
+uniform vec2 resolution;
+uniform float lineWidth;
+uniform vec3 color;
+uniform float opacity;
+uniform float sizeAttenuation;
+uniform float scaleDown;
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying float vCounters;
+
+vec2 intoScreen(vec4 i) {
+    return resolution * (0.5 * i.xy / i.w + 0.5);
+}
+
+void main() {
+    float aspect = resolution.y / resolution.x;
+
+    mat4 m = projectionMatrix * modelViewMatrix;
+
+    vec4 currentClip = m * vec4( position, 1.0 );
+    vec4 prevClip = m * vec4( previous, 1.0 );
+    vec4 nextClip = m * vec4( next, 1.0 );
+
+    vec4 currentNormed = currentClip / currentClip.w;
+    vec4 prevNormed = prevClip / prevClip.w;
+    vec4 nextNormed = nextClip / nextClip.w;
+
+    vec2 currentScreen = intoScreen(currentNormed);
+    vec2 prevScreen = intoScreen(prevNormed);
+    vec2 nextScreen = intoScreen(nextNormed);
+
+    float actualWidth = lineWidth * width;
+
+    vec2 dir;
+    if(nextScreen == currentScreen) {
+        dir = normalize( currentScreen - prevScreen );
+    } else if(prevScreen == currentScreen) {
+        dir = normalize( nextScreen - currentScreen );
+    } else {
+        vec2 inDir = currentScreen - prevScreen;
+        vec2 outDir = nextScreen - currentScreen;
+        vec2 fullDir = nextScreen - prevScreen;
+
+        if(length(fullDir) > 0.0) {
+            dir = normalize(fullDir);
+        } else if(length(inDir) > 0.0){
+            dir = normalize(inDir);
+        } else {
+            dir = normalize(outDir);
+        }
+    }
+
+    vec2 normal = vec2(-dir.y, dir.x);
+
+    if(sizeAttenuation != 0.0) {
+        normal /= currentClip.w;
+        normal *= min(resolution.x, resolution.y);
+    }
+
+    if (scaleDown > 0.0) {
+        float dist = length(nextNormed - prevNormed);
+        normal *= smoothstep(0.0, scaleDown, dist);
+    }
+
+    vec2 offsetInScreen = actualWidth * normal * side * 0.5;
+
+    vec2 withOffsetScreen = currentScreen + offsetInScreen;
+    vec3 withOffsetNormed = vec3((2.0 * withOffsetScreen/resolution - 1.0), currentNormed.z);
+
+    vCounters = counters;
+    vColor = vec4( color, opacity );
+    vUV = uv;
+
+    gl_Position = currentClip.w * vec4(withOffsetNormed, 1.0);
+
+}

app/src/lib/graph-interface/edges/createEdgeGeometry.ts

@@ -1,116 +0,0 @@
-import { BufferAttribute, BufferGeometry, Vector3 } from 'three';
-import { setXY, setXYZ, setXYZW, setXYZXYZ } from './utils.js';
-
-
-export function createEdgeGeometry(points: Vector3[]) {
-
-  const length = points[0].distanceTo(points[points.length - 1]);
-
-  const startRadius = 8;
-  const constantWidth = 2;
-  const taperFraction = 0.8 / length;
-
-  function ease(t: number) {
-    return t * t * (3 - 2 * t);
-  }
-  let shapeFunction = (alpha: number) => {
-    if (alpha < taperFraction) {
-      const easedAlpha = ease(alpha / taperFraction);
-      return startRadius + (constantWidth - startRadius) * easedAlpha;
-    } else if (alpha > 1 - taperFraction) {
-      const easedAlpha = ease((alpha - (1 - taperFraction)) / taperFraction);
-      return constantWidth + (startRadius - constantWidth) * easedAlpha;
-    } else {
-      return constantWidth;
-    }
-  };
-
-  // When the component first runs we create the buffer geometry and allocate the buffer attributes
-  let pointCount = points.length
-  let counters: number[] = []
-  let counterIndex = 0
-  let side: number[] = []
-  let widthArray: number[] = []
-  let doubleIndex = 0
-  let uvArray: number[] = []
-  let uvIndex = 0
-  let indices: number[] = []
-  let indicesIndex = 0
-
-
-
-  for (let j = 0; j < pointCount; j++) {
-    const c = j / points.length
-    counters[counterIndex + 0] = c
-    counters[counterIndex + 1] = c
-    counterIndex += 2
-
-    setXY(side, doubleIndex, 1, -1)
-    let width = shapeFunction((j / (pointCount - 1)))
-    setXY(widthArray, doubleIndex, width, width)
-    doubleIndex += 2
-
-    setXYZW(uvArray, uvIndex, j / (pointCount - 1), 0, j / (pointCount - 1), 1)
-    uvIndex += 4
-
-    if (j < pointCount - 1) {
-      const n = j * 2
-      setXYZ(indices, indicesIndex, n + 0, n + 1, n + 2)
-      setXYZ(indices, indicesIndex + 3, n + 2, n + 1, n + 3)
-      indicesIndex += 6
-    }
-  }
-
-  const geometry = new BufferGeometry()
-  // create these buffer attributes at the correct length but leave them empty for now
-  geometry.setAttribute('position', new BufferAttribute(new Float32Array(pointCount * 6), 3))
-  geometry.setAttribute('previous', new BufferAttribute(new Float32Array(pointCount * 6), 3))
-  geometry.setAttribute('next', new BufferAttribute(new Float32Array(pointCount * 6), 3))
-  // create and populate these buffer attributes
-  geometry.setAttribute('counters', new BufferAttribute(new Float32Array(counters), 1))
-  geometry.setAttribute('side', new BufferAttribute(new Float32Array(side), 1))
-  geometry.setAttribute('width', new BufferAttribute(new Float32Array(widthArray), 1))
-  geometry.setAttribute('uv', new BufferAttribute(new Float32Array(uvArray), 2))
-  geometry.setIndex(new BufferAttribute(new Uint16Array(indices), 1))
-
-
-
-  let positions: number[] = []
-  let previous: number[] = []
-  let next: number[] = []
-  let positionIndex = 0
-  let previousIndex = 0
-  let nextIndex = 0
-  setXYZXYZ(previous, previousIndex, points[0].x, points[0].y, points[0].z)
-  previousIndex += 6
-  for (let j = 0; j < pointCount; j++) {
-    const p = points[j]
-    setXYZXYZ(positions, positionIndex, p.x, p.y, p.z)
-    positionIndex += 6
-    if (j < pointCount - 1) {
-      setXYZXYZ(previous, previousIndex, p.x, p.y, p.z)
-      previousIndex += 6
-    }
-    if (j > 0 && j + 1 <= pointCount) {
-      setXYZXYZ(next, nextIndex, p.x, p.y, p.z)
-      nextIndex += 6
-    }
-  }
-  setXYZXYZ(
-    next,
-    nextIndex,
-    points[pointCount - 1].x,
-    points[pointCount - 1].y,
-    points[pointCount - 1].z
-  )
-  const positionAttribute = (geometry.getAttribute('position') as BufferAttribute).set(positions)
-  const previousAttribute = (geometry.getAttribute('previous') as BufferAttribute).set(previous)
-  const nextAttribute = (geometry.getAttribute('next') as BufferAttribute).set(next)
-  positionAttribute.needsUpdate = true
-  previousAttribute.needsUpdate = true
-  nextAttribute.needsUpdate = true
-  geometry.computeBoundingSphere()
-
-  return geometry;
-
-}

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

@@ -1,23 +1,23 @@
 export const setXYZXYZ = (array: number[], location: number, x: number, y: number, z: number) => {
-  array[location + 0] = x
-  array[location + 1] = y
-  array[location + 2] = z
+  array[location + 0] = x;
+  array[location + 1] = y;
+  array[location + 2] = z;
 
-  array[location + 3] = x
-  array[location + 4] = y
-  array[location + 5] = z
-}
+  array[location + 3] = x;
+  array[location + 4] = y;
+  array[location + 5] = z;
+};
 
 export const setXY = (array: number[], location: number, x: number, y: number) => {
-  array[location + 0] = x
-  array[location + 1] = y
-}
+  array[location + 0] = x;
+  array[location + 1] = y;
+};
 
 export const setXYZ = (array: number[], location: number, x: number, y: number, z: number) => {
-  array[location + 0] = x
-  array[location + 1] = y
-  array[location + 2] = z
-}
+  array[location + 0] = x;
+  array[location + 1] = y;
+  array[location + 2] = z;
+};
 
 export const setXYZW = (
   array: number[],
@@ -27,8 +27,8 @@ export const setXYZW = (
   z: number,
   w: number
 ) => {
-  array[location + 0] = x
-  array[location + 1] = y
-  array[location + 2] = z
-  array[location + 3] = w
-}
+  array[location + 0] = x;
+  array[location + 1] = y;
+  array[location + 2] = z;
+  array[location + 3] = w;
+};

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

@@ -0,0 +1,265 @@
+import { describe, expect, it } from 'vitest';
+import { GraphManager } from './graph-manager.svelte';
+import {
+  createMockNodeRegistry,
+  mockFloatInputNode,
+  mockFloatOutputNode,
+  mockGeometryOutputNode,
+  mockPathInputNode,
+  mockVec3OutputNode
+} from './test-utils';
+
+describe('GraphManager', () => {
+  describe('getPossibleSockets', () => {
+    describe('when dragging an output socket', () => {
+      it('should return compatible input sockets based on type', () => {
+        const registry = createMockNodeRegistry([
+          mockFloatOutputNode,
+          mockFloatInputNode,
+          mockGeometryOutputNode,
+          mockPathInputNode
+        ]);
+
+        const manager = new GraphManager(registry);
+
+        const floatInputNode = manager.createNode({
+          type: 'test/node/input',
+          position: [100, 100],
+          props: {}
+        });
+
+        const floatOutputNode = manager.createNode({
+          type: 'test/node/output',
+          position: [0, 0],
+          props: {}
+        });
+
+        expect(floatInputNode).toBeDefined();
+        expect(floatOutputNode).toBeDefined();
+
+        const possibleSockets = manager.getPossibleSockets({
+          node: floatOutputNode!,
+          index: 0,
+          position: [0, 0]
+        });
+
+        expect(possibleSockets.length).toBe(1);
+        const socketNodeIds = possibleSockets.map(([node]) => node.id);
+        expect(socketNodeIds).toContain(floatInputNode!.id);
+      });
+
+      it('should exclude self node from possible sockets', () => {
+        const registry = createMockNodeRegistry([
+          mockFloatOutputNode,
+          mockFloatInputNode
+        ]);
+
+        const manager = new GraphManager(registry);
+
+        const floatInputNode = manager.createNode({
+          type: 'test/node/input',
+          position: [100, 100],
+          props: {}
+        });
+
+        expect(floatInputNode).toBeDefined();
+
+        const possibleSockets = manager.getPossibleSockets({
+          node: floatInputNode!,
+          index: 'value',
+          position: [0, 0]
+        });
+
+        const socketNodeIds = possibleSockets.map(([node]) => node.id);
+        expect(socketNodeIds).not.toContain(floatInputNode!.id);
+      });
+
+      it('should exclude parent nodes from possible sockets when dragging output', () => {
+        const registry = createMockNodeRegistry([
+          mockFloatOutputNode,
+          mockFloatInputNode
+        ]);
+
+        const manager = new GraphManager(registry);
+
+        const parentNode = manager.createNode({
+          type: 'test/node/output',
+          position: [0, 0],
+          props: {}
+        });
+
+        const childNode = manager.createNode({
+          type: 'test/node/input',
+          position: [100, 100],
+          props: {}
+        });
+
+        expect(parentNode).toBeDefined();
+        expect(childNode).toBeDefined();
+
+        if (parentNode && childNode) {
+          manager.createEdge(parentNode, 0, childNode, 'value');
+        }
+
+        const possibleSockets = manager.getPossibleSockets({
+          node: parentNode!,
+          index: 0,
+          position: [0, 0]
+        });
+
+        const socketNodeIds = possibleSockets.map(([node]) => node.id);
+        expect(socketNodeIds).not.toContain(childNode!.id);
+      });
+
+      it('should return sockets compatible with accepts property', () => {
+        const registry = createMockNodeRegistry([
+          mockGeometryOutputNode,
+          mockPathInputNode
+        ]);
+
+        const manager = new GraphManager(registry);
+
+        const geometryOutputNode = manager.createNode({
+          type: 'test/node/geometry',
+          position: [0, 0],
+          props: {}
+        });
+
+        const pathInputNode = manager.createNode({
+          type: 'test/node/path',
+          position: [100, 100],
+          props: {}
+        });
+
+        expect(geometryOutputNode).toBeDefined();
+        expect(pathInputNode).toBeDefined();
+
+        const possibleSockets = manager.getPossibleSockets({
+          node: geometryOutputNode!,
+          index: 0,
+          position: [0, 0]
+        });
+
+        const socketNodeIds = possibleSockets.map(([node]) => node.id);
+        expect(socketNodeIds).toContain(pathInputNode!.id);
+      });
+
+      it('should return empty array when no compatible sockets exist', () => {
+        const registry = createMockNodeRegistry([
+          mockVec3OutputNode,
+          mockFloatInputNode
+        ]);
+
+        const manager = new GraphManager(registry);
+
+        const vec3OutputNode = manager.createNode({
+          type: 'test/node/vec3',
+          position: [0, 0],
+          props: {}
+        });
+
+        const floatInputNode = manager.createNode({
+          type: 'test/node/input',
+          position: [100, 100],
+          props: {}
+        });
+
+        expect(vec3OutputNode).toBeDefined();
+        expect(floatInputNode).toBeDefined();
+
+        const possibleSockets = manager.getPossibleSockets({
+          node: vec3OutputNode!,
+          index: 0,
+          position: [0, 0]
+        });
+
+        const socketNodeIds = possibleSockets.map(([node]) => node.id);
+        expect(socketNodeIds).not.toContain(floatInputNode!.id);
+        expect(possibleSockets.length).toBe(0);
+      });
+
+      it('should return socket info with correct socket key for inputs', () => {
+        const registry = createMockNodeRegistry([
+          mockFloatOutputNode,
+          mockFloatInputNode
+        ]);
+
+        const manager = new GraphManager(registry);
+
+        const floatOutputNode = manager.createNode({
+          type: 'test/node/output',
+          position: [0, 0],
+          props: {}
+        });
+
+        const floatInputNode = manager.createNode({
+          type: 'test/node/input',
+          position: [100, 100],
+          props: {}
+        });
+
+        expect(floatOutputNode).toBeDefined();
+        expect(floatInputNode).toBeDefined();
+
+        const possibleSockets = manager.getPossibleSockets({
+          node: floatOutputNode!,
+          index: 0,
+          position: [0, 0]
+        });
+
+        const matchingSocket = possibleSockets.find(([node]) => node.id === floatInputNode!.id);
+        expect(matchingSocket).toBeDefined();
+        expect(matchingSocket![1]).toBe('value');
+      });
+
+      it('should return multiple compatible sockets', () => {
+        const registry = createMockNodeRegistry([
+          mockFloatOutputNode,
+          mockFloatInputNode,
+          mockGeometryOutputNode,
+          mockPathInputNode
+        ]);
+
+        const manager = new GraphManager(registry);
+
+        const floatOutputNode = manager.createNode({
+          type: 'test/node/output',
+          position: [0, 0],
+          props: {}
+        });
+
+        const geometryOutputNode = manager.createNode({
+          type: 'test/node/geometry',
+          position: [200, 0],
+          props: {}
+        });
+
+        const floatInputNode = manager.createNode({
+          type: 'test/node/input',
+          position: [100, 100],
+          props: {}
+        });
+
+        const pathInputNode = manager.createNode({
+          type: 'test/node/path',
+          position: [300, 100],
+          props: {}
+        });
+
+        expect(floatOutputNode).toBeDefined();
+        expect(geometryOutputNode).toBeDefined();
+        expect(floatInputNode).toBeDefined();
+        expect(pathInputNode).toBeDefined();
+
+        const possibleSocketsForFloat = manager.getPossibleSockets({
+          node: floatOutputNode!,
+          index: 0,
+          position: [0, 0]
+        });
+
+        expect(possibleSocketsForFloat.length).toBe(1);
+        expect(possibleSocketsForFloat.map(([n]) => n.id)).toContain(floatInputNode!.id);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,851 @@
+import throttle from '$lib/helpers/throttle';
+import { RemoteNodeRegistry } from '$lib/node-registry/index';
+import type {
+  Edge,
+  Graph,
+  NodeDefinition,
+  NodeId,
+  NodeInput,
+  NodeInstance,
+  NodeRegistry,
+  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 { HistoryManager } from './history-manager';
+
+const logger = createLogger('graph-manager');
+logger.mute();
+
+const remoteRegistry = new RemoteNodeRegistry('');
+
+const clone = 'structuredClone' in self
+  ? self.structuredClone
+  : (args: unknown) => JSON.parse(JSON.stringify(args));
+
+function areSocketsCompatible(
+  output: string | undefined,
+  inputs: string | (string | undefined)[] | undefined
+) {
+  if (output === '*') return true;
+  if (Array.isArray(inputs) && output) {
+    return inputs.includes('*') || inputs.includes(output);
+  }
+  return inputs === output;
+}
+
+function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
+  if (firstEdge[0].id !== secondEdge[0].id) {
+    return false;
+  }
+
+  if (firstEdge[1] !== secondEdge[1]) {
+    return false;
+  }
+
+  if (firstEdge[2].id !== secondEdge[2].id) {
+    return false;
+  }
+
+  if (firstEdge[3] !== secondEdge[3]) {
+    return false;
+  }
+
+  return true;
+}
+
+export class GraphManager extends EventEmitter<{
+  save: Graph;
+  result: unknown;
+  settings: {
+    types: Record<string, NodeInput>;
+    values: Record<string, unknown>;
+  };
+}> {
+  status = $state<'loading' | 'idle' | 'error'>();
+  loaded = false;
+
+  graph: Graph = { id: 0, nodes: [], edges: [] };
+  id = $state(0);
+
+  nodes = new SvelteMap<number, NodeInstance>();
+
+  edges = $state<Edge[]>([]);
+
+  settingTypes: Record<string, NodeInput> = {};
+  settings = $state<Record<string, unknown>>();
+
+  currentUndoGroup: number | null = null;
+
+  inputSockets = $derived.by(() => {
+    const s = new SvelteSet<string>();
+    for (const edge of this.edges) {
+      s.add(`${edge[2].id}-${edge[3]}`);
+    }
+    return s;
+  });
+
+  history: HistoryManager = new HistoryManager();
+  execute = throttle(() => {
+    if (this.loaded === false) return;
+    this.emit('result', this.serialize());
+  }, 10);
+
+  constructor(public registry: NodeRegistry) {
+    super();
+  }
+
+  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 serialized = {
+      id: this.graph.id,
+      settings: $state.snapshot(this.settings),
+      meta: $state.snapshot(this.graph.meta),
+      nodes,
+      edges
+    };
+    logger.log('serializing graph', serialized);
+    return clone($state.snapshot(serialized));
+  }
+
+  private lastSettingsHash = 0;
+  setSettings(settings: Record<string, unknown>) {
+    const hash = fastHashString(JSON.stringify(settings));
+    if (hash === this.lastSettingsHash) return;
+    this.lastSettingsHash = hash;
+
+    this.settings = settings;
+    this.save();
+    this.execute();
+  }
+
+  getNodeDefinitions() {
+    return this.registry.getAllNodes();
+  }
+
+  getLinkedNodes(node: NodeInstance) {
+    const nodes = new SvelteSet<NodeInstance>();
+    const stack = [node];
+    while (stack.length) {
+      const n = stack.pop();
+      if (!n) continue;
+      nodes.add(n);
+      const children = this.getChildren(n);
+      const parents = this.getParentsOfNode(n);
+      const newNodes = [...children, ...parents].filter((n) => !nodes.has(n));
+      stack.push(...newNodes);
+    }
+    return [...nodes.values()];
+  }
+
+  getEdgeId(e: Edge) {
+    return `${e[0].id}-${e[1]}-${e[2].id}-${e[3]}`;
+  }
+
+  getEdgeById(id: string): Edge | undefined {
+    return this.edges.find((e) => this.getEdgeId(e) === id);
+  }
+
+  dropNodeOnEdge(nodeId: number, edge: Edge) {
+    const draggedNode = this.getNode(nodeId);
+    if (!draggedNode || !draggedNode.state?.type) return;
+
+    const [fromNode, fromSocketIdx, toNode, toSocketKey] = edge;
+
+    const draggedInputs = Object.entries(draggedNode.state.type.inputs ?? {});
+    const draggedOutputs = draggedNode.state.type.outputs ?? [];
+
+    const edgeOutputSocketType = fromNode.state?.type?.outputs?.[fromSocketIdx];
+    const targetInput = toNode.state?.type?.inputs?.[toSocketKey];
+    const targetAcceptedTypes = [targetInput?.type, ...(targetInput?.accepts || [])];
+
+    const bestInputEntry = draggedInputs.find(([, input]) => {
+      const accepted = [input.type, ...(input.accepts || [])];
+      return areSocketsCompatible(edgeOutputSocketType, accepted);
+    });
+
+    const bestOutputIdx = draggedOutputs.findIndex(outputType =>
+      areSocketsCompatible(outputType, targetAcceptedTypes)
+    );
+
+    if (!bestInputEntry || bestOutputIdx === -1) {
+      logger.error('Could not find compatible sockets for drop');
+      return;
+    }
+
+    this.startUndoGroup();
+
+    this.removeEdge(edge, { applyDeletion: false });
+
+    this.createEdge(fromNode, fromSocketIdx, draggedNode, bestInputEntry[0], {
+      applyUpdate: false
+    });
+
+    this.createEdge(draggedNode, bestOutputIdx, toNode, toSocketKey, {
+      applyUpdate: false
+    });
+
+    this.saveUndoGroup();
+    this.execute();
+  }
+
+  getPossibleDropOnEdges(nodeId: number): Edge[] {
+    const draggedNode = this.getNode(nodeId);
+    if (!draggedNode || !draggedNode.state?.type) return [];
+
+    const draggedInputs = Object.values(draggedNode.state.type.inputs ?? {});
+    const draggedOutputs = draggedNode.state.type.outputs ?? [];
+
+    // Optimization: Pre-calculate parents to avoid cycles
+    const parentIds = new SvelteSet(this.getParentsOfNode(draggedNode).map(n => n.id));
+
+    return this.edges.filter((edge) => {
+      const [fromNode, fromSocketIdx, toNode, toSocketKey] = edge;
+
+      // 1. Prevent cycles: If the target node is already a parent, we can't drop here
+      if (parentIds.has(toNode.id)) return false;
+
+      // 2. Prevent self-dropping: Don't drop on edges already connected to this node
+      if (fromNode.id === nodeId || toNode.id === nodeId) return false;
+
+      // 3. Check if edge.source can plug into ANY draggedNode.input
+      const edgeOutputSocketType = fromNode.state?.type?.outputs?.[fromSocketIdx];
+      const canPlugIntoDragged = draggedInputs.some(input => {
+        const acceptedTypes = [input.type, ...(input.accepts || [])];
+        return areSocketsCompatible(edgeOutputSocketType, acceptedTypes);
+      });
+
+      if (!canPlugIntoDragged) return false;
+
+      // 4. Check if ANY draggedNode.output can plug into edge.target
+      const targetInput = toNode.state?.type?.inputs?.[toSocketKey];
+      const targetAcceptedTypes = [targetInput?.type, ...(targetInput?.accepts || [])];
+
+      const draggedCanPlugIntoTarget = draggedOutputs.some(outputType =>
+        areSocketsCompatible(outputType, targetAcceptedTypes)
+      );
+
+      return draggedCanPlugIntoTarget;
+    });
+  }
+
+  getEdgesBetweenNodes(nodes: NodeInstance[]): [number, number, number, string][] {
+    const edges = [];
+    for (const node of nodes) {
+      const children = node.state?.children || [];
+      for (const child of children) {
+        if (nodes.includes(child)) {
+          const edge = this.edges.find(
+            (e) => e[0].id === node.id && e[2].id === child.id
+          );
+          if (edge) {
+            edges.push([edge[0].id, edge[1], edge[2].id, edge[3]] as [
+              number,
+              number,
+              number,
+              string
+            ]);
+          }
+        }
+      }
+    }
+
+    return edges;
+  }
+
+  private _init(graph: Graph) {
+    const nodes = new SvelteMap(
+      graph.nodes.map((node) => {
+        const nodeType = this.registry.getNode(node.type);
+        const n = node as NodeInstance;
+        if (nodeType) {
+          n.state = {
+            type: nodeType
+          };
+        }
+        return [node.id, n];
+      })
+    );
+
+    this.edges = graph.edges.map((edge) => {
+      const from = nodes.get(edge[0]);
+      const to = nodes.get(edge[2]);
+      if (!from || !to) {
+        throw new Error('Edge references non-existing node');
+      }
+      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;
+    });
+
+    this.nodes.clear();
+    for (const [id, node] of nodes) {
+      this.nodes.set(id, node);
+    }
+
+    this.execute();
+  }
+
+  async load(graph: Graph) {
+    const a = performance.now();
+
+    this.loaded = false;
+    this.graph = graph;
+    this.status = 'loading';
+    this.id = graph.id;
+
+    logger.info('loading graph', { nodes: graph.nodes, edges: graph.edges, id: graph.id });
+
+    const nodeIds = Array.from(new SvelteSet([...graph.nodes.map((n) => n.type)]));
+    await this.registry.load(nodeIds);
+
+    // Fetch all nodes from all collections of the loaded nodes
+    const allCollections = new SvelteSet<`${string}/${string}`>();
+    for (const id of nodeIds) {
+      const [user, collection] = id.split('/');
+      allCollections.add(`${user}/${collection}`);
+    }
+    for (const collection of allCollections) {
+      remoteRegistry
+        .fetchCollection(collection)
+        .then((collection: { nodes: { id: NodeId }[] }) => {
+          const ids = collection.nodes.map((n) => n.id);
+          return this.registry.load(ids);
+        });
+    }
+
+    logger.info('loaded node types', this.registry.getAllNodes());
+
+    for (const node of this.graph.nodes) {
+      const nodeType = this.registry.getNode(node.type);
+      if (!nodeType) {
+        logger.error(`Node type not found: ${node.type}`);
+        this.status = 'error';
+        return;
+      }
+      // Turn into runtime node
+      const n = node as NodeInstance;
+      n.state = {};
+      n.state.type = nodeType;
+    }
+
+    // load settings
+    const settingTypes: Record<
+      string,
+      // Optional metadata to map settings to specific nodes
+      NodeInput & { __node_type: string; __node_input: string }
+    > = {};
+    const settingValues = graph.settings || {};
+    const types = this.getNodeDefinitions();
+    for (const type of types) {
+      if (type.inputs) {
+        for (const key in type.inputs) {
+          const settingId = type.inputs[key].setting;
+          if (settingId) {
+            settingTypes[settingId] = {
+              __node_type: type.id,
+              __node_input: key,
+              ...type.inputs[key]
+            };
+            if (
+              settingValues[settingId] === undefined
+              && 'value' in type.inputs[key]
+            ) {
+              settingValues[settingId] = type.inputs[key].value;
+            }
+          }
+        }
+      }
+    }
+
+    this.settings = settingValues;
+    this.emit('settings', { types: settingTypes, values: settingValues });
+
+    this.history.reset();
+    this._init(this.graph);
+
+    this.save();
+
+    this.status = 'idle';
+
+    this.loaded = true;
+    logger.log(`Graph loaded in ${performance.now() - a}ms`);
+    setTimeout(() => this.execute(), 100);
+  }
+
+  getAllNodes() {
+    return Array.from(this.nodes.values());
+  }
+
+  getNode(id: number) {
+    return this.nodes.get(id);
+  }
+
+  getNodeType(id: string) {
+    return this.registry.getNode(id);
+  }
+
+  async loadNodeType(id: NodeId) {
+    await this.registry.load([id]);
+    const nodeType = this.registry.getNode(id);
+
+    if (!nodeType) return;
+
+    const settingTypes = this.settingTypes;
+    const settingValues = this.settings;
+    if (nodeType.inputs) {
+      for (const key in nodeType.inputs) {
+        const settingId = nodeType.inputs[key].setting;
+        if (settingId) {
+          settingTypes[settingId] = nodeType.inputs[key];
+          if (
+            settingValues
+            && settingValues?.[settingId] === undefined
+            && 'value' in nodeType.inputs[key]
+          ) {
+            settingValues[settingId] = nodeType.inputs[key].value;
+          }
+        }
+      }
+    }
+
+    this.settings = settingValues;
+    this.settingTypes = settingTypes;
+    this.emit('settings', { types: settingTypes, values: settingValues });
+  }
+
+  getChildren(node: NodeInstance) {
+    const children = [];
+    const stack = node.state?.children?.slice(0);
+    while (stack?.length) {
+      const child = stack.pop();
+      if (!child) continue;
+      children.push(child);
+      stack.push(...(child.state?.children || []));
+    }
+    return children;
+  }
+
+  getNodesBetween(from: NodeInstance, to: NodeInstance): NodeInstance[] | undefined {
+    //  < - - - - from
+    const toParents = this.getParentsOfNode(to);
+    //  < - - - - from - - - - to
+    const fromParents = this.getParentsOfNode(from);
+    if (toParents.includes(from)) {
+      const fromChildren = this.getChildren(from);
+      return toParents.filter((n) => fromChildren.includes(n));
+    } else if (fromParents.includes(to)) {
+      const toChildren = this.getChildren(to);
+      return fromParents.filter((n) => toChildren.includes(n));
+    } else {
+      // these two nodes are not connected
+      return;
+    }
+  }
+
+  removeNode(node: NodeInstance, { restoreEdges = false } = {}) {
+    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]) {
+      this.removeEdge(edge, { applyDeletion: false });
+    }
+
+    if (restoreEdges) {
+      const outputSockets = edgesToNode.map((e) => [e[0], e[1]] as const);
+      const inputSockets = edgesFromNode.map((e) => [e[2], e[3]] as const);
+
+      for (const [to, toSocket] of inputSockets) {
+        for (const [from, fromSocket] of outputSockets) {
+          const outputType = from.state?.type?.outputs?.[fromSocket];
+          const inputType = to?.state?.type?.inputs?.[toSocket]?.type;
+          if (outputType === inputType) {
+            this.createEdge(from, fromSocket, to, toSocket, {
+              applyUpdate: false
+            });
+            continue;
+          }
+        }
+      }
+    }
+
+    this.nodes.delete(node.id);
+    this.execute();
+    this.save();
+  }
+
+  smartConnect(from: NodeInstance, to: NodeInstance): Edge | undefined {
+    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];
+      for (let o = 0; o < outputs.length; o++) {
+        const output = outputs[0];
+        if (input.type === output) {
+          return this.createEdge(from, o, to, inputName);
+        }
+      }
+    }
+  }
+
+  createNodeId() {
+    return Math.max(0, ...this.nodes.keys()) + 1;
+  }
+
+  createGraph(nodes: NodeInstance[], 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 id = startId++;
+      idMap.set(node.id, id);
+      const type = this.registry.getNode(node.type);
+      if (!type) {
+        throw new Error(`Node type not found: ${node.type}`);
+      }
+      return { ...node, id, tmp: { type } };
+    });
+
+    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]));
+
+      if (!from || !to) {
+        throw new Error('Edge references non-existing node');
+      }
+
+      to.state.parents = to.state.parents || [];
+      to.state.parents.push(from);
+
+      from.state.children = from.state.children || [];
+      from.state.children.push(to);
+
+      return [from, edge[1], to, edge[3]] as Edge;
+    });
+
+    for (const node of nodes) {
+      this.nodes.set(node.id, node);
+    }
+
+    this.edges.push(..._edges);
+
+    this.save();
+    return nodes;
+  }
+
+  createNode({
+    type,
+    position,
+    props = {}
+  }: {
+    type: NodeInstance['type'];
+    position: NodeInstance['position'];
+    props: NodeInstance['props'];
+  }) {
+    const nodeType = this.registry.getNode(type);
+    if (!nodeType) {
+      logger.error(`Node type not found: ${type}`);
+      return;
+    }
+
+    const node: NodeInstance = $state({
+      id: this.createNodeId(),
+      type,
+      position,
+      state: { type: nodeType },
+      props
+    });
+
+    this.nodes.set(node.id, node);
+
+    this.save();
+
+    return node;
+  }
+
+  createEdge(
+    from: NodeInstance,
+    fromSocket: number,
+    to: NodeInstance,
+    toSocket: string,
+    { applyUpdate = true } = {}
+  ): Edge | undefined {
+    const existingEdges = this.getEdgesToNode(to);
+
+    // check if this exact edge already exists
+    const existingEdge = existingEdges.find(
+      (e) => e[0].id === from.id && e[1] === fromSocket && e[3] === toSocket
+    );
+    if (existingEdge) {
+      logger.error('Edge already exists', existingEdge);
+      return;
+    }
+
+    // check if socket types match
+    const fromSocketType = from.state?.type?.outputs?.[fromSocket];
+    const toSocketType = [to.state?.type?.inputs?.[toSocket]?.type];
+    if (to.state?.type?.inputs?.[toSocket]?.accepts) {
+      toSocketType.push(...(to?.state?.type?.inputs?.[toSocket]?.accepts || []));
+    }
+
+    if (!areSocketsCompatible(fromSocketType, toSocketType)) {
+      logger.error(
+        `Socket types do not match: ${fromSocketType} !== ${toSocketType}`
+      );
+      return;
+    }
+
+    const edgeToBeReplaced = this.edges.find(
+      (e) => e[2].id === to.id && e[3] === toSocket
+    );
+    if (edgeToBeReplaced) {
+      this.removeEdge(edgeToBeReplaced, { applyDeletion: false });
+    }
+
+    const edge = [from, fromSocket, to, toSocket] as Edge;
+
+    this.edges.push(edge);
+
+    from.state.children = from.state.children || [];
+    from.state.children.push(to);
+    to.state.parents = to.state.parents || [];
+    to.state.parents.push(from);
+
+    if (applyUpdate) {
+      this.save();
+    }
+    this.execute();
+
+    return edge;
+  }
+
+  undo() {
+    const nextState = this.history.undo();
+    if (nextState) {
+      this._init(nextState);
+      this.emit('save', this.serialize());
+    }
+  }
+
+  redo() {
+    const nextState = this.history.redo();
+    if (nextState) {
+      this._init(nextState);
+      this.emit('save', this.serialize());
+    }
+  }
+
+  startUndoGroup() {
+    this.currentUndoGroup = 1;
+  }
+
+  saveUndoGroup() {
+    this.currentUndoGroup = null;
+    this.save();
+  }
+
+  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;
+    }
+
+    this.emit('save', state);
+    logger.log('saving graphs', state);
+  }
+
+  getParentsOfNode(node: NodeInstance) {
+    const parents = [];
+    const stack = node.state?.parents?.slice(0);
+    while (stack?.length) {
+      if (parents.length > 1000000) {
+        logger.warn('Infinite loop detected');
+        break;
+      }
+      const parent = stack.pop();
+      if (!parent) continue;
+      parents.push(parent);
+      stack.push(...(parent.state?.parents || []));
+    }
+    return parents.reverse();
+  }
+
+  getPossibleNodes(socket: Socket): NodeDefinition[] {
+    const allDefinitions = this.getNodeDefinitions();
+
+    const nodeType = socket.node.state?.type;
+    if (!nodeType) {
+      return [];
+    }
+
+    const definitions = typeof socket.index === 'string'
+      ? allDefinitions.filter(s => {
+        return s.outputs?.find(_s =>
+          Object
+            .values(nodeType?.inputs || {})
+            .map(s => s.type)
+            .includes(_s as NodeInput['type'])
+        );
+      })
+      : allDefinitions.filter(s =>
+        Object
+          .values(s.inputs ?? {})
+          .find(s => {
+            if (s.hidden) return false;
+            if (nodeType.outputs?.includes(s.type)) {
+              return true;
+            }
+            return s.accepts?.find(a => nodeType.outputs?.includes(a));
+          })
+      );
+
+    return definitions;
+  }
+
+  getPossibleSockets({ node, index }: Socket): [NodeInstance, string | number][] {
+    const nodeType = node?.state?.type;
+    if (!nodeType) return [];
+
+    const sockets: [NodeInstance, string | number][] = [];
+
+    // if index is a string, we are an input looking for outputs
+    if (typeof index === 'string') {
+      // filter out self and child nodes
+      const children = new SvelteSet(this.getChildren(node).map((n) => n.id));
+      const nodes = this.getAllNodes().filter(
+        (n) => n.id !== node.id && !children.has(n.id)
+      );
+
+      const ownType = nodeType?.inputs?.[index].type;
+
+      for (const node of nodes) {
+        const nodeType = node?.state?.type;
+        const inputs = nodeType?.outputs;
+        if (!inputs) continue;
+        for (let index = 0; index < inputs.length; index++) {
+          if (inputs[index] === ownType) {
+            sockets.push([node, index]);
+          }
+        }
+      }
+    } else if (typeof index === 'number') {
+      // if index is a number, we are an output looking for inputs
+
+      // filter out self and parent nodes
+      const parents = new SvelteSet(this.getParentsOfNode(node).map((n) => n.id));
+      const nodes = this.getAllNodes().filter(
+        (n) => n.id !== node.id && !parents.has(n.id)
+      );
+
+      const edges = new SvelteMap<number, string[]>();
+      this.getEdgesFromNode(node)
+        .filter((e) => e[1] === index)
+        .forEach((e) => {
+          if (edges.has(e[2].id)) {
+            edges.get(e[2].id)?.push(e[3]);
+          } else {
+            edges.set(e[2].id, [e[3]]);
+          }
+        });
+
+      const ownType = nodeType.outputs?.[index];
+
+      for (const node of nodes) {
+        const inputs = node?.state?.type?.inputs;
+        if (!inputs) continue;
+        for (const key in inputs) {
+          const otherType = [inputs[key].type];
+          otherType.push(...(inputs[key].accepts || []));
+
+          if (
+            areSocketsCompatible(ownType, otherType)
+            && !edges.get(node.id)?.includes(key)
+          ) {
+            sockets.push([node, key]);
+          }
+        }
+      }
+    }
+
+    return sockets;
+  }
+
+  removeEdge(
+    edge: Edge,
+    { applyDeletion = true }: { applyDeletion?: boolean } = {}
+  ) {
+    const id0 = edge[0].id;
+    const sid0 = edge[1];
+    const id2 = edge[2].id;
+    const sid2 = edge[3];
+
+    const _edge = this.edges.find(
+      (e) => e[0].id === id0 && e[1] === sid0 && e[2].id === id2 && e[3] === sid2
+    );
+
+    if (!_edge) return;
+
+    if (edge[0].state.children) {
+      edge[0].state.children = edge[0].state.children.filter(
+        (n: NodeInstance) => n.id !== id2
+      );
+    }
+
+    if (edge[2].state.parents) {
+      edge[2].state.parents = edge[2].state.parents.filter(
+        (n: NodeInstance) => n.id !== id0
+      );
+    }
+
+    this.edges = this.edges.filter((e) => !areEdgesEqual(e, edge));
+    if (applyDeletion) {
+      this.execute();
+      this.save();
+    }
+  }
+
+  getEdgesToNode(node: NodeInstance) {
+    return this.edges
+      .filter((edge) => edge[2].id === node.id)
+      .map((edge) => {
+        const from = this.getNode(edge[0].id);
+        const to = this.getNode(edge[2].id);
+        if (!from || !to) return;
+        return [from, edge[1], to, edge[3]] as const;
+      })
+      .filter(Boolean) as unknown as [NodeInstance, number, NodeInstance, string][];
+  }
+
+  getEdgesFromNode(node: NodeInstance) {
+    return this.edges
+      .filter((edge) => edge[0].id === node.id)
+      .map((edge) => {
+        const from = this.getNode(edge[0].id);
+        const to = this.getNode(edge[2].id);
+        if (!from || !to) return;
+        return [from, edge[1], to, edge[3]] as const;
+      })
+      .filter(Boolean) as unknown as [NodeInstance, number, NodeInstance, string][];
+  }
+}

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

@@ -1,611 +0,0 @@
-import type { Edge, Graph, Node, NodeInput, NodeRegistry, Socket, } from "@nodes/types";
-import { fastHashString } from "@nodes/utils";
-import { writable, type Writable } from "svelte/store";
-import EventEmitter from "./helpers/EventEmitter.js";
-import { createLogger } from "./helpers/index.js";
-import throttle from "./helpers/throttle.js";
-import { HistoryManager } from "./history-manager.js";
-
-const logger = createLogger("graph-manager");
-
-logger.mute();
-
-const clone = "structuredClone" in self ? self.structuredClone : (args: any) => JSON.parse(JSON.stringify(args));
-
-function areSocketsCompatible(output: string | undefined, inputs: string | string[] | undefined) {
-  if (Array.isArray(inputs) && output) {
-    return inputs.includes(output);
-  }
-  return inputs === output;
-}
-
-export class GraphManager extends EventEmitter<{ "save": Graph, "result": any, "settings": { types: Record<string, NodeInput>, values: Record<string, unknown> } }> {
-
-  status: Writable<"loading" | "idle" | "error"> = writable("loading");
-  loaded = false;
-
-  graph: Graph = { id: 0, nodes: [], edges: [] };
-  id = writable(0);
-
-  private _nodes: Map<number, Node> = new Map();
-  nodes: Writable<Map<number, Node>> = writable(new Map());
-
-  private _edges: Edge[] = [];
-  edges: Writable<Edge[]> = writable([]);
-
-  settingTypes: Record<string, NodeInput> = {};
-  settings: Record<string, unknown> = {};
-
-  currentUndoGroup: number | null = null;
-
-  inputSockets: Writable<Set<string>> = writable(new Set());
-
-  history: HistoryManager = new HistoryManager();
-  execute = throttle(() => {
-    if (this.loaded === false) return;
-    this.emit("result", this.serialize());
-  }, 10);
-
-  constructor(public registry: NodeRegistry) {
-    super();
-    this.nodes.subscribe((nodes) => {
-      this._nodes = nodes;
-    });
-    this.edges.subscribe((edges) => {
-      this._edges = edges;
-      const s = new Set<string>();
-      for (const edge of edges) {
-        s.add(`${edge[2].id}-${edge[3]}`);
-      }
-      this.inputSockets.set(s);
-    });
-  }
-
-  serialize(): Graph {
-    logger.group("serializing graph")
-    const nodes = Array.from(this._nodes.values()).map(node => ({
-      id: node.id,
-      position: [...node.position],
-      type: node.type,
-      props: node.props,
-    })) as Node[];
-    const edges = this._edges.map(edge => [edge[0].id, edge[1], edge[2].id, edge[3]]) as Graph["edges"];
-    const serialized = { id: this.graph.id, settings: this.settings, nodes, edges };
-    logger.groupEnd();
-
-    return clone(serialized);
-  }
-
-
-  private lastSettingsHash = 0;
-  setSettings(settings: Record<string, unknown>) {
-
-    let hash = fastHashString(JSON.stringify(settings));
-    if (hash === this.lastSettingsHash) return;
-    this.lastSettingsHash = hash;
-
-    this.settings = settings;
-    this.save();
-    this.execute();
-  }
-
-
-
-  getNodeDefinitions() {
-    return this.registry.getAllNodes();
-  }
-
-  getLinkedNodes(node: Node) {
-    const nodes = new Set<Node>();
-    const stack = [node];
-    while (stack.length) {
-      const n = stack.pop();
-      if (!n) continue;
-      nodes.add(n);
-      const children = this.getChildrenOfNode(n);
-      const parents = this.getParentsOfNode(n);
-      const newNodes = [...children, ...parents].filter(n => !nodes.has(n));
-      stack.push(...newNodes);
-    }
-    return [...nodes.values()];
-  }
-
-  getEdgesBetweenNodes(nodes: Node[]): [number, number, number, string][] {
-    const edges = [];
-    for (const node of nodes) {
-      const children = node.tmp?.children || [];
-      for (const child of children) {
-        if (nodes.includes(child)) {
-          const edge = this._edges.find(e => e[0].id === node.id && e[2].id === child.id);
-          if (edge) {
-            edges.push([edge[0].id, edge[1], edge[2].id, edge[3]] as [number, number, number, string]);
-          }
-        }
-      }
-    }
-
-    return edges;
-  }
-
-
-  private _init(graph: Graph) {
-    const nodes = new Map(graph.nodes.map(node => {
-      const nodeType = this.registry.getNode(node.type);
-      if (nodeType) {
-        node.tmp = {
-          random: (Math.random() - 0.5) * 2,
-          type: nodeType
-        };
-      }
-      return [node.id, node]
-    }));
-
-    const edges = graph.edges.map((edge) => {
-      const from = nodes.get(edge[0]);
-      const to = nodes.get(edge[2]);
-      if (!from || !to) {
-        throw new Error("Edge references non-existing node");
-      };
-      from.tmp = from.tmp || {};
-      from.tmp.children = from.tmp.children || [];
-      from.tmp.children.push(to);
-      to.tmp = to.tmp || {};
-      to.tmp.parents = to.tmp.parents || [];
-      to.tmp.parents.push(from);
-      return [from, edge[1], to, edge[3]] as Edge;
-    })
-
-    this.edges.set(edges);
-    this.nodes.set(nodes);
-
-    this.execute();
-
-  }
-
-  async load(graph: Graph) {
-
-    const a = performance.now();
-
-    this.loaded = false;
-    this.graph = graph;
-    this.status.set("loading");
-    this.id.set(graph.id);
-
-    const nodeIds = Array.from(new Set([...graph.nodes.map(n => n.type)]));
-    await this.registry.load(nodeIds);
-
-    for (const node of this.graph.nodes) {
-      const nodeType = this.registry.getNode(node.type);
-      if (!nodeType) {
-        logger.error(`Node type not found: ${node.type}`);
-        this.status.set("error");
-        return;
-      }
-      node.tmp = node.tmp || {};
-      node.tmp.random = (Math.random() - 0.5) * 2;
-      node.tmp.type = nodeType;
-    }
-
-
-    // load settings
-    const settingTypes: Record<string, NodeInput> = {};
-    const settingValues = graph.settings || {};
-    const types = this.getNodeDefinitions();
-    for (const type of types) {
-      if (type.inputs) {
-        for (const key in type.inputs) {
-          let settingId = type.inputs[key].setting;
-          if (settingId) {
-            settingTypes[settingId] = { __node_type: type.id, __node_input: key, ...type.inputs[key] };
-            if (settingValues[settingId] === undefined && "value" in type.inputs[key]) {
-              settingValues[settingId] = type.inputs[key].value;
-            }
-          }
-        }
-      }
-    }
-
-    this.settings = settingValues;
-    this.emit("settings", { types: settingTypes, values: settingValues });
-
-    this.history.reset();
-    this._init(this.graph);
-
-    this.save();
-
-    this.status.set("idle");
-
-    this.loaded = true;
-    logger.log(`Graph loaded in ${performance.now() - a}ms`);
-    setTimeout(() => this.execute(), 100);
-  }
-
-
-  getAllNodes() {
-    return Array.from(this._nodes.values());
-  }
-
-  getNode(id: number) {
-    return this._nodes.get(id);
-  }
-
-  getNodeType(id: string) {
-    return this.registry.getNode(id);
-  }
-
-  async loadNode(id: string) {
-
-    await this.registry.load([id]);
-    const nodeType = this.registry.getNode(id);
-
-    if (!nodeType) return;
-
-    const settingTypes = this.settingTypes;
-    const settingValues = this.settings;
-    if (nodeType.inputs) {
-      for (const key in nodeType.inputs) {
-        let settingId = nodeType.inputs[key].setting;
-        if (settingId) {
-          settingTypes[settingId] = nodeType.inputs[key];
-          if (settingValues[settingId] === undefined && "value" in nodeType.inputs[key]) {
-            settingValues[settingId] = nodeType.inputs[key].value;
-          }
-        }
-      }
-    }
-
-    this.settings = settingValues;
-    this.settingTypes = settingTypes;
-    this.emit("settings", { types: settingTypes, values: settingValues });
-  }
-
-  getChildrenOfNode(node: Node) {
-    const children = [];
-    const stack = node.tmp?.children?.slice(0);
-    while (stack?.length) {
-      const child = stack.pop();
-      if (!child) continue;
-      children.push(child);
-      stack.push(...child.tmp?.children || []);
-    }
-    return children;
-  }
-
-  getNodesBetween(from: Node, to: Node): Node[] | undefined {
-    //  < - - - - from
-    const toParents = this.getParentsOfNode(to);
-    //  < - - - - from - - - - to
-    const fromParents = this.getParentsOfNode(from);
-    if (toParents.includes(from)) {
-      const fromChildren = this.getChildrenOfNode(from);
-      return toParents.filter(n => fromChildren.includes(n));
-    } else if (fromParents.includes(to)) {
-      const toChildren = this.getChildrenOfNode(to);
-      return fromParents.filter(n => toChildren.includes(n));
-    } else {
-      // these two nodes are not connected
-      return;
-    }
-  }
-
-  removeNode(node: Node, { restoreEdges = false } = {}) {
-
-    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]) {
-      this.removeEdge(edge, { applyDeletion: false });
-    }
-
-    if (restoreEdges) {
-      const outputSockets = edgesToNode.map(e => [e[0], e[1]] as const);
-      const inputSockets = edgesFromNode.map(e => [e[2], e[3]] as const);
-
-      for (const [to, toSocket] of inputSockets) {
-        for (const [from, fromSocket] of outputSockets) {
-          const outputType = from.tmp?.type?.outputs?.[fromSocket];
-          const inputType = to?.tmp?.type?.inputs?.[toSocket]?.type;
-          if (outputType === inputType) {
-            this.createEdge(from, fromSocket, to, toSocket, { applyUpdate: false });
-            continue;
-          }
-        }
-      }
-    }
-
-    this.edges.set(this._edges);
-
-    this.nodes.update((nodes) => {
-      nodes.delete(node.id);
-      return nodes;
-    });
-    this.execute()
-    this.save();
-  }
-
-  createNodeId() {
-    const max = Math.max(...this._nodes.keys());
-    return max + 1;
-  }
-
-  createGraph(nodes: Node[], edges: [number, number, number, string][]) {
-
-    // map old ids to new ids
-    const idMap = new Map<number, number>();
-
-    const startId = this.createNodeId();
-
-    nodes = nodes.map((node, i) => {
-      const id = startId + i;
-      idMap.set(node.id, id);
-      const type = this.registry.getNode(node.type);
-      if (!type) {
-        throw new Error(`Node type not found: ${node.type}`);
-      }
-      return { ...node, id, tmp: { type } };
-    });
-
-    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]));
-
-      if (!from || !to) {
-        throw new Error("Edge references non-existing node");
-      }
-
-      to.tmp = to.tmp || {};
-      to.tmp.parents = to.tmp.parents || [];
-      to.tmp.parents.push(from);
-
-      from.tmp = from.tmp || {};
-      from.tmp.children = from.tmp.children || [];
-      from.tmp.children.push(to);
-
-      return [from, edge[1], to, edge[3]] as Edge;
-    });
-
-    for (const node of nodes) {
-      this._nodes.set(node.id, node);
-    }
-
-    this._edges.push(..._edges);
-
-    this.nodes.set(this._nodes);
-    this.edges.set(this._edges);
-    this.save();
-    return nodes;
-  }
-
-  createNode({ type, position, props = {} }: { type: Node["type"], position: Node["position"], props: Node["props"] }) {
-
-    const nodeType = this.registry.getNode(type);
-    if (!nodeType) {
-      logger.error(`Node type not found: ${type}`);
-      return;
-    }
-
-    const node: Node = { id: this.createNodeId(), type, position, tmp: { type: nodeType }, props };
-
-    this.nodes.update((nodes) => {
-      nodes.set(node.id, node);
-      return nodes;
-    });
-
-    this.save();
-  }
-
-  createEdge(from: Node, fromSocket: number, to: Node, toSocket: string, { applyUpdate = true } = {}) {
-
-    const existingEdges = this.getEdgesToNode(to);
-
-    // check if this exact edge already exists
-    const existingEdge = existingEdges.find(e => e[0].id === from.id && e[1] === fromSocket && e[3] === toSocket);
-    if (existingEdge) {
-      logger.error("Edge already exists", existingEdge);
-      return;
-    };
-
-    // check if socket types match
-    const fromSocketType = from.tmp?.type?.outputs?.[fromSocket];
-    const toSocketType = [to.tmp?.type?.inputs?.[toSocket]?.type];
-    if (to.tmp?.type?.inputs?.[toSocket]?.accepts) {
-      toSocketType.push(...(to?.tmp?.type?.inputs?.[toSocket]?.accepts || []));
-    }
-
-    if (!areSocketsCompatible(fromSocketType, toSocketType)) {
-      logger.error(`Socket types do not match: ${fromSocketType} !== ${toSocketType}`);
-      return;
-    }
-
-    const edgeToBeReplaced = this._edges.find(e => e[2].id === to.id && e[3] === toSocket);
-    if (edgeToBeReplaced) {
-      this.removeEdge(edgeToBeReplaced, { applyDeletion: false });
-    }
-
-    if (applyUpdate) {
-      this._edges.push([from, fromSocket, to, toSocket]);
-    } else {
-      this._edges.push([from, fromSocket, to, toSocket]);
-    }
-
-    from.tmp = from.tmp || {};
-    from.tmp.children = from.tmp.children || [];
-    from.tmp.children.push(to);
-
-    to.tmp = to.tmp || {};
-    to.tmp.parents = to.tmp.parents || [];
-    to.tmp.parents.push(from);
-
-    if (applyUpdate) {
-      this.edges.set(this._edges);
-      this.save();
-    }
-    this.execute();
-  }
-
-  undo() {
-    const nextState = this.history.undo();
-    if (nextState) {
-      this._init(nextState);
-      this.emit("save", this.serialize());
-    }
-  }
-
-
-  redo() {
-    const nextState = this.history.redo();
-    if (nextState) {
-      this._init(nextState);
-      this.emit("save", this.serialize());
-    }
-
-  }
-
-  startUndoGroup() {
-    this.currentUndoGroup = 1;
-  }
-
-  saveUndoGroup() {
-    this.currentUndoGroup = null;
-    this.save();
-  }
-
-  save() {
-    if (this.currentUndoGroup) return;
-    const state = this.serialize();
-    this.history.save(state);
-    this.emit("save", state);
-    logger.log("saving graphs", state);
-  }
-
-  getParentsOfNode(node: Node) {
-    const parents = [];
-    const stack = node.tmp?.parents?.slice(0);
-    while (stack?.length) {
-      if (parents.length > 1000000) {
-        logger.warn("Infinite loop detected")
-        break;
-      }
-      const parent = stack.pop();
-      if (!parent) continue;
-      parents.push(parent);
-      stack.push(...parent.tmp?.parents || []);
-    }
-    return parents.reverse();
-  }
-
-  getPossibleSockets({ node, index }: Socket): [Node, string | number][] {
-
-    const nodeType = node?.tmp?.type;
-    if (!nodeType) return [];
-
-    const sockets: [Node, string | number][] = []
-
-    // if index is a string, we are an input looking for outputs
-    if (typeof index === "string") {
-
-      // filter out self and child nodes
-      const children = new Set(this.getChildrenOfNode(node).map(n => n.id));
-      const nodes = this.getAllNodes().filter(n => n.id !== node.id && !children.has(n.id));
-
-      const ownType = nodeType?.inputs?.[index].type;
-
-      for (const node of nodes) {
-        const nodeType = node?.tmp?.type;
-        const inputs = nodeType?.outputs;
-        if (!inputs) continue;
-        for (let index = 0; index < inputs.length; index++) {
-          if (inputs[index] === ownType) {
-            sockets.push([node, index]);
-          }
-        }
-      }
-
-    } else if (typeof index === "number") {
-      // if index is a number, we are an output looking for inputs
-
-      // filter out self and parent nodes
-      const parents = new Set(this.getParentsOfNode(node).map(n => n.id));
-      const nodes = this.getAllNodes().filter(n => n.id !== node.id && !parents.has(n.id));
-
-      // get edges from this socket
-      const edges = new Map(this.getEdgesFromNode(node).filter(e => e[1] === index).map(e => [e[2].id, e[3]]));
-
-      const ownType = nodeType.outputs?.[index];
-
-      for (const node of nodes) {
-        const inputs = node?.tmp?.type?.inputs;
-        if (!inputs) continue;
-        for (const key in inputs) {
-
-          const otherType = [inputs[key].type];
-          otherType.push(...(inputs[key].accepts || []));
-
-          if (areSocketsCompatible(ownType, otherType) && edges.get(node.id) !== key) {
-            sockets.push([node, key]);
-          }
-        }
-      }
-    }
-
-    return sockets;
-
-  }
-
-  removeEdge(edge: Edge, { applyDeletion = true }: { applyDeletion?: boolean } = {}) {
-    const id0 = edge[0].id;
-    const sid0 = edge[1];
-    const id2 = edge[2].id;
-    const sid2 = edge[3];
-
-    const _edge = this._edges.find((e) => e[0].id === id0 && e[1] === sid0 && e[2].id === id2 && e[3] === sid2);
-    if (!_edge) return;
-
-    edge[0].tmp = edge[0].tmp || {};
-    if (edge[0].tmp.children) {
-      edge[0].tmp.children = edge[0].tmp.children.filter(n => n.id !== id2);
-    }
-
-    edge[2].tmp = edge[2].tmp || {};
-    if (edge[2].tmp.parents) {
-      edge[2].tmp.parents = edge[2].tmp.parents.filter(n => n.id !== id0);
-    }
-
-    if (applyDeletion) {
-      this.edges.update((edges) => {
-        return edges.filter(e => e !== _edge);
-      });
-      this.execute();
-      this.save();
-    } else {
-      this._edges = this._edges.filter(e => e !== _edge);
-    }
-
-  }
-
-  getEdgesToNode(node: Node) {
-    return this._edges
-      .filter((edge) => edge[2].id === node.id)
-      .map((edge) => {
-        const from = this.getNode(edge[0].id);
-        const to = this.getNode(edge[2].id);
-        if (!from || !to) return;
-        return [from, edge[1], to, edge[3]] as const;
-      })
-      .filter(Boolean) as unknown as [Node, number, Node, string][];
-  }
-
-  getEdgesFromNode(node: Node) {
-    return this._edges
-      .filter((edge) => edge[0].id === node.id)
-      .map((edge) => {
-        const from = this.getNode(edge[0].id);
-        const to = this.getNode(edge[2].id);
-        if (!from || !to) return;
-        return [from, edge[1], to, edge[3]] as const;
-      })
-      .filter(Boolean) as unknown as [Node, number, Node, string][];
-  }
-
-
-}
-

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

@@ -0,0 +1,349 @@
+import type { NodeInstance, Socket } from '@nodarium/types';
+import { getContext, setContext } from 'svelte';
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+import type { OrthographicCamera, Vector3 } from 'three';
+import type { GraphManager } from './graph-manager.svelte';
+import { ColorGenerator } from './graph/colors';
+import { getNodeHeight, getSocketPosition } from './helpers/nodeHelpers';
+
+const graphStateKey = Symbol('graph-state');
+export function getGraphState() {
+  return getContext<GraphState>(graphStateKey);
+}
+export function setGraphState(graphState: GraphState) {
+  return setContext(graphStateKey, graphState);
+}
+
+const graphManagerKey = Symbol('graph-manager');
+export function getGraphManager() {
+  return getContext<GraphManager>(graphManagerKey);
+}
+
+export function setGraphManager(manager: GraphManager) {
+  return setContext(graphManagerKey, manager);
+}
+
+type EdgeData = {
+  x1: number;
+  y1: number;
+  points: Vector3[];
+};
+
+const predefinedColors = {
+  path: {
+    hue: 80,
+    lightness: 20,
+    saturation: 80
+  },
+  float: {
+    hue: 70,
+    lightness: 10,
+    saturation: 0
+  },
+  geometry: {
+    hue: 0,
+    lightness: 50,
+    saturation: 70
+  },
+  '*': {
+    hue: 200,
+    lightness: 20,
+    saturation: 100
+  }
+} as const;
+
+export class GraphState {
+  colors = new ColorGenerator(predefinedColors);
+
+  constructor(private graph: GraphManager) {
+    $effect.root(() => {
+      $effect(() => {
+        localStorage.setItem(
+          'cameraPosition',
+          `[${this.cameraPosition[0]},${this.cameraPosition[1]},${this.cameraPosition[2]}]`
+        );
+      });
+    });
+    const storedPosition = localStorage.getItem('cameraPosition');
+    if (storedPosition) {
+      try {
+        const d = JSON.parse(storedPosition);
+        this.cameraPosition[0] = d[0];
+        this.cameraPosition[1] = d[1];
+        this.cameraPosition[2] = d[2];
+      } catch (e) {
+        console.log('Failed to parsed stored camera position', e);
+      }
+    }
+  }
+
+  width = $state(100);
+  height = $state(100);
+
+  hoveredEdgeId = $state<string | null>(null);
+  edges = new SvelteMap<string, EdgeData>();
+
+  wrapper = $state<HTMLDivElement>(null!);
+  rect: DOMRect = $derived(
+    (this.wrapper && this.width && this.height)
+      ? this.wrapper.getBoundingClientRect()
+      : new DOMRect(0, 0, 0, 0)
+  );
+
+  camera = $state<OrthographicCamera>(null!);
+  cameraPosition: [number, number, number] = $state([140, 100, 3.5]);
+
+  clipboard: null | {
+    nodes: NodeInstance[];
+    edges: [number, number, number, string][];
+  } = null;
+
+  cameraBounds = $derived([
+    this.cameraPosition[0] - this.width / this.cameraPosition[2] / 2,
+    this.cameraPosition[0] + this.width / this.cameraPosition[2] / 2,
+    this.cameraPosition[1] - this.height / this.cameraPosition[2] / 2,
+    this.cameraPosition[1] + this.height / this.cameraPosition[2] / 2
+  ]);
+
+  boxSelection = $state(false);
+  edgeEndPosition = $state<[number, number] | null>();
+  addMenuPosition = $state<[number, number] | null>(null);
+
+  snapToGrid = $state(false);
+  backgroundType = $state<'grid' | 'dots' | 'none'>('grid');
+  showHelp = $state(false);
+
+  cameraDown = [0, 0];
+  mouseDownNodeId = -1;
+
+  isPanning = $state(false);
+  isDragging = $state(false);
+  hoveredNodeId = $state(-1);
+  mousePosition = $state([0, 0]);
+  mouseDown = $state<[number, number] | null>(null);
+  activeNodeId = $state(-1);
+  selectedNodes = new SvelteSet<number>();
+  activeSocket = $state<Socket | null>(null);
+  hoveredSocket = $state<Socket | null>(null);
+  possibleSockets = $state<Socket[]>([]);
+  possibleSocketIds = $derived(
+    new SvelteSet(this.possibleSockets.map((s) => `${s.node.id}-${s.index}`))
+  );
+
+  getEdges() {
+    return $state.snapshot(this.edges);
+  }
+
+  clearSelection() {
+    this.selectedNodes.clear();
+  }
+
+  isBodyFocused = () => document?.activeElement?.nodeName !== 'INPUT';
+
+  setEdgeGeometry(edgeId: string, x1: number, y1: number, points: Vector3[]) {
+    this.edges.set(edgeId, { x1, y1, points });
+  }
+
+  removeEdgeGeometry(edgeId: string) {
+    this.edges.delete(edgeId);
+  }
+
+  getEdgeData() {
+    return this.edges;
+  }
+
+  updateNodePosition(node: NodeInstance) {
+    if (
+      node.state.x === node.position[0]
+      && node.state.y === node.position[1]
+    ) {
+      delete node.state.x;
+      delete node.state.y;
+    }
+
+    if (node.state['x'] !== undefined && node.state['y'] !== undefined) {
+      if (node.state.ref) {
+        node.state.ref.style.setProperty('--nx', `${node.state.x * 10}px`);
+        node.state.ref.style.setProperty('--ny', `${node.state.y * 10}px`);
+      }
+    } else {
+      if (node.state.ref) {
+        node.state.ref.style.setProperty('--nx', `${node.position[0] * 10}px`);
+        node.state.ref.style.setProperty('--ny', `${node.position[1] * 10}px`);
+      }
+    }
+  }
+
+  getSnapLevel() {
+    const z = this.cameraPosition[2];
+    if (z > 66) {
+      return 8;
+    } else if (z > 55) {
+      return 4;
+    } else if (z > 11) {
+      return 2;
+    }
+    return 1;
+  }
+
+  tryConnectToDebugNode(nodeId: number) {
+    const node = this.graph.nodes.get(nodeId);
+    if (!node) return;
+    if (node.type.endsWith('/debug')) return;
+    if (!node.state.type?.outputs?.length) return;
+    for (const _node of this.graph.nodes.values()) {
+      if (_node.type.endsWith('/debug')) {
+        this.graph.createEdge(node, 0, _node, 'input');
+        return;
+      }
+    }
+
+    const debugNode = this.graph.createNode({
+      type: 'max/plantarium/debug',
+      position: [node.position[0] + 30, node.position[1]],
+      props: {}
+    });
+
+    if (debugNode) {
+      this.graph.createEdge(node, 0, debugNode, 'input');
+    }
+  }
+
+  copyNodes() {
+    if (this.activeNodeId === -1 && !this.selectedNodes?.size) {
+      return;
+    }
+    let nodes = [
+      this.activeNodeId,
+      ...(this.selectedNodes?.values() || [])
+    ]
+      .map((id) => this.graph.getNode(id))
+      .filter(b => !!b);
+
+    const edges = this.graph.getEdgesBetweenNodes(nodes);
+    nodes = nodes.map((node) => ({
+      ...node,
+      position: [
+        this.mousePosition[0] - node.position[0],
+        this.mousePosition[1] - node.position[1]
+      ],
+      tmp: undefined
+    }));
+
+    this.clipboard = {
+      nodes: nodes,
+      edges: edges
+    };
+  }
+
+  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[];
+
+    const newNodes = this.graph.createGraph(nodes, this.clipboard.edges);
+    this.selectedNodes.clear();
+    for (const node of newNodes) {
+      this.selectedNodes.add(node.id);
+    }
+  }
+
+  setDownSocket(socket: Socket) {
+    this.activeSocket = socket;
+
+    let { node, index, position } = socket;
+
+    // remove existing edge
+    if (typeof index === 'string') {
+      const edges = this.graph.getEdgesToNode(node);
+      for (const edge of edges) {
+        if (edge[3] === index) {
+          node = edge[0];
+          index = edge[1];
+          position = getSocketPosition(node, index);
+          this.graph.removeEdge(edge);
+          break;
+        }
+      }
+    }
+
+    this.mouseDown = position;
+    this.activeSocket = {
+      node,
+      index,
+      position
+    };
+
+    this.possibleSockets = this.graph
+      .getPossibleSockets(this.activeSocket)
+      .map(([node, index]) => {
+        return {
+          node,
+          index,
+          position: getSocketPosition(node, index)
+        };
+      });
+  }
+
+  projectScreenToWorld(x: number, y: number): [number, number] {
+    return [
+      this.cameraPosition[0]
+      + (x - this.width / 2) / this.cameraPosition[2],
+      this.cameraPosition[1]
+      + (y - this.height / 2) / this.cameraPosition[2]
+    ];
+  }
+
+  getNodeIdFromEvent(event: MouseEvent) {
+    let clickedNodeId = -1;
+
+    const mx = event.clientX - this.rect.x;
+    const my = event.clientY - this.rect.y;
+
+    if (event.button === 0) {
+      // check if the clicked element is a node
+      if (event.target instanceof HTMLElement) {
+        const nodeElement = event.target.closest('.node');
+        const nodeId = nodeElement?.getAttribute?.('data-node-id');
+        if (nodeId) {
+          clickedNodeId = parseInt(nodeId, 10);
+        }
+      }
+
+      // if we do not have an active node,
+      // we are going to check if we clicked on a node by coordinates
+      if (clickedNodeId === -1) {
+        const [downX, downY] = this.projectScreenToWorld(mx, my);
+        for (const node of this.graph.nodes.values()) {
+          const x = node.position[0];
+          const y = node.position[1];
+          const height = getNodeHeight(node.state.type!);
+          if (downX > x && downX < x + 20 && downY > y && downY < y + height) {
+            clickedNodeId = node.id;
+            break;
+          }
+        }
+      }
+    }
+    return clickedNodeId;
+  }
+
+  isNodeInView(node: NodeInstance) {
+    const height = getNodeHeight(node.state.type!);
+    const width = 20;
+    return node.position[0] > this.cameraBounds[0] - width
+      && node.position[0] < this.cameraBounds[1]
+      && node.position[1] > this.cameraBounds[2] - height
+      && node.position[1] < this.cameraBounds[3];
+  }
+
+  openNodePalette() {
+    this.addMenuPosition = [this.mousePosition[0], this.mousePosition[1]];
+  }
+}

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

@@ -1,94 +0,0 @@
-<script lang="ts">
-  import type { Edge as EdgeType, Node as NodeType } from "@nodes/types";
-  import { HTML } from "@threlte/extras";
-  import Edge from "../edges/Edge.svelte";
-  import Node from "../node/Node.svelte";
-  import { getContext, onMount } from "svelte";
-  import type { Writable } from "svelte/store";
-  import { getGraphState } from "./state.svelte";
-  import { useThrelte } from "@threlte/core";
-  import { appSettings } from "$lib/settings/app-settings.svelte";
-
-  type Props = {
-    nodes: Writable<Map<number, NodeType>>;
-    edges: Writable<EdgeType[]>;
-    cameraPosition: [number, number, number];
-  };
-
-  const { nodes, edges, cameraPosition = [0, 0, 4] }: Props = $props();
-
-  const { invalidate } = useThrelte();
-
-  $effect(() => {
-    appSettings.theme;
-    invalidate();
-  });
-
-  const graphState = getGraphState();
-
-  const isNodeInView = getContext<(n: NodeType) => boolean>("isNodeInView");
-
-  const getSocketPosition =
-    getContext<(node: NodeType, index: string | number) => [number, number]>(
-      "getSocketPosition",
-    );
-
-  function getEdgePosition(edge: EdgeType) {
-    const pos1 = getSocketPosition(edge[0], edge[1]);
-    const pos2 = getSocketPosition(edge[2], edge[3]);
-    return [pos1[0], pos1[1], pos2[0], pos2[1]];
-  }
-
-  onMount(() => {
-    for (const node of $nodes.values()) {
-      if (node?.tmp?.ref) {
-        node.tmp.ref.style.setProperty("--nx", `${node.position[0] * 10}px`);
-        node.tmp.ref.style.setProperty("--ny", `${node.position[1] * 10}px`);
-      }
-    }
-  });
-</script>
-
-{#each $edges as edge (`${edge[0].id}-${edge[1]}-${edge[2].id}-${edge[3]}`)}
-  {@const pos = getEdgePosition(edge)}
-  {@const [x1, y1, x2, y2] = pos}
-  <Edge
-    z={cameraPosition[2]}
-    from={{
-      x: x1,
-      y: y1,
-    }}
-    to={{
-      x: x2,
-      y: y2,
-    }}
-  />
-{/each}
-
-<HTML transform={false}>
-  <div
-    role="tree"
-    id="graph"
-    tabindex="0"
-    class="wrapper"
-    style:transform={`scale(${cameraPosition[2] * 0.1})`}
-    class:hovering-sockets={graphState.activeSocket}
-  >
-    {#each $nodes.values() as node (node.id)}
-      <Node
-        {node}
-        inView={cameraPosition && isNodeInView(node)}
-        z={cameraPosition[2]}
-      />
-    {/each}
-  </div>
-</HTML>
-
-<style>
-  .wrapper {
-    position: absolute;
-    z-index: 100;
-    width: 0px;
-    height: 0px;
-  }
-</style>

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

@@ -1,49 +1,59 @@
 <script lang="ts">
-  import type { Graph, Node, NodeRegistry } from "@nodes/types";
-  import GraphEl from "./Graph.svelte";
-  import { GraphManager } from "../graph-manager.js";
-  import { setContext } from "svelte";
-  import { debounce } from "$lib/helpers";
-  import { createKeyMap } from "$lib/helpers/createKeyMap";
-  import { GraphState } from "./state.svelte";
-
-  const graphState = new GraphState();
-  setContext("graphState", graphState);
+  import { createKeyMap } from '$lib/helpers/createKeyMap';
+  import type { Graph, NodeInstance, NodeRegistry } from '@nodarium/types';
+  import { GraphManager } from '../graph-manager.svelte';
+  import { GraphState, setGraphManager, setGraphState } from '../graph-state.svelte';
+  import { setupKeymaps } from '../keymaps';
+  import GraphEl from './Graph.svelte';
 
   type Props = {
-    graph: Graph;
+    graph?: Graph;
     registry: NodeRegistry;
 
-    settings?: Record<string, any>;
+    settings?: Record<string, unknown>;
 
-    activeNode?: Node;
-    showGrid?: boolean;
+    activeNode?: NodeInstance;
+    backgroundType?: 'grid' | 'dots' | 'none';
     snapToGrid?: boolean;
     showHelp?: boolean;
-    settingTypes?: Record<string, any>;
+    settingTypes?: Record<string, unknown>;
+
+    addMenuPadding?: { left?: number; right?: number; bottom?: number; top?: number };
 
     onsave?: (save: Graph) => void;
-    onresult?: (result: any) => void;
+    onresult?: (result: unknown) => void;
   };
 
   let {
     graph,
     registry,
+    addMenuPadding,
     settings = $bindable(),
     activeNode = $bindable(),
-    showGrid,
-    snapToGrid,
+    backgroundType = $bindable('grid'),
+    snapToGrid = $bindable(true),
     showHelp = $bindable(false),
     settingTypes = $bindable(),
     onsave,
-    onresult,
+    onresult
   }: Props = $props();
 
   export const keymap = createKeyMap([]);
-  setContext("keymap", keymap);
 
+  // svelte-ignore state_referenced_locally
   export const manager = new GraphManager(registry);
-  setContext("graphManager", manager);
+  setGraphManager(manager);
+
+  const graphState = new GraphState(manager);
+  $effect(() => {
+    graphState.backgroundType = backgroundType;
+    graphState.snapToGrid = snapToGrid;
+    graphState.showHelp = showHelp;
+  });
+
+  setGraphState(graphState);
+
+  setupKeymaps(keymap, manager, graphState);
 
   $effect(() => {
     if (graphState.activeNodeId !== -1) {
@@ -53,26 +63,27 @@
     }
   });
 
-  const updateSettings = debounce((s) => {
-    manager.setSettings(s);
-  }, 200);
-
   $effect(() => {
-    if (settingTypes && settings) {
-      updateSettings($state.snapshot(settings));
+    if (!graphState.addMenuPosition) {
+      graphState.edgeEndPosition = null;
+      graphState.activeSocket = null;
     }
   });
 
-  manager.on("settings", (_settings) => {
+  manager.on('settings', (_settings) => {
     settingTypes = { ...settingTypes, ..._settings.types };
     settings = _settings.values;
   });
 
-  manager.on("result", (result) => onresult?.(result));
+  manager.on('result', (result) => onresult?.(result));
 
-  manager.on("save", (save) => onsave?.(save));
+  manager.on('save', (save) => onsave?.(save));
 
-  manager.load(graph);
+  $effect(() => {
+    if (graph) {
+      manager.load(graph);
+    }
+  });
 </script>
 
-<GraphEl bind:showGrid bind:snapToGrid bind:showHelp />
+<GraphEl {keymap} {addMenuPadding} />

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

@@ -1,32 +1,34 @@
-import { appSettings } from "$lib/settings/app-settings.svelte";
-import { Color, LinearSRGBColorSpace } from "three";
+import { appSettings } from '$lib/settings/app-settings.svelte';
+import { Color, LinearSRGBColorSpace } from 'three';
 
 const variables = [
-  "layer-0",
-  "layer-1",
-  "layer-2",
-  "layer-3",
-  "outline",
-  "active",
-  "selected",
-  "edge",
+  'layer-0',
+  'layer-1',
+  'layer-2',
+  'layer-3',
+  'outline',
+  'active',
+  'selected',
+  'connection'
 ] as const;
 
-function getColor(variable: typeof variables[number]) {
+function getColor(variable: (typeof variables)[number]) {
   const style = getComputedStyle(document.body.parentElement!);
-  let color = style.getPropertyValue(`--${variable}`);
+  const color = style.getPropertyValue(`--color-${variable}`);
   return new Color().setStyle(color, LinearSRGBColorSpace);
 }
 
-export const colors = Object.fromEntries(variables.map(v => [v, getColor(v)])) as Record<typeof variables[number], Color>;
+export const colors = Object.fromEntries(
+  variables.map((v) => [v, getColor(v)])
+) as Record<(typeof variables)[number], Color>;
 
 $effect.root(() => {
   $effect(() => {
-    if (!appSettings.theme || !("getComputedStyle" in globalThis)) return;
+    if (!appSettings.value.theme || !('getComputedStyle' in globalThis)) return;
     const style = getComputedStyle(document.body.parentElement!);
     for (const v of variables) {
-      const hex = style.getPropertyValue(`--${v}`);
+      const hex = style.getPropertyValue(`--color-${v}`);
       colors[v].setStyle(hex, LinearSRGBColorSpace);
     }
   });
-})
+});

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

@@ -0,0 +1,44 @@
+type Color = { hue: number; saturation: number; lightness: number };
+
+export class ColorGenerator {
+  private colors: Map<string, Color> = new Map();
+  private lightnessLevels = [10, 60];
+
+  constructor(predefined: Record<string, Color>) {
+    for (const [id, colorStr] of Object.entries(predefined)) {
+      this.colors.set(id, colorStr);
+    }
+  }
+
+  public getColor(id: string): string {
+    if (this.colors.has(id)) {
+      return this.colorToHsl(this.colors.get(id)!);
+    }
+
+    const newColor = this.generateNewColor();
+    this.colors.set(id, newColor);
+    return this.colorToHsl(newColor);
+  }
+
+  private generateNewColor(): Color {
+    const existingHues = Array.from(this.colors.values()).map(c => c.hue).sort();
+    let hue = existingHues[0];
+    let attempts = 0;
+
+    while (
+      existingHues.some(h => Math.abs(h - hue) < 30 || Math.abs(h - hue) > 330)
+      && attempts < 360
+    ) {
+      hue = (hue + 30) % 360;
+      attempts++;
+    }
+
+    const lightness = 60;
+
+    return { hue, lightness, saturation: 100 };
+  }
+
+  private colorToHsl(c: Color): string {
+    return `hsl(${c.hue}, ${c.saturation}%, ${c.lightness}%)`;
+  }
+}

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

@@ -0,0 +1,3 @@
+export const minZoom = 1;
+export const maxZoom = 40;
+export const zoomSpeed = 2;

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

@@ -1,6 +0,0 @@
-import type { GraphManager } from "../graph-manager.js";
-import { getContext } from "svelte";
-
-export function getGraphManager(): GraphManager {
-  return getContext("graphManager");
-}

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

@@ -0,0 +1,109 @@
+import { GraphSchema, type NodeId } from '@nodarium/types';
+import type { GraphManager } from '../graph-manager.svelte';
+import type { GraphState } from '../graph-state.svelte';
+
+export class FileDropEventManager {
+  constructor(
+    private graph: GraphManager,
+    private state: GraphState
+  ) {}
+
+  handleFileDrop(event: DragEvent) {
+    event.preventDefault();
+    this.state.isDragging = false;
+    if (!event.dataTransfer) return;
+    const nodeId = event.dataTransfer.getData('data/node-id') as NodeId;
+    let mx = event.clientX - this.state.rect.x;
+    let my = event.clientY - this.state.rect.y;
+
+    if (nodeId) {
+      const nodeOffsetX = event.dataTransfer.getData('data/node-offset-x');
+      const nodeOffsetY = event.dataTransfer.getData('data/node-offset-y');
+      if (nodeOffsetX && nodeOffsetY) {
+        mx += parseInt(nodeOffsetX);
+        my += parseInt(nodeOffsetY);
+      }
+
+      let props = {};
+      const rawNodeProps = event.dataTransfer.getData('data/node-props');
+      if (rawNodeProps) {
+        try {
+          props = JSON.parse(rawNodeProps);
+        } catch (e) {
+          console.error('Failed to parse node dropped', e);
+        }
+      }
+
+      const pos = this.state.projectScreenToWorld(mx, my);
+      this.graph.registry.load([nodeId]).then(() => {
+        this.graph.createNode({
+          type: nodeId,
+          props,
+          position: pos
+        });
+      });
+    } else if (event.dataTransfer.files.length) {
+      const file = event.dataTransfer.files[0];
+
+      if (file.type === 'application/wasm') {
+        const reader = new FileReader();
+        reader.onload = async (e) => {
+          const buffer = e.target?.result;
+          if (buffer?.constructor === ArrayBuffer) {
+            const nodeType = await this.graph.registry.register(nodeId, buffer);
+
+            this.graph.createNode({
+              type: nodeType.id,
+              props: {},
+              position: this.state.projectScreenToWorld(mx, my)
+            });
+          }
+        };
+        reader.readAsArrayBuffer(file);
+      } else if (file.type === 'application/json') {
+        const reader = new FileReader();
+        reader.onload = (e) => {
+          const buffer = e.target?.result as ArrayBuffer;
+          if (buffer) {
+            const state = GraphSchema.parse(JSON.parse(buffer.toString()));
+            this.graph.load(state);
+          }
+        };
+        reader.readAsText(file);
+      }
+    }
+  }
+
+  handleMouseLeave() {
+    this.state.isDragging = false;
+    this.state.isPanning = false;
+  }
+
+  handleDragEnter(e: DragEvent) {
+    e.preventDefault();
+    this.state.isDragging = true;
+    this.state.isPanning = false;
+  }
+
+  handleDragOver(e: DragEvent) {
+    e.preventDefault();
+    this.state.isDragging = true;
+    this.state.isPanning = false;
+  }
+
+  handleDragEnd(e: DragEvent) {
+    e.preventDefault();
+    this.state.isDragging = true;
+    this.state.isPanning = false;
+  }
+
+  getEventListenerProps() {
+    return {
+      ondragenter: (ev: DragEvent) => this.handleDragEnter(ev),
+      ondragover: (ev: DragEvent) => this.handleDragOver(ev),
+      ondragexit: (ev: DragEvent) => this.handleDragEnd(ev),
+      ondrop: (ev: DragEvent) => this.handleFileDrop(ev),
+      onmouseleave: () => this.handleMouseLeave()
+    };
+  }
+}

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

@@ -0,0 +1,117 @@
+import type { Box } from '@nodarium/types';
+import type { GraphManager } from '../graph-manager.svelte';
+import type { GraphState } from '../graph-state.svelte';
+import { distanceFromPointToSegment } from '../helpers';
+
+export class EdgeInteractionManager {
+  constructor(
+    private graph: GraphManager,
+    private state: GraphState
+  ) {}
+
+  private MIN_DISTANCE = 3;
+
+  private _boundingBoxes = new Map<string, Box>();
+
+  handleMouseDown() {
+    this._boundingBoxes.clear();
+
+    const possibleEdges = this.graph
+      .getPossibleDropOnEdges(this.state.activeNodeId)
+      .map(e => this.graph.getEdgeId(e));
+
+    const edges = this.state.getEdges();
+    for (const edge of edges) {
+      const edgeId = edge[0];
+      if (!possibleEdges.includes(edgeId)) {
+        edges.delete(edgeId);
+      }
+    }
+
+    for (const [edgeId, data] of edges) {
+      const points = data.points;
+      let minX = points[0].x + data.x1;
+      let maxX = points[0].x + data.x1;
+      let minY = points[0].z + data.y1;
+      let maxY = points[0].z + data.y1;
+
+      // Iterate through all points to find the true bounds
+      for (let i = 0; i < points.length; i++) {
+        const x = data.x1 + points[i].x;
+        const y = data.y1 + points[i].z;
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+
+      const boundingBox = {
+        minX: minX - this.MIN_DISTANCE,
+        maxX: maxX + this.MIN_DISTANCE,
+        minY: minY - this.MIN_DISTANCE,
+        maxY: maxY + this.MIN_DISTANCE
+      };
+
+      this._boundingBoxes.set(edgeId, boundingBox);
+    }
+  }
+
+  handleMouseMove() {
+    const [mouseX, mouseY] = this.state.mousePosition;
+    const hoveredEdgeIds: string[] = [];
+
+    const edges = this.state.getEdges();
+
+    // Check if mouse is inside any bounding box
+    for (const [edgeId, box] of this._boundingBoxes) {
+      const isInside = mouseX >= box.minX
+        && mouseX <= box.maxX
+        && mouseY >= box.minY
+        && mouseY <= box.maxY;
+
+      if (isInside) {
+        hoveredEdgeIds.push(edgeId);
+      }
+    }
+
+    let hoveredEdgeId: string | null = null;
+    let hoveredEdgeDistance = Infinity;
+
+    const DENSITY = 10; // higher DENSITY = less points checked (yes density might not be the best name :-)
+    for (const edgeId of hoveredEdgeIds) {
+      const edge = edges.get(edgeId)!;
+      for (let i = 0; i < edge.points.length - DENSITY; i += DENSITY) {
+        const pointAx = edge.points[i].x + edge.x1;
+        const pointAy = edge.points[i].z + edge.y1;
+        const pointBx = edge.points[i + DENSITY].x + edge.x1;
+        const pointBy = edge.points[i + DENSITY].z + edge.y1;
+        const distance = distanceFromPointToSegment(
+          pointAx,
+          pointAy,
+          pointBx,
+          pointBy,
+          mouseX,
+          mouseY
+        );
+        if (distance < this.MIN_DISTANCE) {
+          if (distance < hoveredEdgeDistance) {
+            hoveredEdgeDistance = distance;
+            hoveredEdgeId = edgeId;
+          }
+        }
+      }
+    }
+
+    this.state.hoveredEdgeId = hoveredEdgeId;
+  }
+
+  handleMouseUp() {
+    if (this.state.hoveredEdgeId) {
+      const edge = this.graph.getEdgeById(this.state.hoveredEdgeId);
+      if (edge) {
+        this.graph.dropNodeOnEdge(this.state.activeNodeId, edge);
+      }
+      this.state.hoveredEdgeId = null;
+    }
+  }
+}

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

@@ -0,0 +1,402 @@
+import { animate, lerp } from '$lib/helpers';
+import { type NodeInstance } from '@nodarium/types';
+import type { GraphManager } from '../graph-manager.svelte';
+import { type GraphState } from '../graph-state.svelte';
+import { snapToGrid as snapPointToGrid } from '../helpers';
+import { getNodeHeight } from '../helpers/nodeHelpers';
+import { maxZoom, minZoom, zoomSpeed } from './constants';
+import { EdgeInteractionManager } from './edge.events';
+
+export class MouseEventManager {
+  edgeInteractionManager: EdgeInteractionManager;
+
+  constructor(
+    private graph: GraphManager,
+    private state: GraphState
+  ) {
+    this.edgeInteractionManager = new EdgeInteractionManager(graph, state);
+  }
+
+  handleWindowMouseUp(event: MouseEvent) {
+    this.edgeInteractionManager.handleMouseUp();
+    this.state.isPanning = false;
+    if (!this.state.mouseDown) return;
+
+    const activeNode = this.graph.getNode(this.state.activeNodeId);
+
+    const clickedNodeId = this.state.getNodeIdFromEvent(event);
+
+    if (clickedNodeId !== -1) {
+      if (activeNode) {
+        if (!activeNode?.state?.isMoving && !event.ctrlKey && !event.shiftKey) {
+          this.state.activeNodeId = clickedNodeId;
+          this.state.clearSelection();
+        }
+      }
+    }
+
+    if (activeNode?.state?.isMoving) {
+      activeNode.state = activeNode.state || {};
+      activeNode.state.isMoving = false;
+      if (this.state.snapToGrid) {
+        const snapLevel = this.state.getSnapLevel();
+        activeNode.position[0] = snapPointToGrid(
+          activeNode?.state?.x ?? activeNode.position[0],
+          5 / snapLevel
+        );
+        activeNode.position[1] = snapPointToGrid(
+          activeNode?.state?.y ?? activeNode.position[1],
+          5 / snapLevel
+        );
+      } else {
+        activeNode.position[0] = activeNode?.state?.x ?? activeNode.position[0];
+        activeNode.position[1] = activeNode?.state?.y ?? activeNode.position[1];
+      }
+      const nodes = [
+        ...[...(this.state.selectedNodes?.values() || [])].map((id) => this.graph.getNode(id))
+      ] as NodeInstance[];
+
+      const vec = [
+        activeNode.position[0] - (activeNode?.state.x || 0),
+        activeNode.position[1] - (activeNode?.state.y || 0)
+      ];
+
+      for (const node of nodes) {
+        if (!node) continue;
+        node.state = node.state || {};
+        const { x, y } = node.state;
+        if (x !== undefined && y !== undefined) {
+          node.position[0] = x + vec[0];
+          node.position[1] = y + vec[1];
+        }
+      }
+      nodes.push(activeNode);
+      animate(500, (a: number) => {
+        for (const node of nodes) {
+          if (
+            node?.state
+            && node.state['x'] !== undefined
+            && node.state['y'] !== undefined
+          ) {
+            node.state.x = lerp(node.state.x, node.position[0], a);
+            node.state.y = lerp(node.state.y, node.position[1], a);
+            this.state.updateNodePosition(node);
+            if (node?.state?.isMoving) {
+              return false;
+            }
+          }
+        }
+      });
+      this.graph.save();
+    } else if (this.state.hoveredSocket && this.state.activeSocket) {
+      if (
+        typeof this.state.hoveredSocket.index === 'number'
+        && typeof this.state.activeSocket.index === 'string'
+      ) {
+        this.graph.createEdge(
+          this.state.hoveredSocket.node,
+          this.state.hoveredSocket.index || 0,
+          this.state.activeSocket.node,
+          this.state.activeSocket.index
+        );
+      } else if (
+        typeof this.state.activeSocket.index == 'number'
+        && typeof this.state.hoveredSocket.index === 'string'
+      ) {
+        this.graph.createEdge(
+          this.state.activeSocket.node,
+          this.state.activeSocket.index || 0,
+          this.state.hoveredSocket.node,
+          this.state.hoveredSocket.index
+        );
+      }
+      this.graph.save();
+    } else if (this.state.activeSocket && event.ctrlKey) {
+      // Handle automatic adding of nodes on ctrl+mouseUp
+      this.state.edgeEndPosition = [
+        this.state.mousePosition[0],
+        this.state.mousePosition[1]
+      ];
+
+      if (typeof this.state.activeSocket.index === 'number') {
+        this.state.addMenuPosition = [
+          this.state.mousePosition[0],
+          this.state.mousePosition[1] - 25 / this.state.cameraPosition[2]
+        ];
+      } else {
+        this.state.addMenuPosition = [
+          this.state.mousePosition[0] - 155 / this.state.cameraPosition[2],
+          this.state.mousePosition[1] - 25 / this.state.cameraPosition[2]
+        ];
+      }
+      return;
+    }
+
+    // check if camera moved
+    if (
+      clickedNodeId === -1
+      && !this.state.boxSelection
+      && this.state.cameraDown[0] === this.state.cameraPosition[0]
+      && this.state.cameraDown[1] === this.state.cameraPosition[1]
+      && this.state.isBodyFocused()
+    ) {
+      this.state.activeNodeId = -1;
+      this.state.clearSelection();
+    }
+
+    this.state.mouseDown = null;
+    this.state.boxSelection = false;
+    this.state.activeSocket = null;
+    this.state.possibleSockets = [];
+    this.state.hoveredSocket = null;
+    this.state.addMenuPosition = null;
+  }
+
+  handleContextMenu(event: MouseEvent) {
+    if (!this.state.addMenuPosition) {
+      event.preventDefault();
+      this.state.openNodePalette();
+    }
+  }
+
+  handleMouseDown(event: MouseEvent) {
+    // Right click
+    if (event.button === 2) {
+      return;
+    }
+
+    if (this.state.mouseDown) return;
+    this.state.edgeEndPosition = null;
+    const target = event.target as HTMLElement;
+
+    if (
+      target.nodeName !== 'CANVAS'
+      && !target.classList.contains('node')
+      && !target.classList.contains('content')
+    ) {
+      return;
+    }
+
+    const mx = event.clientX - this.state.rect.x;
+    const my = event.clientY - this.state.rect.y;
+
+    this.state.mouseDown = [mx, my];
+    this.state.cameraDown[0] = this.state.cameraPosition[0];
+    this.state.cameraDown[1] = this.state.cameraPosition[1];
+
+    const clickedNodeId = this.state.getNodeIdFromEvent(event);
+    this.state.mouseDownNodeId = clickedNodeId;
+
+    // if we clicked on a node
+    if (clickedNodeId !== -1) {
+      if (event.ctrlKey && event.shiftKey) {
+        this.state.tryConnectToDebugNode(clickedNodeId);
+        return;
+      }
+      if (this.state.activeNodeId === -1) {
+        this.state.activeNodeId = clickedNodeId;
+        // if the selected node is the same as the clicked node
+      } else if (this.state.activeNodeId === clickedNodeId) {
+        // $activeNodeId = -1;
+        // if the clicked node is different from the selected node and secondary
+      } else if (event.ctrlKey) {
+        this.state.selectedNodes.add(this.state.activeNodeId);
+        this.state.selectedNodes.delete(clickedNodeId);
+        this.state.activeNodeId = clickedNodeId;
+        // select the node
+      } else if (event.shiftKey) {
+        const activeNode = this.graph.getNode(this.state.activeNodeId);
+        const newNode = this.graph.getNode(clickedNodeId);
+        if (activeNode && newNode) {
+          const edge = this.graph.getNodesBetween(activeNode, newNode);
+          if (edge) {
+            this.state.selectedNodes.clear();
+            for (const node of edge) {
+              this.state.selectedNodes.add(node.id);
+            }
+            this.state.selectedNodes.add(clickedNodeId);
+          }
+        }
+      } else if (!this.state.selectedNodes.has(clickedNodeId)) {
+        this.state.activeNodeId = clickedNodeId;
+        this.state.clearSelection();
+      }
+      this.edgeInteractionManager.handleMouseDown();
+    } else if (event.ctrlKey) {
+      this.state.boxSelection = true;
+    }
+
+    const node = this.graph.getNode(this.state.activeNodeId);
+    if (!node) return;
+    node.state = node.state || {};
+    node.state.downX = node.position[0];
+    node.state.downY = node.position[1];
+
+    if (this.state.selectedNodes) {
+      for (const nodeId of this.state.selectedNodes) {
+        const n = this.graph.getNode(nodeId);
+        if (!n) continue;
+        n.state = n.state || {};
+        n.state.downX = n.position[0];
+        n.state.downY = n.position[1];
+      }
+    }
+
+    this.state.edgeEndPosition = null;
+  }
+
+  handleWindowMouseMove(event: MouseEvent) {
+    const mx = event.clientX - this.state.rect.x;
+    const my = event.clientY - this.state.rect.y;
+
+    this.state.mousePosition = this.state.projectScreenToWorld(mx, my);
+    this.state.hoveredNodeId = this.state.getNodeIdFromEvent(event);
+
+    if (!this.state.mouseDown) return;
+
+    // we are creating a new edge here
+    if (this.state.activeSocket || this.state.possibleSockets?.length) {
+      let smallestDist = 1000;
+      let _socket;
+      for (const socket of this.state.possibleSockets) {
+        const dist = Math.sqrt(
+          (socket.position[0] - this.state.mousePosition[0]) ** 2
+            + (socket.position[1] - this.state.mousePosition[1]) ** 2
+        );
+        if (dist < smallestDist) {
+          smallestDist = dist;
+          _socket = socket;
+        }
+      }
+
+      if (_socket && smallestDist < 1.5) {
+        this.state.mousePosition = _socket.position;
+        this.state.hoveredSocket = _socket;
+      } else {
+        this.state.hoveredSocket = null;
+      }
+      return;
+    }
+
+    // handle box selection
+    if (this.state.boxSelection) {
+      event.preventDefault();
+      event.stopPropagation();
+      const mouseD = this.state.projectScreenToWorld(
+        this.state.mouseDown[0],
+        this.state.mouseDown[1]
+      );
+      const x1 = Math.min(mouseD[0], this.state.mousePosition[0]);
+      const x2 = Math.max(mouseD[0], this.state.mousePosition[0]);
+      const y1 = Math.min(mouseD[1], this.state.mousePosition[1]);
+      const y2 = Math.max(mouseD[1], this.state.mousePosition[1]);
+      for (const node of this.graph.nodes.values()) {
+        if (!node?.state) continue;
+        const x = node.position[0];
+        const y = node.position[1];
+        const height = getNodeHeight(node.state.type!);
+        if (x > x1 - 20 && x < x2 && y > y1 - height && y < y2) {
+          this.state.selectedNodes?.add(node.id);
+        } else {
+          this.state.selectedNodes?.delete(node.id);
+        }
+      }
+      return;
+    }
+
+    // here we are handling dragging of nodes
+    if (this.state.activeNodeId !== -1 && this.state.mouseDownNodeId !== -1) {
+      this.edgeInteractionManager.handleMouseMove();
+      const node = this.graph.getNode(this.state.activeNodeId);
+      if (!node || event.buttons !== 1) return;
+
+      node.state = node.state || {};
+
+      const oldX = node.state.downX || 0;
+      const oldY = node.state.downY || 0;
+
+      let newX = oldX + (mx - this.state.mouseDown[0]) / this.state.cameraPosition[2];
+      let newY = oldY + (my - this.state.mouseDown[1]) / this.state.cameraPosition[2];
+
+      if (event.ctrlKey) {
+        const snapLevel = this.state.getSnapLevel();
+        if (this.state.snapToGrid) {
+          newX = snapPointToGrid(newX, 5 / snapLevel);
+          newY = snapPointToGrid(newY, 5 / snapLevel);
+        }
+      }
+
+      if (!node.state.isMoving) {
+        const dist = Math.sqrt((oldX - newX) ** 2 + (oldY - newY) ** 2);
+        if (dist > 0.2) {
+          node.state.isMoving = true;
+        }
+      }
+
+      const vecX = oldX - newX;
+      const vecY = oldY - newY;
+
+      if (this.state.selectedNodes?.size) {
+        for (const nodeId of this.state.selectedNodes) {
+          const n = this.graph.getNode(nodeId);
+          if (!n?.state) continue;
+          n.state.x = (n?.state?.downX || 0) - vecX;
+          n.state.y = (n?.state?.downY || 0) - vecY;
+          this.state.updateNodePosition(n);
+        }
+      }
+
+      node.state.x = newX;
+      node.state.y = newY;
+
+      this.state.updateNodePosition(node);
+
+      return;
+    }
+
+    // here we are handling panning of camera
+    this.state.isPanning = true;
+    const newX = this.state.cameraDown[0]
+      - (mx - this.state.mouseDown[0]) / this.state.cameraPosition[2];
+    const newY = this.state.cameraDown[1]
+      - (my - this.state.mouseDown[1]) / this.state.cameraPosition[2];
+
+    this.state.cameraPosition[0] = newX;
+    this.state.cameraPosition[1] = newY;
+  }
+
+  handleMouseScroll(event: WheelEvent) {
+    const bodyIsFocused = document.activeElement === document.body
+      || document.activeElement === this.state.wrapper
+      || document?.activeElement?.id === 'graph';
+    if (!bodyIsFocused) return;
+
+    // Define zoom speed and clamp it between -1 and 1
+    const isNegative = event.deltaY < 0;
+    const normalizedDelta = Math.abs(event.deltaY * 0.01);
+    const delta = Math.pow(0.95, zoomSpeed * normalizedDelta);
+
+    // Calculate new zoom level and clamp it between minZoom and maxZoom
+    const newZoom = Math.max(
+      minZoom,
+      Math.min(
+        maxZoom,
+        isNegative
+          ? this.state.cameraPosition[2] / delta
+          : this.state.cameraPosition[2] * delta
+      )
+    );
+
+    // Calculate the ratio of the new zoom to the original zoom
+    const zoomRatio = newZoom / this.state.cameraPosition[2];
+
+    // Update camera position and zoom level
+    this.state.cameraPosition[0] = this.state.mousePosition[0]
+      - (this.state.mousePosition[0] - this.state.cameraPosition[0])
+        / zoomRatio;
+    this.state.cameraPosition[1] = this.state.mousePosition[1]
+      - (this.state.mousePosition[1] - this.state.cameraPosition[1])
+        / zoomRatio;
+    this.state.cameraPosition[2] = newZoom;
+  }
+}

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

@@ -1,22 +0,0 @@
-import type { Socket } from "@nodes/types";
-import { getContext } from "svelte";
-import { SvelteSet } from 'svelte/reactivity';
-
-export function getGraphState() {
-  return getContext<GraphState>("graphState");
-}
-
-export class GraphState {
-  activeNodeId = $state(-1);
-  selectedNodes = new SvelteSet<number>();
-  activeSocket = $state<Socket | null>(null);
-  hoveredSocket = $state<Socket | null>(null);
-  possibleSockets = $state<Socket[]>([]);
-  possibleSocketIds = $derived(new Set(
-    this.possibleSockets.map((s) => `${s.node.id}-${s.index}`),
-  ));
-  clearSelection() {
-    this.selectedNodes.clear();
-  }
-}
-

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

@@ -1,15 +1,15 @@
-import throttle from './throttle.js';
+import throttle from '$lib/helpers/throttle';
 
 type EventMap = Record<string, unknown>;
 type EventKey<T extends EventMap> = string & keyof T;
 type EventReceiver<T> = (params: T, stuff?: Record<string, unknown>) => unknown;
 
-
-export default class EventEmitter<T extends EventMap = { [key: string]: unknown }> {
+export default class EventEmitter<
+  T extends EventMap = { [key: string]: unknown }
+> {
   index = 0;
   public eventMap: T = {} as T;
-  constructor() {
-  }
+  constructor() {}
 
   private cbs: { [key: string]: ((data?: unknown) => unknown)[] } = {};
   private cbsOnce: { [key: string]: ((data?: unknown) => unknown)[] } = {};
@@ -29,16 +29,20 @@ export default class EventEmitter<T extends EventMap = { [key: string]: unknown
     }
   }
 
-  public on<K extends EventKey<T>>(event: K, cb: EventReceiver<T[K]>, throttleTimer = 0) {
+  public on<K extends EventKey<T>>(
+    event: K,
+    cb: EventReceiver<T[K]>,
+    throttleTimer = 0
+  ) {
     if (throttleTimer > 0) cb = throttle(cb, throttleTimer);
     const cbs = Object.assign(this.cbs, {
-      [event]: [...(this.cbs[event] || []), cb],
+      [event]: [...(this.cbs[event] || []), cb]
     });
     this.cbs = cbs;
 
     // console.log('New EventEmitter ', this.constructor.name);
     return () => {
-      cbs[event]?.splice(cbs[event].indexOf(cb), 1);
+      this.cbs[event]?.splice(cbs[event].indexOf(cb), 1);
     };
   }
 
@@ -48,10 +52,17 @@ export default class EventEmitter<T extends EventMap = { [key: string]: unknown
    * @param {function} cb Listener, gets called everytime the event is emitted
    * @returns {function} Returns a function which removes the listener when called
    */
-  public once<K extends EventKey<T>>(event: K, cb: EventReceiver<T[K]>): () => void {
-    this.cbsOnce[event] = [...(this.cbsOnce[event] || []), cb];
+  public once<K extends EventKey<T>>(
+    event: K,
+    cb: EventReceiver<T[K]>
+  ): () => void {
+    const cbsOnce = Object.assign(this.cbsOnce, {
+      [event]: [...(this.cbsOnce[event] || []), cb]
+    });
+    this.cbsOnce = cbsOnce;
+
     return () => {
-      this.cbsOnce[event].splice(this.cbsOnce[event].indexOf(cb), 1);
+      cbsOnce[event]?.splice(cbsOnce[event].indexOf(cb), 1);
     };
   }
 

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

@@ -6,7 +6,10 @@ export function lerp(a: number, b: number, t: number) {
   return a + (b - a) * t;
 }
 
-export function animate(duration: number, callback: (progress: number) => void | false) {
+export function animate(
+  duration: number,
+  callback: (progress: number) => void | false
+) {
   const start = performance.now();
   const loop = (time: number) => {
     const progress = (time - start) / duration;
@@ -18,7 +21,7 @@ export function animate(duration: number, callback: (progress: number) => void |
     } else {
       callback(1);
     }
-  }
+  };
   requestAnimationFrame(loop);
 }
 
@@ -30,10 +33,14 @@ export function createNodePath({
   cornerBottom = 0,
   leftBump = false,
   rightBump = false,
-  aspectRatio = 1,
+  aspectRatio = 1
 } = {}) {
+  const leftBumpTopY = y + height / 2;
+  const leftBumpBottomY = y - height / 2;
+
   return `M0,${cornerTop}
-      ${cornerTop
+      ${
+    cornerTop
       ? ` V${cornerTop}
               Q0,0 ${cornerTop * aspectRatio},0
               H${100 - cornerTop * aspectRatio}
@@ -42,62 +49,35 @@ export function createNodePath({
       : ` V0
               H100
             `
-    }
+  }
       V${y - height / 2}
-      ${rightBump
+      ${
+    rightBump
       ? ` C${100 - depth},${y - height / 2} ${100 - depth},${y + height / 2} 100,${y + height / 2}`
       : ` H100`
-    }
-      ${cornerBottom
+  }
+      ${
+    cornerBottom
       ? ` V${100 - cornerBottom}
               Q100,100 ${100 - cornerBottom * aspectRatio},100
               H${cornerBottom * aspectRatio}
               Q0,100  0,${100 - cornerBottom}
             `
       : `${leftBump ? `V100 H0` : `V100`}`
-    }
-      ${leftBump
-      ? ` V${y + height / 2} C${depth},${y + height / 2} ${depth},${y - height / 2} 0,${y - height / 2}`
+  }
+      ${
+    leftBump
+      ? ` V${leftBumpTopY} C${depth},${leftBumpTopY} ${depth},${leftBumpBottomY} 0,${leftBumpBottomY}`
       : ` H0`
-    }
-      Z`.replace(/\s+/g, " ");
+  }
+      Z`.replace(/\s+/g, ' ');
 }
 
-export const debounce = (fn: Function, ms = 300) => {
-  let timeoutId: ReturnType<typeof setTimeout>;
-  return function (this: any, ...args: any[]) {
-    clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => fn.apply(this, args), ms);
-  };
-};
+export const clone: <T>(v: T) => T = 'structedClone' in globalThis
+  ? globalThis.structuredClone
+  : (obj) => JSON.parse(JSON.stringify(obj));
 
-export const clone: <T>(v: T) => T = "structedClone" in globalThis ? globalThis.structuredClone : (obj) => JSON.parse(JSON.stringify(obj));
-
-export const createLogger = (() => {
-  let maxLength = 5;
-  return (scope: string) => {
-    maxLength = Math.max(maxLength, scope.length);
-    let muted = false;
-    return {
-      log: (...args: any[]) => !muted && console.log(`[%c${scope.padEnd(maxLength, " ")}]:`, "color: #888", ...args),
-      group: (...args: any[]) => !muted && console.groupCollapsed(`[%c${scope.padEnd(maxLength, " ")}]:`, "color: #888", ...args),
-      groupEnd: () => !muted && console.groupEnd(),
-      info: (...args: any[]) => !muted && console.info(`[%c${scope.padEnd(maxLength, " ")}]:`, "color: #888", ...args),
-      warn: (...args: any[]) => !muted && console.warn(`[%c${scope.padEnd(maxLength, " ")}]:`, "color: #888", ...args),
-      error: (...args: any[]) => console.error(`[%c${scope.padEnd(maxLength, " ")}]:`, "color: #f88", ...args),
-      mute() {
-        muted = true;
-      },
-      unmute() {
-        muted = false;
-      }
-
-    }
-  }
-})();
-
-
-export function withSubComponents<A, B extends Record<string, any>>(
+export function withSubComponents<A, B extends Record<string, unknown>>(
   component: A,
   subcomponents: B
 ): A & B {
@@ -107,3 +87,27 @@ export function withSubComponents<A, B extends Record<string, any>>(
   });
   return component as A & B;
 }
+
+export function distanceFromPointToSegment(
+  x1: number,
+  y1: number,
+  x2: number,
+  y2: number,
+  x0: number,
+  y0: number
+): number {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+
+  if (dx === 0 && dy === 0) {
+    return Math.hypot(x0 - x1, y0 - y1);
+  }
+
+  const t = ((x0 - x1) * dx + (y0 - y1) * dy) / (dx * dx + dy * dy);
+  const clampedT = Math.max(0, Math.min(1, t));
+
+  const px = x1 + clampedT * dx;
+  const py = y1 + clampedT * dy;
+
+  return Math.hypot(x0 - px, y0 - py);
+}

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

@@ -1,15 +1,14 @@
-import { writable, type Writable } from "svelte/store";
+import { type Writable, writable } from 'svelte/store';
 
 function isStore(v: unknown): v is Writable<unknown> {
-  return v !== null && typeof v === "object" && "subscribe" in v && "set" in v;
+  return v !== null && typeof v === 'object' && 'subscribe' in v && 'set' in v;
 }
 
 const storeIds: Map<string, ReturnType<typeof createLocalStore>> = new Map();
 
-const HAS_LOCALSTORAGE = "localStorage" in globalThis;
+const HAS_LOCALSTORAGE = 'localStorage' in globalThis;
 
 function createLocalStore<T>(key: string, initialValue: T | Writable<T>) {
-
   let store: Writable<T>;
 
   if (HAS_LOCALSTORAGE) {
@@ -36,18 +35,15 @@ function createLocalStore<T>(key: string, initialValue: T | Writable<T>) {
     subscribe: store.subscribe,
     set: store.set,
     update: store.update
-  }
+  };
 }
 
-
 export default function localStore<T>(key: string, initialValue: T | Writable<T>): Writable<T> {
-
   if (storeIds.has(key)) return storeIds.get(key) as Writable<T>;
 
-  const store = createLocalStore(key, initialValue)
+  const store = createLocalStore(key, initialValue);
 
   storeIds.set(key, store);
 
-  return store
-
+  return store;
 }

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

@@ -0,0 +1,71 @@
+import type { NodeDefinition, NodeInstance } from '@nodarium/types';
+
+export function getParameterHeight(node: NodeDefinition, inputKey: string) {
+  const input = node.inputs?.[inputKey];
+  if (!input) {
+    return 0;
+  }
+
+  if (inputKey === 'seed') return 0;
+  if (!node.inputs) return 0;
+  if ('setting' in input) return 0;
+  if (input.hidden) return 0;
+
+  if (input.type === 'shape' && input.external !== true) {
+    return 200;
+  }
+  if (
+    input?.label !== '' && !input.external && input.type !== 'path'
+    && input.type !== 'geometry'
+  ) {
+    return 100;
+  }
+  return 50;
+}
+
+export function getSocketPosition(
+  node: NodeInstance,
+  index: string | number
+): [number, number] {
+  if (typeof index === 'number') {
+    return [
+      (node?.state?.x ?? node.position[0]) + 20,
+      (node?.state?.y ?? node.position[1]) + 2.5 + 10 * index
+    ];
+  } else {
+    let height = 5;
+    const nodeType = node.state.type!;
+    const inputs = nodeType.inputs || {};
+    for (const inputKey in inputs) {
+      const h = getParameterHeight(nodeType, inputKey) / 10;
+      if (inputKey === index) {
+        height += h / 2;
+        break;
+      }
+      height += h;
+    }
+    return [
+      node?.state?.x ?? node.position[0],
+      (node?.state?.y ?? node.position[1]) + height
+    ];
+  }
+}
+
+const nodeHeightCache: Record<string, number> = {};
+export function getNodeHeight(node: NodeDefinition) {
+  if (node.id in nodeHeightCache) {
+    return nodeHeightCache[node.id];
+  }
+  if (!node?.inputs) {
+    return 5;
+  }
+  let height = 5;
+
+  for (const key in node.inputs) {
+    const h = getParameterHeight(node, key) / 10;
+    height += h;
+  }
+
+  nodeHeightCache[node.id] = height;
+  return height;
+}

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

@@ -1,20 +0,0 @@
-export default <R, A extends any[]>(
-  fn: (...args: A) => R,
-  delay: number
-): ((...args: A) => R) => {
-  let wait = false;
-
-  return (...args: A) => {
-    if (wait) return undefined;
-
-    const val = fn(...args);
-
-    wait = true;
-
-    setTimeout(() => {
-      wait = false;
-    }, delay);
-
-    return val;
-  }
-};

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

@@ -1,24 +1,24 @@
-import { create, type Delta } from "jsondiffpatch";
-import type { Graph } from "@nodes/types";
-import { createLogger, clone } from "./helpers/index.js";
-
+import type { Graph } from '@nodarium/types';
+import { createLogger } from '@nodarium/utils';
+import { create, type Delta } from 'jsondiffpatch';
+import { clone } from './helpers/index.js';
 
 const diff = create({
-  objectHash: function (obj, index) {
+  objectHash: function(obj, index) {
     if (obj === null) return obj;
-    if ("id" in obj) return obj.id;
+    if ('id' in obj) return obj.id as string;
+    if ('_id' in obj) return obj._id as string;
     if (Array.isArray(obj)) {
-      return obj.join("-")
+      return obj.join('-');
     }
-    return obj?.id || obj._id || '$$index:' + index;
+    return '$$index:' + index;
   }
-})
+});
 
-const log = createLogger("history")
+const log = createLogger('history');
 log.mute();
 
 export class HistoryManager {
-
   index: number = -1;
   history: Delta[] = [];
   private initialState: Graph | undefined;
@@ -26,27 +26,26 @@ export class HistoryManager {
 
   private opts = {
     debounce: 400,
-    maxHistory: 100,
-  }
+    maxHistory: 100
+  };
 
   constructor({ maxHistory = 100, debounce = 100 } = {}) {
     this.history = [];
     this.index = -1;
     this.opts.debounce = debounce;
     this.opts.maxHistory = maxHistory;
-    globalThis["_history"] = this;
   }
 
   save(state: Graph) {
     if (!this.state) {
       this.state = clone(state);
       this.initialState = this.state;
-      log.log("initial state saved")
+      log.log('initial state saved');
     } else {
       const newState = state;
       const delta = diff.diff(this.state, newState);
       if (delta) {
-        log.log("saving state")
+        log.log('saving state');
         // Add the delta to history
         if (this.index < this.history.length - 1) {
           // Clear the history after the current index if new changes are made
@@ -62,7 +61,7 @@ export class HistoryManager {
         }
         this.state = newState;
       } else {
-        log.log("no changes")
+        log.log('no changes');
       }
     }
   }
@@ -76,7 +75,7 @@ export class HistoryManager {
 
   undo() {
     if (this.index === -1 && this.initialState) {
-      log.log("reached start, loading initial state")
+      log.log('reached start, loading initial state');
       return clone(this.initialState);
     } else {
       const delta = this.history[this.index];
@@ -96,7 +95,7 @@ export class HistoryManager {
       this.state = nextState;
       return clone(nextState);
     } else {
-      log.log("reached end")
+      log.log('reached end');
     }
   }
 }

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

@@ -0,0 +1,183 @@
+import { animate, lerp } from '$lib/helpers';
+import type { createKeyMap } from '$lib/helpers/createKeyMap';
+import { panelState } from '$lib/sidebar/PanelState.svelte';
+import FileSaver from 'file-saver';
+import type { GraphManager } from './graph-manager.svelte';
+import type { GraphState } from './graph-state.svelte';
+
+type Keymap = ReturnType<typeof createKeyMap>;
+export function setupKeymaps(keymap: Keymap, graph: GraphManager, graphState: GraphState) {
+  keymap.addShortcut({
+    key: 'l',
+    description: 'Select linked nodes',
+    callback: () => {
+      const activeNode = graph.getNode(graphState.activeNodeId);
+      if (activeNode) {
+        const nodes = graph.getLinkedNodes(activeNode);
+        graphState.selectedNodes.clear();
+        for (const node of nodes) {
+          graphState.selectedNodes.add(node.id);
+        }
+      }
+    }
+  });
+
+  keymap.addShortcut({
+    key: '?',
+    description: 'Toggle Help',
+    callback: () => {
+      panelState.setActivePanel('shortcuts');
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'c',
+    ctrl: true,
+    description: 'Copy active nodes',
+    callback: () => graphState.copyNodes()
+  });
+
+  keymap.addShortcut({
+    key: 'v',
+    ctrl: true,
+    description: 'Paste nodes',
+    callback: () => graphState.pasteNodes()
+  });
+
+  keymap.addShortcut({
+    key: 'Escape',
+    description: 'Deselect nodes',
+    callback: () => {
+      graphState.activeNodeId = -1;
+      graphState.clearSelection();
+      graphState.edgeEndPosition = null;
+      (document.activeElement as HTMLElement)?.blur();
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'A',
+    shift: true,
+    description: 'Add new Node',
+    callback: () => graphState.openNodePalette()
+  });
+
+  keymap.addShortcut({
+    key: '.',
+    description: 'Center camera',
+    callback: () => {
+      if (!graphState.isBodyFocused()) return;
+
+      const average = [0, 0];
+      for (const node of graph.nodes.values()) {
+        average[0] += node.position[0];
+        average[1] += node.position[1];
+      }
+      average[0] = average[0] ? average[0] / graph.nodes.size : 0;
+      average[1] = average[1] ? average[1] / graph.nodes.size : 0;
+
+      const camX = graphState.cameraPosition[0];
+      const camY = graphState.cameraPosition[1];
+      const camZ = graphState.cameraPosition[2];
+
+      const ease = (t: number) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t);
+
+      animate(500, (a: number) => {
+        graphState.cameraPosition[0] = lerp(camX, average[0], ease(a));
+        graphState.cameraPosition[1] = lerp(camY, average[1], ease(a));
+        graphState.cameraPosition[2] = lerp(camZ, 2, ease(a));
+        if (graphState.mouseDown) return false;
+      });
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'a',
+    ctrl: true,
+    preventDefault: true,
+    description: 'Select all nodes',
+    callback: () => {
+      if (!graphState.isBodyFocused()) return;
+      for (const node of graph.nodes.keys()) {
+        graphState.selectedNodes.add(node);
+      }
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'z',
+    ctrl: true,
+    description: 'Undo',
+    callback: () => {
+      if (!graphState.isBodyFocused()) return;
+      graph.undo();
+      for (const node of graph.nodes.values()) {
+        graphState.updateNodePosition(node);
+      }
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'y',
+    ctrl: true,
+    description: 'Redo',
+    callback: () => {
+      graph.redo();
+      for (const node of graph.nodes.values()) {
+        graphState.updateNodePosition(node);
+      }
+    }
+  });
+
+  keymap.addShortcut({
+    key: 's',
+    ctrl: true,
+    description: 'Save',
+    preventDefault: true,
+    callback: () => {
+      const state = graph.serialize();
+      const blob = new Blob([JSON.stringify(state)], {
+        type: 'application/json;charset=utf-8'
+      });
+      FileSaver.saveAs(blob, 'nodarium-graph.json');
+    }
+  });
+
+  keymap.addShortcut({
+    key: ['Delete', 'Backspace', 'x'],
+    description: 'Delete selected nodes',
+    callback: (event) => {
+      if (!graphState.isBodyFocused()) return;
+      graph.startUndoGroup();
+      if (graphState.activeNodeId !== -1) {
+        const node = graph.getNode(graphState.activeNodeId);
+        if (node) {
+          graph.removeNode(node, { restoreEdges: event.ctrlKey });
+          graphState.activeNodeId = -1;
+        }
+      }
+      if (graphState.selectedNodes) {
+        for (const nodeId of graphState.selectedNodes) {
+          const node = graph.getNode(nodeId);
+          if (node) {
+            graph.removeNode(node, { restoreEdges: event.ctrlKey });
+          }
+        }
+        graphState.clearSelection();
+      }
+      graph.saveUndoGroup();
+    }
+  });
+
+  keymap.addShortcut({
+    key: 'f',
+    description: 'Smart Connect Nodes',
+    callback: () => {
+      const nodes = [...graphState.selectedNodes.values()]
+        .map((g) => graph.getNode(g))
+        .filter((n) => !!n);
+      const edge = graph.smartConnect(nodes[0], nodes[1]);
+      if (!edge) graph.smartConnect(nodes[1], nodes[0]);
+    }
+  });
+}

app/src/lib/graph-interface/node/Node.frag

@@ -1,56 +1,88 @@
-
 varying vec2 vUv;
 
 uniform float uWidth;
 uniform float uHeight;
+uniform float uZoom; 
 
 uniform vec3 uColorDark;
 uniform vec3 uColorBright;
-
 uniform vec3 uStrokeColor;
-uniform float uStrokeWidth;
+
+const float uHeaderHeight = 5.0; 
+uniform float uSectionHeights[16]; 
+uniform int uNumSections;
 
 float msign(in float x) { return (x < 0.0) ? -1.0 : 1.0; }
+float sdCircle(vec2 p, float r) { return length(p) - r; }
 
 vec4 roundedBoxSDF( in vec2 p, in vec2 b, in float r, in float s) {
   vec2 q = abs(p) - b + r;
   float l = b.x + b.y + 1.570796 * r;
-
   float k1 = min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - r;
   float k2 = ((q.x > 0.0) ? atan(q.y, q.x) : 1.570796);
   float k3 = 3.0 + 2.0 * msign(min(p.x, -p.y)) - msign(p.x);
   float k4 = msign(p.x * p.y);
   float k5 = r * k2 + max(-q.x, 0.0);
-
   float ra = s * round(k1 / s);
   float l2 = l + 1.570796 * ra;
-
   return vec4(k1 - ra, k3 * l2 + k4 * (b.y + ((q.y > 0.0) ? k5 + k2 * ra : q.y)), 4.0 * l2, k1);
 }
 
 void main(){
+  float strokeWidth = mix(2.0, 0.5, uZoom);
+  
+  float borderRadius = 0.5;
+  float dentRadius = 0.8;
 
-  float y = (1.0-vUv.y) * uHeight;
+  float y = (1.0 - vUv.y) * uHeight;
   float x = vUv.x * uWidth;
-
   vec2 size = vec2(uWidth, uHeight);
-  vec2 uv = (vUv - 0.5) * 2.0;
+  vec2 uvCenter = (vUv - 0.5) * 2.0;
 
-  float u_border_radius = 0.4;
-  vec4 distance = roundedBoxSDF(uv * size, size, u_border_radius*2.0, 0.0);
+  vec4 boxData = roundedBoxSDF(uvCenter * size, size, borderRadius * 2.0, 0.0);
+  float sceneSDF = boxData.w;
 
-  if (distance.w > 0.0 ) {
-    // outside
-    gl_FragColor = vec4(0.0,0.0,0.0, 0.0);
-  }else{
-    if (distance.w > -uStrokeWidth || mod(y+5.0, 10.0) < uStrokeWidth/2.0) {
-      // draw the outer stroke
-      gl_FragColor = vec4(uStrokeColor, 1.0);
-    }else if (y<5.0){
-      // draw the header
-      gl_FragColor = vec4(uColorBright, 1.0);
-    }else{
-      gl_FragColor = vec4(uColorDark, 1.0);
-    }
+  vec2 headerDentPos = vec2(uWidth, uHeaderHeight * 0.5);
+  float headerDentDist = sdCircle(vec2(x, y) - headerDentPos, dentRadius);
+  sceneSDF = max(sceneSDF, -headerDentDist*2.0);
+
+  float currentYBoundary = uHeaderHeight;
+  float previousYBoundary = uHeaderHeight;
+
+  for (int i = 0; i < 16; i++) {
+    if (i >= uNumSections) break;
+    
+    float sectionHeight = uSectionHeights[i];
+    currentYBoundary += sectionHeight;
+    
+    float centerY = previousYBoundary + (sectionHeight * 0.5);
+    vec2 circlePos = vec2(0.0, centerY);
+    float circleDist = sdCircle(vec2(x, y) - circlePos, dentRadius);
+    
+    sceneSDF = max(sceneSDF, -circleDist*2.0);
+    previousYBoundary = currentYBoundary;
+  }
+
+  if (sceneSDF > 0.05) { 
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+    return;
+  }
+
+  vec3 finalColor = (y < uHeaderHeight) ? uColorBright : uColorDark;
+  bool isDivider = false;
+
+  float dividerY = uHeaderHeight;
+  if (abs(y - dividerY) < strokeWidth * 0.25) isDivider = true;
+  
+  for (int i = 0; i < 16; i++) {
+    if (i >= uNumSections - 1) break;
+    dividerY += uSectionHeights[i];
+    if (abs(y - dividerY) < strokeWidth * 0.25) isDivider = true;
+  }
+
+  if (sceneSDF > -strokeWidth || isDivider) {
+    gl_FragColor = vec4(uStrokeColor, 1.0);
+  } else {
+    gl_FragColor = vec4(finalColor, 1.0);
   }
 }

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

@@ -1,65 +1,68 @@
 <script lang="ts">
-  import type { Node } from "@nodes/types";
-  import { getContext, onMount } from "svelte";
-  import { getGraphState } from "../graph/state.svelte";
-  import { T } from "@threlte/core";
-  import { type Mesh } from "three";
-  import NodeFrag from "./Node.frag";
-  import NodeVert from "./Node.vert";
-  import NodeHtml from "./NodeHTML.svelte";
-  import { colors } from "../graph/colors.svelte";
-  import { appSettings } from "$lib/settings/app-settings.svelte";
+  import { appSettings } from '$lib/settings/app-settings.svelte';
+  import type { NodeInstance } from '@nodarium/types';
+  import { T } from '@threlte/core';
+  import { type Mesh } from 'three';
+  import { getGraphState } from '../graph-state.svelte';
+  import { colors } from '../graph/colors.svelte';
+  import { getNodeHeight, getParameterHeight } from '../helpers/nodeHelpers';
+  import NodeFrag from './Node.frag';
+  import NodeVert from './Node.vert';
+  import NodeHtml from './NodeHTML.svelte';
 
   const graphState = getGraphState();
 
   type Props = {
-    node: Node;
+    node: NodeInstance;
     inView: boolean;
-    z: number;
   };
-  const { node, inView, z }: Props = $props();
+  let { node = $bindable(), inView }: Props = $props();
+
+  const nodeType = $derived(node.state.type!);
 
   const isActive = $derived(graphState.activeNodeId === node.id);
   const isSelected = $derived(graphState.selectedNodes.has(node.id));
-  let strokeColor = $state(colors.selected);
-  $effect(() => {
-    appSettings.theme;
-    strokeColor = isSelected
-      ? colors.selected
-      : isActive
+  const strokeColor = $derived(
+    appSettings.value.theme
+      && (isSelected
+        ? colors.selected
+        : isActive
         ? colors.active
-        : colors.outline;
-  });
+        : colors.outline)
+  );
 
-  const updateNodePosition =
-    getContext<(n: Node) => void>("updateNodePosition");
-
-  const getNodeHeight = getContext<(n: string) => number>("getNodeHeight");
+  const sectionHeights = $derived(
+    Object
+      .keys(nodeType.inputs || {})
+      .map(key => getParameterHeight(nodeType, key) / 10)
+      .filter(b => !!b)
+  );
 
   let meshRef: Mesh | undefined = $state();
 
-  const height = getNodeHeight?.(node.type);
+  const height = getNodeHeight(node.state.type!);
+
+  const zoom = $derived(graphState.cameraPosition[2]);
 
   $effect(() => {
-    node.tmp = node.tmp || {};
-    node.tmp.mesh = meshRef;
-    updateNodePosition?.(node);
-  });
-
-  onMount(() => {
-    node.tmp = node.tmp || {};
-    node.tmp.mesh = meshRef;
-    updateNodePosition?.(node);
+    if (meshRef && !node.state?.mesh) {
+      node.state.mesh = meshRef;
+      graphState.updateNodePosition(node);
+    }
   });
+  const zoomValue = $derived(
+    (Math.log(graphState.cameraPosition[2]) - Math.log(1)) / (Math.log(40) - Math.log(1))
+  );
+  // const zoomValue = (graphState.cameraPosition[2] - 1) / 39;
 </script>
 
 <T.Mesh
-  position.x={node.position[0] + 10}
-  position.z={node.position[1] + height / 2}
+  position.x={(node.state.x ?? node.position[0]) + 10}
+  position.z={(node.state.y ?? node.position[1]) + height / 2}
   position.y={0.8}
   rotation.x={-Math.PI / 2}
   bind:ref={meshRef}
-  visible={inView && z < 7}
+  visible={inView && zoom < 7}
 >
   <T.PlaneGeometry args={[20, height]} radius={1} />
   <T.ShaderMaterial
@@ -67,16 +70,21 @@
     fragmentShader={NodeFrag}
     transparent
     uniforms={{
-      uColorBright: { value: colors["layer-2"] },
-      uColorDark: { value: colors["layer-1"] },
+      uColorBright: { value: colors['layer-2'] },
+      uColorDark: { value: colors['layer-1'] },
       uStrokeColor: { value: colors.outline.clone() },
-      uStrokeWidth: { value: 1.0 },
+      uSectionHeights: { value: [5, 10] },
+      uNumSections: { value: 2 },
       uWidth: { value: 20 },
-      uHeight: { value: height },
+      uHeight: { value: 200 },
+      uZoom: { value: 1.0 }
     }}
-    uniforms.uStrokeColor.value={strokeColor.clone()}
-    uniforms.uStrokeWidth.value={(7 - z) / 3}
+    uniforms.uZoom.value={zoomValue}
+    uniforms.uHeight.value={height}
+    uniforms.uSectionHeights.value={sectionHeights}
+    uniforms.uNumSections.value={sectionHeights.length}
+    uniforms.uStrokeColor.value={strokeColor}
   />
 </T.Mesh>
 
-<NodeHtml {node} {inView} {isActive} {isSelected} {z} />
+<NodeHtml bind:node {inView} {isActive} {isSelected} z={zoom} />

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

@@ -1,14 +1,16 @@
 <script lang="ts">
-  import type { Node } from "@nodes/types";
-  import NodeHeader from "./NodeHeader.svelte";
-  import NodeParameter from "./NodeParameter.svelte";
-  import { getContext, onMount } from "svelte";
+  import type { NodeInstance } from '@nodarium/types';
+  import { getGraphState } from '../graph-state.svelte';
+  import NodeHeader from './NodeHeader.svelte';
+  import NodeParameter from './NodeParameter.svelte';
 
   let ref: HTMLDivElement;
 
+  const graphState = getGraphState();
+
   type Props = {
-    node: Node;
-    position?: "absolute" | "fixed" | "relative";
+    node: NodeInstance;
+    position?: 'absolute' | 'fixed' | 'relative';
     isActive?: boolean;
     isSelected?: boolean;
     inView?: boolean;
@@ -17,30 +19,26 @@
 
   let {
     node = $bindable(),
-    position = "absolute",
+    position = 'absolute',
     isActive = false,
     isSelected = false,
     inView = true,
-    z = 2,
+    z = 2
   }: Props = $props();
 
-  const zOffset = (node.tmp?.random || 0) * 0.5;
+  // If we dont have a random offset, all nodes becom visible at the same zoom level -> stuttering
+  const zOffset = Math.random() - 0.5;
   const zLimit = 2 - zOffset;
 
-  const type = node?.tmp?.type;
-
-  const parameters = Object.entries(type?.inputs || {}).filter(
-    (p) =>
-      p[1].type !== "seed" && !("setting" in p[1]) && p[1]?.hidden !== true,
+  const parameters = Object.entries(node.state?.type?.inputs || {}).filter(
+    (p) => p[1].type !== 'seed' && !('setting' in p[1]) && p[1]?.hidden !== true
   );
 
-  const updateNodePosition =
-    getContext<(n: Node) => void>("updateNodePosition");
-
-  onMount(() => {
-    node.tmp = node.tmp || {};
-    node.tmp.ref = ref;
-    updateNodePosition?.(node);
+  $effect(() => {
+    if ('state' in node && !node.state.ref) {
+      node.state.ref = ref;
+      graphState?.updateNodePosition(node);
+    }
   });
 </script>
 
@@ -48,7 +46,7 @@
   class="node {position}"
   class:active={isActive}
   style:--cz={z + zOffset}
-  style:display={inView && z > zLimit ? "block" : "none"}
+  style:display={inView && z > zLimit ? 'block' : 'none'}
   class:selected={isSelected}
   class:out-of-view={!inView}
   data-node-id={node.id}
@@ -57,7 +55,7 @@
 >
   <NodeHeader {node} />
 
-  {#each parameters as [key, value], i}
+  {#each parameters as [key, value], i (key)}
     <NodeParameter
       bind:node
       id={key}
@@ -73,22 +71,22 @@
     user-select: none !important;
     cursor: pointer;
     width: 200px;
-    color: var(--text-color);
+    color: var(--color-text);
     transform: translate3d(var(--nx), var(--ny), 0);
     z-index: 1;
     opacity: calc((var(--cz) - 2.5) / 3.5);
     font-weight: 300;
-    --stroke: var(--outline);
+    --stroke: var(--color-outline);
     --stroke-width: 2px;
   }
 
   .node.active {
-    --stroke: var(--active);
+    --stroke: var(--color-active);
     --stroke-width: 2px;
   }
 
   .node.selected {
-    --stroke: var(--selected);
+    --stroke: var(--color-selected);
     --stroke-width: 2px;
   }
 </style>

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

@@ -1,66 +1,84 @@
 <script lang="ts">
-  import { createNodePath } from "../helpers/index.js";
-  import type { Node, Socket } from "@nodes/types";
-  import { getContext } from "svelte";
+  import { appSettings } from '$lib/settings/app-settings.svelte';
+  import type { NodeInstance, Socket } from '@nodarium/types';
+  import { getGraphState } from '../graph-state.svelte';
+  import { createNodePath } from '../helpers/index.js';
+  import { getSocketPosition } from '../helpers/nodeHelpers';
 
-  export let node: Node;
+  const graphState = getGraphState();
 
-  const setDownSocket = getContext<(socket: Socket) => void>("setDownSocket");
-  const getSocketPosition =
-    getContext<(node: Node, index: number) => [number, number]>(
-      "getSocketPosition",
-    );
+  const { node }: { node: NodeInstance } = $props();
 
   function handleMouseDown(event: MouseEvent) {
     event.stopPropagation();
     event.preventDefault();
-    setDownSocket?.({
-      node,
-      index: 0,
-      position: getSocketPosition?.(node, 0),
-    });
+    if ('state' in node) {
+      graphState.setDownSocket?.({
+        node,
+        index: 0,
+        position: getSocketPosition?.(node, 0)
+      });
+    }
   }
 
   const cornerTop = 10;
-  const rightBump = !!node?.tmp?.type?.outputs?.length;
+  const rightBump = $derived(!!node?.state?.type?.outputs?.length);
   const aspectRatio = 0.25;
 
-  const path = createNodePath({
-    depth: 5.5,
-    height: 34,
-    y: 49,
-    cornerTop,
-    rightBump,
-    aspectRatio,
-  });
-  const pathDisabled = createNodePath({
-    depth: 0,
-    height: 15,
-    y: 50,
-    cornerTop,
-    rightBump,
-    aspectRatio,
-  });
-  const pathHover = createNodePath({
-    depth: 8.5,
-    height: 50,
-    y: 49,
-    cornerTop,
-    rightBump,
-    aspectRatio,
-  });
+  const path = $derived(
+    createNodePath({
+      depth: 5.5,
+      height: 34,
+      y: 49,
+      cornerTop,
+      rightBump,
+      aspectRatio
+    })
+  );
+  const pathHover = $derived(
+    createNodePath({
+      depth: 7,
+      height: 40,
+      y: 49,
+      cornerTop,
+      rightBump,
+      aspectRatio
+    })
+  );
+
+  const socketId = $derived(`${node.id}-${0}`);
+
+  function getSocketType(s: Socket | null) {
+    if (!s) return 'unknown';
+    if (typeof s.index === 'string') {
+      return s.node.state.type?.inputs?.[s.index].type || 'unknown';
+    }
+    return s.node.state.type?.outputs?.[s.index] || 'unknown';
+  }
+  const socketType = $derived(getSocketType(graphState.activeSocket));
+  const hoverColor = $derived(graphState.colors.getColor(socketType));
 </script>
 
-<div class="wrapper" data-node-id={node.id} data-node-type={node.type}>
+<div
+  class="wrapper"
+  data-node-id={node.id}
+  data-node-type={node.type}
+  style:--socket-color={hoverColor}
+  class:possible-socket={graphState?.possibleSocketIds.has(socketId)}
+>
   <div class="content">
-    {node.type.split("/").pop()}
+    {#if appSettings.value.debug.advancedMode}
+      <span class="bg-white text-black! mr-2 px-1 rounded-sm opacity-30">{node.id}</span>
+    {/if}
+    {node.type.split('/').pop()}
   </div>
   <div
-    class="click-target"
+    class="target"
     role="button"
     tabindex="0"
-    on:mousedown={handleMouseDown}
-  ></div>
+    onmousedown={handleMouseDown}
+  >
+  </div>
   <svg
     xmlns="http://www.w3.org/2000/svg"
     viewBox="0 0 100 100"
@@ -72,8 +90,7 @@
       --hover-path: path("${pathHover}");
     `}
   >
-    <path vector-effect="non-scaling-stroke" stroke="white" stroke-width="0.1"
-    ></path>
+    <path vector-effect="non-scaling-stroke" stroke="white" stroke-width="0.1"></path>
   </svg>
 </div>
 
@@ -84,7 +101,20 @@
     height: 50px;
   }
 
-  .click-target {
+  .possible-socket .target::before {
+    content: "";
+    position: absolute;
+    width: 30px;
+    height: 30px;
+    border-radius: 100%;
+    box-shadow: 0px 0px 10px var(--socket-color);
+    background-color: var(--socket-color);
+    outline: solid thin var(--socket-color);
+    opacity: 0.7;
+    z-index: -10;
+  }
+
+  .target {
     position: absolute;
     right: 0px;
     top: 50%;
@@ -93,11 +123,9 @@
     width: 30px;
     z-index: 100;
     border-radius: 50%;
-    /* background: red; */
-    /* opacity: 0.2; */
   }
 
-  .click-target:hover + svg path {
+  .target:hover + svg path {
     d: var(--hover-path);
   }
 
@@ -117,10 +145,13 @@
     transition:
       d 0.3s ease,
       fill 0.3s ease;
-    fill: var(--layer-2);
+    fill: var(--color-layer-2);
     stroke: var(--stroke);
     stroke-width: var(--stroke-width);
     d: var(--path);
+
+    stroke-linejoin: round;
+    shape-rendering: geometricPrecision;
   }
 
   .content {

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

@@ -1,40 +1,54 @@
 <script lang="ts">
-  import type { Node, NodeInput } from "@nodes/types";
-  import { getGraphManager } from "../graph/context.js";
-  import { Input } from "@nodes/ui";
+  import type { NodeInput, NodeInstance } from '@nodarium/types';
+  import { Input } from '@nodarium/ui';
+  import type { GraphManager } from '../graph-manager.svelte';
 
   type Props = {
-    node: Node;
+    node: NodeInstance;
     input: NodeInput;
     id: string;
     elementId?: string;
+    graph?: GraphManager;
   };
 
   const {
-    node,
+    node = $bindable(),
     input,
     id,
     elementId = `input-${Math.random().toString(36).substring(7)}`,
+    graph
   }: Props = $props();
 
-  const graph = getGraphManager();
-
   function getDefaultValue() {
     if (node?.props?.[id] !== undefined) return node?.props?.[id] as number;
-    if ("value" in input && input?.value !== undefined)
+    if ('value' in input && input?.value !== undefined) {
       return input?.value as number;
-    if (input.type === "boolean") return 0;
-    if (input.type === "float") return 0.5;
-    if (input.type === "integer") return 0;
-    if (input.type === "select") return 0;
+    }
+    if (input.type === 'boolean') return 0;
+    if (input.type === 'float') return 0.5;
+    if (input.type === 'integer') return 0;
+    if (input.type === 'select') return 0;
     return 0;
   }
 
-  let value = $state(getDefaultValue());
+  let value = $state(structuredClone($state.snapshot(getDefaultValue())));
+
+  function diffArray(a: number[], b?: number[] | number) {
+    if (!Array.isArray(b)) return true;
+    if (Array.isArray(a) !== Array.isArray(b)) return true;
+    if (a.length !== b.length) return true;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return true;
+    }
+    return false;
+  }
 
   $effect(() => {
-    if (value !== undefined && node?.props?.[id] !== value) {
-      node.props = { ...node.props, [id]: value };
+    const a = $state.snapshot(value);
+    const b = $state.snapshot(node?.props?.[id]);
+    const isDiff = Array.isArray(a) ? diffArray(a, b) : a !== b;
+    if (value !== undefined && isDiff) {
+      node.props = { ...node.props, [id]: a };
       if (graph) {
         graph.save();
         graph.execute();

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

@@ -1,126 +1,114 @@
 <script lang="ts">
-  import type {
-    NodeInput as NodeInputType,
-    Socket,
-    Node as NodeType,
-  } from "@nodes/types";
-  import { getContext } from "svelte";
-  import { createNodePath } from "../helpers/index.js";
-  import { getGraphManager } from "../graph/context.js";
-  import NodeInput from "./NodeInput.svelte";
-  import { getGraphState } from "../graph/state.svelte.js";
+  import type { NodeInput, NodeInstance, Socket } from '@nodarium/types';
+  import { getGraphManager, getGraphState } from '../graph-state.svelte';
+  import { createNodePath } from '../helpers';
+  import { getParameterHeight, getSocketPosition } from '../helpers/nodeHelpers';
+  import NodeInputEl from './NodeInput.svelte';
 
   type Props = {
-    node: NodeType;
-    input: NodeInputType;
+    node: NodeInstance;
+    input: NodeInput;
     id: string;
     isLast?: boolean;
   };
 
-  const { node = $bindable(), input, id, isLast }: Props = $props();
-
-  const inputType = node?.tmp?.type?.inputs?.[id]!;
-
-  const socketId = `${node.id}-${id}`;
-
   const graph = getGraphManager();
   const graphState = getGraphState();
   const graphId = graph?.id;
-  const inputSockets = graph?.inputSockets;
-
   const elementId = `input-${Math.random().toString(36).substring(7)}`;
 
-  const setDownSocket = getContext<(socket: Socket) => void>("setDownSocket");
-  const getSocketPosition =
-    getContext<(node: NodeType, index: string) => [number, number]>(
-      "getSocketPosition",
-    );
+  let { node = $bindable(), input, id, isLast }: Props = $props();
+
+  const nodeType = $derived(node.state.type!);
+
+  const inputType = $derived(nodeType.inputs?.[id]);
+
+  const socketId = $derived(`${node.id}-${id}`);
+  const height = $derived(getParameterHeight(nodeType, id));
 
   function handleMouseDown(ev: MouseEvent) {
     ev.preventDefault();
     ev.stopPropagation();
-    setDownSocket?.({
+    graphState.setDownSocket({
       node,
       index: id,
-      position: getSocketPosition?.(node, id),
+      position: getSocketPosition(node, id)
     });
   }
 
-  const leftBump = node.tmp?.type?.inputs?.[id].internal !== true;
-  const cornerBottom = isLast ? 5 : 0;
+  const leftBump = $derived(nodeType.inputs?.[id].internal !== true);
+  const cornerBottom = $derived(isLast ? 5 : 0);
   const aspectRatio = 0.5;
 
-  const path = createNodePath({
-    depth: 7,
-    height: 20,
-    y: 50.5,
-    cornerBottom,
-    leftBump,
-    aspectRatio,
-  });
-  const pathDisabled = createNodePath({
-    depth: 6,
-    height: 18,
-    y: 50.5,
-    cornerBottom,
-    leftBump,
-    aspectRatio,
-  });
-  const pathHover = createNodePath({
-    depth: 8,
-    height: 25,
-    y: 50.5,
-    cornerBottom,
-    leftBump,
-    aspectRatio,
-  });
+  const path = $derived(
+    createNodePath({
+      depth: 6,
+      height: 2000 / height,
+      y: 50.5,
+      cornerBottom,
+      leftBump,
+      aspectRatio
+    })
+  );
+  const pathHover = $derived(
+    createNodePath({
+      depth: 7,
+      height: 2200 / height,
+      y: 50.5,
+      cornerBottom,
+      leftBump,
+      aspectRatio
+    })
+  );
+
+  function getSocketType(s: Socket | null) {
+    if (!s) return 'unknown';
+    if (typeof s.index === 'string') {
+      return s.node.state.type?.inputs?.[s.index].type || 'unknown';
+    }
+    return s.node.state.type?.outputs?.[s.index] || 'unknown';
+  }
+
+  const socketType = $derived(getSocketType(graphState.activeSocket));
+  const hoverColor = $derived(graphState.colors.getColor(socketType));
 </script>
 
 <div
   class="wrapper"
   data-node-type={node.type}
   data-node-input={id}
-  class:disabled={!graphState?.possibleSocketIds.has(socketId)}
+  style:height="{height}px"
+  style:--socket-color={hoverColor}
+  class:possible-socket={graphState?.possibleSocketIds.has(socketId)}
 >
   {#key id && graphId}
-    <div class="content" class:disabled={$inputSockets?.has(socketId)}>
-      {#if inputType.label !== ""}
-        <label for={elementId}>{input.label || id}</label>
+    <div class="content" class:disabled={graph?.inputSockets?.has(socketId)}>
+      {#if inputType?.label !== ''}
+        <label for={elementId} title={input.description}>{input.label || id}</label>
       {/if}
-      {#if inputType.external !== true}
-        <NodeInput {elementId} {node} {input} {id} />
+      {#if inputType?.external !== true}
+        <NodeInputEl {graph} {elementId} bind:node {input} {id} />
       {/if}
     </div>
 
-    {#if node?.tmp?.type?.inputs?.[id]?.internal !== true}
+    {#if node?.state?.type?.inputs?.[id]?.internal !== true}
       <div
         data-node-socket
-        class="large target"
+        class="target"
         onmousedown={handleMouseDown}
         role="button"
         tabindex="0"
-      ></div>
-      <div
-        data-node-socket
-        class="small target"
-        onmousedown={handleMouseDown}
-        role="button"
-        tabindex="0"
-      ></div>
+      >
+      </div>
     {/if}
   {/key}
 
   <svg
     xmlns="http://www.w3.org/2000/svg"
     viewBox="0 0 100 100"
-    width="100"
-    height="100"
     preserveAspectRatio="none"
-    style={`
-      --path: path("${path}");
-      --hover-path: path("${pathHover}");
-      --hover-path-disabled: path("${pathDisabled}");
-    `}
+    style:--path={`path("${path}")`}
+    style:--hover-path={`path("${pathHover}")`}
   >
     <path vector-effect="non-scaling-stroke"></path>
   </svg>
@@ -130,42 +118,43 @@
   .wrapper {
     position: relative;
     width: 100%;
-    height: 100px;
     transform: translateY(-0.5px);
   }
 
   .target {
+    width: 30px;
+    height: 30px;
     position: absolute;
     border-radius: 50%;
     top: 50%;
     transform: translateY(-50%) translateX(-50%);
-    /* background: red; */
-    /* opacity: 0.1; */
   }
 
-  .small.target {
+  .possible-socket .target::before {
+    content: "";
+    position: absolute;
     width: 30px;
     height: 30px;
+    border-radius: 100%;
+    box-shadow: 0px 0px 10px var(--socket-color);
+    background-color: var(--socket-color);
+    outline: solid thin var(--socket-color);
+    opacity: 0.5;
+    z-index: -10;
   }
 
-  .large.target {
-    width: 60px;
-    height: 60px;
-    cursor: unset;
-    pointer-events: none;
-  }
-
-  :global(.hovering-sockets) .large.target {
-    pointer-events: all;
+  .target:hover ~ svg path{
+    d: var(--hover-path);
   }
 
   .content {
     position: relative;
-    padding: 10px 20px;
     display: flex;
     flex-direction: column;
+    padding-inline: 20px;
     height: 100%;
-    justify-content: space-around;
+    justify-content: center;
+    gap: 10px;
     box-sizing: border-box;
   }
 
@@ -181,29 +170,21 @@
   }
 
   svg path {
-    transition:
-      d 0.3s ease,
-      fill 0.3s ease;
-    fill: var(--layer-1);
+    transition: d 0.3s ease, fill 0.3s ease;
+    fill: var(--color-layer-1);
     stroke: var(--stroke);
     stroke-width: var(--stroke-width);
     d: var(--path);
-  }
 
-  :global {
-    .hovering-sockets .large:hover ~ svg path {
-      d: var(--hover-path);
-    }
+    stroke-linejoin: round;
+    shape-rendering: geometricPrecision;
   }
 
   .content.disabled {
     opacity: 0.2;
   }
-  .content.disabled > * {
-    pointer-events: none;
-  }
 
-  .disabled svg path {
-    d: var(--hover-path-disabled) !important;
+  .possible-socket svg path {
+     d: var(--hover-path);
   }
 </style>

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

@@ -0,0 +1,86 @@
+import type { NodeDefinition, NodeId, NodeRegistry } from '@nodarium/types';
+
+export function createMockNodeRegistry(nodes: NodeDefinition[]): NodeRegistry {
+  const nodesMap = new Map(nodes.map(n => [n.id, n]));
+  return {
+    status: 'ready' as const,
+    load: async (nodeIds: NodeId[]) => {
+      const loaded: NodeDefinition[] = [];
+      for (const id of nodeIds) {
+        if (nodesMap.has(id)) {
+          loaded.push(nodesMap.get(id)!);
+        }
+      }
+      return loaded;
+    },
+    getNode: (id: string) => nodesMap.get(id as NodeId),
+    getAllNodes: () => Array.from(nodesMap.values()),
+    register: async () => {
+      throw new Error('Not implemented in mock');
+    }
+  };
+}
+
+export const mockFloatOutputNode: NodeDefinition = {
+  id: 'test/node/output',
+  inputs: {},
+  outputs: ['float'],
+  meta: { title: 'Float Output' },
+  execute: () => new Int32Array()
+};
+
+export const mockFloatInputNode: NodeDefinition = {
+  id: 'test/node/input',
+  inputs: { value: { type: 'float' } },
+  outputs: [],
+  meta: { title: 'Float Input' },
+  execute: () => new Int32Array()
+};
+
+export const mockGeometryOutputNode: NodeDefinition = {
+  id: 'test/node/geometry',
+  inputs: {},
+  outputs: ['geometry'],
+  meta: { title: 'Geometry Output' },
+  execute: () => new Int32Array()
+};
+
+export const mockPathInputNode: NodeDefinition = {
+  id: 'test/node/path',
+  inputs: { input: { type: 'path', accepts: ['geometry'] } },
+  outputs: [],
+  meta: { title: 'Path Input' },
+  execute: () => new Int32Array()
+};
+
+export const mockVec3OutputNode: NodeDefinition = {
+  id: 'test/node/vec3',
+  inputs: {},
+  outputs: ['vec3'],
+  meta: { title: 'Vec3 Output' },
+  execute: () => new Int32Array()
+};
+
+export const mockIntegerInputNode: NodeDefinition = {
+  id: 'test/node/integer',
+  inputs: { value: { type: 'integer' } },
+  outputs: [],
+  meta: { title: 'Integer Input' },
+  execute: () => new Int32Array()
+};
+
+export const mockBooleanOutputNode: NodeDefinition = {
+  id: 'test/node/boolean',
+  inputs: {},
+  outputs: ['boolean'],
+  meta: { title: 'Boolean Output' },
+  execute: () => new Int32Array()
+};
+
+export const mockBooleanInputNode: NodeDefinition = {
+  id: 'test/node/boolean-input',
+  inputs: { value: { type: 'boolean' } },
+  outputs: [],
+  meta: { title: 'Boolean Input' },
+  execute: () => new Int32Array()
+};

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

@@ -1,20 +0,0 @@
-import type { Node, NodeDefinition } from "@nodes/types";
-
-export type GraphNode = Node & {
-  tmp?: {
-    depth?: number;
-    mesh?: any;
-    random?: number;
-    parents?: Node[];
-    children?: Node[];
-    inputNodes?: Record<string, Node>;
-    type?: NodeDefinition;
-    downX?: number;
-    downY?: number;
-    x?: number;
-    y?: number;
-    ref?: HTMLElement;
-    visible?: boolean;
-    isMoving?: boolean;
-  };
-};

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

@@ -0,0 +1,110 @@
+import { grid } from '$lib/graph-templates/grid';
+import { tree } from '$lib/graph-templates/tree';
+import { describe, expect, it } from 'vitest';
+
+describe('graph-templates', () => {
+  describe('grid', () => {
+    it('should create a grid graph with nodes and edges', () => {
+      const result = grid(2, 3);
+      expect(result.nodes.length).toBeGreaterThan(0);
+      expect(result.edges.length).toBeGreaterThan(0);
+    });
+
+    it('should have output node at the end', () => {
+      const result = grid(1, 1);
+      const outputNode = result.nodes.find(n => n.type === 'max/plantarium/output');
+      expect(outputNode).toBeDefined();
+    });
+
+    it('should create nodes based on grid dimensions', () => {
+      const result = grid(2, 2);
+      const mathNodes = result.nodes.filter(n => n.type === 'max/plantarium/math');
+      expect(mathNodes.length).toBeGreaterThan(0);
+      const outputNode = result.nodes.find(n => n.type === 'max/plantarium/output');
+      expect(outputNode).toBeDefined();
+    });
+
+    it('should have output node at the end', () => {
+      const result = grid(1, 1);
+      const outputNode = result.nodes.find(n => n.type === 'max/plantarium/output');
+      expect(outputNode).toBeDefined();
+    });
+
+    it('should create nodes based on grid dimensions', () => {
+      const result = grid(2, 2);
+      const mathNodes = result.nodes.filter(n => n.type === 'max/plantarium/math');
+      expect(mathNodes.length).toBeGreaterThan(0);
+      const outputNode = result.nodes.find(n => n.type === 'max/plantarium/output');
+      expect(outputNode).toBeDefined();
+    });
+
+    it('should have valid node positions', () => {
+      const result = grid(3, 2);
+
+      result.nodes.forEach(node => {
+        expect(node.position).toHaveLength(2);
+        expect(typeof node.position[0]).toBe('number');
+        expect(typeof node.position[1]).toBe('number');
+      });
+    });
+
+    it('should generate valid graph structure', () => {
+      const result = grid(2, 2);
+
+      result.nodes.forEach(node => {
+        expect(typeof node.id).toBe('number');
+        expect(node.type).toBeTruthy();
+      });
+
+      result.edges.forEach(edge => {
+        expect(edge).toHaveLength(4);
+      });
+    });
+  });
+
+  describe('tree', () => {
+    it('should create a tree graph with specified depth', () => {
+      const result = tree(0);
+
+      expect(result.nodes.length).toBeGreaterThan(0);
+      expect(result.edges.length).toBeGreaterThan(0);
+    });
+
+    it('should have root output node', () => {
+      const result = tree(2);
+
+      const outputNode = result.nodes.find(n => n.type === 'max/plantarium/output');
+      expect(outputNode).toBeDefined();
+      expect(outputNode?.id).toBe(0);
+    });
+
+    it('should increase node count with depth', () => {
+      const tree0 = tree(0);
+      const tree1 = tree(1);
+      const tree2 = tree(2);
+
+      expect(tree0.nodes.length).toBeLessThan(tree1.nodes.length);
+      expect(tree1.nodes.length).toBeLessThan(tree2.nodes.length);
+    });
+
+    it('should create binary tree structure', () => {
+      const result = tree(2);
+
+      const mathNodes = result.nodes.filter(n => n.type === 'max/plantarium/math');
+      expect(mathNodes.length).toBeGreaterThan(0);
+
+      const edgeCount = result.edges.length;
+      expect(edgeCount).toBe(result.nodes.length - 1);
+    });
+
+    it('should have valid node positions', () => {
+      const result = tree(3);
+
+      result.nodes.forEach(node => {
+        expect(node.position).toHaveLength(2);
+        expect(typeof node.position[0]).toBe('number');
+        expect(typeof node.position[1]).toBe('number');
+      });
+    });
+  });
+});

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

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

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

@@ -1,11 +1,10 @@
-import type { Graph } from "@nodes/types";
+import type { Graph } from '@nodarium/types';
 
 export function grid(width: number, height: number) {
-
   const graph: Graph = {
     id: Math.floor(Math.random() * 100000),
     edges: [],
-    nodes: [],
+    nodes: []
   };
 
   const amount = width * height;
@@ -16,27 +15,20 @@ export function grid(width: number, height: number) {
 
     graph.nodes.push({
       id: i,
-      tmp: {
-        visible: false,
-      },
       position: [x * 30, y * 40],
       props: i == 0 ? { value: 0 } : { op_type: 0, a: 1, b: 0.05 },
-      type: i == 0 ? "max/plantarium/float" : "max/plantarium/math",
+      type: i == 0 ? 'max/plantarium/float' : 'max/plantarium/math'
     });
 
-    graph.edges.push([i, 0, i + 1, i === amount - 1 ? "input" : "a",]);
+    graph.edges.push([i, 0, i + 1, i === amount - 1 ? 'input' : 'a']);
   }
 
   graph.nodes.push({
     id: amount,
-    tmp: {
-      visible: false,
-    },
     position: [width * 30, (height - 1) * 40],
-    type: "max/plantarium/output",
-    props: {},
+    type: 'max/plantarium/output',
+    props: {}
   });
 
   return graph;
-
 }

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

@@ -1,8 +1,8 @@
-export { grid } from "./grid";
-export { tree } from "./tree";
-export { plant } from "./plant";
-export { default as lottaFaces } from "./lotta-faces.json";
-export { default as lottaNodes } from "./lotta-nodes.json";
-export { default as defaultPlant } from "./default.json"
-export { default as lottaNodesAndFaces } from "./lotta-nodes-and-faces.json";
-
+export { default as defaultPlant } from './default.json';
+export { grid } from './grid';
+export { default as lottaFaces } from './lotta-faces.json';
+export { default as lottaNodesAndFaces } from './lotta-nodes-and-faces.json';
+export { default as lottaNodes } from './lotta-nodes.json';
+export { plant } from './plant';
+export { default as simple } from './simple.json';
+export { tree } from './tree';

app/src/lib/graph-templates/lotta-faces.json

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

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

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

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

@@ -0,0 +1,63 @@
+{
+  "id": 0,
+  "settings": {
+    "resolution.circle": 54,
+    "resolution.curve": 20,
+    "randomSeed": true
+  },
+  "meta": {
+    "title": "New Project",
+    "lastModified": "2026-02-03T16:56:40.375Z"
+  },
+  "nodes": [
+    {
+      "id": 9,
+      "position": [
+        215,
+        85
+      ],
+      "type": "max/plantarium/output",
+      "props": {}
+    },
+    {
+      "id": 10,
+      "position": [
+        165,
+        72.5
+      ],
+      "type": "max/plantarium/stem",
+      "props": {
+        "amount": 50,
+        "length": 4,
+        "thickness": 1
+      }
+    },
+    {
+      "id": 11,
+      "position": [
+        190,
+        77.5
+      ],
+      "type": "max/plantarium/noise",
+      "props": {
+        "plant": 0,
+        "scale": 0.5,
+        "strength": 5
+      }
+    }
+  ],
+  "edges": [
+    [
+      10,
+      0,
+      11,
+      "plant"
+    ],
+    [
+      11,
+      0,
+      9,
+      "input"
+    ]
+  ]
+}

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

@@ -1,28 +1,26 @@
-import type { Graph, Node } from "@nodes/types";
+import type { Graph, SerializedNode } from '@nodarium/types';
 
 export function tree(depth: number): Graph {
-
-  const nodes: Node[] = [
+  const nodes: SerializedNode[] = [
     {
       id: 0,
-      type: "max/plantarium/output",
+      type: 'max/plantarium/output',
       position: [0, 0]
     },
     {
       id: 1,
-      type: "max/plantarium/math",
+      type: 'max/plantarium/math',
       position: [-40, -10]
     }
-  ]
+  ];
 
   const edges: [number, number, number, string][] = [
-    [1, 0, 0, "input"]
+    [1, 0, 0, 'input']
   ];
 
   for (let d = 0; d < depth; d++) {
     const amount = Math.pow(2, d);
     for (let i = 0; i < amount; i++) {
-
       const id0 = amount * 2 + i * 2;
       const id1 = amount * 2 + i * 2 + 1;
 
@@ -33,24 +31,22 @@ export function tree(depth: number): Graph {
 
       nodes.push({
         id: id0,
-        type: "max/plantarium/math",
-        position: [x, y],
+        type: 'max/plantarium/math',
+        position: [x, y]
       });
-      edges.push([id0, 0, parent, "a"]);
+      edges.push([id0, 0, parent, 'a']);
       nodes.push({
         id: id1,
-        type: "max/plantarium/math",
-        position: [x, y + 35],
+        type: 'max/plantarium/math',
+        position: [x, y + 35]
       });
-      edges.push([id1, 0, parent, "b"]);
+      edges.push([id1, 0, parent, 'b']);
     }
   }
 
-
   return {
     id: Math.floor(Math.random() * 100000),
     nodes,
     edges
   };
-
 }

app/src/lib/grid/Cell.svelte

@@ -1,23 +1,24 @@
 <script lang="ts">
-  import { getContext } from "svelte";
-  import type { Writable } from "svelte/store";
+  import { getContext, type Snippet } from 'svelte';
 
-  let index = -1;
+  let index = $state(-1);
   let wrapper: HTMLDivElement;
 
-  $: if (index === -1) {
-    index = getContext<() => number>("registerCell")();
-  }
+  const { children } = $props<{ children?: Snippet }>();
 
-  const sizes = getContext<Writable<string[]>>("sizes");
+  $effect(() => {
+    if (index === -1) {
+      index = getContext<() => number>('registerCell')();
+    }
+  });
+
+  const sizes = getContext<{ value: string[] }>('sizes');
 
-  let downSizes: string[] = [];
   let downWidth = 0;
   let mouseDown = false;
   let startX = 0;
 
   function handleMouseDown(event: MouseEvent) {
-    downSizes = [...$sizes];
     mouseDown = true;
     startX = event.clientX;
     downWidth = wrapper.getBoundingClientRect().width;
@@ -26,15 +27,14 @@
   function handleMouseMove(event: MouseEvent) {
     if (mouseDown) {
       const width = downWidth + startX - event.clientX;
-      $sizes[index] = `${width}px`;
-      $sizes = $sizes;
+      sizes.value[index] = `${width}px`;
     }
   }
 </script>
 
 <svelte:window
-  on:mouseup={() => (mouseDown = false)}
-  on:mousemove={handleMouseMove}
+  onmouseup={() => (mouseDown = false)}
+  onmousemove={handleMouseMove}
 />
 
 {#if index > 0}
@@ -42,12 +42,13 @@
     class="seperator"
     role="button"
     tabindex="0"
-    on:mousedown={handleMouseDown}
-  ></div>
+    onmousedown={handleMouseDown}
+  >
+  </div>
 {/if}
 
 <div class="cell" bind:this={wrapper}>
-  <slot />
+  {@render children?.()}
 </div>
 
 <style>
@@ -61,7 +62,7 @@
     cursor: ew-resize;
     height: 100%;
     width: 1px;
-    background: var(--outline);
+    background: var(--color-outline);
   }
   .seperator::before {
     content: "";

app/src/lib/grid/Grid.svelte

@@ -1,9 +1,11 @@
 <script lang="ts">
-  import { setContext } from "svelte";
+  import { onMount, setContext, type Snippet } from 'svelte';
 
-  export let id = "grid-0";
+  const { children, id } = $props<{ children?: Snippet; id?: string }>();
 
-  setContext("grid-id", id);
+  onMount(() => {
+    setContext('grid-id', id);
+  });
 </script>
 
-<slot {id} />
+{@render children({ id })}

app/src/lib/grid/Row.svelte

@@ -1,27 +1,31 @@
 <script lang="ts">
-  import { setContext, getContext } from "svelte";
-  import localStore from "$lib/helpers/localStore";
+  import { localState } from '$lib/helpers/localState.svelte';
+  import { getContext, setContext } from 'svelte';
 
-  const gridId = getContext<string>("grid-id") || "grid-0";
-  let sizes = localStore<string[]>(gridId, []);
+  const gridId = getContext<string>('grid-id') || 'grid-0';
+  let sizes = localState<string[]>(gridId, []);
+
+  const { children } = $props();
 
   let registerIndex = 0;
-  setContext("registerCell", function () {
+  setContext('registerCell', function() {
     let index = registerIndex;
     registerIndex++;
-    if (registerIndex > $sizes.length) {
-      $sizes = [...$sizes, "1fr"];
+    if (registerIndex > sizes.value.length) {
+      sizes.value = [...sizes.value, '1fr'];
     }
     return index;
   });
 
-  setContext("sizes", sizes);
+  setContext('sizes', sizes);
 
-  $: cols = $sizes.map((size, i) => `${i > 0 ? "1px " : ""}` + size).join(" ");
+  const cols = $derived(
+    sizes.value.map((size, i) => `${i > 0 ? '1px ' : ''}` + size).join(' ')
+  );
 </script>
 
 <div class="wrapper" style={`grid-template-columns: ${cols};`}>
-  <slot />
+  {@render children()}
 </div>
 
 <style>

app/src/lib/grid/index.ts

@@ -1,6 +1,6 @@
-import { withSubComponents } from "$lib/helpers";
-import Grid from "./Grid.svelte";
-import Row from "./Row.svelte";
-import Cell from "./Cell.svelte";
+import { withSubComponents } from '$lib/helpers';
+import Cell from './Cell.svelte';
+import Grid from './Grid.svelte';
+import Row from './Row.svelte';
 
 export default withSubComponents(Grid, { Row, Cell });

app/src/lib/helpers.test.ts

@@ -0,0 +1,145 @@
+import { clone, debounce, humanizeDuration, humanizeNumber, lerp, snapToGrid } from '$lib/helpers';
+import { describe, expect, it } from 'vitest';
+
+describe('helpers', () => {
+  describe('snapToGrid', () => {
+    it('should snap to nearest grid point', () => {
+      expect(snapToGrid(5, 10)).toBe(10);
+      expect(snapToGrid(15, 10)).toBe(20);
+      expect(snapToGrid(0, 10)).toBe(0);
+      expect(snapToGrid(-10, 10)).toBe(-10);
+    });
+
+    it('should snap exact midpoint values', () => {
+      expect(snapToGrid(5, 10)).toBe(10);
+    });
+
+    it('should use default grid size of 10', () => {
+      expect(snapToGrid(5)).toBe(10);
+      expect(snapToGrid(15)).toBe(20);
+    });
+
+    it('should handle values exactly on grid', () => {
+      expect(snapToGrid(10, 10)).toBe(10);
+      expect(snapToGrid(20, 10)).toBe(20);
+    });
+  });
+
+  describe('lerp', () => {
+    it('should linearly interpolate between two values', () => {
+      expect(lerp(0, 100, 0)).toBe(0);
+      expect(lerp(0, 100, 0.5)).toBe(50);
+      expect(lerp(0, 100, 1)).toBe(100);
+    });
+
+    it('should handle negative values', () => {
+      expect(lerp(-50, 50, 0.5)).toBe(0);
+      expect(lerp(-100, 0, 0.5)).toBe(-50);
+    });
+
+    it('should handle t values outside 0-1 range', () => {
+      expect(lerp(0, 100, -0.5)).toBe(-50);
+      expect(lerp(0, 100, 1.5)).toBe(150);
+    });
+  });
+
+  describe('humanizeNumber', () => {
+    it('should return unchanged numbers below 1000', () => {
+      expect(humanizeNumber(0)).toBe('0');
+      expect(humanizeNumber(999)).toBe('999');
+    });
+
+    it('should add K suffix for thousands', () => {
+      expect(humanizeNumber(1000)).toBe('1K');
+      expect(humanizeNumber(1500)).toBe('1.5K');
+      expect(humanizeNumber(999999)).toBe('1000K');
+    });
+
+    it('should add M suffix for millions', () => {
+      expect(humanizeNumber(1000000)).toBe('1M');
+      expect(humanizeNumber(2500000)).toBe('2.5M');
+    });
+
+    it('should add B suffix for billions', () => {
+      expect(humanizeNumber(1000000000)).toBe('1B');
+    });
+  });
+
+  describe('humanizeDuration', () => {
+    it('should return ms for very short durations', () => {
+      expect(humanizeDuration(100)).toBe('100ms');
+      expect(humanizeDuration(999)).toBe('999ms');
+    });
+
+    it('should format seconds', () => {
+      expect(humanizeDuration(1000)).toBe('1s');
+      expect(humanizeDuration(1500)).toBe('1s500ms');
+      expect(humanizeDuration(59000)).toBe('59s');
+    });
+
+    it('should format minutes', () => {
+      expect(humanizeDuration(60000)).toBe('1m');
+      expect(humanizeDuration(90000)).toBe('1m 30s');
+    });
+
+    it('should format hours', () => {
+      expect(humanizeDuration(3600000)).toBe('1h');
+      expect(humanizeDuration(3661000)).toBe('1h 1m 1s');
+    });
+
+    it('should format days', () => {
+      expect(humanizeDuration(86400000)).toBe('1d');
+      expect(humanizeDuration(90061000)).toBe('1d 1h 1m 1s');
+    });
+
+    it('should handle zero', () => {
+      expect(humanizeDuration(0)).toBe('0ms');
+    });
+  });
+
+  describe('debounce', () => {
+    it('should return a function', () => {
+      const fn = debounce(() => {}, 100);
+      expect(typeof fn).toBe('function');
+    });
+
+    it('should only call once when invoked multiple times within delay', () => {
+      let callCount = 0;
+      const fn = debounce(() => {
+        callCount++;
+      }, 100);
+      fn();
+      const firstCall = callCount;
+      fn();
+      fn();
+      expect(callCount).toBe(firstCall);
+    });
+  });
+
+  describe('clone', () => {
+    it('should deep clone objects', () => {
+      const original = { a: 1, b: { c: 2 } };
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned.b).not.toBe(original.b);
+    });
+
+    it('should handle arrays', () => {
+      const original = [1, 2, [3, 4]];
+      const cloned = clone(original);
+
+      expect(cloned).toEqual(original);
+      expect(cloned).not.toBe(original);
+      expect(cloned[2]).not.toBe(original[2]);
+    });
+
+    it('should handle primitives', () => {
+      expect(clone(42)).toBe(42);
+      expect(clone('hello')).toBe('hello');
+      expect(clone(true)).toBe(true);
+      expect(clone(null)).toBe(null);
+    });
+  });
+});

app/src/lib/helpers/createKeyMap.ts

@@ -1,38 +1,39 @@
-import { derived, get, writable } from "svelte/store";
+import { derived, get, writable } from 'svelte/store';
 
-type Shortcut = {
-  key: string | string[],
-  shift?: boolean,
-  ctrl?: boolean,
-  alt?: boolean,
-  preventDefault?: boolean,
-  description?: string,
-  callback: (event: KeyboardEvent) => void
+export type ShortCut = {
+  key: string | string[];
+  shift?: boolean;
+  ctrl?: boolean;
+  alt?: boolean;
+  preventDefault?: boolean;
+  description?: string;
+  callback: (event: KeyboardEvent) => void;
+};
+
+function getShortcutId(shortcut: ShortCut) {
+  return `${shortcut.key}${shortcut.shift ? '+shift' : ''}${shortcut.ctrl ? '+ctrl' : ''}${
+    shortcut.alt ? '+alt' : ''
+  }`;
 }
 
-function getShortcutId(shortcut: Shortcut) {
-  return `${shortcut.key}${shortcut.shift ? "+shift" : ""}${shortcut.ctrl ? "+ctrl" : ""}${shortcut.alt ? "+alt" : ""}`;
-}
-
-export function createKeyMap(keys: Shortcut[]) {
-
+export function createKeyMap(keys: ShortCut[]) {
   const store = writable(new Map(keys.map(k => [getShortcutId(k), k])));
 
   return {
     handleKeyboardEvent: (event: KeyboardEvent) => {
       const activeElement = document.activeElement as HTMLElement;
-      if (activeElement?.tagName === "INPUT" || activeElement?.tagName === "TEXTAREA") return;
+      if (activeElement?.tagName === 'INPUT' || activeElement?.tagName === 'TEXTAREA') return;
       const key = [...get(store).values()].find(k => {
         if (Array.isArray(k.key) ? !k.key.includes(event.key) : k.key !== event.key) return false;
-        if ("shift" in k && k.shift !== event.shiftKey) return false;
-        if ("ctrl" in k && k.ctrl !== event.ctrlKey) return false;
-        if ("alt" in k && k.alt !== event.altKey) return false;
+        if ('shift' in k && k.shift !== event.shiftKey) return false;
+        if ('ctrl' in k && k.ctrl !== event.ctrlKey) return false;
+        if ('alt' in k && k.alt !== event.altKey) return false;
         return true;
       });
       if (key && key.preventDefault) event.preventDefault();
       key?.callback(event);
     },
-    addShortcut: (shortcut: Shortcut) => {
+    addShortcut: (shortcut: ShortCut) => {
       if (Array.isArray(shortcut.key)) {
         for (const k of shortcut.key) {
           store.update(shortcuts => {
@@ -52,6 +53,5 @@ export function createKeyMap(keys: Shortcut[]) {
       }
     },
     keys: derived(store, $store => Array.from($store.values()))
-  }
-
+  };
 }

app/src/lib/helpers/deepMerge.test.ts

@@ -0,0 +1,72 @@
+import { isObject, mergeDeep } from '$lib/helpers/deepMerge';
+import { describe, expect, it } from 'vitest';
+
+describe('deepMerge', () => {
+  describe('isObject', () => {
+    it('should return true for plain objects', () => {
+      expect(isObject({})).toBe(true);
+      expect(isObject({ a: 1 })).toBe(true);
+    });
+
+    it('should return false for non-objects', () => {
+      expect(isObject([])).toBe(false);
+      expect(isObject('string')).toBe(false);
+      expect(isObject(42)).toBe(false);
+      expect(isObject(undefined)).toBe(false);
+    });
+  });
+
+  describe('mergeDeep', () => {
+    it('should merge two flat objects', () => {
+      const target = { a: 1, b: 2 };
+      const source = { b: 3, c: 4 };
+      const result = mergeDeep(target, source);
+
+      expect(result).toEqual({ a: 1, b: 3, c: 4 });
+    });
+
+    it('should deeply merge nested objects', () => {
+      const target = { a: { x: 1 }, b: { y: 2 } };
+      const source = { a: { y: 2 }, c: { z: 3 } };
+      const result = mergeDeep(target, source);
+
+      expect(result).toEqual({
+        a: { x: 1, y: 2 },
+        b: { y: 2 },
+        c: { z: 3 }
+      });
+    });
+
+    it('should handle multiple sources', () => {
+      const target = { a: 1 };
+      const source1 = { b: 2 };
+      const source2 = { c: 3 };
+      const result = mergeDeep(target, source1, source2);
+
+      expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    it('should return target if no sources provided', () => {
+      const target = { a: 1 };
+      const result = mergeDeep(target);
+
+      expect(result).toBe(target);
+    });
+
+    it('should overwrite non-object values', () => {
+      const target = { a: { b: 1 } };
+      const source = { a: 'string' };
+      const result = mergeDeep(target, source);
+
+      expect(result.a).toBe('string');
+    });
+
+    it('should handle arrays by replacing', () => {
+      const target = { a: [1, 2] };
+      const source = { a: [3, 4] };
+      const result = mergeDeep(target, source);
+
+      expect(result.a).toEqual([3, 4]);
+    });
+  });
+});

app/src/lib/helpers/index.ts

@@ -18,7 +18,7 @@ export function animate(duration: number, callback: (progress: number) => void |
     } else {
       callback(1);
     }
-  }
+  };
   requestAnimationFrame(loop);
 }
 
@@ -30,10 +30,11 @@ export function createNodePath({
   cornerBottom = 0,
   leftBump = false,
   rightBump = false,
-  aspectRatio = 1,
+  aspectRatio = 1
 } = {}) {
   return `M0,${cornerTop}
-      ${cornerTop
+      ${
+    cornerTop
       ? ` V${cornerTop}
               Q0,0 ${cornerTop * aspectRatio},0
               H${100 - cornerTop * aspectRatio}
@@ -42,40 +43,45 @@ export function createNodePath({
       : ` V0
               H100
             `
-    }
+  }
       V${y - height / 2}
-      ${rightBump
+      ${
+    rightBump
       ? ` C${100 - depth},${y - height / 2} ${100 - depth},${y + height / 2} 100,${y + height / 2}`
       : ` H100`
-    }
-      ${cornerBottom
+  }
+      ${
+    cornerBottom
       ? ` V${100 - cornerBottom}
               Q100,100 ${100 - cornerBottom * aspectRatio},100
               H${cornerBottom * aspectRatio}
               Q0,100  0,${100 - cornerBottom}
             `
       : `${leftBump ? `V100 H0` : `V100`}`
-    }
-      ${leftBump
-      ? ` V${y + height / 2} C${depth},${y + height / 2} ${depth},${y - height / 2} 0,${y - height / 2}`
+  }
+      ${
+    leftBump
+      ? ` V${y + height / 2} C${depth},${y + height / 2} ${depth},${y - height / 2} 0,${
+        y - height / 2
+      }`
       : ` H0`
-    }
-      Z`.replace(/\s+/g, " ");
+  }
+      Z`.replace(/\s+/g, ' ');
 }
 
-export const debounce = (fn: Function, ms = 300) => {
+export const debounce = (fn: () => void, ms = 300) => {
   let timeoutId: ReturnType<typeof setTimeout>;
-  return function (this: any, ...args: any[]) {
+  return function(this: unknown, ...args: unknown[]) {
     clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => fn.apply(this, args), ms);
+    timeoutId = setTimeout(() => fn.apply(this, args as []), ms);
   };
 };
 
-export const clone: <T>(v: T) => T = "structedClone" in globalThis ? globalThis.structuredClone : (obj) => JSON.parse(JSON.stringify(obj));
+export const clone: <T>(v: T) => T = 'structedClone' in globalThis
+  ? globalThis.structuredClone
+  : (obj) => JSON.parse(JSON.stringify(obj));
 
-
-
-export function withSubComponents<A, B extends Record<string, any>>(
+export function withSubComponents<A, B extends Record<string, unknown>>(
   component: A,
   subcomponents: B
 ): A & B {
@@ -87,7 +93,7 @@ export function withSubComponents<A, B extends Record<string, any>>(
 }
 
 export function humanizeNumber(number: number): string {
-  const suffixes = ["", "K", "M", "B", "T"];
+  const suffixes = ['', 'K', 'M', 'B', 'T'];
   if (number < 1000) {
     return number.toString();
   }
@@ -104,11 +110,15 @@ export function humanizeDuration(durationInMilliseconds: number) {
   const millisecondsPerHour = 3600000;
   const millisecondsPerDay = 86400000;
 
-  let days = Math.floor(durationInMilliseconds / millisecondsPerDay);
-  let hours = Math.floor((durationInMilliseconds % millisecondsPerDay) / millisecondsPerHour);
-  let minutes = Math.floor((durationInMilliseconds % millisecondsPerHour) / millisecondsPerMinute);
-  let seconds = Math.floor((durationInMilliseconds % millisecondsPerMinute) / millisecondsPerSecond);
-  let millis = durationInMilliseconds % millisecondsPerSecond;
+  const days = Math.floor(durationInMilliseconds / millisecondsPerDay);
+  const hours = Math.floor((durationInMilliseconds % millisecondsPerDay) / millisecondsPerHour);
+  const minutes = Math.floor(
+    (durationInMilliseconds % millisecondsPerHour) / millisecondsPerMinute
+  );
+  const seconds = Math.floor(
+    (durationInMilliseconds % millisecondsPerMinute) / millisecondsPerSecond
+  );
+  const millis = durationInMilliseconds % millisecondsPerSecond;
 
   let durationString = '';
 
@@ -126,37 +136,15 @@ export function humanizeDuration(durationInMilliseconds: number) {
   }
 
   if (millis > 0 || durationString === '') {
-    durationString += millis + 'ms';
+    durationString += Math.floor(millis) + 'ms';
   }
 
   return durationString.trim();
 }
-// export function debounceAsyncFunction<T extends any[], R>(
-//   func: (...args: T) => Promise<R>
-// ): (...args: T) => Promise<R> {
-//   let timeoutId: ReturnType<typeof setTimeout> | null = null;
-//   let lastPromise: Promise<R> | null = null;
-//   let lastReject: ((reason?: any) => void) | null = null;
-//
-//   return (...args: T): Promise<R> => {
-//     if (timeoutId) {
-//       clearTimeout(timeoutId);
-//       if (lastReject) {
-//         lastReject(new Error("Debounced: Previous call was canceled."));
-//       }
-//     }
-//
-//     return new Promise<R>((resolve, reject) => {
-//       lastReject = reject;
-//       timeoutId = setTimeout(() => {
-//         timeoutId = null;
-//         lastReject = null;
-//         lastPromise = func(...args).then(resolve, reject);
-//       }, 300); // Default debounce time is 300ms; you can make this configurable.
-//     });
-//   };
-// }
-export function debounceAsyncFunction<T extends (...args: any[]) => Promise<any>>(asyncFn: T): T {
+
+export function debounceAsyncFunction<T extends (...args: never[]) => Promise<unknown>>(
+  asyncFn: T
+): T {
   let isRunning = false;
   let latestArgs: Parameters<T> | null = null;
   let resolveNext: (() => void) | null = null;
@@ -177,7 +165,7 @@ export function debounceAsyncFunction<T extends (...args: any[]) => Promise<any>
     try {
       // Execute with the latest arguments
       const result = await asyncFn(...latestArgs!);
-      return result;
+      return result as ReturnType<T>;
     } finally {
       // Allow the next execution
       isRunning = false;
@@ -190,48 +178,18 @@ export function debounceAsyncFunction<T extends (...args: any[]) => Promise<any>
   }) as T;
 }
 
-// export function debounceAsyncFunction<T extends any[], R>(func: (...args: T) => Promise<R>): (...args: T) => Promise<R> {
-//   let currentPromise: Promise<R> | null = null;
-//   let nextArgs: T | null = null;
-//   let resolveNext: ((result: R) => void) | null = null;
-//
-//   const debouncedFunction = async (...args: T): Promise<R> => {
-//     if (currentPromise) {
-//       // Store the latest arguments and create a new promise to resolve them later
-//       nextArgs = args;
-//       return new Promise<R>((resolve) => {
-//         resolveNext = resolve;
-//       });
-//     } else {
-//       // Execute the function immediately
-//       try {
-//         currentPromise = func(...args);
-//         const result = await currentPromise;
-//         return result;
-//       } finally {
-//         currentPromise = null;
-//         // If there are stored arguments, call the function again with the latest arguments
-//         if (nextArgs) {
-//           const argsToUse = nextArgs;
-//           const resolver = resolveNext;
-//           nextArgs = null;
-//           resolveNext = null;
-//           resolver!(await debouncedFunction(...argsToUse));
-//         }
-//       }
-//     }
-//   };
-//
-//   return debouncedFunction;
-// }
-
-export function withArgsChangeOnly<T extends any[], R>(func: (...args: T) => R): (...args: T) => R {
+export function withArgsChangeOnly<T extends unknown[], R>(
+  func: (...args: T) => R
+): (...args: T) => R {
   let lastArgs: T | undefined = undefined;
   let lastResult: R;
 
   return (...args: T): R => {
     // Check if arguments are the same as last call
-    if (lastArgs && args.length === lastArgs.length && args.every((val, index) => val === lastArgs?.[index])) {
+    if (
+      lastArgs && args.length === lastArgs.length
+      && args.every((val, index) => val === lastArgs?.[index])
+    ) {
       return lastResult; // Return cached result if arguments haven't changed
     }
 
@@ -241,4 +199,3 @@ export function withArgsChangeOnly<T extends any[], R>(func: (...args: T) => R):
     return lastResult; // Return new result
   };
 }
-

app/src/lib/helpers/localState.svelte.ts

@@ -1,11 +1,69 @@
-export function localState<T>(key: string, defaultValue: T): T {
-  const stored = localStorage.getItem(key)
-  const state = $state(stored ? JSON.parse(stored) : defaultValue)
-  $effect.root(() => {
-    $effect(() => {
-      const value = $state.snapshot(state);
-      localStorage.setItem(key, JSON.stringify(value));
-    });
-  });
-  return state;
+import { browser } from '$app/environment';
+
+function mergeRecursive<T>(current: T, initial: T): T {
+  if (typeof initial === 'number') {
+    if (typeof current === 'number') return current;
+    return initial;
+  }
+
+  if (typeof initial === 'boolean') {
+    if (typeof current === 'boolean') return current;
+    return initial;
+  }
+
+  if (Array.isArray(initial)) {
+    if (Array.isArray(current)) return current;
+    return initial;
+  }
+
+  if (typeof initial === 'object' && initial) {
+    const merged = initial;
+    if (typeof current === 'object' && current) {
+      for (const key of Object.keys(initial)) {
+        if (key in current) {
+          // @ts-expect-error It's safe dont worry about it
+          merged[key] = mergeRecursive(current[key], initial[key]);
+        }
+      }
+    }
+    return merged;
+  }
+
+  return current;
+}
+
+export class LocalStore<T> {
+  value = $state<T>() as T;
+  key = '';
+
+  constructor(key: string, value: T) {
+    this.key = key;
+    this.value = value;
+
+    if (browser) {
+      const item = localStorage.getItem(key);
+      if (item) {
+        const storedValue = this.deserialize(item);
+        this.value = mergeRecursive(storedValue, value);
+      }
+    }
+
+    $effect.root(() => {
+      $effect(() => {
+        localStorage.setItem(this.key, this.serialize(this.value));
+      });
+    });
+  }
+
+  serialize(value: T): string {
+    return JSON.stringify(value);
+  }
+
+  deserialize(item: string): T {
+    return JSON.parse(item);
+  }
+}
+
+export function localState<T>(key: string, value: T) {
+  return new LocalStore(key, value);
 }

app/src/lib/helpers/localStore.ts

@@ -1,15 +1,14 @@
-import { writable, type Writable } from "svelte/store";
+import { type Writable, writable } from 'svelte/store';
 
 function isStore(v: unknown): v is Writable<unknown> {
-  return v !== null && typeof v === "object" && "subscribe" in v && "set" in v;
+  return v !== null && typeof v === 'object' && 'subscribe' in v && 'set' in v;
 }
 
 const storeIds: Map<string, ReturnType<typeof createLocalStore>> = new Map();
 
-const HAS_LOCALSTORAGE = "localStorage" in globalThis;
+const HAS_LOCALSTORAGE = 'localStorage' in globalThis;
 
 function createLocalStore<T>(key: string, initialValue: T | Writable<T>) {
-
   let store: Writable<T>;
 
   if (HAS_LOCALSTORAGE) {
@@ -36,18 +35,15 @@ function createLocalStore<T>(key: string, initialValue: T | Writable<T>) {
     subscribe: store.subscribe,
     set: store.set,
     update: store.update
-  }
+  };
 }
 
-
 export default function localStore<T>(key: string, initialValue: T | Writable<T>): Writable<T> {
-
   if (storeIds.has(key)) return storeIds.get(key) as Writable<T>;
 
-  const store = createLocalStore(key, initialValue)
+  const store = createLocalStore(key, initialValue);
 
   storeIds.set(key, store);
 
-  return store
-
+  return store;
 }