fix(app): handle error while parsing commit

- Hide releases under a Detail
- Hide all commits under a Detail

.dprint.jsonc

@@ -10,38 +10,29 @@
   "json": {
     // https://dprint.dev/plugins/json/config/
   },
-  "markdown": {
+  "markdown": {},
-  },
+  "toml": {},
-  "toml": {
+  "dockerfile": {},
-  },
-  "dockerfile": {
-  },
-  "ruff": {
-  },
-  "jupyter": {
-  },
-  "malva": {
-  },
   "markup": {
     // https://dprint.dev/plugins/markup_fmt/config/
     "scriptIndent": true,
     "styleIndent": true,
   },
-  "yaml": {
+  "yaml": {},
-  },
-  "graphql": {
-  },
   "exec": {
     "cwd": "${configDir}",
-
+    "commands": [
-    "commands": [{
+      {
         "command": "rustfmt",
-      "exts": ["rs"],
+        "exts": [
+          "rs",
+        ],
         "cacheKeyFiles": [
           "rustfmt.toml",
           "rust-toolchain.toml",
         ],
-    }],
+      },
+    ],
   },
   "excludes": [
     "**/node_modules",
@@ -51,6 +42,9 @@
     "**/*-lock.yaml",
     "**/yaml.lock",
     "**/.DS_Store",
+    "**/.pnpm-store",
+    "**/.cargo",
+    "**/target",
   ],
   "plugins": [
     "https://plugins.dprint.dev/typescript-0.95.13.wasm",
@@ -58,13 +52,8 @@
     "https://plugins.dprint.dev/markdown-0.20.0.wasm",
     "https://plugins.dprint.dev/toml-0.7.0.wasm",
     "https://plugins.dprint.dev/dockerfile-0.3.3.wasm",
-    "https://plugins.dprint.dev/ruff-0.6.11.wasm",
-    "https://plugins.dprint.dev/jupyter-0.2.1.wasm",
-    "https://plugins.dprint.dev/g-plane/malva-v0.15.1.wasm",
     "https://plugins.dprint.dev/g-plane/markup_fmt-v0.25.3.wasm",
     "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.5.1.wasm",
-    "https://plugins.dprint.dev/g-plane/pretty_graphql-v0.2.3.wasm",
     "https://plugins.dprint.dev/exec-0.6.0.json@a054130d458f124f9b5c91484833828950723a5af3f8ff2bd1523bd47b83b364",
-    "https://plugins.dprint.dev/biome-0.11.10.wasm",
   ],
 }

.gitea/scripts/build.sh

@@ -0,0 +1,43 @@
+#!/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
+
+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": "$(git log -1 --pretty=%B)",
+  "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/ci-checks.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+pnpm build
+
+pnpm lint &
+LINT_PID=$!
+pnpm format:check &
+FORMAT_PID=$!
+pnpm check &
+TYPE_PID=$!
+xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x24" pnpm test &
+TEST_PID=$!
+
+wait $LINT_PID
+wait $FORMAT_PID
+wait $TYPE_PID
+wait $TEST_PID

.gitea/scripts/create-release.sh

@@ -0,0 +1,91 @@
+#!/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 "$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. Create release commit
+# -------------------------------------------------------------------
+git config user.name "release-bot"
+git config user.email "release-bot@ci"
+
+git add CHANGELOG.md $(find . -name package.json ! -path "*/node_modules/*")
+
+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
+
+rm app/static/CHANGELOG.md
+cp CHANGELOG.md app/static/CHANGELOG.md
+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,76 @@
+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:fd7268d6208aede435e1685817ae6b271c68bd83
+
+    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: ./.gitea/scripts/ci-checks.sh
+
+      - name: 🛠️ Build
+        run: ./.gitea/scripts/build.sh
+
+      - name: 🚀 Create Release Commit
+        if: gitea.ref_type == 'tag'
+        run: ./.gitea/scripts/create-release.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 --frozen-lockfile
-
-      - 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 -e "[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 }}

CHANGELOG.md

@@ -0,0 +1,70 @@
+# 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

Dockerfile

@@ -1,15 +0,0 @@
-FROM node:24-alpine
-
-RUN apk add --no-cache --update curl rclone g++
-
-ENV RUSTUP_HOME=/usr/local/rustup \
-  CARGO_HOME=/usr/local/cargo \
-  PATH=/usr/local/cargo/bin:$PATH
-
-RUN curl --silent --show-error --location --fail --retry 3 \
-  --proto '=https' --tlsv1.2 \
-  --output /tmp/rustup-init.sh https://sh.rustup.rs \
-  && sh /tmp/rustup-init.sh -y --no-modify-path --profile minimal \
-  && rm /tmp/rustup-init.sh \
-  && rustup target add wasm32-unknown-unknown \
-  && npm i -g pnpm

Dockerfile.ci

@@ -0,0 +1,30 @@
+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 \
+  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">
+<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/.gitignore

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

app/Dockerfile

@@ -25,18 +25,7 @@ FROM nginx:alpine AS runner
 
 RUN rm /etc/nginx/conf.d/default.conf
 
-COPY <<EOF /etc/nginx/conf.d/app.conf
+COPY app/docker/app.conf /etc/nginx/conf.d/app.conf
-server {
-    listen 80;
-    server_name _;
-    root /app;
-    index index.html;
-
-    location / {
-        try_files \$uri \$uri/ /index.html;
-    }
-}
-EOF
 
 COPY --from=builder /app/app/build /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,19 +1,24 @@
 {
   "name": "@nodarium/app",
   "private": true,
-  "version": "0.0.0",
+  "version": "0.0.3",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
     "build": "svelte-kit sync && vite build",
-    "test": "vitest",
+    "test:unit": "vitest",
-    "preview": "vite preview"
+    "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": {
-    "@nodarium/registry": "workspace:*",
     "@nodarium/ui": "workspace:*",
     "@nodarium/utils": "workspace:*",
-    "@sveltejs/kit": "^2.50.0",
+    "@sveltejs/kit": "^2.50.2",
     "@tailwindcss/vite": "^4.1.18",
     "@threlte/core": "8.3.1",
     "@threlte/extras": "9.7.1",
@@ -21,27 +26,37 @@
     "file-saver": "^2.0.5",
     "idb": "^8.0.3",
     "jsondiffpatch": "^0.7.3",
+    "micromark": "^4.0.2",
     "tailwindcss": "^4.1.18",
-    "three": "^0.182.0",
+    "three": "^0.182.0"
-    "wabt": "^1.0.39"
   },
   "devDependencies": {
+    "@eslint/compat": "^2.0.2",
+    "@eslint/js": "^9.39.2",
     "@iconify-json/tabler": "^1.2.26",
     "@iconify/tailwind4": "^1.2.1",
-    "@nodarium/types": "workspace:",
+    "@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.6",
+    "@tsconfig/svelte": "^5.0.7",
     "@types/file-saver": "^2.0.7",
     "@types/three": "^0.182.0",
-    "svelte": "^5.46.4",
+    "@vitest/browser-playwright": "^4.0.18",
-    "svelte-check": "^4.3.5",
+    "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.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.17"
+    "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

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

app/src/app.html

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

app/src/lib/config.ts

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

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

@@ -1,9 +1,9 @@
 <script lang="ts">
-  import { T } from "@threlte/core";
+  import { appSettings } from '$lib/settings/app-settings.svelte';
-  import BackgroundVert from "./Background.vert";
+  import { T } from '@threlte/core';
-  import BackgroundFrag from "./Background.frag";
+  import { colors } from '../graph/colors.svelte';
-  import { colors } from "../graph/colors.svelte";
+  import BackgroundFrag from './Background.frag';
-  import { appSettings } from "$lib/settings/app-settings.svelte";
+  import BackgroundVert from './Background.vert';
 
   type Props = {
     minZoom: number;
@@ -18,7 +18,7 @@
     maxZoom = 150,
     cameraPosition = [0, 1, 0],
     width = globalThis?.innerWidth || 100,
-    height = globalThis?.innerHeight || 100,
+    height = globalThis?.innerHeight || 100
   }: Props = $props();
 
   let bw = $derived(width / cameraPosition[2]);
@@ -38,25 +38,25 @@
       fragmentShader={BackgroundFrag}
       uniforms={{
         camPos: {
-          value: [0, 1, 0],
+          value: [0, 1, 0]
         },
         backgroundColor: {
-          value: colors["layer-0"],
+          value: colors['layer-0']
         },
         lineColor: {
-          value: colors["outline"],
+          value: colors['outline']
         },
         zoomLimits: {
-          value: [2, 50],
+          value: [2, 50]
         },
         dimensions: {
-          value: [100, 100],
+          value: [100, 100]
-        },
+        }
       }}
       uniforms.camPos.value={cameraPosition}
-      uniforms.backgroundColor.value={appSettings.value.theme &&
+      uniforms.backgroundColor.value={appSettings.value.theme
-        colors["layer-0"]}
+      && colors['layer-0']}
-      uniforms.lineColor.value={appSettings.value.theme && colors["outline"]}
+      uniforms.lineColor.value={appSettings.value.theme && colors['outline']}
       uniforms.zoomLimits.value={[minZoom, maxZoom]}
       uniforms.dimensions.value={[width, height]}
     />

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

@@ -116,7 +116,7 @@
     </div>
 
     <div class="content">
-      {#each nodes as node}
+      {#each nodes as node (node.id)}
         <div
           class="result"
           role="treeitem"
@@ -149,7 +149,7 @@
   }
 
   input {
-    background: var(--layer-0);
+    background: var(--color-layer-0);
     font-family: var(--font-family);
     border: none;
     border-radius: 5px;
@@ -168,10 +168,10 @@
 
   .add-menu-wrapper {
     position: absolute;
-    background: var(--layer-1);
+    background: var(--color-layer-1);
     border-radius: 7px;
     overflow: hidden;
-    border: solid 2px var(--layer-2);
+    border: solid 2px var(--color-layer-2);
     width: 150px;
   }
   .content {
@@ -184,14 +184,14 @@
 
   .result {
     padding: 1em 0.9em;
-    border-bottom: solid 1px var(--layer-2);
+    border-bottom: solid 1px var(--color-layer-2);
     opacity: 0.7;
     font-size: 0.9em;
     cursor: pointer;
   }
 
   .result[aria-selected="true"] {
-    background: var(--layer-2);
+    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 { T } from '@threlte/core';
-  import { type OrthographicCamera } from "three";
+  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 "@nodarium/types";
+  import type { NodeDefinition, NodeRegistry } from '@nodarium/types';
-  import { onMount } from "svelte";
+  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 nodeType = closest.getAttribute('data-node-type');
-    let nodeInput = closest.getAttribute("data-node-input");
+    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,11 +1,32 @@
 <script lang="ts">
-  import { MeshLineGeometry, MeshLineMaterial } from "@threlte/extras";
+  import type { Box } from '@nodarium/types';
-  import { points, lines, rects } from "./store.js";
+  import { T } from '@threlte/core';
-  import { T } from "@threlte/core";
+  import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
-  import { Color } from "three";
+  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}
+{#each $points as point (getEachKey(point))}
   <T.Mesh
     position.x={point.x}
     position.y={point.y}
@@ -17,7 +38,7 @@
   </T.Mesh>
 {/each}
 
-{#each $rects as rect, i}
+{#each $rects as rect, i (getEachKey(rect))}
   <T.Mesh
     position.x={(rect.minX + rect.maxX) / 2}
     position.y={0}
@@ -32,11 +53,11 @@
   </T.Mesh>
 {/each}
 
-{#each $lines as line}
+{#each $lines as line (getEachKey(line))}
   <T.Mesh position.y={1}>
     <MeshLineGeometry points={line.points} />
     <MeshLineMaterial
-      color={line.color || "red"}
+      color={line.color || 'red'}
       linewidth={1}
       attenuate={false}
     />

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

@@ -1,16 +1,18 @@
 <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,
+    toneMapped: false
   });
 
   let lineColor = $state(colors.edge.clone().convertSRGBToLinear());
 
   $effect.root(() => {
     $effect(() => {
-      appSettings.value.theme;
+      if (appSettings.value.theme === undefined) {
+        return;
+      }
       circleMaterial.color = colors.edge.clone().convertSRGBToLinear();
       lineColor = colors.edge.clone().convertSRGBToLinear();
     });
@@ -20,19 +22,19 @@
     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 { appSettings } from '$lib/settings/app-settings.svelte';
-  import { MeshLineGeometry, MeshLineMaterial } from "@threlte/extras";
+  import { T } from '@threlte/core';
-  import { MeshBasicMaterial, Vector3 } from "three";
+  import { MeshLineGeometry, MeshLineMaterial } from '@threlte/extras';
-  import { CubicBezierCurve } from "three/src/extras/curves/CubicBezierCurve.js";
+  import { onDestroy } from 'svelte';
-  import { Vector2 } from "three/src/math/Vector2.js";
+  import { MeshBasicMaterial, Vector3 } from 'three';
-  import { appSettings } from "$lib/settings/app-settings.svelte";
+  import { CubicBezierCurve } from 'three/src/extras/curves/CubicBezierCurve.js';
-  import { getGraphState } from "../graph-state.svelte";
+  import { Vector2 } from 'three/src/math/Vector2.js';
-  import { onDestroy } from "svelte";
+  import { getGraphState } from '../graph-state.svelte';
 
   const graphState = getGraphState();
 
@@ -63,7 +65,7 @@
     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);
@@ -83,7 +85,7 @@
         id,
         x1,
         y1,
-        $state.snapshot(points) as unknown as Vector3[],
+        $state.snapshot(points) as unknown as Vector3[]
       );
     }
   }

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 + 0] = x;
-  array[location + 1] = y
+  array[location + 1] = y;
-  array[location + 2] = z
+  array[location + 2] = z;
 
-  array[location + 3] = x
+  array[location + 3] = x;
-  array[location + 4] = y
+  array[location + 4] = y;
-  array[location + 5] = z
+  array[location + 5] = z;
-}
+};
 
 export const setXY = (array: number[], location: number, x: number, y: number) => {
-  array[location + 0] = x
+  array[location + 0] = x;
-  array[location + 1] = y
+  array[location + 1] = y;
-}
+};
 
 export const setXYZ = (array: number[], location: number, x: number, y: number, z: number) => {
-  array[location + 0] = x
+  array[location + 0] = x;
-  array[location + 1] = y
+  array[location + 1] = y;
-  array[location + 2] = z
+  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 + 0] = x;
-  array[location + 1] = y
+  array[location + 1] = y;
-  array[location + 2] = z
+  array[location + 2] = z;
-  array[location + 3] = w
+  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

@@ -1,5 +1,5 @@
 import throttle from '$lib/helpers/throttle';
-import { RemoteNodeRegistry } from '@nodarium/registry';
+import { RemoteNodeRegistry } from '$lib/node-registry/index';
 import type {
   Edge,
   Graph,
@@ -12,7 +12,7 @@ import type {
 } from '@nodarium/types';
 import { fastHashString } from '@nodarium/utils';
 import { createLogger } from '@nodarium/utils';
-import { SvelteMap } from 'svelte/reactivity';
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import EventEmitter from './helpers/EventEmitter';
 import { HistoryManager } from './history-manager';
 
@@ -23,7 +23,7 @@ const remoteRegistry = new RemoteNodeRegistry('');
 
 const clone = 'structuredClone' in self
   ? self.structuredClone
-  : (args: any) => JSON.parse(JSON.stringify(args));
+  : (args: unknown) => JSON.parse(JSON.stringify(args));
 
 function areSocketsCompatible(
   output: string | undefined,
@@ -57,7 +57,7 @@ function areEdgesEqual(firstEdge: Edge, secondEdge: Edge) {
 
 export class GraphManager extends EventEmitter<{
   save: Graph;
-  result: any;
+  result: unknown;
   settings: {
     types: Record<string, NodeInput>;
     values: Record<string, unknown>;
@@ -79,7 +79,7 @@ export class GraphManager extends EventEmitter<{
   currentUndoGroup: number | null = null;
 
   inputSockets = $derived.by(() => {
-    const s = new Set<string>();
+    const s = new SvelteSet<string>();
     for (const edge of this.edges) {
       s.add(`${edge[2].id}-${edge[3]}`);
     }
@@ -122,7 +122,7 @@ export class GraphManager extends EventEmitter<{
 
   private lastSettingsHash = 0;
   setSettings(settings: Record<string, unknown>) {
-    let hash = fastHashString(JSON.stringify(settings));
+    const hash = fastHashString(JSON.stringify(settings));
     if (hash === this.lastSettingsHash) return;
     this.lastSettingsHash = hash;
 
@@ -136,7 +136,7 @@ export class GraphManager extends EventEmitter<{
   }
 
   getLinkedNodes(node: NodeInstance) {
-    const nodes = new Set<NodeInstance>();
+    const nodes = new SvelteSet<NodeInstance>();
     const stack = [node];
     while (stack.length) {
       const n = stack.pop();
@@ -171,7 +171,7 @@ export class GraphManager extends EventEmitter<{
     const targetInput = toNode.state?.type?.inputs?.[toSocketKey];
     const targetAcceptedTypes = [targetInput?.type, ...(targetInput?.accepts || [])];
 
-    const bestInputEntry = draggedInputs.find(([_, input]) => {
+    const bestInputEntry = draggedInputs.find(([, input]) => {
       const accepted = [input.type, ...(input.accepts || [])];
       return areSocketsCompatible(edgeOutputSocketType, accepted);
     });
@@ -209,7 +209,7 @@ export class GraphManager extends EventEmitter<{
     const draggedOutputs = draggedNode.state.type.outputs ?? [];
 
     // Optimization: Pre-calculate parents to avoid cycles
-    const parentIds = new Set(this.getParentsOfNode(draggedNode).map(n => n.id));
+    const parentIds = new SvelteSet(this.getParentsOfNode(draggedNode).map(n => n.id));
 
     return this.edges.filter((edge) => {
       const [fromNode, fromSocketIdx, toNode, toSocketKey] = edge;
@@ -266,7 +266,7 @@ export class GraphManager extends EventEmitter<{
   }
 
   private _init(graph: Graph) {
-    const nodes = new Map(
+    const nodes = new SvelteMap(
       graph.nodes.map((node) => {
         const nodeType = this.registry.getNode(node.type);
         const n = node as NodeInstance;
@@ -310,11 +310,11 @@ export class GraphManager extends EventEmitter<{
 
     logger.info('loading graph', { nodes: graph.nodes, edges: graph.edges, id: graph.id });
 
-    const nodeIds = Array.from(new Set([...graph.nodes.map((n) => n.type)]));
+    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 Set<`${string}/${string}`>();
+    const allCollections = new SvelteSet<`${string}/${string}`>();
     for (const id of nodeIds) {
       const [user, collection] = id.split('/');
       allCollections.add(`${user}/${collection}`);
@@ -354,7 +354,7 @@ export class GraphManager extends EventEmitter<{
     for (const type of types) {
       if (type.inputs) {
         for (const key in type.inputs) {
-          let settingId = type.inputs[key].setting;
+          const settingId = type.inputs[key].setting;
           if (settingId) {
             settingTypes[settingId] = {
               __node_type: type.id,
@@ -409,7 +409,7 @@ export class GraphManager extends EventEmitter<{
     const settingValues = this.settings;
     if (nodeType.inputs) {
       for (const key in nodeType.inputs) {
-        let settingId = nodeType.inputs[key].setting;
+        const settingId = nodeType.inputs[key].setting;
         if (settingId) {
           settingTypes[settingId] = nodeType.inputs[key];
           if (
@@ -507,7 +507,7 @@ export class GraphManager extends EventEmitter<{
 
   createGraph(nodes: NodeInstance[], edges: [number, number, number, string][]) {
     // map old ids to new ids
-    const idMap = new Map<number, number>();
+    const idMap = new SvelteMap<number, number>();
 
     let startId = this.createNodeId();
 
@@ -731,7 +731,7 @@ export class GraphManager extends EventEmitter<{
     // 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.getChildren(node).map((n) => n.id));
+      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)
       );
@@ -752,17 +752,21 @@ export class GraphManager extends EventEmitter<{
       // 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 parents = new SvelteSet(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 SvelteMap<number, string[]>();
-      const edges = new Map(
       this.getEdgesFromNode(node)
         .filter((e) => e[1] === index)
-          .map((e) => [e[2].id, e[3]])
+        .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];
 
@@ -775,7 +779,7 @@ export class GraphManager extends EventEmitter<{
 
           if (
             areSocketsCompatible(ownType, otherType)
-            && edges.get(node.id) !== key
+            && !edges.get(node.id)?.includes(key)
           ) {
             sockets.push([node, key]);
           }

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

@@ -1,6 +1,6 @@
 import type { NodeInstance, Socket } from '@nodarium/types';
 import { getContext, setContext } from 'svelte';
-import { SvelteSet } from 'svelte/reactivity';
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import type { OrthographicCamera, Vector3 } from 'three';
 import type { GraphManager } from './graph-manager.svelte';
 
@@ -54,7 +54,7 @@ export class GraphState {
   height = $state(100);
 
   hoveredEdgeId = $state<string | null>(null);
-  edges = new Map<string, EdgeData>();
+  edges = new SvelteMap<string, EdgeData>();
 
   wrapper = $state<HTMLDivElement>(null!);
   rect: DOMRect = $derived(
@@ -100,7 +100,7 @@ export class GraphState {
   hoveredSocket = $state<Socket | null>(null);
   possibleSockets = $state<Socket[]>([]);
   possibleSocketIds = $derived(
-    new Set(this.possibleSockets.map((s) => `${s.node.id}-${s.index}`))
+    new SvelteSet(this.possibleSockets.map((s) => `${s.node.id}-${s.index}`))
   );
 
   getEdges() {
@@ -155,7 +155,6 @@ export class GraphState {
       return 4;
     } else if (z > 11) {
       return 2;
-    } else {
     }
     return 1;
   }
@@ -193,7 +192,7 @@ export class GraphState {
           (p) =>
             p !== 'seed'
             && node?.inputs
-            && !('setting' in node?.inputs?.[p])
+            && !(node?.inputs?.[p] !== undefined && 'setting' in node.inputs[p])
             && node.inputs[p].hidden !== true
         ).length;
     this.nodeHeightCache[nodeTypeId] = height;
@@ -294,8 +293,8 @@ export class GraphState {
   getNodeIdFromEvent(event: MouseEvent) {
     let clickedNodeId = -1;
 
-    let mx = event.clientX - this.rect.x;
+    const mx = event.clientX - this.rect.x;
-    let my = event.clientY - this.rect.y;
+    const my = event.clientY - this.rect.y;
 
     if (event.button === 0) {
       // check if the clicked element is a node

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

@@ -74,7 +74,7 @@
 
         const output = newNode.state?.type?.outputs?.find((out) => {
           if (socketType?.type === out) return true;
-          if (socketType?.accepts?.includes(out as any)) return true;
+          if ((socketType?.accepts as string[])?.includes(out)) return true;
           return false;
         });
 
@@ -172,7 +172,7 @@
         />
       {/if}
 
-      {#each graph.edges as edge}
+      {#each graph.edges as edge (edge)}
         {@const [x1, y1, x2, y2] = getEdgePosition(edge)}
         <EdgeEl
           id={graph.getEdgeId(edge)}
@@ -244,7 +244,7 @@
     z-index: 1;
     width: 100%;
     height: 100%;
-    background: var(--layer-2);
+    background: var(--color-layer-2);
     opacity: 0;
   }
   input:disabled {
@@ -264,8 +264,8 @@
     border-radius: 5px;
     width: calc(100% - 20px);
     height: calc(100% - 25px);
-    border: dashed 4px var(--layer-2);
+    border: dashed 4px var(--color-layer-2);
-    background: var(--layer-1);
+    background: var(--color-layer-1);
     opacity: 0.5;
   }
 </style>

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

@@ -1,29 +1,25 @@
 <script lang="ts">
-  import type { Graph, NodeInstance, NodeRegistry } from "@nodarium/types";
+  import { createKeyMap } from '$lib/helpers/createKeyMap';
-  import GraphEl from "./Graph.svelte";
+  import type { Graph, NodeInstance, NodeRegistry } from '@nodarium/types';
-  import { GraphManager } from "../graph-manager.svelte";
+  import { GraphManager } from '../graph-manager.svelte';
-  import { createKeyMap } from "$lib/helpers/createKeyMap";
+  import { GraphState, setGraphManager, setGraphState } from '../graph-state.svelte';
-  import {
+  import { setupKeymaps } from '../keymaps';
-    GraphState,
+  import GraphEl from './Graph.svelte';
-    setGraphManager,
-    setGraphState,
-  } from "../graph-state.svelte";
-  import { setupKeymaps } from "../keymaps";
 
   type Props = {
     graph?: Graph;
     registry: NodeRegistry;
 
-    settings?: Record<string, any>;
+    settings?: Record<string, unknown>;
 
     activeNode?: NodeInstance;
     showGrid?: boolean;
     snapToGrid?: boolean;
     showHelp?: boolean;
-    settingTypes?: Record<string, any>;
+    settingTypes?: Record<string, unknown>;
 
     onsave?: (save: Graph) => void;
-    onresult?: (result: any) => void;
+    onresult?: (result: unknown) => void;
   };
 
   let {
@@ -36,11 +32,12 @@
     showHelp = $bindable(false),
     settingTypes = $bindable(),
     onsave,
-    onresult,
+    onresult
   }: Props = $props();
 
   export const keymap = createKeyMap([]);
 
+  // svelte-ignore state_referenced_locally
   export const manager = new GraphManager(registry);
   setGraphManager(manager);
 
@@ -70,14 +67,14 @@
     }
   });
 
-  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));
 
   $effect(() => {
     if (graph) {

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

@@ -1,33 +1,33 @@
-import { appSettings } from "$lib/settings/app-settings.svelte";
+import { appSettings } from '$lib/settings/app-settings.svelte';
-import { Color, LinearSRGBColorSpace } from "three";
+import { Color, LinearSRGBColorSpace } from 'three';
 
 const variables = [
-  "layer-0",
+  'layer-0',
-  "layer-1",
+  'layer-1',
-  "layer-2",
+  'layer-2',
-  "layer-3",
+  'layer-3',
-  "outline",
+  'outline',
-  "active",
+  'active',
-  "selected",
+  'selected',
-  "edge",
+  'edge'
 ] as const;
 
 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)]),
+  variables.map((v) => [v, getColor(v)])
 ) as Record<(typeof variables)[number], Color>;
 
 $effect.root(() => {
   $effect(() => {
-    if (!appSettings.value.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/drop.events.ts

@@ -6,7 +6,7 @@ export class FileDropEventManager {
   constructor(
     private graph: GraphManager,
     private state: GraphState
-  ) { }
+  ) {}
 
   handleFileDrop(event: DragEvent) {
     event.preventDefault();
@@ -17,19 +17,21 @@ export class FileDropEventManager {
     let my = event.clientY - this.state.rect.y;
 
     if (nodeId) {
-      let nodeOffsetX = event.dataTransfer.getData('data/node-offset-x');
+      const nodeOffsetX = event.dataTransfer.getData('data/node-offset-x');
-      let nodeOffsetY = event.dataTransfer.getData('data/node-offset-y');
+      const nodeOffsetY = event.dataTransfer.getData('data/node-offset-y');
       if (nodeOffsetX && nodeOffsetY) {
         mx += parseInt(nodeOffsetX);
         my += parseInt(nodeOffsetY);
       }
 
       let props = {};
-      let rawNodeProps = event.dataTransfer.getData('data/node-props');
+      const rawNodeProps = event.dataTransfer.getData('data/node-props');
       if (rawNodeProps) {
         try {
           props = JSON.parse(rawNodeProps);
-        } catch (e) { }
+        } catch (e) {
+          console.error('Failed to parse node dropped', e);
+        }
       }
 
       const pos = this.state.projectScreenToWorld(mx, my);
@@ -48,7 +50,7 @@ export class FileDropEventManager {
         reader.onload = async (e) => {
           const buffer = e.target?.result;
           if (buffer?.constructor === ArrayBuffer) {
-            const nodeType = await this.graph.registry.register(buffer);
+            const nodeType = await this.graph.registry.register(nodeId, buffer);
 
             this.graph.createNode({
               type: nodeType.id,

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

@@ -7,7 +7,7 @@ export class EdgeInteractionManager {
   constructor(
     private graph: GraphManager,
     private state: GraphState
-  ) { }
+  ) {}
 
   private MIN_DISTANCE = 3;
 
@@ -85,7 +85,14 @@ export class EdgeInteractionManager {
         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);
+        const distance = distanceFromPointToSegment(
+          pointAx,
+          pointAy,
+          pointBx,
+          pointBy,
+          mouseX,
+          mouseY
+        );
         if (distance < this.MIN_DISTANCE) {
           if (distance < hoveredEdgeDistance) {
             hoveredEdgeDistance = distance;

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

@@ -177,8 +177,8 @@ export class MouseEventManager {
       }
     }
 
-    let mx = event.clientX - this.state.rect.x;
+    const mx = event.clientX - this.state.rect.x;
-    let my = event.clientY - this.state.rect.y;
+    const my = event.clientY - this.state.rect.y;
 
     this.state.mouseDown = [mx, my];
     this.state.cameraDown[0] = this.state.cameraPosition[0];
@@ -242,8 +242,8 @@ export class MouseEventManager {
   }
 
   handleWindowMouseMove(event: MouseEvent) {
-    let mx = event.clientX - this.state.rect.x;
+    const mx = event.clientX - this.state.rect.x;
-    let my = event.clientY - this.state.rect.y;
+    const my = event.clientY - this.state.rect.y;
 
     this.state.mousePosition = this.state.projectScreenToWorld(mx, my);
     this.state.hoveredNodeId = this.state.getNodeIdFromEvent(event);
@@ -265,7 +265,7 @@ export class MouseEventManager {
         }
       }
 
-      if (_socket && smallestDist < 0.9) {
+      if (_socket && smallestDist < 1.5) {
         this.state.mousePosition = _socket.position;
         this.state.hoveredSocket = _socket;
       } else {
@@ -352,9 +352,9 @@ export class MouseEventManager {
 
     // here we are handling panning of camera
     this.state.isPanning = true;
-    let newX = this.state.cameraDown[0]
+    const newX = this.state.cameraDown[0]
       - (mx - this.state.mouseDown[0]) / this.state.cameraPosition[2];
-    let newY = this.state.cameraDown[1]
+    const newY = this.state.cameraDown[1]
       - (my - this.state.mouseDown[1]) / this.state.cameraPosition[2];
 
     this.state.cameraPosition[0] = newX;
@@ -392,6 +392,7 @@ export class MouseEventManager {
         / zoomRatio;
     this.state.cameraPosition[1] = this.state.mousePosition[1]
       - (this.state.mousePosition[1] - this.state.cameraPosition[1])
-        / zoomRatio, this.state.cameraPosition[2] = newZoom;
+        / zoomRatio;
+    this.state.cameraPosition[2] = newZoom;
   }
 }

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

@@ -1,11 +1,11 @@
-import throttle from "$lib/helpers/throttle";
+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 },
+  T extends EventMap = { [key: string]: unknown }
 > {
   index = 0;
   public eventMap: T = {} as T;
@@ -32,11 +32,11 @@ export default class EventEmitter<
   public on<K extends EventKey<T>>(
     event: K,
     cb: EventReceiver<T[K]>,
-    throttleTimer = 0,
+    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;
 
@@ -54,10 +54,10 @@ export default class EventEmitter<
    */
   public once<K extends EventKey<T>>(
     event: K,
-    cb: EventReceiver<T[K]>,
+    cb: EventReceiver<T[K]>
   ): () => void {
     const cbsOnce = Object.assign(this.cbsOnce, {
-      [event]: [...(this.cbsOnce[event] || []), cb],
+      [event]: [...(this.cbsOnce[event] || []), cb]
     });
     this.cbsOnce = cbsOnce;
 

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

@@ -36,7 +36,8 @@ export function createNodePath({
   aspectRatio = 1
 } = {}) {
   return `M0,${cornerTop}
-      ${cornerTop
+      ${
+    cornerTop
       ? ` V${cornerTop}
               Q0,0 ${cornerTop * aspectRatio},0
               H${100 - cornerTop * aspectRatio}
@@ -47,11 +48,13 @@ export function createNodePath({
             `
   }
       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}
@@ -59,26 +62,21 @@ export function createNodePath({
             `
       : `${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, ' ');
 }
 
-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 function withSubComponents<A, B extends Record<string, any>>(
+export function withSubComponents<A, B extends Record<string, unknown>>(
   component: A,
   subcomponents: B
 ): A & B {

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/history-manager.ts

@@ -1,21 +1,21 @@
-import { create, type Delta } from "jsondiffpatch";
+import type { Graph } from '@nodarium/types';
-import type { Graph } from "@nodarium/types";
+import { createLogger } from '@nodarium/utils';
-import { clone } from "./helpers/index.js";
+import { create, type Delta } from 'jsondiffpatch';
-import { createLogger } from "@nodarium/utils";
+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 as string;
+    if ('id' in obj) return obj.id as string;
-    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 '$$index:' + index;
   }
-    return "$$index:" + index;
-  },
 });
 
-const log = createLogger("history");
+const log = createLogger('history');
 log.mute();
 
 export class HistoryManager {
@@ -26,7 +26,7 @@ export class HistoryManager {
 
   private opts = {
     debounce: 400,
-    maxHistory: 100,
+    maxHistory: 100
   };
 
   constructor({ maxHistory = 100, debounce = 100 } = {}) {
@@ -40,12 +40,12 @@ export class HistoryManager {
     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
@@ -61,7 +61,7 @@ export class HistoryManager {
         }
         this.state = newState;
       } else {
-        log.log("no changes");
+        log.log('no changes');
       }
     }
   }
@@ -75,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];
@@ -95,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/node/Node.svelte

@@ -1,13 +1,13 @@
 <script lang="ts">
-  import type { NodeInstance } from "@nodarium/types";
+  import { appSettings } from '$lib/settings/app-settings.svelte';
-  import { getGraphState } from "../graph-state.svelte";
+  import type { NodeInstance } from '@nodarium/types';
-  import { T } from "@threlte/core";
+  import { T } from '@threlte/core';
-  import { type Mesh } from "three";
+  import { type Mesh } from 'three';
-  import NodeFrag from "./Node.frag";
+  import { getGraphState } from '../graph-state.svelte';
-  import NodeVert from "./Node.vert";
+  import { colors } from '../graph/colors.svelte';
-  import NodeHtml from "./NodeHTML.svelte";
+  import NodeFrag from './Node.frag';
-  import { colors } from "../graph/colors.svelte";
+  import NodeVert from './Node.vert';
-  import { appSettings } from "$lib/settings/app-settings.svelte";
+  import NodeHtml from './NodeHTML.svelte';
 
   const graphState = getGraphState();
 
@@ -21,12 +21,12 @@
   const isActive = $derived(graphState.activeNodeId === node.id);
   const isSelected = $derived(graphState.selectedNodes.has(node.id));
   const strokeColor = $derived(
-    appSettings.value.theme &&
+    appSettings.value.theme
-      (isSelected
+      && (isSelected
         ? colors.selected
         : isActive
         ? colors.active
-          : colors.outline),
+        : colors.outline)
   );
 
   let meshRef: Mesh | undefined = $state();
@@ -55,12 +55,12 @@
     fragmentShader={NodeFrag}
     transparent
     uniforms={{
-      uColorBright: { value: colors["layer-2"] },
+      uColorBright: { value: colors['layer-2'] },
-      uColorDark: { value: colors["layer-1"] },
+      uColorDark: { value: colors['layer-1'] },
       uStrokeColor: { value: colors.outline.clone() },
       uStrokeWidth: { value: 1.0 },
       uWidth: { value: 20 },
-      uHeight: { value: height },
+      uHeight: { value: height }
     }}
     uniforms.uStrokeColor.value={strokeColor.clone()}
     uniforms.uStrokeWidth.value={(7 - z) / 3}

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

@@ -1,8 +1,8 @@
 <script lang="ts">
-  import type { NodeInstance } from "@nodarium/types";
+  import type { NodeInstance } from '@nodarium/types';
-  import NodeHeader from "./NodeHeader.svelte";
+  import { getGraphState } from '../graph-state.svelte';
-  import NodeParameter from "./NodeParameter.svelte";
+  import NodeHeader from './NodeHeader.svelte';
-  import { getGraphState } from "../graph-state.svelte";
+  import NodeParameter from './NodeParameter.svelte';
 
   let ref: HTMLDivElement;
 
@@ -10,7 +10,7 @@
 
   type Props = {
     node: NodeInstance;
-    position?: "absolute" | "fixed" | "relative";
+    position?: 'absolute' | 'fixed' | 'relative';
     isActive?: boolean;
     isSelected?: boolean;
     inView?: boolean;
@@ -19,11 +19,11 @@
 
   let {
     node = $bindable(),
-    position = "absolute",
+    position = 'absolute',
     isActive = false,
     isSelected = false,
     inView = true,
-    z = 2,
+    z = 2
   }: Props = $props();
 
   // If we dont have a random offset, all nodes becom visible at the same zoom level -> stuttering
@@ -31,12 +31,11 @@
   const zLimit = 2 - zOffset;
 
   const parameters = Object.entries(node.state?.type?.inputs || {}).filter(
-    (p) =>
+    (p) => p[1].type !== 'seed' && !('setting' in p[1]) && p[1]?.hidden !== true
-      p[1].type !== "seed" && !("setting" in p[1]) && p[1]?.hidden !== true,
   );
 
   $effect(() => {
-    if ("state" in node && !node.state.ref) {
+    if ('state' in node && !node.state.ref) {
       node.state.ref = ref;
       graphState?.updateNodePosition(node);
     }
@@ -47,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}
@@ -56,7 +55,7 @@
 >
   <NodeHeader {node} />
 
-  {#each parameters as [key, value], i}
+  {#each parameters as [key, value], i (key)}
     <NodeParameter
       bind:node
       id={key}
@@ -72,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,7 +1,7 @@
 <script lang="ts">
-  import { getGraphState } from "../graph-state.svelte";
+  import type { NodeInstance } from '@nodarium/types';
-  import { createNodePath } from "../helpers/index.js";
+  import { getGraphState } from '../graph-state.svelte';
-  import type { NodeInstance } from "@nodarium/types";
+  import { createNodePath } from '../helpers/index.js';
 
   const graphState = getGraphState();
 
@@ -10,47 +10,52 @@
   function handleMouseDown(event: MouseEvent) {
     event.stopPropagation();
     event.preventDefault();
-    if ("state" in node) {
+    if ('state' in node) {
       graphState.setDownSocket?.({
         node,
         index: 0,
-        position: graphState.getSocketPosition?.(node, 0),
+        position: graphState.getSocketPosition?.(node, 0)
       });
     }
   }
 
   const cornerTop = 10;
-  const rightBump = !!node?.state?.type?.outputs?.length;
+  const rightBump = $derived(!!node?.state?.type?.outputs?.length);
   const aspectRatio = 0.25;
 
-  const path = createNodePath({
+  const path = $derived(
+    createNodePath({
       depth: 5.5,
       height: 34,
       y: 49,
       cornerTop,
       rightBump,
-    aspectRatio,
+      aspectRatio
-  });
+    })
-  const pathHover = createNodePath({
+  );
-    depth: 8.5,
+  const pathHover = $derived(
-    height: 50,
+    createNodePath({
+      depth: 7,
+      height: 40,
       y: 49,
       cornerTop,
       rightBump,
-    aspectRatio,
+      aspectRatio
-  });
+    })
+  );
 </script>
 
 <div class="wrapper" data-node-id={node.id} data-node-type={node.type}>
   <div class="content">
-    {node.type.split("/").pop()}
+    {node.type.split('/').pop()}
   </div>
   <div
     class="click-target"
     role="button"
     tabindex="0"
     onmousedown={handleMouseDown}
-  ></div>
+  >
+  </div>
   <svg
     xmlns="http://www.w3.org/2000/svg"
     viewBox="0 0 100 100"
@@ -62,8 +67,7 @@
       --hover-path: path("${pathHover}");
     `}
   >
-    <path vector-effect="non-scaling-stroke" stroke="white" stroke-width="0.1"
+    <path vector-effect="non-scaling-stroke" stroke="white" stroke-width="0.1"></path>
-    ></path>
   </svg>
 </div>
 
@@ -104,13 +108,14 @@
 
   svg path {
     stroke-width: 0.2px;
-    transition:
+    transition: d 0.3s ease, fill 0.3s ease;
-      d 0.3s ease,
+    fill: var(--color-layer-2);
-      fill 0.3s ease;
-    fill: var(--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,7 +1,7 @@
 <script lang="ts">
-  import type { NodeInstance, NodeInput } from "@nodarium/types";
+  import type { NodeInput, NodeInstance } from '@nodarium/types';
-  import { Input } from "@nodarium/ui";
+  import { Input } from '@nodarium/ui';
-  import type { GraphManager } from "../graph-manager.svelte";
+  import type { GraphManager } from '../graph-manager.svelte';
 
   type Props = {
     node: NodeInstance;
@@ -16,17 +16,18 @@
     input,
     id,
     elementId = `input-${Math.random().toString(36).substring(7)}`,
-    graph,
+    graph
   }: Props = $props();
 
   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 === 'boolean') return 0;
-    if (input.type === "integer") return 0;
+    if (input.type === 'float') return 0.5;
-    if (input.type === "select") return 0;
+    if (input.type === 'integer') return 0;
+    if (input.type === 'select') return 0;
     return 0;
   }
 

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

@@ -1,8 +1,8 @@
 <script lang="ts">
-  import type { NodeInput, NodeInstance } from "@nodarium/types";
+  import type { NodeInput, NodeInstance } from '@nodarium/types';
-  import { createNodePath } from "../helpers";
+  import { getGraphManager, getGraphState } from '../graph-state.svelte';
-  import NodeInputEl from "./NodeInput.svelte";
+  import { createNodePath } from '../helpers';
-  import { getGraphManager, getGraphState } from "../graph-state.svelte";
+  import NodeInputEl from './NodeInput.svelte';
 
   type Props = {
     node: NodeInstance;
@@ -15,9 +15,9 @@
 
   let { node = $bindable(), input, id, isLast }: Props = $props();
 
-  const inputType = node?.state?.type?.inputs?.[id]!;
+  const inputType = $derived(node?.state?.type?.inputs?.[id]);
 
-  const socketId = `${node.id}-${id}`;
+  const socketId = $derived(`${node.id}-${id}`);
 
   const graphState = getGraphState();
   const graphId = graph?.id;
@@ -30,71 +30,65 @@
     graphState.setDownSocket({
       node,
       index: id,
-      position: graphState.getSocketPosition?.(node, id),
+      position: graphState.getSocketPosition?.(node, id)
     });
   }
 
-  const leftBump = node.state?.type?.inputs?.[id].internal !== true;
+  const leftBump = $derived(node.state?.type?.inputs?.[id].internal !== true);
-  const cornerBottom = isLast ? 5 : 0;
+  const cornerBottom = $derived(isLast ? 5 : 0);
   const aspectRatio = 0.5;
 
-  const path = createNodePath({
+  const path = $derived(
-    depth: 7,
+    createNodePath({
-    height: 20,
-    y: 50.5,
-    cornerBottom,
-    leftBump,
-    aspectRatio,
-  });
-  const pathDisabled = createNodePath({
       depth: 6,
       height: 18,
       y: 50.5,
       cornerBottom,
       leftBump,
-    aspectRatio,
+      aspectRatio
-  });
+    })
-  const pathHover = createNodePath({
+  );
-    depth: 8,
+  const pathHover = $derived(
-    height: 25,
+    createNodePath({
+      depth: 7,
+      height: 20,
       y: 50.5,
       cornerBottom,
       leftBump,
-    aspectRatio,
+      aspectRatio
-  });
+    })
+  );
 </script>
 
 <div
   class="wrapper"
   data-node-type={node.type}
   data-node-input={id}
-  class:disabled={!graphState?.possibleSocketIds.has(socketId)}
+  class:possible-socket={graphState?.possibleSocketIds.has(socketId)}
 >
   {#key id && graphId}
     <div class="content" class:disabled={graph?.inputSockets?.has(socketId)}>
-      {#if inputType.label !== ""}
+      {#if inputType?.label !== ''}
-        <label for={elementId} title={input.description}
+        <label for={elementId} title={input.description}>{input.label || id}</label>
-          >{input.label || id}</label
-        >
       {/if}
       <span
         class="absolute i-[tabler--help-circle] size-4 block top-2 right-2 opacity-30"
         title={JSON.stringify(input, null, 2)}
       ></span>
-      {#if inputType.external !== true}
+      {#if inputType?.external !== true}
         <NodeInputEl {graph} {elementId} bind:node {input} {id} />
       {/if}
     </div>
 
     {#if node?.state?.type?.inputs?.[id]?.internal !== true}
-      <div data-node-socket class="large target"></div>
       <div
         data-node-socket
-        class="small target"
+        class="target"
         onmousedown={handleMouseDown}
         role="button"
         tabindex="0"
-      ></div>
+      >
+      </div>
     {/if}
   {/key}
 
@@ -107,7 +101,6 @@
     style={`
       --path: path("${path}");
       --hover-path: path("${pathHover}");
-      --hover-path-disabled: path("${pathDisabled}");
     `}
   >
     <path vector-effect="non-scaling-stroke"></path>
@@ -123,28 +116,22 @@
   }
 
   .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 {
-    width: 30px;
+    box-shadow: 0px 0px 10px rgba(255, 255, 255, 0.5);
-    height: 30px;
+    background-color: rgba(255, 255, 255, 0.2);
+    z-index: -10;
   }
 
-  .large.target {
+  .target:hover ~ svg path{
-    width: 60px;
+    d: var(--hover-path);
-    height: 60px;
-    cursor: unset;
-    pointer-events: none;
-  }
-
-  :global(.hovering-sockets) .large.target {
-    pointer-events: all;
   }
 
   .content {
@@ -169,26 +156,21 @@
   }
 
   svg path {
-    transition:
+    transition: d 0.3s ease, fill 0.3s ease;
-      d 0.3s ease,
+    fill: var(--color-layer-1);
-      fill 0.3s ease;
-    fill: var(--layer-1);
     stroke: var(--stroke);
     stroke-width: var(--stroke-width);
     d: var(--path);
-  }
 
-  :global {
+    stroke-linejoin: round;
-    .hovering-sockets .large:hover ~ svg path {
+    shape-rendering: geometricPrecision;
-      d: var(--hover-path);
-    }
   }
 
   .content.disabled {
     opacity: 0.2;
   }
 
-  .disabled svg path {
+  .possible-socket svg path {
-    d: var(--hover-path-disabled) !important;
+     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-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 "@nodarium/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;
@@ -18,19 +17,18 @@ export function grid(width: number, height: number) {
       id: i,
       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,
     position: [width * 30, (height - 1) * 40],
-    type: "max/plantarium/output",
+    type: 'max/plantarium/output',
-    props: {},
+    props: {}
   });
 
   return graph;
-
 }

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

@@ -1,8 +1,8 @@
-export { grid } from "./grid";
+export { default as defaultPlant } from './default.json';
-export { tree } from "./tree";
+export { grid } from './grid';
-export { plant } from "./plant";
+export { default as lottaFaces } from './lotta-faces.json';
-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 { default as lottaNodes } from './lotta-nodes.json';
-export { default as defaultPlant } from "./default.json"
+export { plant } from './plant';
-export { default as lottaNodesAndFaces } from "./lotta-nodes-and-faces.json";
+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 },
+  'settings': { 'resolution.circle': 26, 'resolution.curve': 39 },
-  "nodes": [
+  'nodes': [
-    { "id": 9, "position": [180, 80], "type": "max/plantarium/output", "props": {} },
+    { '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': 10,
-    { "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 } },
+      'position': [55, 80],
-    { "id": 13, "position": [130, 80], "type": "max/plantarium/noise", "props": { "strength": 8, "scale": 7.7, "fixBottom": 1, "directionalStrength": [1, 0, 1], "depth": 1 } },
+      'type': 'max/plantarium/stem',
-    { "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 } }
+      '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, SerializedNode } from "@nodarium/types";
+import type { Graph, SerializedNode } from '@nodarium/types';
 
 export function tree(depth: number): Graph {
-
   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",
+        type: 'max/plantarium/math',
-        position: [x, y],
+        position: [x, y]
       });
-      edges.push([id0, 0, parent, "a"]);
+      edges.push([id0, 0, parent, 'a']);
       nodes.push({
         id: id1,
-        type: "max/plantarium/math",
+        type: 'max/plantarium/math',
-        position: [x, y + 35],
+        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,5 +1,5 @@
 <script lang="ts">
-  import { getContext, type Snippet } from "svelte";
+  import { getContext, type Snippet } from 'svelte';
 
   let index = $state(-1);
   let wrapper: HTMLDivElement;
@@ -8,19 +8,17 @@
 
   $effect(() => {
     if (index === -1) {
-      index = getContext<() => number>("registerCell")();
+      index = getContext<() => number>('registerCell')();
     }
   });
 
-  const sizes = getContext<{ value: string[] }>("sizes");
+  const sizes = getContext<{ value: string[] }>('sizes');
 
-  let downSizes: string[] = [];
   let downWidth = 0;
   let mouseDown = false;
   let startX = 0;
 
   function handleMouseDown(event: MouseEvent) {
-    downSizes = [...sizes.value];
     mouseDown = true;
     startX = event.clientX;
     downWidth = wrapper.getBoundingClientRect().width;
@@ -45,7 +43,8 @@
     role="button"
     tabindex="0"
     onmousedown={handleMouseDown}
-  ></div>
+  >
+  </div>
 {/if}
 
 <div class="cell" bind:this={wrapper}>
@@ -63,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, type Snippet } from "svelte";
+  import { onMount, setContext, type Snippet } from 'svelte';
 
   const { children, id } = $props<{ children?: Snippet; id?: string }>();
 
-  setContext("grid-id", id);
+  onMount(() => {
+    setContext('grid-id', id);
+  });
 </script>
 
 {@render children({ id })}

app/src/lib/grid/Row.svelte

@@ -1,26 +1,26 @@
 <script lang="ts">
-  import { setContext, getContext } from "svelte";
+  import { localState } from '$lib/helpers/localState.svelte';
-  import { localState } from "$lib/helpers/localState.svelte";
+  import { getContext, setContext } from 'svelte';
 
-  const gridId = getContext<string>("grid-id") || "grid-0";
+  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.value.length) {
-      sizes.value = [...sizes.value, "1fr"];
+      sizes.value = [...sizes.value, '1fr'];
     }
     return index;
   });
 
-  setContext("sizes", sizes);
+  setContext('sizes', sizes);
 
   const cols = $derived(
-    sizes.value.map((size, i) => `${i > 0 ? "1px " : ""}` + size).join(" "),
+    sizes.value.map((size, i) => `${i > 0 ? '1px ' : ''}` + size).join(' ')
   );
 </script>
 

app/src/lib/grid/index.ts

@@ -1,6 +1,6 @@
-import { withSubComponents } from "$lib/helpers";
+import { withSubComponents } from '$lib/helpers';
-import Grid from "./Grid.svelte";
+import Cell from './Cell.svelte';
-import Row from "./Row.svelte";
+import Grid from './Grid.svelte';
-import Cell from "./Cell.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 = {
+export type ShortCut = {
-  key: string | string[],
+  key: string | string[];
-  shift?: boolean,
+  shift?: boolean;
-  ctrl?: boolean,
+  ctrl?: boolean;
-  alt?: boolean,
+  alt?: boolean;
-  preventDefault?: boolean,
+  preventDefault?: boolean;
-  description?: string,
+  description?: string;
-  callback: (event: KeyboardEvent) => void
+  callback: (event: KeyboardEvent) => void;
+};
+
+function getShortcutId(shortcut: ShortCut) {
+  return `${shortcut.key}${shortcut.shift ? '+shift' : ''}${shortcut.ctrl ? '+ctrl' : ''}${
+    shortcut.alt ? '+alt' : ''
+  }`;
 }
 
-function getShortcutId(shortcut: Shortcut) {
+export function createKeyMap(keys: ShortCut[]) {
-  return `${shortcut.key}${shortcut.shift ? "+shift" : ""}${shortcut.ctrl ? "+ctrl" : ""}${shortcut.alt ? "+alt" : ""}`;
-}
-
-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 ('shift' in k && k.shift !== event.shiftKey) return false;
-        if ("ctrl" in k && k.ctrl !== event.ctrlKey) return false;
+        if ('ctrl' in k && k.ctrl !== event.ctrlKey) return false;
-        if ("alt" in k && k.alt !== event.altKey) 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}
@@ -44,11 +45,13 @@ export function createNodePath({
             `
   }
       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}
@@ -56,26 +59,29 @@ export function createNodePath({
             `
       : `${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, unknown>>(
-
-export function withSubComponents<A, B extends Record<string, any>>(
   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);
+  const days = Math.floor(durationInMilliseconds / millisecondsPerDay);
-  let hours = Math.floor((durationInMilliseconds % millisecondsPerDay) / millisecondsPerHour);
+  const hours = Math.floor((durationInMilliseconds % millisecondsPerDay) / millisecondsPerHour);
-  let minutes = Math.floor((durationInMilliseconds % millisecondsPerHour) / millisecondsPerMinute);
+  const minutes = Math.floor(
-  let seconds = Math.floor((durationInMilliseconds % millisecondsPerMinute) / millisecondsPerSecond);
+    (durationInMilliseconds % millisecondsPerHour) / millisecondsPerMinute
-  let millis = durationInMilliseconds % millisecondsPerSecond;
+  );
+  const seconds = Math.floor(
+    (durationInMilliseconds % millisecondsPerMinute) / millisecondsPerSecond
+  );
+  const millis = durationInMilliseconds % millisecondsPerSecond;
 
   let durationString = '';
 
@@ -131,32 +141,10 @@ export function humanizeDuration(durationInMilliseconds: number) {
 
   return durationString.trim();
 }
-// export function debounceAsyncFunction<T extends any[], R>(
+
-//   func: (...args: T) => Promise<R>
+export function debounceAsyncFunction<T extends (...args: never[]) => Promise<unknown>>(
-// ): (...args: T) => Promise<R> {
+  asyncFn: T
-//   let timeoutId: ReturnType<typeof setTimeout> | null = null;
+): T {
-//   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 {
   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> {
+export function withArgsChangeOnly<T extends unknown[], R>(
-//   let currentPromise: Promise<R> | null = null;
+  func: (...args: T) => R
-//   let nextArgs: T | null = null;
+): (...args: T) => R {
-//   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 {
   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,8 +1,8 @@
-import { browser } from "$app/environment";
+import { browser } from '$app/environment';
 
 export class LocalStore<T> {
   value = $state<T>() as T;
-  key = "";
+  key = '';
 
   constructor(key: string, value: T) {
     this.key = key;

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;
-
 }

app/src/lib/helpers/throttle.ts

@@ -1,6 +1,6 @@
 export default <T extends unknown[]>(
   callback: (...args: T) => void,
-  delay: number,
+  delay: number
 ) => {
   let isWaiting = false;
 

app/src/lib/icons/graph.svg

@@ -1,6 +1,10 @@
 <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <rect x="17" y="8" width="5" height="7" rx="1" stroke="currentColor" stroke-width="2"/> 
+  <rect x="17" y="8" width="5" height="7" rx="1" stroke="currentColor" stroke-width="2" />
-  <rect x="2" y="3" width="5" height="7" rx="1" stroke="currentColor" stroke-width="2"/> 
+  <rect x="2" y="3" width="5" height="7" rx="1" stroke="currentColor" stroke-width="2" />
-  <rect x="2" y="14" width="5" height="7" rx="1" stroke="currentColor" stroke-width="2"/> 
+  <rect x="2" y="14" width="5" height="7" rx="1" stroke="currentColor" stroke-width="2" />
-  <path d="M16 10.5C9.33333 10.5 14.8889 6 8.22222 6H6M16 12.5C8.77778 12.5 14.8889 17 8.22222 17H6" stroke="currentColor" stroke-width="2"/> 
+  <path
+    d="M16 10.5C9.33333 10.5 14.8889 6 8.22222 6H6M16 12.5C8.77778 12.5 14.8889 17 8.22222 17H6"
+    stroke="currentColor"
+    stroke-width="2"
+  />
 </svg>

app/src/lib/node-registry.ts

@@ -8,6 +8,7 @@ export async function getWasm(id: `${string}/${string}/${string}`) {
   try {
     await fs.access(filePath);
   } catch (e) {
+    console.error(`Failed to read node: ${id}`, e);
     return null;
   }
 
@@ -20,9 +21,11 @@ export async function getNodeWasm(id: `${string}/${string}/${string}`) {
   const wasmBytes = await getWasm(id);
   if (!wasmBytes) return null;
 
-  const wrapper = createWasmWrapper(wasmBytes);
+  try {
-
+    return createWasmWrapper(wasmBytes.buffer);
-  return wrapper;
+  } catch (error) {
+    console.error(`Failed to create node wrapper for node: ${id}`, error);
+  }
 }
 
 export async function getNode(id: `${string}/${string}/${string}`) {

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

@@ -0,0 +1,2 @@
+export * from './node-registry-cache';
+export * from './node-registry-client';

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

@@ -1,8 +1,7 @@
 import type { AsyncCache } from '@nodarium/types';
-import { openDB, type IDBPDatabase } from 'idb';
+import { type IDBPDatabase, openDB } from 'idb';
 
 export class IndexDBCache implements AsyncCache<unknown> {
-
   size: number = 100;
 
   db: Promise<IDBPDatabase<unknown>>;
@@ -12,7 +11,7 @@ export class IndexDBCache implements AsyncCache<unknown> {
     this.db = openDB<unknown>('cache/' + id, 1, {
       upgrade(db) {
         db.createObjectStore('keyval');
-      },
+      }
     });
   }
 
@@ -33,16 +32,16 @@ export class IndexDBCache implements AsyncCache<unknown> {
     if (res instanceof ArrayBuffer) {
       return res;
     }
-    return
+    return;
   }
 
   async getString(key: string) {
     const res = await this.get(key);
     if (!res) return;
-    if (typeof res === "string") {
+    if (typeof res === 'string') {
       return res;
     }
-    return
+    return;
   }
 
   async set(key: string, value: unknown) {
@@ -54,5 +53,4 @@ export class IndexDBCache implements AsyncCache<unknown> {
   clear() {
     this.db.then(db => db.clear('keyval'));
   }
-
 }

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

@@ -16,7 +16,7 @@ export class RemoteNodeRegistry implements NodeRegistry {
   constructor(
     private url: string,
     public cache?: AsyncCache<ArrayBuffer | string>
-  ) { }
+  ) {}
 
   async fetchJson(url: string, skipCache = false) {
     const finalUrl = `${this.url}/${url}`;
@@ -105,7 +105,7 @@ export class RemoteNodeRegistry implements NodeRegistry {
         const wasmBuffer = await this.fetchNodeWasm(id);
 
         try {
-          return await this.register(wasmBuffer);
+          return await this.register(id, wasmBuffer);
         } catch (e) {
           console.log('Failed to register: ', id);
           console.error(e);
@@ -125,20 +125,30 @@ export class RemoteNodeRegistry implements NodeRegistry {
     return nodes;
   }
 
-  async register(wasmBuffer: ArrayBuffer) {
+  async register(id: string, wasmBuffer: ArrayBuffer) {
-    const wrapper = createWasmWrapper(wasmBuffer);
+    let wrapper: ReturnType<typeof createWasmWrapper> = null!;
+    try {
+      wrapper = createWasmWrapper(wasmBuffer);
+    } catch (error) {
+      console.error(`Failed to create node wrapper for node: ${id}`, error);
+    }
 
-    const definition = NodeDefinitionSchema.safeParse(wrapper.get_definition());
+    const rawDefinition = wrapper.get_definition();
+    const definition = NodeDefinitionSchema.safeParse(rawDefinition);
 
     if (definition.error) {
-      throw definition.error;
+      throw new Error(
+        'Failed to parse node definition from node:+\n' + JSON.stringify(rawDefinition, null, 2)
+          + '\n'
+          + definition.error
+      );
     }
 
     if (this.cache) {
       this.cache.set(definition.data.id, wasmBuffer);
     }
 
-    let node = {
+    const node = {
       ...definition.data,
       execute: wrapper.execute
     };

app/src/lib/node-store/BreadCrumbs.svelte

@@ -1,16 +1,16 @@
 <script lang="ts">
-  import { Select } from "@nodarium/ui";
+  import { InputSelect } from '@nodarium/ui';
 
   let activeStore = $state(0);
   let { activeId }: { activeId: string } = $props();
   const [activeUser, activeCollection, activeNode] = $derived(
-    activeId.split(`/`),
+    activeId.split(`/`)
   );
 </script>
 
 <div class="breadcrumbs">
   {#if activeUser}
-    <Select id="root" options={["root"]} bind:value={activeStore}></Select>
+    <InputSelect id="root" options={['root']} bind:value={activeStore}></InputSelect>
     {#if activeCollection}
       <button
         onclick={() => {
@@ -35,7 +35,7 @@
       <span>{activeUser}</span>
     {/if}
   {:else}
-    <Select id="root" options={["root"]} bind:value={activeStore}></Select>
+    <InputSelect id="root" options={['root']} bind:value={activeStore}></InputSelect>
   {/if}
 </div>
 
@@ -47,7 +47,7 @@
     gap: 0.8em;
     height: 35px;
     box-sizing: border-box;
-    border-bottom: solid thin var(--outline);
+    border-bottom: solid thin var(--color-outline);
   }
   .breadcrumbs > button {
     position: relative;

app/src/lib/node-store/DraggableNode.svelte

@@ -1,39 +1,44 @@
 <script lang="ts">
-  import NodeHtml from "$lib/graph-interface/node/NodeHTML.svelte";
+  import NodeHtml from '$lib/graph-interface/node/NodeHTML.svelte';
-  import type { NodeDefinition, NodeId, NodeInstance } from "@nodarium/types";
+  import type { NodeDefinition, NodeId, NodeInstance } from '@nodarium/types';
+  import { onMount } from 'svelte';
 
   const { node }: { node: NodeDefinition } = $props();
 
   let dragging = $state(false);
 
-  let nodeData = $state<NodeInstance>({
+  let nodeData = $state<NodeInstance>(null!);
-    id: 0,
-    type: node.id as unknown as NodeId,
-    position: [0, 0] as [number, number],
-    props: {},
-    state: {
-      type: node,
-    },
-  });
 
   function handleDragStart(e: DragEvent) {
     dragging = true;
     const box = (e?.target as HTMLElement)?.getBoundingClientRect();
     if (e.dataTransfer === null) return;
-    e.dataTransfer.effectAllowed = "move";
+    e.dataTransfer.effectAllowed = 'move';
-    e.dataTransfer.setData("data/node-id", node.id.toString());
+    e.dataTransfer.setData('data/node-id', node.id.toString());
-    if (nodeData.props) {
+    if (nodeData?.props) {
-      e.dataTransfer.setData("data/node-props", JSON.stringify(nodeData.props));
+      e.dataTransfer.setData('data/node-props', JSON.stringify(nodeData.props));
     }
     e.dataTransfer.setData(
-      "data/node-offset-x",
+      'data/node-offset-x',
-      Math.round(box.left - e.clientX).toString(),
+      Math.round(box.left - e.clientX).toString()
     );
     e.dataTransfer.setData(
-      "data/node-offset-y",
+      'data/node-offset-y',
-      Math.round(box.top - e.clientY).toString(),
+      Math.round(box.top - e.clientY).toString()
     );
   }
+
+  onMount(() => {
+    nodeData = {
+      id: 0,
+      type: node.id as unknown as NodeId,
+      position: [0, 0] as [number, number],
+      props: {},
+      state: {
+        type: node
+      }
+    };
+  });
 </script>
 
 <div class="node-wrapper" class:dragging>
@@ -46,7 +51,9 @@
     tabindex="0"
     ondragstart={handleDragStart}
   >
-    <NodeHtml bind:node={nodeData} inView={true} position={"relative"} z={5} />
+    {#if nodeData}
+      <NodeHtml bind:node={nodeData} inView={true} position="relative" z={5} />
+    {/if}
   </div>
 </div>
 
@@ -61,7 +68,7 @@
   }
 
   .dragging {
-    border: dashed 2px var(--outline);
+    border: dashed 2px var(--color-outline);
   }
   .node-wrapper > div {
     opacity: 1;

app/src/lib/node-store/NodeStore.svelte

@@ -1,15 +1,15 @@
 <script lang="ts">
-  import BreadCrumbs from "./BreadCrumbs.svelte";
+  import type { RemoteNodeRegistry } from '$lib/node-registry/index';
-  import DraggableNode from "./DraggableNode.svelte";
+  import BreadCrumbs from './BreadCrumbs.svelte';
-  import type { RemoteNodeRegistry } from "@nodarium/registry";
+  import DraggableNode from './DraggableNode.svelte';
 
   const { registry }: { registry: RemoteNodeRegistry } = $props();
 
-  let activeId = $state("max/plantarium");
+  let activeId = $state('max/plantarium');
   let showBreadCrumbs = false;
 
   const [activeUser, activeCollection, activeNode] = $derived(
-    activeId.split(`/`),
+    activeId.split(`/`)
   );
 </script>
 
@@ -22,12 +22,14 @@
     {#await registry.fetchUsers()}
       <div>Loading Users...</div>
     {:then users}
-      {#each users as user}
+      {#each users as user (user.id)}
         <button
           onclick={() => {
             activeId = user.id;
-          }}>{user.id}</button
+          }}
         >
+          {user.id}
+        </button>
       {/each}
     {:catch error}
       <div>{error.message}</div>
@@ -36,7 +38,7 @@
     {#await registry.fetchUser(activeUser)}
       <div>Loading User...</div>
     {:then user}
-      {#each user.collections as collection}
+      {#each user.collections as collection (collection)}
         <button
           onclick={() => {
             activeId = collection.id;
@@ -52,7 +54,7 @@
     {#await registry.fetchCollection(`${activeUser}/${activeCollection}`)}
       <div>Loading Collection...</div>
     {:then collection}
-      {#each collection.nodes as node}
+      {#each collection.nodes as node (node.id)}
         {#await registry.fetchNodeDefinition(node.id)}
           <div>Loading Node... {node.id}</div>
         {:then node}

app/src/lib/performance/BarSplit.svelte

@@ -8,15 +8,15 @@
 
   const total = $derived(values.reduce((acc, v) => acc + v, 0));
 
-  let colors = ["red", "green", "blue"];
+  let colors = ['red', 'green', 'blue'];
 </script>
 
 <div class="wrapper">
   <div class="bars">
-    {#each values as value, i}
+    {#each values as value, i (value)}
       <div
         class="bar bg-{colors[i]}-400"
-        style="width: {(value / total) * 100}%;"
+        style:width={(value / total) * 100 + '%'}
       >
         {Math.round(value)}ms
       </div>
@@ -24,7 +24,7 @@
   </div>
 
   <div class="labels mt-2">
-    {#each values as _label, i}
+    {#each values as _label, i (_label)}
       <div class="text-{colors[i]}-400">{labels[i]}</div>
     {/each}
   </div>

app/src/lib/performance/Monitor.svelte

@@ -9,17 +9,17 @@
 
   let {
     points,
-    type = "ms",
+    type = 'ms',
-    title = "Performance",
+    title = 'Performance',
     max,
-    min,
+    min
   }: Props = $props();
 
   let internalMax = $derived(max ?? Math.max(...points));
   let internalMin = $derived(min ?? Math.min(...points))!;
 
   const maxText = $derived.by(() => {
-    if (type === "%") {
+    if (type === '%') {
       return 100;
     }
 
@@ -40,11 +40,10 @@
     points
       .map((point, i) => {
         const x = (i / (points.length - 1)) * 100;
-        const y =
+        const y = 100 - ((point - internalMin) / (internalMax - internalMin)) * 100;
-          100 - ((point - internalMin) / (internalMax - internalMin)) * 100;
         return `${x},${y}`;
       })
-      .join(" "),
+      .join(' ')
   );
 </script>
 
@@ -75,7 +74,7 @@
 
   .wrapper {
     position: relative;
-    border-bottom: solid thin var(--outline);
+    border-bottom: solid thin var(--color-outline);
     display: flex;
   }
   p {
@@ -89,13 +88,13 @@
   svg {
     height: 124px;
     margin: 24px 0px;
-    border-top: solid thin var(--outline);
+    border-top: solid thin var(--color-outline);
-    border-bottom: solid thin var(--outline);
+    border-bottom: solid thin var(--color-outline);
     width: 100%;
   }
   polyline {
     fill: none;
-    stroke: var(--layer-3);
+    stroke: var(--color-layer-3);
     opacity: 0.5;
     stroke-width: 1;
   }

app/src/lib/performance/PerformanceViewer.svelte

@@ -1,13 +1,13 @@
 <script lang="ts">
-  import Monitor from "./Monitor.svelte";
+  import { humanizeNumber } from '$lib/helpers';
-  import { humanizeNumber } from "$lib/helpers";
+  import { InputCheckbox } from '@nodarium/ui';
-  import { Checkbox } from "@nodarium/ui";
+  import type { PerformanceData } from '@nodarium/utils';
-  import type { PerformanceData } from "@nodarium/utils";
+  import BarSplit from './BarSplit.svelte';
-  import BarSplit from "./BarSplit.svelte";
+  import Monitor from './Monitor.svelte';
 
   const { data }: { data: PerformanceData } = $props();
 
-  let activeType = $state("total");
+  let activeType = $state('total');
   let showAverage = $state(true);
 
   function round(v: number) {
@@ -21,21 +21,21 @@
   }
 
   function getTitle(t: string) {
-    if (t.includes("/")) {
+    if (t.includes('/')) {
-      return `Node ${t.split("/").slice(-1).join("/")}`;
+      return `Node ${t.split('/').slice(-1).join('/')}`;
     }
 
     return t
-      .split("-")
+      .split('-')
       .map((v) => v[0].toUpperCase() + v.slice(1))
-      .join(" ");
+      .join(' ');
   }
 
   const viewerKeys = [
-    "total-vertices",
+    'total-vertices',
-    "total-faces",
+    'total-faces',
-    "update-geometries",
+    'update-geometries',
-    "split-result",
+    'split-result'
   ];
 
   // --- Small helpers that query `data` directly ---
@@ -64,21 +64,19 @@
   const lasts = $derived.by(() => data.at(-1) || {});
 
   const totalPerformance = $derived.by(() => {
-    const onlyLast =
+    const onlyLast = getLast('runtime')
-      getLast("runtime") +
+      + getLast('update-geometries')
-      getLast("update-geometries") +
+      + getLast('worker-transfer');
-      getLast("worker-transfer");
+    const average = getAverage('runtime')
-    const average =
+      + getAverage('update-geometries')
-      getAverage("runtime") +
+      + getAverage('worker-transfer');
-      getAverage("update-geometries") +
-      getAverage("worker-transfer");
     return { onlyLast, average };
   });
 
   const cacheRatio = $derived.by(() => {
     return {
-      onlyLast: Math.floor(getLast("cache-hit") * 100),
+      onlyLast: Math.floor(getLast('cache-hit') * 100),
-      average: Math.floor(getAverage("cache-hit") * 100),
+      average: Math.floor(getAverage('cache-hit') * 100)
     };
   });
 
@@ -87,10 +85,10 @@
     return Object.entries(source)
       .filter(
         ([key]) =>
-          !key.startsWith("node/") &&
+          !key.startsWith('node/')
-          key !== "total" &&
+          && key !== 'total'
-          !key.includes("cache") &&
+          && !key.includes('cache')
-          !viewerKeys.includes(key),
+          && !viewerKeys.includes(key)
       )
       .sort((a, b) => b[1] - a[1]);
   });
@@ -98,7 +96,7 @@
   const nodePerformanceData = $derived.by(() => {
     const source = showAverage ? averages : lasts;
     return Object.entries(source)
-      .filter(([key]) => key.startsWith("node/"))
+      .filter(([key]) => key.startsWith('node/'))
       .sort((a, b) => b[1] - a[1]);
   });
 
@@ -107,9 +105,9 @@
     return Object.entries(source)
       .filter(
         ([key]) =>
-          key !== "total-vertices" &&
+          key !== 'total-vertices'
-          key !== "total-faces" &&
+          && key !== 'total-faces'
-          viewerKeys.includes(key),
+          && viewerKeys.includes(key)
       )
       .sort((a, b) => b[1] - a[1]);
   });
@@ -117,15 +115,15 @@
   const splitValues = $derived.by(() => {
     if (showAverage) {
       return [
-        getAverage("worker-transfer"),
+        getAverage('worker-transfer'),
-        getAverage("runtime"),
+        getAverage('runtime'),
-        getAverage("update-geometries"),
+        getAverage('update-geometries')
       ];
     }
     return [
-      getLast("worker-transfer"),
+      getLast('worker-transfer'),
-      getLast("runtime"),
+      getLast('runtime'),
-      getLast("update-geometries"),
+      getLast('update-geometries')
     ];
   });
 
@@ -133,24 +131,24 @@
     if (showAverage) {
       return data.map((run) => {
         return (
-          (run["runtime"]?.reduce((acc, v) => acc + v, 0) || 0) +
+          (run['runtime']?.reduce((acc, v) => acc + v, 0) || 0)
-          (run["update-geometries"]?.reduce((acc, v) => acc + v, 0) || 0) +
+          + (run['update-geometries']?.reduce((acc, v) => acc + v, 0) || 0)
-          (run["worker-transfer"]?.reduce((acc, v) => acc + v, 0) || 0)
+          + (run['worker-transfer']?.reduce((acc, v) => acc + v, 0) || 0)
         );
       });
     }
 
     return data.map((run) => {
       return (
-        (run["runtime"]?.[0] || 0) +
+        (run['runtime']?.[0] || 0)
-        (run["update-geometries"]?.[0] || 0) +
+        + (run['update-geometries']?.[0] || 0)
-        (run["worker-transfer"]?.[0] || 0)
+        + (run['worker-transfer']?.[0] || 0)
       );
     });
   });
 
   function constructPoints(key: string) {
-    if (key === "total") {
+    if (key === 'total') {
       return totalPoints;
     }
     return data.map((run) => {
@@ -166,21 +164,21 @@
   }
 
   const computedTotalDisplay = $derived.by(() =>
-    round(showAverage ? totalPerformance.average : totalPerformance.onlyLast),
+    round(showAverage ? totalPerformance.average : totalPerformance.onlyLast)
   );
 
   const computedFps = $derived.by(() =>
     Math.floor(
-      1000 /
+      1000
-        (showAverage
+        / (showAverage
           ? totalPerformance.average || 1
-          : totalPerformance.onlyLast || 1),
+          : totalPerformance.onlyLast || 1)
-    ),
+    )
   );
 </script>
 
 {#if data.length !== 0}
-  {#if activeType === "cache-hit"}
+  {#if activeType === 'cache-hit'}
     <Monitor
       title="Cache Hits"
       points={constructPoints(activeType)}
@@ -197,12 +195,12 @@
 
   <div class="p-4 performance-tabler">
     <div class="flex items-center gap-2">
-      <Checkbox id="show-total" bind:value={showAverage} />
+      <InputCheckbox id="show-total" bind:value={showAverage} />
       <label for="show-total">Show Average</label>
     </div>
 
     <BarSplit
-      labels={["worker-transfer", "runtime", "update-geometries"]}
+      labels={['worker-transfer', 'runtime', 'update-geometries']}
       values={splitValues}
     />
 
@@ -215,14 +213,14 @@
             {computedTotalDisplay}<span>ms</span>
           </td>
           <td
-            class:active={activeType === "total"}
+            class:active={activeType === 'total'}
-            onclick={() => (activeType = "total")}
+            onclick={() => (activeType = 'total')}
           >
             total<span>({computedFps}fps)</span>
           </td>
         </tr>
 
-        {#each performanceData as [key, value]}
+        {#each performanceData as [key, value] (key)}
           <tr>
             <td>{round(value)}<span>ms</span></td>
             <td
@@ -246,27 +244,23 @@
 
       <tbody>
         <tr>
+          <td>{showAverage ? cacheRatio.average : cacheRatio.onlyLast}<span>%</span></td>
           <td
-            >{showAverage ? cacheRatio.average : cacheRatio.onlyLast}<span
+            class:active={activeType === 'cache-hit'}
-              >%</span
+            onclick={() => (activeType = 'cache-hit')}
-            ></td
-          >
-          <td
-            class:active={activeType === "cache-hit"}
-            onclick={() => (activeType = "cache-hit")}
           >
             cache hits
           </td>
         </tr>
 
-        {#each nodePerformanceData as [key, value]}
+        {#each nodePerformanceData as [key, value] (key)}
           <tr>
             <td>{round(value)}<span>ms</span></td>
             <td
               class:active={activeType === key}
               onclick={() => (activeType = key)}
             >
-              {key.split("/").slice(-1).join("/")}
+              {key.split('/').slice(-1).join('/')}
             </td>
           </tr>
         {/each}
@@ -278,22 +272,22 @@
 
       <tbody>
         <tr>
-          <td>{humanizeNumber(getLast("total-vertices"))}</td>
+          <td>{humanizeNumber(getLast('total-vertices'))}</td>
           <td>Vertices</td>
         </tr>
         <tr>
-          <td>{humanizeNumber(getLast("total-faces"))}</td>
+          <td>{humanizeNumber(getLast('total-faces'))}</td>
           <td>Faces</td>
         </tr>
 
-        {#each viewerPerformanceData as [key, value]}
+        {#each viewerPerformanceData as [key, value] (key)}
           <tr>
             <td>{round(value)}<span>ms</span></td>
             <td
               class:active={activeType === key}
               onclick={() => (activeType = key)}
             >
-              {key.split("/").slice(-1).join("/")}
+              {key.split('/').slice(-1).join('/')}
             </td>
           </tr>
         {/each}

app/src/lib/performance/SmallGraph.svelte

@@ -10,7 +10,7 @@
         const y = 100 - ((point - min) / (max - min)) * 100;
         return `${x},${y}`;
       })
-      .join(" ");
+      .join(' ');
   });
 </script>
 
@@ -25,7 +25,7 @@
   }
   polyline {
     fill: none;
-    stroke: var(--layer-3);
+    stroke: var(--color-layer-3);
     opacity: 1;
     stroke-width: 1;
   }

app/src/lib/performance/SmallPerformanceViewer.svelte

@@ -1,19 +1,19 @@
 <script lang="ts">
-  import { humanizeDuration, humanizeNumber } from "$lib/helpers";
+  import { humanizeDuration, humanizeNumber } from '$lib/helpers';
-  import { localState } from "$lib/helpers/localState.svelte";
+  import { localState } from '$lib/helpers/localState.svelte';
-  import SmallGraph from "./SmallGraph.svelte";
+  import type { PerformanceData, PerformanceStore } from '@nodarium/utils';
-  import type { PerformanceData, PerformanceStore } from "@nodarium/utils";
+  import SmallGraph from './SmallGraph.svelte';
 
   const { store, fps }: { store: PerformanceStore; fps: number[] } = $props();
 
-  const open = localState("node.performance.small.open", {
+  const open = localState('node.performance.small.open', {
     runtime: false,
-    fps: false,
+    fps: false
   });
 
-  const vertices = $derived($store?.at(-1)?.["total-vertices"]?.[0] || 0);
+  const vertices = $derived($store?.at(-1)?.['total-vertices']?.[0] || 0);
-  const faces = $derived($store?.at(-1)?.["total-faces"]?.[0] || 0);
+  const faces = $derived($store?.at(-1)?.['total-faces']?.[0] || 0);
-  const runtime = $derived($store?.at(-1)?.["runtime"]?.[0] || 0);
+  const runtime = $derived($store?.at(-1)?.['runtime']?.[0] || 0);
 
   function getPoints(data: PerformanceData, key: string) {
     return data?.map((run) => run[key]?.[0] || 0) || [];
@@ -24,25 +24,25 @@
   <table>
     <tbody>
       <tr
-        style="cursor:pointer;"
+        style="cursor: pointer"
         onclick={() => (open.value.runtime = !open.value.runtime)}
       >
-        <td>{open.value.runtime ? "-" : "+"} runtime </td>
+        <td>{open.value.runtime ? '-' : '+'} runtime</td>
         <td>{humanizeDuration(runtime || 1000)}</td>
       </tr>
       {#if open.value.runtime}
         <tr>
           <td colspan="2">
-            <SmallGraph points={getPoints($store, "runtime")} />
+            <SmallGraph points={getPoints($store, 'runtime')} />
           </td>
         </tr>
       {/if}
 
       <tr
-        style="cursor:pointer;"
+        style="cursor: pointer"
         onclick={() => (open.value.fps = !open.value.fps)}
       >
-        <td>{open.value.fps ? "-" : "+"} fps </td>
+        <td>{open.value.fps ? '-' : '+'} fps</td>
         <td>
           {Math.floor(fps[fps.length - 1])}fps
         </td>
@@ -56,12 +56,12 @@
       {/if}
 
       <tr>
-        <td>vertices </td>
+        <td>vertices</td>
         <td>{humanizeNumber(vertices || 0)}</td>
       </tr>
 
       <tr>
-        <td>faces </td>
+        <td>faces</td>
         <td>{humanizeNumber(faces || 0)}</td>
       </tr>
     </tbody>
@@ -74,14 +74,14 @@
     top: 10px;
     left: 10px;
     z-index: 2;
-    background: var(--layer-0);
+    background: var(--color-layer-0);
-    border: solid thin var(--outline);
+    border: solid thin var(--color-outline);
     border-collapse: collapse;
   }
   td {
     padding: 4px;
     padding-inline: 8px;
     font-size: 0.8em;
-    border: solid thin var(--outline);
+    border: solid thin var(--color-outline);
   }
 </style>

app/src/lib/performance/index.ts

@@ -1 +1 @@
-export { default as PerformanceViewer } from "./PerformanceViewer.svelte";
+export { default as PerformanceViewer } from './PerformanceViewer.svelte';

app/src/lib/project-manager/ProjectManager.svelte

@@ -1,43 +1,42 @@
 <script lang="ts">
-  import type { Graph } from "$lib/types";
+  import { defaultPlant, lottaFaces, plant, simple } from '$lib/graph-templates';
-  import { defaultPlant, plant, lottaFaces } from "$lib/graph-templates";
+  import type { Graph } from '$lib/types';
-  import type { ProjectManager } from "./project-manager.svelte";
+  import { InputSelect } from '@nodarium/ui';
+  import type { ProjectManager } from './project-manager.svelte';
 
   const { projectManager } = $props<{ projectManager: ProjectManager }>();
 
   let showNewProject = $state(false);
-  let newProjectName = $state("");
+  let newProjectName = $state('');
-  let selectedTemplate = $state("defaultPlant");
 
   const templates = [
     {
-      name: "Default Plant",
+      name: 'Default Plant',
-      value: "defaultPlant",
+      value: 'defaultPlant',
-      graph: defaultPlant as unknown as Graph,
+      graph: defaultPlant as unknown as Graph
     },
-    { name: "Plant", value: "plant", graph: plant as unknown as Graph },
+    { name: 'Plant', value: 'plant', graph: plant as unknown as Graph },
+    { name: 'Simple', value: 'simple', graph: simple as unknown as Graph },
     {
-      name: "Lotta Faces",
+      name: 'Lotta Faces',
-      value: "lottaFaces",
+      value: 'lottaFaces',
-      graph: lottaFaces as unknown as Graph,
+      graph: lottaFaces as unknown as Graph
-    },
+    }
   ];
+  let selectedTemplateIndex = $state(0);
 
   function handleCreate() {
-    const template =
+    const template = templates[selectedTemplateIndex] || templates[0];
-      templates.find((t) => t.value === selectedTemplate) || templates[0];
     projectManager.handleCreateProject(template.graph, newProjectName);
-    newProjectName = "";
+    newProjectName = '';
     showNewProject = false;
   }
 </script>
 
-<header
+<header class="flex justify-between px-4 h-[70px] border-b-1 border-outline items-center bg-layer-2">
-  class="flex justify-between px-4 h-[70px] border-b-1 border-[var(--outline)] items-center"
->
   <h3>Project</h3>
   <button
-    class="px-3 py-1 bg-[var(--layer-0)] rounded"
+    class="px-3 py-1 bg-layer-1 rounded"
     onclick={() => (showNewProject = !showNewProject)}
   >
     New
@@ -45,24 +44,17 @@
 </header>
 
 {#if showNewProject}
-  <div class="flex flex-col px-4 py-3 border-b-1 border-[var(--outline)] gap-2">
+  <div class="flex flex-col px-4 py-3.5 mt-[1px] border-b-1 border-outline gap-3">
     <input
       type="text"
       bind:value={newProjectName}
       placeholder="Project name"
-      class="w-full px-2 py-2 bg-gray-800 border border-gray-700 rounded"
+      class="w-full px-2 py-2 bg-layer-2 rounded"
-      onkeydown={(e) => e.key === "Enter" && handleCreate()}
+      onkeydown={(e) => e.key === 'Enter' && handleCreate()}
     />
-    <select
+    <InputSelect options={templates.map(t => t.name)} bind:value={selectedTemplateIndex} />
-      bind:value={selectedTemplate}
-      class="w-full px-2 py-2 bg-gray-800 border border-gray-700 rounded"
-    >
-      {#each templates as template}
-        <option value={template.value}>{template.name}</option>
-      {/each}
-    </select>
     <button
-      class="cursor-pointer self-end px-3 py-1 bg-blue-600 rounded"
+      class="cursor-pointer self-end px-3 py-1 bg-selected rounded"
       onclick={() => handleCreate()}
     >
       Create
@@ -70,30 +62,34 @@
   </div>
 {/if}
 
-<div class="p-4 text-white min-h-screen">
+<div class="text-white min-h-screen">
   {#if projectManager.loading}
     <p>Loading...</p>
   {/if}
 
-  <ul class="space-y-2">
+  <ul>
     {#each projectManager.projects as project (project.id)}
       <li>
         <div
-          class="w-full text-left px-3 py-2 rounded cursor-pointer {projectManager
+          class="
+            h-[70px] border-b-1 border-b-outline
+            flex
+            w-full text-left px-3 py-2 cursor-pointer {projectManager
             .activeProjectId.value === project.id
-            ? 'bg-blue-600'
+            ? 'border-l-2 border-l-selected pl-2.5!'
-            : 'bg-gray-800 hover:bg-gray-700'}"
+            : ''}
+          "
           onclick={() => projectManager.handleSelectProject(project.id!)}
           role="button"
           tabindex="0"
           onkeydown={(e) =>
-            e.key === "Enter" &&
+          e.key === 'Enter'
-            projectManager.handleSelectProject(project.id!)}
+          && projectManager.handleSelectProject(project.id!)}
         >
-          <div class="flex justify-between items-center">
+          <div class="flex justify-between items-center grow">
-            <span>{project.meta?.title || "Untitled"}</span>
+            <span>{project.meta?.title || 'Untitled'}</span>
             <button
-              class="text-red-400 hover:text-red-300"
+              class="text-layer-1! bg-red-500 w-7 text-xl rounded-sm cursor-pointer opacity-20 hover:opacity-80"
               onclick={() => {
                 projectManager.handleDeleteProject(project.id!);
               }}

app/src/lib/project-manager/project-database.svelte.ts

@@ -31,6 +31,7 @@ export async function getGraph(id: number): Promise<Graph | undefined> {
 
 export async function saveGraph(graph: Graph): Promise<Graph> {
   const db = await getDB();
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
   graph.meta = { ...graph.meta, lastModified: new Date().toISOString() };
   await db.put(STORE_NAME, graph);
   return graph;

app/src/lib/project-manager/project-manager.svelte.ts

@@ -25,7 +25,7 @@ export class ProjectManager {
     this.projects = await db.getGraphs();
 
     if (this.activeProjectId.value !== undefined) {
-      let loadedGraph = await db.getGraph(this.activeProjectId.value);
+      const loadedGraph = await db.getGraph(this.activeProjectId.value);
       if (loadedGraph) {
         this.graph = loadedGraph;
       }
@@ -54,7 +54,7 @@ export class ProjectManager {
 
     g.id = id;
     if (!g.meta) g.meta = {};
-    if (!g.meta.title) g.meta.title = title;
+    g.meta.title = title;
 
     db.saveGraph(g);
     this.projects = [...this.projects, g];

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

@@ -1,11 +1,11 @@
 <script lang="ts">
-  import localStore from "$lib/helpers/localStore";
+  import localStore from '$lib/helpers/localStore';
-  import { T, useTask } from "@threlte/core";
+  import { T, useTask } from '@threlte/core';
-  import { OrbitControls } from "@threlte/extras";
+  import { OrbitControls } from '@threlte/extras';
-  import { onMount } from "svelte";
+  import { onMount } from 'svelte';
-  import { Vector3 } from "three";
+  import { Vector3 } from 'three';
-  import type { PerspectiveCamera, Vector3Tuple } from "three";
+  import type { PerspectiveCamera, Vector3Tuple } from 'three';
-  import type { OrbitControls as OrbitControlsType } from "three/examples/jsm/controls/OrbitControls.js";
+  import type { OrbitControls as OrbitControlsType } from 'three/examples/jsm/controls/OrbitControls.js';
 
   let camera = $state<PerspectiveCamera>();
   let controls = $state<OrbitControlsType>();
@@ -20,9 +20,9 @@
   const cameraTransform = localStore<{
     camera: Vector3Tuple;
     target: Vector3Tuple;
-  }>("nodes.camera.transform", {
+  }>('nodes.camera.transform', {
     camera: [10, 10, 10],
-    target: [0, 0, 0],
+    target: [0, 0, 0]
   });
 
   function saveCameraState() {
@@ -33,7 +33,7 @@
     if (tPos.some((v) => isNaN(v)) || cPos.some((v) => isNaN(v))) return;
     $cameraTransform = {
       camera: cPos,
-      target: tPos,
+      target: tPos
     };
   }
 
@@ -54,13 +54,13 @@
 
   $effect(() => {
     if (
-      center &&
+      center
-      controls &&
+      && controls
-      centerCamera &&
+      && centerCamera
-      (center.x !== controls.target.x ||
+      && (center.x !== controls.target.x
-        center.y !== controls.target.y ||
+        || center.y !== controls.target.y
-        center.z !== controls.target.z) &&
+        || center.z !== controls.target.z)
-      !isRunning
+      && !isRunning
     ) {
       isRunning = true;
       task.start();

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

@@ -1,23 +1,18 @@
 <script lang="ts">
-  import { T, useTask, useThrelte } from "@threlte/core";
+  import { colors } from '$lib/graph-interface/graph/colors.svelte';
+  import { T, useTask, useThrelte } from '@threlte/core';
+  import { Grid, MeshLineGeometry, MeshLineMaterial, Text } from '@threlte/extras';
   import {
-    Grid,
-    MeshLineGeometry,
-    MeshLineMaterial,
-    Text,
-  } from "@threlte/extras";
-  import {
-    type Group,
-    type BufferGeometry,
-    Vector3,
-    type Vector3Tuple,
     Box3,
+    type BufferGeometry,
+    type Group,
     Mesh,
     MeshBasicMaterial,
-  } from "three";
+    Vector3,
-  import { appSettings } from "../settings/app-settings.svelte";
+    type Vector3Tuple
-  import Camera from "./Camera.svelte";
+  } from 'three';
-  import { colors } from "$lib/graph-interface/graph/colors.svelte";
+  import { appSettings } from '../settings/app-settings.svelte';
+  import Camera from './Camera.svelte';
 
   const { renderStage, invalidate: _invalidate } = useThrelte();
 
@@ -32,7 +27,7 @@
     lines,
     centerCamera,
     fps = $bindable(),
-    scene = $bindable(),
+    scene = $bindable()
   }: Props = $props();
 
   let geometries = $state.raw<BufferGeometry[]>([]);
@@ -43,13 +38,13 @@
       fps.push(1 / delta);
       fps = fps.slice(-100);
     },
-    { stage: renderStage, autoInvalidate: false },
+    { stage: renderStage, autoInvalidate: false }
   );
 
-  export const invalidate = function () {
+  export const invalidate = function() {
     if (scene) {
       const geos: BufferGeometry[] = [];
-      scene.traverse(function (child) {
+      scene.traverse(function(child) {
         if (isMesh(child)) {
           geos.push(child.geometry);
         }
@@ -67,17 +62,29 @@
     _invalidate();
   };
 
-  function isMesh(child: Mesh | any): child is Mesh {
+  function isMesh(child: unknown): child is Mesh {
-    return child.isObject3D && "material" in child;
+    return (
+      child !== null
+      && typeof child === 'object'
+      && 'isObject3D' in child
+      && child.isObject3D === true
+      && 'material' in child
+    );
   }
 
-  function isMatCapMaterial(material: any): material is MeshBasicMaterial {
+  function isMatCapMaterial(material: unknown): material is MeshBasicMaterial {
-    return material.isMaterial && "matcap" in material;
+    return (
+      material !== null
+      && typeof material === 'object'
+      && 'isMaterial' in material
+      && material.isMaterial === true
+      && 'matcap' in material
+    );
   }
 
   $effect(() => {
     const wireframe = appSettings.value.debug.wireframe;
-    scene.traverse(function (child) {
+    scene.traverse(function(child) {
       if (isMesh(child) && isMatCapMaterial(child.material) && child.visible) {
         child.material.wireframe = wireframe;
       }
@@ -89,7 +96,7 @@
     return [
       geo.attributes.position.array[i],
       geo.attributes.position.array[i + 1],
-      geo.attributes.position.array[i + 2],
+      geo.attributes.position.array[i + 2]
     ] as Vector3Tuple;
   }
 </script>
@@ -98,12 +105,12 @@
 
 {#if appSettings.value.showGrid}
   <Grid
-    cellColor={colors["outline"]}
+    cellColor={colors['outline']}
     cellThickness={0.7}
     infiniteGrid
     sectionThickness={0.7}
     sectionDistance={2}
-    sectionColor={colors["outline"]}
+    sectionColor={colors['outline']}
     fadeDistance={50}
     fadeStrength={10}
     fadeOrigin={new Vector3(0, 0, 0)}
@@ -112,9 +119,9 @@
 
 <T.Group>
   {#if geometries}
-    {#each geometries as geo}
+    {#each geometries as geo (geo.id)}
       {#if appSettings.value.debug.showIndices}
-        {#each geo.attributes.position.array as _, i}
+        {#each geo.attributes.position.array, i (i)}
           {#if i % 3 === 0}
             <Text fontSize={0.25} position={getPosition(geo, i)} />
           {/if}
@@ -134,7 +141,7 @@
 </T.Group>
 
 {#if appSettings.value.debug.showStemLines && lines}
-  {#each lines as line}
+  {#each lines as line (line[0].x + '-' + line[0].y + '-' + '' + line[0].z)}
     <T.Mesh>
       <MeshLineGeometry points={line} />
       <MeshLineMaterial width={0.1} color="red" depthTest={false} />

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

@@ -1,23 +1,20 @@
 <script lang="ts">
-  import { Canvas } from "@threlte/core";
+  import SmallPerformanceViewer from '$lib/performance/SmallPerformanceViewer.svelte';
-  import Scene from "./Scene.svelte";
+  import { appSettings } from '$lib/settings/app-settings.svelte';
-  import { Vector3 } from "three";
+  import { decodeFloat, splitNestedArray } from '@nodarium/utils';
-  import { decodeFloat, splitNestedArray } from "@nodarium/utils";
+  import type { PerformanceStore } from '@nodarium/utils';
-  import type { PerformanceStore } from "@nodarium/utils";
+  import { Canvas } from '@threlte/core';
-  import { appSettings } from "$lib/settings/app-settings.svelte";
+  import { Vector3 } from 'three';
-  import SmallPerformanceViewer from "$lib/performance/SmallPerformanceViewer.svelte";
+  import { type Group, MeshMatcapMaterial, TextureLoader } from 'three';
-  import { MeshMatcapMaterial, TextureLoader, type Group } from "three";
+  import { createGeometryPool, createInstancedGeometryPool } from './geometryPool';
-  import {
+  import Scene from './Scene.svelte';
-    createGeometryPool,
-    createInstancedGeometryPool,
-  } from "./geometryPool";
 
   const loader = new TextureLoader();
-  const matcap = loader.load("/matcap_green.jpg");
+  const matcap = loader.load('/matcap_green.jpg');
-  matcap.colorSpace = "srgb";
+  matcap.colorSpace = 'srgb';
   const material = new MeshMatcapMaterial({
     color: 0xffffff,
-    matcap,
+    matcap
   });
 
   let sceneComponent = $state<ReturnType<typeof Scene>>();
@@ -34,7 +31,7 @@
 
     return {
       totalFaces: meshes.totalFaces + faces.totalFaces,
-      totalVertices: meshes.totalVertices + faces.totalVertices,
+      totalVertices: meshes.totalVertices + faces.totalVertices
     };
   }
 
@@ -64,12 +61,12 @@
   }
 
   export const update = function update(result: Int32Array) {
-    perf.addPoint("split-result");
+    perf.addPoint('split-result');
     const inputs = splitNestedArray(result);
     perf.endPoint();
 
     if (appSettings.value.debug.showStemLines) {
-      perf.addPoint("create-lines");
+      perf.addPoint('create-lines');
       lines = inputs
         .map((input) => {
           if (input[0] === 0) {
@@ -80,13 +77,13 @@
       perf.endPoint();
     }
 
-    perf.addPoint("update-geometries");
+    perf.addPoint('update-geometries');
 
     const { totalVertices, totalFaces } = updateGeometries(inputs, scene);
     perf.endPoint();
 
-    perf.addPoint("total-vertices", totalVertices);
+    perf.addPoint('total-vertices', totalVertices);
-    perf.addPoint("total-faces", totalFaces);
+    perf.addPoint('total-faces', totalFaces);
     sceneComponent?.invalidate();
   };
 </script>

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

@@ -1,4 +1,4 @@
-import { fastHashArrayBuffer } from "@nodarium/utils";
+import { fastHashArrayBuffer } from '@nodarium/utils';
 import {
   BufferAttribute,
   BufferGeometry,
@@ -7,14 +7,14 @@ import {
   InstancedMesh,
   Material,
   Matrix4,
-  Mesh,
+  Mesh
-} from "three";
+} from 'three';
 
 function fastArrayHash(arr: Int32Array) {
   const sampleDistance = Math.max(Math.floor(arr.length / 1000), 1);
   const sampleCount = Math.floor(arr.length / sampleDistance);
 
-  let hash = new Int32Array(sampleCount);
+  const hash = new Int32Array(sampleCount);
 
   for (let i = 0; i < sampleCount; i++) {
     const index = i * sampleDistance;
@@ -28,18 +28,18 @@ export function createGeometryPool(parentScene: Group, material: Material) {
   const scene = new Group();
   parentScene.add(scene);
 
-  let meshes: Mesh[] = [];
+  const meshes: Mesh[] = [];
 
   let totalVertices = 0;
   let totalFaces = 0;
 
   function updateSingleGeometry(
     data: Int32Array,
-    existingMesh: Mesh | null = null,
+    existingMesh: Mesh | null = null
   ) {
-    let hash = fastArrayHash(data);
+    const hash = fastArrayHash(data);
 
-    let geometry = existingMesh ? existingMesh.geometry : new BufferGeometry();
+    const geometry = existingMesh ? existingMesh.geometry : new BufferGeometry();
     if (existingMesh) {
       existingMesh.visible = true;
     }
@@ -65,8 +65,8 @@ export function createGeometryPool(parentScene: Group, material: Material) {
     const vertices = new Float32Array(data.buffer, index * 4, vertexCount * 3);
     index = index + vertexCount * 3;
 
-    let posAttribute = geometry.getAttribute(
+    const posAttribute = geometry.getAttribute(
-      "position",
+      'position'
     ) as BufferAttribute | null;
 
     if (posAttribute && posAttribute.count === vertexCount) {
@@ -74,8 +74,8 @@ export function createGeometryPool(parentScene: Group, material: Material) {
       posAttribute.needsUpdate = true;
     } else {
       geometry.setAttribute(
-        "position",
+        'position',
-        new Float32BufferAttribute(vertices, 3),
+        new Float32BufferAttribute(vertices, 3)
       );
     }
 
@@ -83,27 +83,27 @@ export function createGeometryPool(parentScene: Group, material: Material) {
     index = index + vertexCount * 3;
 
     if (
-      geometry.userData?.faceCount !== faceCount ||
+      geometry.userData?.faceCount !== faceCount
-      geometry.userData?.vertexCount !== vertexCount
+      || geometry.userData?.vertexCount !== vertexCount
     ) {
       // Add data to geometry
       geometry.setIndex([...indices]);
     }
 
     const normalsAttribute = geometry.getAttribute(
-      "normal",
+      'normal'
     ) as BufferAttribute | null;
     if (normalsAttribute && normalsAttribute.count === vertexCount) {
       normalsAttribute.set(normals, 0);
       normalsAttribute.needsUpdate = true;
     } else {
-      geometry.setAttribute("normal", new Float32BufferAttribute(normals, 3));
+      geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
     }
 
     geometry.userData = {
       vertexCount,
       faceCount,
-      hash,
+      hash
     };
 
     if (!existingMesh) {
@@ -119,7 +119,7 @@ export function createGeometryPool(parentScene: Group, material: Material) {
       totalFaces = 0;
       for (let i = 0; i < Math.max(newData.length, meshes.length); i++) {
         const existingMesh = meshes[i];
-        let input = newData[i];
+        const input = newData[i];
         if (input) {
           updateSingleGeometry(input, existingMesh || null);
         } else if (existingMesh) {
@@ -127,13 +127,13 @@ export function createGeometryPool(parentScene: Group, material: Material) {
         }
       }
       return { totalVertices, totalFaces };
-    },
+    }
   };
 }
 
 export function createInstancedGeometryPool(
   parentScene: Group,
-  material: Material,
+  material: Material
 ) {
   const scene = new Group();
   parentScene.add(scene);
@@ -144,11 +144,11 @@ export function createInstancedGeometryPool(
 
   function updateSingleInstance(
     data: Int32Array,
-    existingInstance: InstancedMesh | null = null,
+    existingInstance: InstancedMesh | null = null
   ) {
-    let hash = fastArrayHash(data);
+    const hash = fastArrayHash(data);
 
-    let geometry = existingInstance
+    const geometry = existingInstance
       ? existingInstance.geometry
       : new BufferGeometry();
 
@@ -169,8 +169,8 @@ export function createInstancedGeometryPool(
     const indices = data.subarray(index, indicesEnd);
     index = indicesEnd;
     if (
-      geometry.userData?.faceCount !== faceCount ||
+      geometry.userData?.faceCount !== faceCount
-      geometry.userData?.vertexCount !== vertexCount
+      || geometry.userData?.vertexCount !== vertexCount
     ) {
       // Add data to geometry
       geometry.setIndex([...indices]);
@@ -179,34 +179,34 @@ export function createInstancedGeometryPool(
     // Vertices
     const vertices = new Float32Array(data.buffer, index * 4, vertexCount * 3);
     index = index + vertexCount * 3;
-    let posAttribute = geometry.getAttribute(
+    const posAttribute = geometry.getAttribute(
-      "position",
+      'position'
     ) as BufferAttribute | null;
     if (posAttribute && posAttribute.count === vertexCount) {
       posAttribute.set(vertices, 0);
       posAttribute.needsUpdate = true;
     } else {
       geometry.setAttribute(
-        "position",
+        'position',
-        new Float32BufferAttribute(vertices, 3),
+        new Float32BufferAttribute(vertices, 3)
       );
     }
 
     const normals = new Float32Array(data.buffer, index * 4, vertexCount * 3);
     index = index + vertexCount * 3;
     const normalsAttribute = geometry.getAttribute(
-      "normal",
+      'normal'
     ) as BufferAttribute | null;
     if (normalsAttribute && normalsAttribute.count === vertexCount) {
       normalsAttribute.set(normals, 0);
       normalsAttribute.needsUpdate = true;
     } else {
-      geometry.setAttribute("normal", new Float32BufferAttribute(normals, 3));
+      geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
     }
 
     if (
-      existingInstance &&
+      existingInstance
-      instanceCount > existingInstance.geometry.userData.count
+      && instanceCount > existingInstance.geometry.userData.count
     ) {
       scene.remove(existingInstance);
       instances.splice(instances.indexOf(existingInstance), 1);
@@ -226,12 +226,12 @@ export function createInstancedGeometryPool(
     const matrices = new Float32Array(
       data.buffer,
       index * 4,
-      instanceCount * 16,
+      instanceCount * 16
     );
 
     for (let i = 0; i < instanceCount; i++) {
       const matrix = new Matrix4().fromArray(
-        matrices.subarray(i * 16, i * 16 + 16),
+        matrices.subarray(i * 16, i * 16 + 16)
       );
       existingInstance.setMatrixAt(i, matrix);
     }
@@ -241,9 +241,9 @@ export function createInstancedGeometryPool(
       faceCount,
       count: Math.max(
         instanceCount,
-        existingInstance.geometry.userData.count || 0,
+        existingInstance.geometry.userData.count || 0
       ),
-      hash,
+      hash
     };
 
     existingInstance.instanceMatrix.needsUpdate = true;
@@ -255,7 +255,7 @@ export function createInstancedGeometryPool(
       totalFaces = 0;
       for (let i = 0; i < Math.max(newData.length, instances.length); i++) {
         const existingMesh = instances[i];
-        let input = newData[i];
+        const input = newData[i];
         if (input) {
           updateSingleInstance(input, existingMesh || null);
         } else if (existingMesh) {
@@ -263,6 +263,6 @@ export function createInstancedGeometryPool(
         }
       }
       return { totalVertices, totalFaces };
-    },
+    }
   };
 }

app/src/lib/runtime/index.ts

@@ -1,4 +1,3 @@
-export * from "./runtime-executor"
+export * from './runtime-executor';
-export * from "./runtime-executor-cache"
+export * from './runtime-executor-cache';
-export * from "./worker-runtime-executor"
+export * from './worker-runtime-executor';
-

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

@@ -1,18 +1,18 @@
-import type { Graph, RuntimeExecutor } from "@nodarium/types";
+import type { Graph, RuntimeExecutor } from '@nodarium/types';
 
 export class RemoteRuntimeExecutor implements RuntimeExecutor {
+  constructor(private url: string) {}
 
-  constructor(private url: string) { }
+  async execute(graph: Graph, settings: Record<string, unknown>): Promise<Int32Array> {
-
+    const res = await fetch(this.url, {
-  async execute(graph: Graph, settings: Record<string, any>): Promise<Int32Array> {
+      method: 'POST',
-
+      body: JSON.stringify({ graph, settings })
-    const res = await fetch(this.url, { method: "POST", body: JSON.stringify({ graph, settings }) });
+    });
 
     if (!res.ok) {
       throw new Error(`Failed to execute graph`);
     }
 
     return new Int32Array(await res.arrayBuffer());
-
   }
 }

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

@@ -1,4 +1,4 @@
-import { type SyncCache } from "@nodarium/types";
+import { type SyncCache } from '@nodarium/types';
 
 export class MemoryRuntimeCache implements SyncCache {
   private map = new Map<string, unknown>();

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

@@ -4,47 +4,47 @@ import type {
   NodeInput,
   NodeRegistry,
   RuntimeExecutor,
-  SyncCache,
+  SyncCache
-} from "@nodarium/types";
+} from '@nodarium/types';
 import {
   concatEncodedArrays,
   createLogger,
   encodeFloat,
   fastHashArrayBuffer,
-  type PerformanceStore,
+  type PerformanceStore
-} from "@nodarium/utils";
+} from '@nodarium/utils';
-import type { RuntimeNode } from "./types";
+import type { RuntimeNode } from './types';
 
-const log = createLogger("runtime-executor");
+const log = createLogger('runtime-executor');
 log.mute();
 
 function getValue(input: NodeInput, value?: unknown) {
-  if (value === undefined && "value" in input) {
+  if (value === undefined && 'value' in input) {
     value = input.value;
   }
 
-  if (input.type === "float") {
+  if (input.type === 'float') {
     return encodeFloat(value as number);
   }
 
   if (Array.isArray(value)) {
-    if (input.type === "vec3") {
+    if (input.type === 'vec3') {
       return [
         0,
         value.length + 1,
         ...value.map((v) => encodeFloat(v)),
         1,
-        1,
+        1
       ] as number[];
     }
     return [0, value.length + 1, ...value, 1, 1] as number[];
   }
 
-  if (typeof value === "boolean") {
+  if (typeof value === 'boolean') {
     return value ? 1 : 0;
   }
 
-  if (typeof value === "number") {
+  if (typeof value === 'number') {
     return value;
   }
 
@@ -64,14 +64,14 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
 
   constructor(
     private registry: NodeRegistry,
-    public cache?: SyncCache<Int32Array>,
+    public cache?: SyncCache<Int32Array>
   ) {
     this.cache = undefined;
   }
 
   private async getNodeDefinitions(graph: Graph) {
-    if (this.registry.status !== "ready") {
+    if (this.registry.status !== 'ready') {
-      throw new Error("Node registry is not ready");
+      throw new Error('Node registry is not ready');
     }
 
     await this.registry.load(graph.nodes.map((node) => node.type));
@@ -98,26 +98,23 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
         depth: 0,
         children: [],
         parents: [],
-        inputNodes: {},
+        inputNodes: {}
-      }
+      };
-      return n
+      return n;
-    })
+    });
 
-
+    const outputNode = graphNodes.find((node) => node.type.endsWith('/output'));
-    const outputNode = graphNodes.find((node) =>
-      node.type.endsWith("/output"),
-    );
     if (!outputNode) {
-      throw new Error("No output node found");
+      throw new Error('No output node found');
     }
 
     const nodeMap = new Map(
-      graphNodes.map((node) => [node.id, node]),
+      graphNodes.map((node) => [node.id, node])
     );
 
     // loop through all edges and assign the parent and child nodes to each node
     for (const edge of graph.edges) {
-      const [parentId, _parentOutput, childId, childInput] = edge;
+      const [parentId, /*_parentOutput*/, childId, childInput] = edge;
       const parent = nodeMap.get(parentId);
       const child = nodeMap.get(childId);
       if (parent && child) {
@@ -146,7 +143,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
   }
 
   async execute(graph: Graph, settings: Record<string, unknown>) {
-    this.perf?.addPoint("runtime");
+    this.perf?.addPoint('runtime');
 
     let a = performance.now();
 
@@ -154,7 +151,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
     const [outputNode, nodes] = await this.addMetaData(graph);
     let b = performance.now();
 
-    this.perf?.addPoint("collect-metadata", b - a);
+    this.perf?.addPoint('collect-metadata', b - a);
 
     /*
      * Here we sort the nodes into buckets, which we then execute one by one
@@ -169,13 +166,13 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
 
     // we execute the nodes from the bottom up
     const sortedNodes = nodes.sort(
-      (a, b) => (b.state?.depth || 0) - (a.state?.depth || 0),
+      (a, b) => (b.state?.depth || 0) - (a.state?.depth || 0)
     );
 
     // here we store the intermediate results of the nodes
     const results: Record<string, Int32Array> = {};
 
-    if (settings["randomSeed"]) {
+    if (settings['randomSeed']) {
       this.seed = Math.floor(Math.random() * 100000000);
     }
 
@@ -192,7 +189,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
       // Collect the inputs for the node
       const inputs = Object.entries(node_type.inputs || {}).map(
         ([key, input]) => {
-          if (input.type === "seed") {
+          if (input.type === 'seed') {
             return this.seed;
           }
 
@@ -206,7 +203,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
           if (inputNode) {
             if (results[inputNode.id] === undefined) {
               throw new Error(
-                `Node ${node.type} is missing input from node ${inputNode.type}`,
+                `Node ${node.type} is missing input from node ${inputNode.type}`
               );
             }
             return results[inputNode.id];
@@ -218,45 +215,45 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
           }
 
           return getValue(input);
-        },
+        }
       );
       b = performance.now();
 
-      this.perf?.addPoint("collected-inputs", b - a);
+      this.perf?.addPoint('collected-inputs', b - a);
 
       try {
         a = performance.now();
         const encoded_inputs = concatEncodedArrays(inputs);
         b = performance.now();
-        this.perf?.addPoint("encoded-inputs", b - a);
+        this.perf?.addPoint('encoded-inputs', b - a);
 
         a = performance.now();
-        let inputHash = `node-${node.id}-${fastHashArrayBuffer(encoded_inputs)}`;
+        const inputHash = `node-${node.id}-${fastHashArrayBuffer(encoded_inputs)}`;
         b = performance.now();
-        this.perf?.addPoint("hash-inputs", b - a);
+        this.perf?.addPoint('hash-inputs', b - a);
 
-        let cachedValue = this.cache?.get(inputHash);
+        const cachedValue = this.cache?.get(inputHash);
         if (cachedValue !== undefined) {
           log.log(`Using cached value for ${node_type.id || node.id}`);
-          this.perf?.addPoint("cache-hit", 1);
+          this.perf?.addPoint('cache-hit', 1);
           results[node.id] = cachedValue as Int32Array;
           continue;
         }
-        this.perf?.addPoint("cache-hit", 0);
+        this.perf?.addPoint('cache-hit', 0);
 
         log.group(`executing ${node_type.id}-${node.id}`);
         log.log(`Inputs:`, inputs);
         a = performance.now();
         results[node.id] = node_type.execute(encoded_inputs);
-        log.log("Executed", node.type, node.id)
+        log.log('Executed', node.type, node.id);
         b = performance.now();
 
         if (this.cache && node.id !== outputNode.id) {
           this.cache.set(inputHash, results[node.id]);
         }
 
-        this.perf?.addPoint("node/" + node_type.id, b - a);
+        this.perf?.addPoint('node/' + node_type.id, b - a);
-        log.log("Result:", results[node.id]);
+        log.log('Result:', results[node.id]);
         log.groupEnd();
       } catch (e) {
         log.groupEnd();
@@ -271,7 +268,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
       this.cache.size = sortedNodes.length * 2;
     }
 
-    this.perf?.endPoint("runtime");
+    this.perf?.endPoint('runtime');
 
     return res as unknown as Int32Array;
   }

app/src/lib/runtime/types.ts

@@ -1,10 +1,10 @@
-import type { SerializedNode } from "@nodarium/types";
+import type { SerializedNode } from '@nodarium/types';
 
 type RuntimeState = {
-  depth: number
+  depth: number;
-  parents: RuntimeNode[],
+  parents: RuntimeNode[];
-  children: RuntimeNode[],
+  children: RuntimeNode[];
-  inputNodes: Record<string, RuntimeNode>
+  inputNodes: Record<string, RuntimeNode>;
-}
+};
 
-export type RuntimeNode = SerializedNode & { state: RuntimeState }
+export type RuntimeNode = SerializedNode & { state: RuntimeState };

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

@@ -1,13 +1,13 @@
-import { MemoryRuntimeExecutor } from "./runtime-executor";
+import { IndexDBCache, RemoteNodeRegistry } from '$lib/node-registry/index';
-import { RemoteNodeRegistry, IndexDBCache } from "@nodarium/registry";
+import type { Graph } from '@nodarium/types';
-import type { Graph } from "@nodarium/types";
+import { createPerformanceStore } from '@nodarium/utils';
-import { createPerformanceStore } from "@nodarium/utils";
+import { MemoryRuntimeExecutor } from './runtime-executor';
-import { MemoryRuntimeCache } from "./runtime-executor-cache";
+import { MemoryRuntimeCache } from './runtime-executor-cache';
 
-const indexDbCache = new IndexDBCache("node-registry");
+const indexDbCache = new IndexDBCache('node-registry');
-const nodeRegistry = new RemoteNodeRegistry("", indexDbCache);
+const nodeRegistry = new RemoteNodeRegistry('', indexDbCache);
 
-const cache = new MemoryRuntimeCache()
+const cache = new MemoryRuntimeCache();
 const executor = new MemoryRuntimeExecutor(nodeRegistry, cache);
 
 const performanceStore = createPerformanceStore();
@@ -31,11 +31,11 @@ export async function setUseRuntimeCache(useCache: boolean) {
 
 export async function executeGraph(
   graph: Graph,
-  settings: Record<string, unknown>,
+  settings: Record<string, unknown>
 ): Promise<Int32Array> {
   await nodeRegistry.load(graph.nodes.map((n) => n.type));
   performanceStore.startRun();
-  let res = await executor.execute(graph, settings);
+  const res = await executor.execute(graph, settings);
   performanceStore.stopRun();
   return res;
 }