feat: add initial e2e tests

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

@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest';
+import { grid } from '$lib/graph-templates/grid';
+import { tree } from '$lib/graph-templates/tree';
+
+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,4 +4,5 @@ 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

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

app/src/lib/helpers.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect } from 'vitest';
+import {
+  snapToGrid,
+  lerp,
+  humanizeNumber,
+  humanizeDuration,
+  debounce,
+  clone
+} from '$lib/helpers';
+
+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

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { mergeDeep, isObject } from '$lib/helpers/deepMerge';
+
+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/project-manager/ProjectManager.svelte

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

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

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

app/src/lib/sidebar/Panel.svelte

@@ -34,7 +34,7 @@
   <div class="wrapper" class:hidden>
     {#if title}
       <header class="bg-layer-2">
-        <h3 class="font-bold">{title}</h3>
+        <h3>{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 class="font-bold">Node Settings</h3>
+  <h3>Node Settings</h3>
 </div>
 
 {#if node}