chore: format

.dprint.jsonc

@@ -13,12 +13,16 @@
   "markdown": {},
   "toml": {},
   "dockerfile": {},
+  "ruff": {},
+  "jupyter": {},
+  "malva": {},
   "markup": {
     // https://dprint.dev/plugins/markup_fmt/config/
     "scriptIndent": true,
     "styleIndent": true,
   },
   "yaml": {},
+  "graphql": {},
   "exec": {
     "cwd": "${configDir}",
     "commands": [
@@ -42,18 +46,20 @@
     "**/*-lock.yaml",
     "**/yaml.lock",
     "**/.DS_Store",
-    "**/.pnpm-store",
-    "**/.cargo",
-    "**/target",
   ],
   "plugins": [
-    "https://plugins.dprint.dev/typescript-0.95.15.wasm",
+    "https://plugins.dprint.dev/typescript-0.95.13.wasm",
     "https://plugins.dprint.dev/json-0.21.1.wasm",
-    "https://plugins.dprint.dev/markdown-0.21.1.wasm",
+    "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.6.0.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

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

.gitea/scripts/ci-checks.sh

@@ -1,18 +0,0 @@
-#!/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

@@ -5,21 +5,16 @@ TAG="$GITHUB_REF_NAME"
 VERSION=$(echo "$TAG" | sed 's/^v//')
 DATE=$(date +%Y-%m-%d)
 
-echo "🚀 Creating release for $TAG"
+echo "🚀 Creating release for $TAG (safe mode)"
 
 # -------------------------------------------------------------------
 # 1. Extract release notes from annotated tag
 # -------------------------------------------------------------------
 
-# Ensure the local git knows this is an annotated tag with metadata
+NOTES=$(git tag -l "$TAG" --format='%(contents)')
-git fetch origin "refs/tags/$TAG:refs/tags/$TAG" --force
 
-# %(contents) gets the whole message.
+if [ -z "$NOTES" ]; then
-# If you want ONLY what you typed after the first line, use %(contents:body)
+  echo "❌ Tag message is empty"
-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
 
@@ -28,39 +23,26 @@ 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
+
+find . -name package.json ! -path "*/node_modules/*" | while read 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
+# 3. Update CHANGELOG.md (prepend)
 # -------------------------------------------------------------------
-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 "## $TAG ($DATE)"
   echo ""
   echo "$NOTES"
   echo ""
-  if [ -n "$COMMITS" ]; then
+  echo "---"
-    echo "---"
-    echo "$COMMITS"
-    echo ""
-  fi
   echo ""
   if [ -f CHANGELOG.md ]; then
     cat CHANGELOG.md
@@ -69,23 +51,27 @@ tmp_changelog="CHANGELOG.tmp"
 
 mv "$tmp_changelog" CHANGELOG.md
 
-pnpm exec dprint fmt CHANGELOG.md
+# -------------------------------------------------------------------
+# 4. Create release commit
+# -------------------------------------------------------------------
 
-# -------------------------------------------------------------------
-# 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/*")
 
+# Skip commit if nothing changed
 if git diff --cached --quiet; then
   echo "No changes to commit for release $TAG"
-else
+  exit 0
-  git commit -m "chore(release): $TAG"
-  git push origin main
 fi
 
-rm app/static/CHANGELOG.md
+git commit -m "chore(release): $TAG"
-cp CHANGELOG.md app/static/CHANGELOG.md
+
-echo "✅ Release process for $TAG complete"
+# -------------------------------------------------------------------
+# 5. Push changes
+# -------------------------------------------------------------------
+
+git push origin main
+
+echo "✅ Release commit for $TAG created successfully (tag untouched)"

.gitea/scripts/deploy-files.sh

@@ -1,43 +0,0 @@
-#!/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

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

@@ -1,28 +1,24 @@
-name: 🚀 Lint & Test & Deploy
+name: 🚀 Release
 
 on:
   push:
     branches: ["*"]
     tags: ["*"]
-  pull_request:
-    branches: ["*"]
 
 env:
-  PNPM_CACHE_FOLDER: .pnpm-store
+  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
+    container: jimfx/nodes:latest
 
     steps:
       - name: 📑 Checkout Code
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ secrets.GITEA_TOKEN }}
+          token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: 💾 Setup pnpm Cache
         uses: actions/cache@v4
@@ -32,45 +28,31 @@ jobs:
           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
+      - name: 🧹 Lint
-        run: ./.gitea/scripts/ci-checks.sh
+        run: pnpm lint
+
+      - name: 🎨 Format Check
+        run: pnpm format:check
+
+      - name: 🧬 Type Check
+        run: pnpm check
 
       - name: 🛠️ Build
-        run: ./.gitea/scripts/build.sh
+        run: pnpm build:deploy
 
       - name: 🚀 Create Release Commit
-        if: gitea.ref_type == 'tag'
+        if: github.ref_type == 'tag'
         run: ./.gitea/scripts/create-release.sh
 
       - name: 🏷️ Create Gitea Release
-        if: gitea.ref_type == 'tag'
+        if: github.ref_type == 'tag'
         uses: akkuman/gitea-release-action@v1
         with:
-          tag_name: ${{ gitea.ref_name }}
+          tag_name: ${{ github.ref_name }}
-          release_name: Release ${{ gitea.ref_name }}
+          release_name: Release ${{ github.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 }}

CHANGELOG.md

@@ -1,70 +0,0 @@
-# v0.0.3 (2026-02-07)
-
-## Features
-
-- Edge dragging now highlights valid connection sockets, improving graph editing clarity.
-- InputNumber supports snapping to predefined values while holding Alt.
-- Changelog is accessible directly from the sidebar and now includes git metadata and a list of commits.
-
-## Fixes
-
-- Fixed incorrect socket highlighting when an edge already existed.
-- Corrected initialization of `InputNumber` values outside min/max bounds.
-- Fixed initialization of nested vec3 inputs.
-- Multiple CI fixes to ensure reliable builds, correct environment variables, and proper image handling.
-
-## Maintenance / CI
-
-- Significant CI and Dockerfile cleanup and optimization.
-- Improved git metadata generation during builds.
-- Dependency updates, formatting, and test snapshot updates.
-
----
-
-- [f8a2a95](https://git.max-richter.dev/max/nodarium/commit/f8a2a95bc18fa3c8c1db67dc0c2b66db1ff0d866) chore: clean CHANGELOG.md
-- [c9dd143](https://git.max-richter.dev/max/nodarium/commit/c9dd143916d758991f3ba30723a32c18b6f98bb5) fix(ci): correctly add release notes from tag to changelog
-- [898dd49](https://git.max-richter.dev/max/nodarium/commit/898dd49aee930350af8645382ef5042765a1fac7) fix(ci): correctly copy changelog to build output
-- [9fb69d7](https://git.max-richter.dev/max/nodarium/commit/9fb69d760fdf92ecc2448e468242970ec48443b0) feat: show commits since last release in changelog
-- [bafbcca](https://git.max-richter.dev/max/nodarium/commit/bafbcca2b8a7cd9f76e961349f11ec84d1e4da63) fix: wrong socket was highlighted when dragging node
-- [8ad9e55](https://git.max-richter.dev/max/nodarium/commit/8ad9e5535cd752ef111504226b4dac57b5adcf3d) feat: highlight possible sockets when dragging edge
-- [11eaeb7](https://git.max-richter.dev/max/nodarium/commit/11eaeb719be7f34af8db8b7908008a15308c0cac) feat(app): display some git metadata in changelog
-- [74c2978](https://git.max-richter.dev/max/nodarium/commit/74c2978cd16d2dd95ce1ae8019dfb9098e52b4b6) chore: cleanup git.json a bit
-- [4fdc247](https://git.max-richter.dev/max/nodarium/commit/4fdc24790490d3f13ee94a557159617f4077a2f9) ci: update build.sh to correct git.json
-- [c3f8b4b](https://git.max-richter.dev/max/nodarium/commit/c3f8b4b5aad7a525fb11ab14c9236374cb60442d) ci: debug available env vars
-- [67591c0](https://git.max-richter.dev/max/nodarium/commit/67591c0572b873d8c7cd00db8efb7dac2d6d4de2) chore: pnpm format
-- [de1f9d6](https://git.max-richter.dev/max/nodarium/commit/de1f9d6ab669b8e699d98b8855e125e21030b5b3) feat(ui): change inputnumber to snap to values when alt is pressed
-- [6acce72](https://git.max-richter.dev/max/nodarium/commit/6acce72fb8c416cc7f6eec99c2ae94d6529e960c) fix(ui): correctly initialize InputNumber
-- [cf8943b](https://git.max-richter.dev/max/nodarium/commit/cf8943b2059aa286e41865caf75058d35498daf7) chore: pnpm update
-- [9e03d36](https://git.max-richter.dev/max/nodarium/commit/9e03d36482bb4f972c384b66b2dcf258f0cd18be) chore: use newest ci image
-- [fd7268d](https://git.max-richter.dev/max/nodarium/commit/fd7268d6208aede435e1685817ae6b271c68bd83) ci: make dockerfile work
-- [6358c22](https://git.max-richter.dev/max/nodarium/commit/6358c22a853ec340be5223fabb8289092e4f4afe) ci: use tagged own image for ci
-- [655b6a1](https://git.max-richter.dev/max/nodarium/commit/655b6a18b282f0cddcc750892e575ee6c311036b) ci: make dockerfile work
-- [37b2bdc](https://git.max-richter.dev/max/nodarium/commit/37b2bdc8bdbd8ded6b22b89214b49de46f788351) ci: update ci Dockerfile to work
-- [94e01d4](https://git.max-richter.dev/max/nodarium/commit/94e01d4ea865f15ce06b52827a1ae6906de5be5e) ci: correctly build and push ci image
-- [35f5177](https://git.max-richter.dev/max/nodarium/commit/35f5177884b62bbf119af1bbf4df61dd0291effb) feat: try to optimize the Dockerfile
-- [ac2c61f](https://git.max-richter.dev/max/nodarium/commit/ac2c61f2211ba96bbdbb542179905ca776537cec) ci: use actual git url in ci
-- [ef3d462](https://git.max-richter.dev/max/nodarium/commit/ef3d46279f4ff9c04d80bb2d9a9e7cfec63b224e) fix(ci): build before testing
-- [703da32](https://git.max-richter.dev/max/nodarium/commit/703da324fabbef0e2c017f0f7a925209fa26bd03) ci: automatically build ci image and store locally
-- [1dae472](https://git.max-richter.dev/max/nodarium/commit/1dae472253ccb5e3766f2270adc053b922f46738) ci: add a git.json metadata file during build
-- [09fdfb8](https://git.max-richter.dev/max/nodarium/commit/09fdfb88cd203ace0e36663ebdb2c8c7ba53f190) chore: update test screenshots
-- [04b63cc](https://git.max-richter.dev/max/nodarium/commit/04b63cc7e2fc4fcfa0973cf40592d11457179db3) feat: add changelog to sidebar
-- [cb6a356](https://git.max-richter.dev/max/nodarium/commit/cb6a35606dfda50b0c81b04902d7a6c8e59458d2) feat(ci): also cache cargo stuff
-- [9c9f3ba](https://git.max-richter.dev/max/nodarium/commit/9c9f3ba3b7c94215a86b0a338a5cecdd87b96b28) fix(ci): use GITHUB_instead of GITEA_ for env vars
-- [08dda2b](https://git.max-richter.dev/max/nodarium/commit/08dda2b2cb4d276846abe30bc260127626bb508a) chore: pnpm format
-- [059129a](https://git.max-richter.dev/max/nodarium/commit/059129a738d02b8b313bb301a515697c7c4315ac) fix(ci): deploy prs and main
-- [437c9f4](https://git.max-richter.dev/max/nodarium/commit/437c9f4a252125e1724686edace0f5f006f58439) feat(ci): add list of all commits to changelog entry
-- [48bf447](https://git.max-richter.dev/max/nodarium/commit/48bf447ce12949d7c29a230806d160840b7847e1) docs: straighten up changelog a bit
-- [548fa4f](https://git.max-richter.dev/max/nodarium/commit/548fa4f0a1a14adc40a74da1182fa6da81eab3df) fix(app): correctly initialize vec3 inputs in nestedsettings
-
-# v0.0.2 (2026-02-04)
-
-## Fixes
-
----
-
-- []() fix(ci): actually deploy on tags
-- []() fix(app): correctly handle false value in settings
-
-# v0.0.1 (2026-02-03)
-
-chore: format

Cargo.lock

@@ -245,14 +245,6 @@ dependencies = [
  "zmij",
 ]
 
-[[package]]
-name = "shape"
-version = "0.1.0"
-dependencies = [
- "nodarium_macros",
- "nodarium_utils",
-]
-
 [[package]]
 name = "stem"
 version = "0.1.0"

Dockerfile

@@ -0,0 +1,19 @@
+FROM node:24-alpine
+
+# Install all required packages in one layer
+RUN apk add --no-cache curl git jq g++ make
+
+# Set Rust paths
+ENV RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    PATH=/usr/local/cargo/bin:$PATH
+
+# Install Rust, wasm target, and pnpm
+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 \
+    && rm -rf /usr/local/rustup/toolchains/*/share/doc \
+    && npm i -g pnpm

Dockerfile.ci

@@ -1,30 +0,0 @@
-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/*

app/.gitignore

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

app/e2e/main.test.ts

@@ -1,62 +0,0 @@
-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/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@nodarium/app",
   "private": true,
-  "version": "0.0.3",
+  "version": "0.0.0",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
     "build": "svelte-kit sync && vite build",
-    "test:unit": "vitest",
+    "test": "vitest",
-    "test": "npm run test:unit -- --run && npm run test:e2e",
-    "test:e2e": "playwright test",
     "preview": "vite preview",
     "format": "dprint fmt -c '../.dprint.jsonc' .",
     "format:check": "dprint check -c '../.dprint.jsonc' .",
@@ -18,7 +16,7 @@
   "dependencies": {
     "@nodarium/ui": "workspace:*",
     "@nodarium/utils": "workspace:*",
-    "@sveltejs/kit": "^2.50.2",
+    "@sveltejs/kit": "^2.50.0",
     "@tailwindcss/vite": "^4.1.18",
     "@threlte/core": "8.3.1",
     "@threlte/extras": "9.7.1",
@@ -26,29 +24,27 @@
     "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.7",
+    "@tsconfig/svelte": "^5.0.6",
     "@types/file-saver": "^2.0.7",
     "@types/three": "^0.182.0",
-    "@vitest/browser-playwright": "^4.0.18",
     "dprint": "^0.51.1",
     "eslint": "^9.39.2",
     "eslint-plugin-svelte": "^3.14.0",
     "globals": "^17.3.0",
-    "svelte": "^5.49.2",
+    "svelte": "^5.46.4",
-    "svelte-check": "^4.3.6",
+    "svelte-check": "^4.3.5",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.54.0",
@@ -56,7 +52,6 @@
     "vite-plugin-comlink": "^5.3.0",
     "vite-plugin-glsl": "^1.5.5",
     "vite-plugin-wasm": "^3.5.0",
-    "vitest": "^4.0.18",
+    "vitest": "^4.0.17"
-    "vitest-browser-svelte": "^2.0.2"
   }
 }

app/playwright.config.ts

@@ -1,20 +0,0 @@
-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,7 +2,7 @@
 @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 * {

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

@@ -2,19 +2,19 @@
   import { colors } from '../graph/colors.svelte';
 
   const circleMaterial = new MeshBasicMaterial({
-    color: colors.connection.clone(),
+    color: colors.edge.clone(),
     toneMapped: false
   });
 
-  let lineColor = $state(colors.connection.clone().convertSRGBToLinear());
+  let lineColor = $state(colors.edge.clone().convertSRGBToLinear());
 
   $effect.root(() => {
     $effect(() => {
       if (appSettings.value.theme === undefined) {
         return;
       }
-      circleMaterial.color = colors.connection.clone().convertSRGBToLinear();
+      circleMaterial.color = colors.edge.clone().convertSRGBToLinear();
-      lineColor = colors.connection.clone().convertSRGBToLinear();
+      lineColor = colors.edge.clone().convertSRGBToLinear();
     });
   });
 

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

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

@@ -757,16 +757,12 @@ export class GraphManager extends EventEmitter<{
         (n) => n.id !== node.id && !parents.has(n.id)
       );
 
-      const edges = new SvelteMap<number, string[]>();
+      // get edges from this socket
-      this.getEdgesFromNode(node)
+      const edges = new SvelteMap(
-        .filter((e) => e[1] === index)
+        this.getEdgesFromNode(node)
-        .forEach((e) => {
+          .filter((e) => e[1] === index)
-          if (edges.has(e[2].id)) {
+          .map((e) => [e[2].id, e[3]])
-            edges.get(e[2].id)?.push(e[3]);
+      );
-          } else {
-            edges.set(e[2].id, [e[3]]);
-          }
-        });
 
       const ownType = nodeType.outputs?.[index];
 
@@ -779,7 +775,7 @@ export class GraphManager extends EventEmitter<{
 
           if (
             areSocketsCompatible(ownType, otherType)
-            && !edges.get(node.id)?.includes(key)
+            && edges.get(node.id) !== key
           ) {
             sockets.push([node, key]);
           }

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

@@ -186,21 +186,15 @@ export class GraphState {
     if (!node?.inputs) {
       return 5;
     }
-    let height = 5;
+    const height = 5
-
+      + 10
-    for (const key of Object.keys(node.inputs)) {
+        * Object.keys(node.inputs).filter(
-      if (key === 'seed') continue;
+          (p) =>
-      if (!node.inputs) continue;
+            p !== 'seed'
-      if (node?.inputs?.[key] === undefined) continue;
+            && node?.inputs
-      if ('setting' in node.inputs[key]) continue;
+            && !(node?.inputs?.[p] !== undefined && 'setting' in node.inputs[p])
-      if (node.inputs[key].hidden) continue;
+            && node.inputs[p].hidden !== true
-      if (node.inputs[key].type === 'shape') {
+        ).length;
-        height += 20;
-        continue;
-      }
-      height += 10;
-    }
-
     this.nodeHeightCache[nodeTypeId] = height;
     return height;
   }

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

@@ -9,7 +9,7 @@ const variables = [
   'outline',
   'active',
   'selected',
-  'connection'
+  'edge'
 ] as const;
 
 function getColor(variable: (typeof variables)[number]) {

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

@@ -166,14 +166,15 @@ export class MouseEventManager {
 
     if (this.state.mouseDown) return;
     this.state.edgeEndPosition = null;
-    const target = event.target as HTMLElement;
 
-    if (
+    if (event.target instanceof HTMLElement) {
-      target.nodeName !== 'CANVAS'
+      if (
-      && !target.classList.contains('node')
+        event.target.nodeName !== 'CANVAS'
-      && !target.classList.contains('content')
+        && !event.target.classList.contains('node')
-    ) {
+        && !event.target.classList.contains('content')
-      return;
+      ) {
+        return;
+      }
     }
 
     const mx = event.clientX - this.state.rect.x;
@@ -264,7 +265,7 @@ export class MouseEventManager {
         }
       }
 
-      if (_socket && smallestDist < 1.5) {
+      if (_socket && smallestDist < 0.9) {
         this.state.mousePosition = _socket.position;
         this.state.hoveredSocket = _socket;
       } else {

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

@@ -35,8 +35,8 @@
   );
   const pathHover = $derived(
     createNodePath({
-      depth: 7,
+      depth: 8.5,
-      height: 40,
+      height: 50,
       y: 49,
       cornerTop,
       rightBump,
@@ -113,9 +113,6 @@
     stroke: var(--stroke);
     stroke-width: var(--stroke-width);
     d: var(--path);
-
-    stroke-linejoin: round;
-    shape-rendering: geometricPrecision;
   }
 
   .content {

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

@@ -18,7 +18,6 @@
   const inputType = $derived(node?.state?.type?.inputs?.[id]);
 
   const socketId = $derived(`${node.id}-${id}`);
-  const height = $derived(input.type === 'shape' ? 200 : 100);
 
   const graphState = getGraphState();
   const graphId = graph?.id;
@@ -40,6 +39,16 @@
   const aspectRatio = 0.5;
 
   const path = $derived(
+    createNodePath({
+      depth: 7,
+      height: 20,
+      y: 50.5,
+      cornerBottom,
+      leftBump,
+      aspectRatio
+    })
+  );
+  const pathDisabled = $derived(
     createNodePath({
       depth: 6,
       height: 18,
@@ -51,8 +60,8 @@
   );
   const pathHover = $derived(
     createNodePath({
-      depth: 7,
+      depth: 8,
-      height: 20,
+      height: 25,
       y: 50.5,
       cornerBottom,
       leftBump,
@@ -65,8 +74,7 @@
   class="wrapper"
   data-node-type={node.type}
   data-node-input={id}
-  style:height="{height}px"
+  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)}>
@@ -83,9 +91,10 @@
     </div>
 
     {#if node?.state?.type?.inputs?.[id]?.internal !== true}
+      <div data-node-socket class="large target"></div>
       <div
         data-node-socket
-        class="target"
+        class="small target"
         onmousedown={handleMouseDown}
         role="button"
         tabindex="0"
@@ -97,10 +106,13 @@
   <svg
     xmlns="http://www.w3.org/2000/svg"
     viewBox="0 0 100 100"
+    width="100"
+    height="100"
     preserveAspectRatio="none"
     style={`
       --path: path("${path}");
       --hover-path: path("${pathHover}");
+      --hover-path-disabled: path("${pathDisabled}");
     `}
   >
     <path vector-effect="non-scaling-stroke"></path>
@@ -111,26 +123,33 @@
   .wrapper {
     position: relative;
     width: 100%;
+    height: 100px;
     transform: translateY(-0.5px);
   }
 
   .target {
-    width: 30px;
-    height: 30px;
     position: absolute;
     border-radius: 50%;
     top: 50%;
     transform: translateY(-50%) translateX(-50%);
+    /* background: red; */
+    /* opacity: 0.1; */
   }
 
-  .possible-socket .target {
+  .small.target {
-    box-shadow: 0px 0px 10px rgba(255, 255, 255, 0.5);
+    width: 30px;
-    background-color: rgba(255, 255, 255, 0.2);
+    height: 30px;
-    z-index: -10;
   }
 
-  .target:hover ~ svg path{
+  .large.target {
-    d: var(--hover-path);
+    width: 60px;
+    height: 60px;
+    cursor: unset;
+    pointer-events: none;
+  }
+
+  :global(.hovering-sockets) .large.target {
+    pointer-events: all;
   }
 
   .content {
@@ -160,16 +179,19 @@
     stroke: var(--stroke);
     stroke-width: var(--stroke-width);
     d: var(--path);
+  }
 
-    stroke-linejoin: round;
+  :global {
-    shape-rendering: geometricPrecision;
+    .hovering-sockets .large:hover ~ svg path {
+      d: var(--hover-path);
+    }
   }
 
   .content.disabled {
     opacity: 0.2;
   }
 
-  .possible-socket svg path {
+  .disabled svg path {
-     d: var(--hover-path);
+    d: var(--hover-path-disabled) !important;
   }
 </style>

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

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

@@ -1,110 +0,0 @@
-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/index.ts

@@ -4,5 +4,4 @@ export { default as lottaFaces } from './lotta-faces.json';
 export { default as lottaNodesAndFaces } from './lotta-nodes-and-faces.json';
 export { default as lottaNodes } from './lotta-nodes.json';
 export { plant } from './plant';
-export { default as simple } from './simple.json';
 export { tree } from './tree';

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

@@ -1,63 +0,0 @@
-{
-  "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/helpers.test.ts

@@ -1,145 +0,0 @@
-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/deepMerge.test.ts

@@ -1,72 +0,0 @@
-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/performance/Monitor.svelte

@@ -86,7 +86,7 @@
     position: absolute;
   }
   svg {
-    height: 126px;
+    height: 124px;
     margin: 24px 0px;
     border-top: solid thin var(--color-outline);
     border-bottom: solid thin var(--color-outline);

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

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

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

@@ -54,7 +54,7 @@ export class ProjectManager {
 
     g.id = id;
     if (!g.meta) g.meta = {};
-    g.meta.title = title;
+    if (!g.meta.title) g.meta.title = title;
 
     db.saveGraph(g);
     this.projects = [...this.projects, g];

app/src/lib/settings/NestedSettings.svelte

@@ -56,10 +56,6 @@
       return 0;
     }
 
-    if (Array.isArray(inputValue) && node.type === 'vec3') {
-      return inputValue;
-    }
-
     // If the component is supplied with a default value use that
     if (inputValue !== undefined && typeof inputValue !== 'object') {
       return inputValue;
@@ -102,7 +98,7 @@
       && typeof internalValue === 'number'
     ) {
       value[key] = node?.options?.[internalValue];
-    } else if (internalValue !== undefined) {
+    } else if (internalValue) {
       value[key] = internalValue;
     }
   });
@@ -128,6 +124,7 @@
 
 {#if key && isNodeInput(type?.[key])}
   {@const inputType = type[key]}
+  <!-- Leaf input -->
   <div class="input input-{inputType.type}" class:first-level={depth === 1}>
     {#if inputType.type === 'button'}
       <button onclick={handleClick}>
@@ -141,6 +138,7 @@
     {/if}
   </div>
 {:else if depth === 0}
+  <!-- Root: iterate over top-level keys -->
   {#each Object.keys(type ?? {}).filter((k) => k !== 'title') as childKey (childKey)}
     <NestedSettings
       id={`${id}.${childKey}`}
@@ -152,6 +150,7 @@
   {/each}
   <hr />
 {:else if key && type?.[key]}
+  <!-- Group -->
   {#if depth > 0}
     <hr />
   {/if}
@@ -211,7 +210,7 @@
   .first-level.input {
     padding-left: 1em;
     padding-right: 1em;
-    padding-bottom: 0.5px;
+    padding-bottom: 1px;
     gap: 3px;
   }
 

app/src/lib/sidebar/Panel.svelte

@@ -34,7 +34,7 @@
   <div class="wrapper" class:hidden>
     {#if title}
       <header class="bg-layer-2">
-        <h3>{title}</h3>
+        <h3 class="font-bold">{title}</h3>
       </header>
     {/if}
     {@render children?.()}

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

@@ -12,7 +12,7 @@
 </script>
 
 <div class='{node?"border-l-2 pl-3.5!":""} bg-layer-2 flex items-center h-[70px] border-b-1 border-l-selected border-b-outline pl-4'>
-  <h3>Node Settings</h3>
+  <h3 class="font-bold">Node Settings</h3>
 </div>
 
 {#if node}

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

@@ -1,185 +0,0 @@
-<script lang="ts">
-  import { Details } from '@nodarium/ui';
-  import { micromark } from 'micromark';
-
-  type Props = {
-    git?: Record<string, string>;
-    changelog?: string;
-  };
-
-  const {
-    git,
-    changelog
-  }: Props = $props();
-
-  const typeMap = new Map([
-    ['fix', 'border-l-red-800'],
-    ['feat', 'border-l-green-800'],
-    ['chore', 'border-l-gray-800'],
-    ['docs', 'border-l-blue-800'],
-    ['refactor', 'border-l-purple-800'],
-    ['ci', 'border-l-red-400']
-  ]);
-
-  function detectCommitType(commit: string) {
-    for (const key of typeMap.keys()) {
-      if (commit.startsWith(key)) {
-        return key;
-      }
-    }
-    return '';
-  }
-
-  function parseCommit(line?: string) {
-    if (!line) return;
-
-    const regex = /^\s*-\s*\[([a-f0-9]+)\]\((https?:\/\/[^\s)]+)\)\s+(.+)$/;
-
-    const match = line.match(regex);
-    if (!match) {
-      return undefined;
-    }
-
-    const [, sha, link, description] = match;
-
-    return {
-      sha,
-      link,
-      description,
-      type: detectCommitType(description)
-    };
-  }
-
-  function parseChangelog(md: string) {
-    return md.split(/^# v/gm)
-      .filter(l => !!l.length)
-      .map(release => {
-        const [firstLine, ...rest] = release.split('\n');
-        const title = firstLine.trim();
-
-        const blocks = rest
-          .join('\n')
-          .split('---');
-
-        const commits = blocks.length > 1
-          ? blocks
-            .at(-1)
-            ?.split('\n')
-            ?.map(line => parseCommit(line))
-            ?.filter(c => !!c)
-          : [];
-
-        const description = (
-          blocks.length > 1
-            ? blocks
-              .slice(0, -1)
-              .join('\n')
-            : blocks[0]
-        ).trim();
-
-        return {
-          description: micromark(description),
-          title,
-          commits
-        };
-      });
-  }
-</script>
-
-<div id="changelog" class="p-4 font-mono text-text overflow-y-auto max-h-full space-y-5">
-  {#if git}
-    <div class="mb-4 p-3 bg-layer-2 text-xs rounded">
-      <p><strong>Branch:</strong> {git.branch}</p>
-      <p>
-        <strong>Commit:</strong>
-        <a
-          href="https://git.max-richter.dev/max/nodarium/commit/{git.sha}"
-          class="link"
-          target="_blank"
-        >
-          {git.sha.slice(0, 7)}
-        </a>
-        – {git.commit_message}
-      </p>
-      <p>
-        <strong>Commits since last release:</strong>
-        {git.commits_since_last_release}
-      </p>
-      <p>
-        <strong>Timestamp:</strong>
-        {new Date(git.commit_timestamp).toLocaleString()}
-      </p>
-    </div>
-  {/if}
-
-  {#if changelog}
-    {#each parseChangelog(changelog) as release (release)}
-      <Details title={release.title}>
-        <!-- eslint-disable-next-line svelte/no-at-html-tags -->
-        <div id="description" class="pb-5">{@html release.description}</div>
-
-        {#if release?.commits?.length}
-          <Details
-            title="All Commits"
-            class="commits"
-          >
-            {#each release.commits as commit (commit)}
-              <p class="py-1 leading-7 text-xs border-b-1 border-l-1 border-b-outline last:border-b-0 -ml-2 pl-2 {typeMap.get(commit.type)}">
-                <!-- eslint-disable-next-line svelte/no-navigation-without-resolve -->
-                <a href={commit.link} class="link" target="_blank">{commit.sha}</a>
-                {commit.description}
-              </p>
-            {/each}
-          </Details>
-        {/if}
-      </Details>
-    {/each}
-  {/if}
-</div>
-
-<style>
-  @reference "tailwindcss";
-
-  #changelog :global(.commits) {
-    margin-left: -16px;
-    margin-right: -16px;
-    border-radius: 0px 0px 2px 2px !important;
-  }
-
-  #changelog :global(details > div){
-    padding-bottom: 0px;
-  }
-
-  #changelog :global(.commits > div) {
-    padding-bottom: 0px;
-    padding-top: 0px;
-  }
-
-  #description :global(h2) {
-    @apply font-bold mt-4 mb-1;
-  }
-  #description :global(h2:first-child) {
-    margin-top: 0px !important;
-  }
-
-  #description :global(ul) {
-    padding-left: 1em;
-  }
-  #description :global(li),
-  #description :global(p) {
-    @apply text-xs!;
-    list-style-type: disc;
-  }
-
-  #changelog :global(details > details[open] > summary){
-    margin-bottom: 20px !important;
-  }
-
-  .link {
-    color: #60a5fa;
-    text-decoration: none;
-  }
-  .link:hover {
-    text-decoration: underline;
-  }
-</style>

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

@@ -7,7 +7,7 @@
     return JSON.stringify(
       {
         ...g,
-        nodes: g.nodes.map((n: object) => ({ ...n, tmp: undefined, state: undefined }))
+        nodes: g.nodes.map((n: object) => ({ ...n, tmp: undefined }))
       },
       null,
       2

app/src/routes/+layout.server.ts

@@ -1,28 +1 @@
 export const prerender = true;
-
-export async function load({ fetch }) {
-  async function fetchChangelog() {
-    try {
-      const res = await fetch('/CHANGELOG.md');
-      return await res.text();
-    } catch (error) {
-      console.log('Failed to fetch CHANGELOG.md', error);
-      return;
-    }
-  }
-
-  async function fetchGitInfo() {
-    try {
-      const res = await fetch('/git.json');
-      return await res.json();
-    } catch (error) {
-      console.log('Failed to fetch git.json', error);
-      return;
-    }
-  }
-
-  return {
-    git: await fetchGitInfo(),
-    changelog: await fetchChangelog()
-  };
-}

app/src/routes/+page.svelte

@@ -17,7 +17,6 @@
   import Panel from '$lib/sidebar/Panel.svelte';
   import ActiveNodeSettings from '$lib/sidebar/panels/ActiveNodeSettings.svelte';
   import BenchmarkPanel from '$lib/sidebar/panels/BenchmarkPanel.svelte';
-  import Changelog from '$lib/sidebar/panels/Changelog.svelte';
   import ExportSettings from '$lib/sidebar/panels/ExportSettings.svelte';
   import GraphSource from '$lib/sidebar/panels/GraphSource.svelte';
   import Keymap from '$lib/sidebar/panels/Keymap.svelte';
@@ -29,8 +28,6 @@
 
   let performanceStore = createPerformanceStore();
 
-  const { data } = $props();
-
   const registryCache = new IndexDBCache('node-registry');
   const nodeRegistry = new RemoteNodeRegistry('', registryCache);
   const workerRuntime = new WorkerRuntimeExecutor();
@@ -252,13 +249,6 @@
           />
           <ActiveNodeSettings {manager} bind:node={activeNode} />
         </Panel>
-        <Panel
-          id="changelog"
-          title="Changelog"
-          icon="i-[tabler--file-text-spark] bg-green-400"
-        >
-          <Changelog git={data.git} changelog={data.changelog} />
-        </Panel>
       </Sidebar>
     </Grid.Cell>
   </Grid.Row>

app/src/routes/dev/+page.svelte

@@ -7,6 +7,7 @@
   import Sidebar from '$lib/sidebar/Sidebar.svelte';
   import { type NodeId, type NodeInstance } from '@nodarium/types';
   import { concatEncodedArrays, createWasmWrapper, encodeNestedArray } from '@nodarium/utils';
+  import Code from './Code.svelte';
 
   const registryCache = new IndexDBCache('node-registry');
   const nodeRegistry = new RemoteNodeRegistry('', registryCache);
@@ -77,7 +78,11 @@
   </Grid.Cell>
 
   <Grid.Cell>
-    <div class="h-screen w-[80vw] overflow-y-auto"></div>
+    <div class="h-screen w-[80vw] overflow-y-auto">
+      {#if nodeWasm}
+        <Code wasm={nodeWasm} />
+      {/if}
+    </div>
   </Grid.Cell>
 </Grid.Row>
 

app/src/routes/dev/Code.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+  import wabtInit from 'wabt';
+
+  const { wasm } = $props<{ wasm: ArrayBuffer }>();
+
+  async function toWat(arrayBuffer: ArrayBuffer) {
+    const wabt = await wabtInit();
+
+    const module = wabt.readWasm(new Uint8Array(arrayBuffer), {
+      readDebugNames: true
+    });
+
+    module.generateNames();
+    module.applyNames();
+
+    return module.toText({ foldExprs: false, inlineExport: false });
+  }
+</script>
+
+{#await toWat(wasm)}
+  <p>Converting to WAT</p>
+{:then c}
+  <pre>
+    <code class="text-gray-50">{c}</code>
+  </pre>
+{/await}

app/static/.gitignore

@@ -1,3 +1 @@
 nodes/
-CHANGELOG.md
-git.json

app/vite.config.ts

@@ -1,10 +1,9 @@
 import { sveltekit } from '@sveltejs/kit/vite';
 import tailwindcss from '@tailwindcss/vite';
-import { playwright } from '@vitest/browser-playwright';
+import { defineConfig } from 'vite';
 import comlink from 'vite-plugin-comlink';
 import glsl from 'vite-plugin-glsl';
 import wasm from 'vite-plugin-wasm';
-import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
   plugins: [
@@ -21,36 +20,5 @@ export default defineConfig({
   },
   ssr: {
     noExternal: ['three']
-  },
-  build: {
-    chunkSizeWarningLimit: 2000
-  },
-  test: {
-    expect: { requireAssertions: true },
-    projects: [
-      {
-        extends: './vite.config.ts',
-        test: {
-          name: 'client',
-          browser: {
-            enabled: true,
-            provider: playwright(),
-            instances: [{ browser: 'firefox', headless: true }]
-          },
-          include: ['src/**/*.svelte.{test,spec}.{js,ts}'],
-          exclude: ['src/lib/server/**']
-        }
-      },
-
-      {
-        extends: './vite.config.ts',
-        test: {
-          name: 'server',
-          environment: 'node',
-          include: ['src/**/*.{test,spec}.{js,ts}'],
-          exclude: ['src/**/*.svelte.{test,spec}.{js,ts}']
-        }
-      }
-    ]
   }
 });

nodes/max/plantarium/shape/.gitignore

@@ -1,6 +0,0 @@
-/target
-**/*.rs.bk
-Cargo.lock
-bin/
-pkg/
-wasm-pack.log

nodes/max/plantarium/shape/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "shape"
-version = "0.1.0"
-authors = ["Max Richter <jim-x@web.de>"]
-edition = "2018"
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[dependencies]
-nodarium_macros = { version = "0.1.0", path = "../../../../packages/macros" }
-nodarium_utils = { version = "0.1.0", path = "../../../../packages/utils" }

nodes/max/plantarium/shape/src/input.json

@@ -1,27 +0,0 @@
-{
-  "id": "max/plantarium/shape",
-  "outputs": [
-    "shape"
-  ],
-  "inputs": {
-    "shape": {
-      "type": "shape",
-      "internal": true,
-      "value": [
-        47.8,
-        100,
-        47.8,
-        82.8,
-        30.9,
-        69.1,
-        23.2,
-        40.7,
-        27.1,
-        14.5,
-        42.5,
-        0
-      ],
-      "label": ""
-    }
-  }
-}

nodes/max/plantarium/shape/src/lib.rs

@@ -1,13 +0,0 @@
-use nodarium_macros::nodarium_definition_file;
-use nodarium_macros::nodarium_execute;
-use nodarium_utils::{concat_args, log, split_args};
-
-nodarium_definition_file!("src/input.json");
-
-#[nodarium_execute]
-pub fn execute(input: &[i32]) -> Vec<i32> {
-    let args = split_args(input);
-    log!("vec3 input: {:?}", input);
-    log!("vec3 args: {:?}", args);
-    concat_args(args)
-}

package.json

@@ -1,15 +1,15 @@
 {
-  "version": "0.0.3",
   "scripts": {
     "postinstall": "pnpm run -r --filter 'ui' build",
+    "build": "pnpm build:nodes && pnpm build:app",
     "lint": "pnpm run -r --parallel lint",
     "format": "pnpm dprint fmt",
     "format:check": "pnpm dprint check",
-    "test": "pnpm run -r test",
     "check": "pnpm run -r check",
-    "build": "pnpm build:nodes && pnpm build:app",
+    "build:story": "pnpm -r --filter 'ui' story:build",
     "build:app": "BASE_PATH=/ui pnpm -r --filter 'ui' build && pnpm -r --filter 'app' build",
     "build:nodes": "cargo build --workspace --target wasm32-unknown-unknown --release && rm -rf ./app/static/nodes/max/plantarium/ && mkdir -p ./app/static/nodes/max/plantarium/ && cp -R ./target/wasm32-unknown-unknown/release/*.wasm ./app/static/nodes/max/plantarium/",
+    "build:deploy": "pnpm build && cp -R packages/ui/build app/build/ui",
     "dev:nodes": "chokidar './nodes/**' --initial -i '/pkg/' -c 'pnpm build:nodes'",
     "dev:app_ui": "pnpm -r --parallel --filter 'app' --filter './packages/ui' dev",
     "dev_ui": "pnpm -r --filter 'ui' dev:ui",

packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodarium/types",
-  "version": "0.0.3",
+  "version": "0.0.0",
   "description": "",
   "main": "src/index.ts",
   "scripts": {
@@ -17,7 +17,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "zod": "^4.3.6"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "dprint": "^0.51.1"

packages/types/src/inputs.ts

@@ -26,6 +26,7 @@ const DefaultOptionsSchema = z.object({
 export const NodeInputFloatSchema = z.object({
   ...DefaultOptionsSchema.shape,
   type: z.literal('float'),
+  element: z.literal('slider').optional(),
   value: z.number().optional(),
   min: z.number().optional(),
   max: z.number().optional(),
@@ -35,17 +36,12 @@ export const NodeInputFloatSchema = z.object({
 export const NodeInputIntegerSchema = z.object({
   ...DefaultOptionsSchema.shape,
   type: z.literal('integer'),
+  element: z.literal('slider').optional(),
   value: z.number().optional(),
   min: z.number().optional(),
   max: z.number().optional()
 });
 
-export const NodeInputShapeSchema = z.object({
-  ...DefaultOptionsSchema.shape,
-  type: z.literal('shape'),
-  value: z.array(z.number()).optional()
-});
-
 export const NodeInputBooleanSchema = z.object({
   ...DefaultOptionsSchema.shape,
   type: z.literal('boolean'),
@@ -88,7 +84,6 @@ export const NodeInputSchema = z.union([
   NodeInputBooleanSchema,
   NodeInputFloatSchema,
   NodeInputIntegerSchema,
-  NodeInputShapeSchema,
   NodeInputSelectSchema,
   NodeInputSeedSchema,
   NodeInputVec3Schema,

packages/types/src/lib.rs

@@ -103,15 +103,6 @@ pub struct NodeInputVec3 {
     pub value: Option<Vec<f64>>,
 }
 
-#[derive(Serialize, Deserialize)]
-pub struct NodeInputShape {
-    #[serde(flatten)]
-    pub default_options: DefaultOptions,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub value: Option<Vec<f64>>,
-}
-
 #[derive(Serialize, Deserialize)]
 pub struct NodeInputGeometry {
     #[serde(flatten)]
@@ -134,7 +125,6 @@ pub enum NodeInput {
     select(NodeInputSelect),
     seed(NodeInputSeed),
     vec3(NodeInputVec3),
-    shape(NodeInputShape),
     geometry(NodeInputGeometry),
     path(NodeInputPath),
 }

packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodarium/ui",
-  "version": "0.0.3",
+  "version": "0.0.1",
   "scripts": {
     "dev": "vite",
     "build": "vite build && npm run package",
@@ -33,32 +33,28 @@
     "@eslint/compat": "^2.0.2",
     "@eslint/eslintrc": "^3.3.3",
     "@eslint/js": "^9.39.2",
-    "@nodarium/types": "workspace:^",
+    "@nodarium/types": "workspace:",
-    "@playwright/test": "^1.58.1",
     "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/kit": "^2.50.2",
+    "@sveltejs/kit": "^2.50.0",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
-    "@testing-library/svelte": "^5.3.1",
     "@types/eslint": "^9.6.1",
     "@types/three": "^0.182.0",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
-    "@typescript-eslint/parser": "^8.54.0",
+    "@typescript-eslint/parser": "^8.53.0",
-    "@vitest/browser-playwright": "^4.0.18",
     "dprint": "^0.51.1",
     "eslint": "^9.39.2",
     "eslint-plugin-svelte": "^3.14.0",
     "globals": "^17.3.0",
-    "publint": "^0.3.17",
+    "publint": "^0.3.16",
-    "svelte": "^5.49.2",
+    "svelte": "^5.46.4",
-    "svelte-check": "^4.3.6",
+    "svelte-check": "^4.3.5",
     "svelte-eslint-parser": "^1.4.1",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.54.0",
     "vite": "^7.3.1",
-    "vitest": "^4.0.18",
+    "vitest": "^4.0.17"
-    "vitest-browser-svelte": "^2.0.2"
   },
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",

packages/ui/src/lib/Details.svelte

@@ -1,46 +1,31 @@
 <script lang="ts">
-  import { type Snippet } from 'svelte';
+  import type { Snippet } from 'svelte';
   interface Props {
     title?: string;
     transparent?: boolean;
     children?: Snippet;
     open?: boolean;
-    class?: string;
   }
-  let { title = 'Details', transparent = false, children, open = $bindable(false), class: _class }:
+  let { title = 'Details', transparent = false, children, open = $bindable(false) }: Props =
-    Props = $props();
+    $props();
 </script>
 
-<details
+<details class:transparent bind:open class="text-text outline-1 outline-outline bg-layer-1">
-  class:transparent
-  bind:open
-  class="text-text outline-1 outline-outline bg-layer-1 {_class}"
->
   <summary>{title}</summary>
-  <div>
+  <div class="content">
     {@render children?.()}
   </div>
 </details>
 
 <style>
   details {
-    border-radius: 2px;
-  }
-  summary {
     padding: 1em;
     padding-left: 20px;
+    border-radius: 2px;
     font-weight: 300;
     font-size: 0.9em;
   }
 
-  details[open] > summary {
-    border-bottom: solid thin var(--color-outline);
-  }
-
-  details > div {
-    padding: 1em;
-  }
-
   details.transparent {
     background-color: transparent;
     padding: 0;

packages/ui/src/lib/Details.svelte.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { render } from 'vitest-browser-svelte';
-import { page } from 'vitest/browser';
-import Details from './Details.svelte';
-
-describe('Details', () => {
-  it('should render summary element', async () => {
-    render(Details, { title: 'Click me' });
-
-    const summary = page.getByText('Click me');
-    await expect.element(summary).toBeInTheDocument();
-  });
-});

packages/ui/src/lib/Input.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
   import type { NodeInput } from '@nodarium/types';
 
-  import { InputCheckbox, InputNumber, InputSelect, InputShape, InputVec3 } from './index';
+  import { InputCheckbox, InputNumber, InputSelect, InputVec3 } from './index';
 
   interface Props {
     input: NodeInput;
@@ -19,8 +19,6 @@
     max={input?.max}
     step={input?.step}
   />
-{:else if input.type === 'shape'}
-  <InputShape bind:value={value as number[]} />
 {:else if input.type === 'integer'}
   <InputNumber bind:value={value as number} min={input?.min} max={input?.max} step={1} />
 {:else if input.type === 'boolean'}

packages/ui/src/lib/ShortCut.svelte.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { render } from 'vitest-browser-svelte';
-import { page } from 'vitest/browser';
-import ShortCut from './ShortCut.svelte';
-
-describe('ShortCut', () => {
-  it('should render with key label', async () => {
-    render(ShortCut, { key: 'S' });
-
-    const shortcut = page.getByText('S');
-    await expect.element(shortcut).toBeInTheDocument();
-  });
-
-  it('should render ctrl modifier', async () => {
-    render(ShortCut, { ctrl: true, key: 'S' });
-
-    const shortcut = page.getByText(/Ctrl/);
-    await expect.element(shortcut).toBeInTheDocument();
-  });
-
-  it('should render alt modifier', async () => {
-    render(ShortCut, { alt: true, key: 'F4' });
-
-    const shortcut = page.getByText(/Alt/);
-    await expect.element(shortcut).toBeInTheDocument();
-  });
-
-  it('should render multiple modifiers', async () => {
-    render(ShortCut, { ctrl: true, alt: true, key: 'Delete' });
-
-    const shortcut = page.getByText(/Ctrl/);
-    await expect.element(shortcut).toBeInTheDocument();
-  });
-});

packages/ui/src/lib/app.css

@@ -11,6 +11,7 @@
 @source inline("{hover:,}{bg-,outline-,text-,}selected");
 @source inline("{hover:,}{bg-,outline-,text-,}outline{!,}");
 @source inline("{hover:,}{bg-,outline-,text-,}connection");
+@source inline("{hover:,}{bg-,outline-,text-,}edge");
 @source inline("{hover:,}{bg-,outline-,text-,}text");
 
 /* fira-code-300 - latin */
@@ -71,12 +72,12 @@
 
   --color-outline: var(--neutral-400);
   --color-connection: #333333;
+  --color-edge: var(--connection, var(--color-outline));
 
   --color-text: var(--neutral-200);
 }
 
 html {
-  --neutral-050: #f0f0f0;
   --neutral-100: #e7e7e7;
   --neutral-200: #cecece;
   --neutral-300: #7c7c7c;
@@ -88,13 +89,14 @@ html {
   --color-layer-0: var(--neutral-900);
   --color-layer-1: var(--neutral-500);
   --color-layer-2: var(--neutral-400);
-  --color-layer-3: var(--neutral-300);
+  --color-layer-3: var(--neutral-200);
 
   --color-active: #ffffff;
   --color-selected: #c65a19;
 
-  --color-outline: #3e3e3e;
+  --color-outline: var(--neutral-400);
   --color-connection: #333333;
+  --color-edge: var(--connection, var(--color-outline));
 
   --color-text-color: var(--neutral-200);
 }
@@ -108,10 +110,10 @@ body {
 html.theme-light {
   --color-text: var(--neutral-800);
   --color-outline: var(--neutral-300);
-  --color-layer-0: var(--neutral-050);
+  --color-layer-0: var(--neutral-100);
   --color-layer-1: var(--neutral-100);
   --color-layer-2: var(--neutral-200);
-  --color-layer-3: var(--neutral-300);
+  --color-layer-3: var(--neutral-500);
   --color-active: #000000;
   --color-selected: #c65a19;
   --color-connection: #888;

packages/ui/src/lib/helpers/getBoundingValue.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getBoundingValue } from './getBoundingValue';
-
-describe('getBoundingValue', () => {
-  it('should return 1 for values between 0 and 1', () => {
-    expect(getBoundingValue(0)).toBe(1);
-    expect(getBoundingValue(0.5)).toBe(1);
-    expect(getBoundingValue(1)).toBe(1);
-  });
-
-  it('should return 2 for values between 1 and 2', () => {
-    expect(getBoundingValue(1.1)).toBe(2);
-    expect(getBoundingValue(1.5)).toBe(2);
-    expect(getBoundingValue(2)).toBe(2);
-  });
-
-  it('should return 4 for values between 2 and 4', () => {
-    expect(getBoundingValue(2.1)).toBe(4);
-    expect(getBoundingValue(3)).toBe(4);
-    expect(getBoundingValue(4)).toBe(4);
-  });
-
-  it('should return positive level for positive input', () => {
-    expect(getBoundingValue(5)).toBe(10);
-    expect(getBoundingValue(15)).toBe(20);
-    expect(getBoundingValue(50)).toBe(50);
-    expect(getBoundingValue(150)).toBe(200);
-  });
-
-  it('should return negative level for negative input', () => {
-    expect(getBoundingValue(-5)).toBe(-10);
-    expect(getBoundingValue(-15)).toBe(-20);
-    expect(getBoundingValue(-50)).toBe(-50);
-    expect(getBoundingValue(-150)).toBe(-200);
-  });
-
-  it('should return correct level for boundary values', () => {
-    expect(getBoundingValue(10)).toBe(10);
-    expect(getBoundingValue(20)).toBe(20);
-    expect(getBoundingValue(50)).toBe(50);
-    expect(getBoundingValue(100)).toBe(100);
-    expect(getBoundingValue(200)).toBe(200);
-  });
-
-  it('should handle large values', () => {
-    expect(getBoundingValue(1000)).toBe(1000);
-    expect(getBoundingValue(1500)).toBe(1000);
-    expect(getBoundingValue(-1000)).toBe(-1000);
-  });
-
-  it('should handle very small values', () => {
-    expect(getBoundingValue(0.001)).toBe(1);
-    expect(getBoundingValue(-0.001)).toBe(-1);
-  });
-});

packages/ui/src/lib/index.ts

@@ -2,7 +2,6 @@ export { default as Input } from './Input.svelte';
 export { default as InputCheckbox } from './inputs/InputCheckbox.svelte';
 export { default as InputNumber } from './inputs/InputNumber.svelte';
 export { default as InputSelect } from './inputs/InputSelect.svelte';
-export { default as InputShape } from './inputs/InputShape.svelte';
 export { default as InputVec3 } from './inputs/InputVec3.svelte';
 
 export { default as Details } from './Details.svelte';

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

@@ -27,7 +27,7 @@
     {id}
   />
   <span
-    class="absolute opacity-0 peer-checked:opacity-100 transition-opacity duration-50 flex w-full h-full items-center justify-center"
+    class="absolute opacity-0 peer-checked:opacity-100 transition-opacity duration-100 flex w-full h-full items-center justify-center"
   >
     <svg
       viewBox="0 0 19 14"

packages/ui/src/lib/inputs/InputCheckbox.svelte.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { render } from 'vitest-browser-svelte';
-import { page } from 'vitest/browser';
-import InputCheckbox from './InputCheckbox.svelte';
-
-describe('InputCheckbox', () => {
-  it('should render checkbox label', async () => {
-    render(InputCheckbox, { value: false });
-
-    const checkbox = page.getByRole('checkbox');
-    await expect.element(checkbox).toBeInTheDocument();
-  });
-
-  it('should be unchecked when value is false', async () => {
-    render(InputCheckbox, { value: false });
-
-    const input = page.getByRole('checkbox');
-    await expect.element(input).not.toBeChecked();
-  });
-
-  it('should be checked when value is true', async () => {
-    render(InputCheckbox, { value: true });
-
-    const input = page.getByRole('checkbox');
-    await expect.element(input).toBeChecked();
-  });
-});

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

@@ -19,6 +19,7 @@
 
   // normalize bounds
   if (min > max) [min, max] = [max, min];
+  if (value > max) max = value;
 
   let inputEl: HTMLInputElement | undefined = $state();
 
@@ -26,18 +27,11 @@
     return Math.min(max, Math.max(min, v));
   }
 
-  function snap(v: number, s = step) {
+  function snap(v: number) {
-    if (s) v = Math.round(v / s) * s;
+    if (step) v = Math.round(v / step) * step;
     return +v.toFixed(3);
   }
 
-  function getAutoStep(v: number): number {
-    const abs = Math.abs(v);
-    if (abs === 0) return 0.1; // fallback for 0
-    const exponent = Math.floor(Math.log10(abs));
-    return Math.pow(10, exponent);
-  }
-
   let dragging = $state(false);
   let startValue = 0;
   let rect: DOMRect;
@@ -65,8 +59,7 @@
     value = snap(
       e.ctrlKey
         ? startValue + delta
-        : clamp(startValue + delta),
+        : clamp(startValue + delta)
-      (e.altKey && !step) ? getAutoStep(value) : step
     );
   }
 
@@ -112,7 +105,7 @@
   }
 
   onMount(() => {
-    value = snap(value);
+    value = snap(clamp(value));
   });
 </script>
 
@@ -137,7 +130,7 @@
     <div
       class="absolute inset-y-0 left-0 bg-layer-3 opacity-30 pointer-events-none transition-[width]"
       class:transition-none={dragging}
-      style={`width: ${Math.max(0, Math.min((value - min) / (max - min), 1) * 100)}%`}
+      style={`width: ${Math.min((value - min) / (max - min), 1) * 100}%`}
     >
     </div>
 

packages/ui/src/lib/inputs/InputNumber.svelte.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { render } from 'vitest-browser-svelte';
-import { page } from 'vitest/browser';
-import InputNumber from './InputNumber.svelte';
-
-describe('InputNumber', () => {
-  it('should render input element', async () => {
-    render(InputNumber, { value: 0.5 });
-
-    const input = page.getByRole('spinbutton');
-    await expect.element(input).toBeInTheDocument();
-  });
-
-  it('should render with step buttons when step is provided', async () => {
-    render(InputNumber, { value: 0.5, step: 0.1 });
-
-    const decrementBtn = page.getByRole('button', { name: 'step down' });
-    const incrementBtn = page.getByRole('button', { name: 'step up' });
-    await expect.element(decrementBtn).toBeInTheDocument();
-    await expect.element(incrementBtn).toBeInTheDocument();
-  });
-
-  it('should not render step buttons when step is undefined', async () => {
-    const screen = render(InputNumber, { value: 0.5 });
-
-    const buttons = screen.locator.getByRole('button');
-    const count = buttons.all().length;
-    expect(count).toBe(0);
-  });
-
-  it('should accept numeric value', async () => {
-    render(InputNumber, { value: 42 });
-
-    const input = page.getByRole('spinbutton');
-    await expect.element(input).toHaveValue(42);
-  });
-
-  it('should accept min and max bounds', async () => {
-    render(InputNumber, { value: 5, min: 0, max: 10 });
-
-    const input = page.getByRole('spinbutton');
-    await expect.element(input).toHaveAttribute('min', '0');
-    await expect.element(input).toHaveAttribute('max', '10');
-  });
-
-  it('should not clamp value on init when value exceeds min/max', async () => {
-    render(InputNumber, { value: 100, min: 0, max: 10 });
-
-    const input = page.getByRole('spinbutton');
-    await expect.element(input).toHaveValue(100);
-  });
-
-  it('should not clamp value on init when value is below min', async () => {
-    render(InputNumber, { value: -50, min: 0, max: 10 });
-
-    const input = page.getByRole('spinbutton');
-    await expect.element(input).toHaveValue(-50);
-  });
-});

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

@@ -18,7 +18,7 @@
   select {
     font-family: var(--font-family);
     outline: solid 1px var(--color-outline);
-    padding: 0.5em 0.8em;
+    padding: 0.8em 1em;
     border-radius: 5px;
     border: none;
   }

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

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { render } from 'vitest-browser-svelte';
-import { page } from 'vitest/browser';
-import InputSelect from './InputSelect.svelte';
-
-describe('InputSelect', () => {
-  it('should render select element', async () => {
-    render(InputSelect, { options: ['a', 'b', 'c'], value: 0 });
-
-    const select = page.getByRole('combobox');
-    await expect.element(select).toBeInTheDocument();
-  });
-
-  it('should render all options', async () => {
-    render(InputSelect, { options: ['apple', 'banana', 'cherry'], value: 0 });
-
-    const select = page.getByRole('combobox');
-    await expect.element(select).toHaveTextContent('applebananacherry');
-  });
-
-  it('should select correct option by index', async () => {
-    render(InputSelect, { options: ['first', 'second', 'third'], value: 1 });
-
-    const select = page.getByRole('combobox');
-    await expect.element(select).toHaveTextContent('second');
-  });
-});

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

@@ -1,265 +0,0 @@
-<script lang="ts">
-  type Props = {
-    value: number[];
-    mirror?: boolean;
-  };
-
-  let { value: points = $bindable(), mirror = true }: Props = $props();
-
-  let mouseDown = $state<number[]>();
-  let draggingIndex = $state<number>();
-  let downCirclePosition = $state<number[]>();
-  let svgElement = $state<SVGElement>(null!);
-  let svgRect = $state<DOMRect>(null!);
-  let isMirroredEvent = $state(false);
-
-  const pathD = $derived(calculatePath(points, mirror));
-  const groupedPoints = $derived(group(points));
-
-  function group<T>(arr: T[], size = 2): T[][] {
-    const result = [];
-    for (let i = 0; i < arr.length; i += size) {
-      result.push(arr.slice(i, i + size));
-    }
-    return result;
-  }
-  const dist = (a: [number, number], b: [number, number]) => Math.hypot(a[0] - b[0], a[1] - b[1]);
-  const clamp = (v: number, min: number, max: number) => Math.min(Math.max(v, min), max);
-  const round = (v: number) => Math.floor(v * 10) / 10;
-  const getPt = (i: number) => [points[i * 2], points[i * 2 + 1]] as [number, number];
-
-  $effect(() => {
-    if (!points.length) {
-      points = [47.8, 100, 47.8, 82.8, 30.9, 69.1, 23.2, 40.7, 27.1, 14.5, 42.5, 0];
-    }
-  });
-
-  $effect(() => {
-    if (mirror) {
-      const _points: [number, number, number][] = [];
-      for (let i = 0; i < points.length / 2; i++) {
-        _points.push([...getPt(i), i]);
-      }
-
-      const sortedPoints = _points
-        .sort((a, b) => {
-          if (a[1] !== b[1]) return b[1] - a[1];
-          return a[0] - b[0];
-        });
-
-      const newIndices = new Map(sortedPoints.map((p, i) => [p[2], i]));
-
-      const sorted = sortedPoints
-        .map(p => [p[0], p[1]])
-        .flat();
-
-      let sortChanged = false;
-
-      for (let i = 0; i < sorted.length; i++) {
-        if (sorted[i] !== points[i]) {
-          sortChanged = true;
-          break;
-        }
-      }
-
-      if (sortChanged) {
-        points = sorted;
-        draggingIndex = newIndices.get(draggingIndex || 0) || 0;
-      }
-    }
-  });
-
-  function insertBetween(newPt: [number, number]): number {
-    const count = points.length / 2;
-
-    if (count < 2) {
-      points = [...points, ...newPt];
-      return count;
-    }
-
-    let minDist = Infinity;
-    let insertIdx = 0;
-
-    for (let i = 0; i < count - 1; i++) {
-      const a = getPt(i);
-      const b = getPt(i + 1);
-      const d = dist(newPt, a) + dist(newPt, b) - dist(a, b);
-      if (d < minDist) {
-        minDist = d;
-        insertIdx = i + 1;
-      }
-    }
-
-    points.splice(insertIdx * 2, 0, newPt[0], newPt[1]);
-    return insertIdx;
-  }
-
-  function calculatePath(pts: number[], mirror = false): string {
-    if (pts.length === 0) return '';
-
-    const arr = [...pts];
-
-    let d = `M ${arr[0]} ${arr[1]}`;
-    for (let i = 2; i < arr.length; i += 2) {
-      d += ` L ${arr[i]} ${arr[i + 1]}`;
-    }
-
-    if (mirror) {
-      for (let i = arr.length - 2; i >= 0; i -= 2) {
-        const x = 100 - arr[i];
-        d += ` L ${x} ${arr[i + 1]}`;
-      }
-      d += ' Z';
-    }
-
-    return d;
-  }
-
-  function handleMouseMove(ev: MouseEvent) {
-    if (mouseDown === undefined || draggingIndex === undefined || !downCirclePosition) return;
-
-    let vx = (mouseDown[0] - ev.clientX) * (100 / svgRect.width);
-    let vy = (mouseDown[1] - ev.clientY) * (100 / svgRect.height);
-
-    if (ev.shiftKey) {
-      vx /= 10;
-      vy /= 10;
-    }
-
-    let x = downCirclePosition[0] + ((isMirroredEvent ? 1 : -1) * vx);
-    let y = downCirclePosition[1] - vy;
-
-    x = clamp(x, 0, mirror ? 50 : 100);
-    y = clamp(y, 0, 100);
-
-    points[draggingIndex * 2] = round(x);
-    points[draggingIndex * 2 + 1] = round(y);
-  }
-
-  function handleMouseDown(ev: MouseEvent) {
-    ev.preventDefault();
-    isMirroredEvent = false;
-
-    svgRect = svgElement.getBoundingClientRect();
-    mouseDown = [ev.clientX, ev.clientY];
-
-    const indexText = (ev.target as SVGCircleElement).dataset.index;
-
-    const x = ((ev.clientX - svgRect.left) / svgRect.width) * 100;
-    const y = ((ev.clientY - svgRect.top) / svgRect.height) * 100;
-    isMirroredEvent = x > 50;
-
-    if (indexText !== undefined) {
-      draggingIndex = parseInt(indexText);
-      downCirclePosition = getPt(draggingIndex);
-    } else {
-      draggingIndex = undefined;
-
-      const pt = [
-        round(clamp(x, 0, 100)),
-        round(clamp(y, 0, 100))
-      ] as [
-        number,
-        number
-      ];
-      if (isMirroredEvent) {
-        pt[0] = 100 - pt[0];
-      }
-
-      draggingIndex = insertBetween(pt);
-      downCirclePosition = pt;
-    }
-  }
-
-  function handleMouseUp() {
-    mouseDown = undefined;
-    draggingIndex = undefined;
-  }
-
-  function handleContextMenu(ev: MouseEvent) {
-    const indexText = (ev.target as HTMLElement).dataset?.index;
-    if (indexText !== undefined) {
-      ev.preventDefault();
-      ev.stopImmediatePropagation();
-      const index = parseInt(indexText);
-      draggingIndex = undefined;
-      points.splice(index * 2, 2);
-    }
-  }
-</script>
-
-<svelte:window
-  onmousemove={handleMouseMove}
-  onmouseup={handleMouseUp}
-  oncontextmenu={handleContextMenu}
-/>
-
-<div class="wrapper" class:mirrored={mirror}>
-  <!-- svelte-ignore a11y_no_static_element_interactions -->
-  <svg
-    width="100"
-    height="100"
-    viewBox="0 0 100 100"
-    bind:this={svgElement}
-    aria-label="Interactive 2D Shape Editor"
-    onmousedown={handleMouseDown}
-  >
-    <path d={pathD} style:fill="var(--color-layer-3)" style:opacity={0.3} />
-    <path d={pathD} fill="none" stroke="var(--color-layer-3)" />
-    {#if mirror}
-      {#each groupedPoints as p, i (i)}
-        {@const x = 100 - p[0]}
-        {@const y = p[1]}
-        <circle
-          class:active={isMirroredEvent && draggingIndex === i}
-          data-index={i}
-          cx={x}
-          cy={y}
-          r={3}
-        >
-        </circle>
-      {/each}
-    {/if}
-
-    {#each groupedPoints as p, i (i)}
-      <circle
-        class:active={!isMirroredEvent && draggingIndex === i}
-        data-index={i}
-        cx={p[0]}
-        cy={p[1]}
-        r={3}
-      >
-      </circle>
-    {/each}
-  </svg>
-</div>
-
-<style>
-  .wrapper {
-    width: 100%;
-    aspect-ratio: 1;
-    background-color: var(--color-layer-2);
-    padding: 7px;
-    border-radius: 5px;
-    outline: solid thin var(--color-outline);
-  }
-
-  svg {
-    height: 100%;
-    width: 100%;
-    overflow: visible;
-  }
-
-  circle {
-    cursor: pointer;
-    stroke: transparent;
-    transition: fill 0.2s ease;
-    stroke-width: 1px;
-    stroke: var(--color-layer-3); 
-    fill: var(--color-layer-2);
-  }
-  circle.active,
-  circle:hover {
-    fill: var(--color-layer-3);
-  }
-</style>

packages/ui/src/lib/inputs/InputVec3.svelte.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { render } from 'vitest-browser-svelte';
-import { page } from 'vitest/browser';
-import InputVec3 from './InputVec3.svelte';
-
-describe('InputVec3', () => {
-  it('should render with correct initial values', async () => {
-    const value = $state([1.5, 2.5, 3.5]);
-    render(InputVec3, { value });
-
-    const inputs = page.getByRole('spinbutton');
-    await expect.element(inputs.first()).toBeInTheDocument();
-
-    expect(inputs.nth(0)).toHaveValue(1.5);
-    expect(inputs.nth(1)).toHaveValue(2.5);
-    expect(inputs.nth(2)).toHaveValue(3.5);
-  });
-
-  it('should have step attribute', async () => {
-    const value = $state([0, 0, 0]);
-    render(InputVec3, { value });
-
-    const input = page.getByRole('spinbutton').first();
-    await expect.element(input).toHaveAttribute('step', '0.01');
-  });
-});

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

@@ -1,14 +1,6 @@
 <script lang="ts">
   import '$lib/app.css';
-  import {
+  import { Details, InputCheckbox, InputNumber, InputSelect, InputVec3, ShortCut } from '$lib';
-    Details,
-    InputCheckbox,
-    InputNumber,
-    InputSelect,
-    InputShape,
-    InputVec3,
-    ShortCut
-  } from '$lib';
   import Section from './Section.svelte';
 
   let intValue = $state(0);
@@ -18,11 +10,9 @@
   const options = ['strawberry', 'raspberry', 'chickpeas'];
   let selectValue = $state(0);
   const d = $derived(options[selectValue]);
-  let checked = $state(false);
-  let mirrorShape = $state(true);
-  let detailsOpen = $state(false);
 
-  let points = $state([]);
+  let checked = $state(false);
+  let detailsOpen = $state(false);
 
   const themes = [
     'dark',
@@ -51,6 +41,7 @@
     'selected',
     'outline',
     'connection',
+    'edge',
     'text'
   ];
 </script>
@@ -99,19 +90,6 @@
     <InputCheckbox bind:value={checked} />
   </Section>
 
-  <Section title="Shape">
-    {#snippet header()}
-      <label class="flex gap-2">
-        <InputCheckbox bind:value={mirrorShape} />
-        <p>mirror</p>
-      </label>
-      <p>{JSON.stringify(points)}</p>
-    {/snippet}
-    <div style:width="300px">
-      <InputShape bind:value={points} mirror={mirrorShape} />
-    </div>
-  </Section>
-
   <Section title="Details" value={detailsOpen}>
     <Details title="More Information" bind:open={detailsOpen}>
       <p>Here is some more information that was previously hidden.</p>

packages/ui/src/routes/Section.svelte

@@ -1,9 +1,8 @@
 <script lang="ts">
   import { type Snippet } from 'svelte';
-  let { title, value, header, children, class: _class } = $props<{
+  let { title, value, children, class: _class } = $props<{
     title?: string;
     value?: unknown;
-    header?: Snippet;
     children?: Snippet;
     class?: string;
   }>();
@@ -12,13 +11,7 @@
 <section class="border-outline border-1/2 bg-layer-1 rounded border mb-4 p-4 flex flex-col gap-4 {_class}">
   <h3 class="flex gap-2 font-bold">
     {title}
-    <div class="flex gap-4 w-full font-normal opacity-50 max-w-[75%] whitespace-pre overflow-hidden text-clip">
+    <p class="font-normal! opacity-50!">{value}</p>
-      {#if header}
-        {@render header()}
-      {:else}
-        {value}
-      {/if}
-    </div>
   </h3>
   <div>
     {@render children()}

packages/ui/svelte.config.js

@@ -11,7 +11,7 @@ const config = {
 
   kit: {
     paths: {
-      base: BASE_URL === '/' ? '' : BASE_URL
+      base: BASE_URL
     },
     // adapter-auto only supports some environments, see https://kit.svelte.dev/docs/adapter-auto for a list.
     // If your environment is not supported, or you settled on a specific environment, switch out the adapter.

packages/ui/vite.config.ts

@@ -1,6 +1,5 @@
 import { sveltekit } from '@sveltejs/kit/vite';
 import tailwindcss from '@tailwindcss/vite';
-import { playwright } from '@vitest/browser-playwright';
 import { exec } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { defineConfig } from 'vitest/config';
@@ -22,31 +21,6 @@ const postDevPackagePlugin = () => {
 export default defineConfig({
   plugins: [tailwindcss(), sveltekit(), postDevPackagePlugin()],
   test: {
-    expect: { requireAssertions: true },
+    include: ['src/**/*.{test,spec}.{js,ts}']
-    projects: [
-      {
-        extends: './vite.config.ts',
-        test: {
-          name: 'client',
-          browser: {
-            enabled: true,
-            provider: playwright(),
-            instances: [{ browser: 'firefox', headless: true }]
-          },
-          include: ['src/**/*.svelte.ts'],
-          exclude: ['src/lib/server/**']
-        }
-      },
-
-      {
-        extends: './vite.config.ts',
-        test: {
-          name: 'server',
-          environment: 'node',
-          include: ['src/**/*.{test,spec}.{js,ts}'],
-          exclude: ['src/**/*.svelte.{test,spec}.{js,ts}']
-        }
-      }
-    ]
   }
 });

packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodarium/utils",
-  "version": "0.0.3",
+  "version": "0.0.1",
   "description": "",
   "main": "src/index.ts",
   "scripts": {
@@ -12,11 +12,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@nodarium/types": "workspace:^"
+    "@nodarium/types": "workspace:"
   },
   "devDependencies": {
     "dprint": "^0.51.1",
     "vite": "^7.3.1",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.17"
   }
 }

packages/utils/src/encoding.test.ts

@@ -5,6 +5,7 @@ test('encode_float', () => {
   const input = 1.23;
   const encoded = encodeFloat(input);
   const output = decodeFloat(encoded);
+  console.log(input, output);
   expect(output).toBeCloseTo(input);
 });
 

packages/utils/src/fastHash.test.ts

@@ -21,6 +21,24 @@ test('fastHashArray doesnt product collisions', () => {
   expect(hash_a).not.toEqual(hash_b);
 });
 
+test('fastHashArray is fast(ish) < 20ms', () => {
+  const a = new Int32Array(10_000);
+
+  const t0 = performance.now();
+  fastHashArrayBuffer(a);
+
+  const t1 = performance.now();
+
+  a[0] = 1;
+
+  fastHashArrayBuffer(a);
+
+  const t2 = performance.now();
+
+  expect(t1 - t0).toBeLessThan(20);
+  expect(t2 - t1).toBeLessThan(20);
+});
+
 // test if the fastHashArray function is deterministic
 test('fastHashArray is deterministic', () => {
   const a = new Int32Array(1000);

packages/utils/src/flatTree.test.ts

@@ -8,6 +8,8 @@ test('it correctly concats nested arrays', () => {
 
   const output = concatEncodedArrays([input_a, input_b, input_c]);
 
+  console.log('Output', output);
+
   const decoded = decodeNestedArray(output);
 
   expect(decoded[0]).toEqual([1, 2, 3]);

packages/utils/src/flatTree.ts

@@ -88,7 +88,7 @@ function decode_recursive(dense: number[] | Int32Array, index = 0) {
           dense,
           index
         );
-        decoded.push(p as number[]);
+        decoded.push(...p);
         index = nextIndex + 1;
         nextBracketIndex = _nextBracketIndex;
       } else {