2025-09-14 13:23:41 +02:00
184 changed files with 4652 additions and 3258 deletions
--- a/.env.example.ini
+++ b/.env.example.ini
@ -1,15 +1,7 @@
-[mariadb]
-host = ""
-user = ""
-pass = ""
-db   = ""
+[api]
+base_url    = "https://api.vlw.one/"
+api_key     = ""
+verify_peer = 0

-[config_time_available]
-time_zone           = "Europe/Stockholm"
-available_to_hour   = 0;
-reply_average_hours = 0;
-available_from_hour = 0;
-
-[service_forgejo]
-url      = ""
-profiles = ""
+[time]
+date_time_zone = "Europe/Stockholm"
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,24 @@
+# Public assets #
+#################
+public/robots.txt
+public/.well-known
+
+assets/js/modules/npm
+
+# Bootstrapping #
+#################
 vendor
+node_modules
 .env.ini
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+Icon?
+ehthumbs.db
+Thumbs.db
+.directory
--- a/.gitmodules
+++ b/.gitmodules
@ -1,6 +0,0 @@
-[submodule "reflect"]
-	path = reflect
-	url = https://codeberg.org/reflect/reflect
-[submodule "vegvisir"]
-	path = vegvisir
-	url = https://codeberg.org/vegvisir/vegvisir
--- a/README.md
+++ b/README.md
@ -1,27 +1,73 @@
 # vlw.se
-This is the source code behind [vlw.se](https://vlw.se) which is my personal website that I have written and designed from the ground up. The website is built on top of my own [Vegvisir web framework](https://vegvisir.vlw.se) and its optional REST API is built on top of my [Reflect API framework](https://reflect.vlw.se).
+This is the source code behind [vlw.se](https://vlw.se) which has been written from the ground up by me. This website is built on top of my [Vegvisir web framework](https://vegvisir.vlw.se) and my [Reflect API framework](https://reflect.vlw.se).

 # Installation
-Here's how you get my website up and running on your own machine. Note, I have only tested this on Linux and the install script we will run requires Bash with `coreutils` installed.
+If you for whatever reason want to get this website up and running for yourself this is how that is done.

-## Prerequisites
- A web server
- A MariaDB/MySQL server
- PHP 8.4 or newer with the following extensions enabled:
- - `php8.4-mysql`
- - `php8.4-mbstring`
- The composer package manager
- Bash with `coreutils` installed (for the install script)
+## This website requires the following prerequisites
+- [PHP 8.0+](https://www.php.net/)
+- [MariaDB 14+](https://mariadb.org/)
+- [The NPM package manager](https://www.npmjs.com/)
+- [The Reflect API framework](https://reflect.vlw.se)
+- [The Vegvisir web framework](https://vegvisir.vlw.se)
+- [The composer package manager](https://getcomposer.org/)

-## 1. Clone this repo
-Clone this repository with its submodules. Preferably to a non-public directory - the frameworks will handle that.
-```
-git clone https://codeberg.org/vlw/vlw.se --recurse-submodules --depth 1
-```
+**Confimed supported framework versions:**
+Vegvisir|Reflect
+--|--
+✅ [`3.0.1`](https://codeberg.org/vegvisir/vegvisir/releases/tag/3.0.1)|✅ [`2.7.2`](https://codeberg.org/reflect/reflect/releases/tag/2.7.2)

-## 2. Run the install script
-Run the `install.sh` script from the root directory of this repository.
-```
-./install.sh
-```
-This script will install and configure Vegvisir, Reflect, and the website through a few propmpted steps.
+## Website (Vegvisir)
+1. **Download this repo**
+   
+   Git clone or download this repo to any local folder
+   ```
+   git clone https://codeberg.org/vlw/vlw.se
+   ```
+2. **Download and install Vegvisir**
+   
+   Follow the installation instructions for [Vegvisir](https://vegvisir.vlw.se/docs/installation) and point the `root_path` variable to your local vlw.se folder.
+
+3. **Run the install script**
+
+   This bash script will install dependencies and make npm modules public.
+   ```
+   ./install.sh
+   ```
+
+Et voila! You probably want to install the API-side too but the website itself should now be accessible from your configured Vegvisir host.
+
+## API (Reflect)
+The API (and database) is where most content is stored and served from on this website.
+
+1. **Download this repo**
+
+   **You can skip this if you've already downloaded the repo from step 1 in the website installation.**
+
+   Otherwise... Git clone or download this repo to any local folder
+   ```
+   git clone https://codeberg.org/vlw/vlw.se
+   ```
+
+2. **Download and install Reflect**
+   
+   Follow the installation instructions for [Reflect](https://reflect.vlw.se/docs/installation) and point the `endpoints` variable to the `/api` subdirectory in the local vlw.se folder.
+
+3. **Install dependencies**
+
+   `cd` into the api folder and install dependencies with composer.
+   ```
+   composer install --optimize-autoloader
+   ```
+
+4. **Create and import database**
+
+   [Create and] import the two databases associated with vlw.se data and the Reflect API configurations from `.sql` files on the Releases page.
+
+5. **Set environment variables**
+
+   Make a copy of `/api/.env.example.ini` and change the `[vlwdb]` variables with your MariaDB credentials.
+
+6. **Set environment variables for website**
+
+   It's reasonable to assume if you've installed the website from this repo that you'd also want to use the API with it. Start my making a copy of `/.env.example.ini` (root directory) and change the `[api]` variables to point to your API hostname.
--- a/api/.env.example.ini
+++ b/api/.env.example.ini
@ -0,0 +1,8 @@
+[connect]
+host = ""
+user = ""
+pass = ""
+
+[databases]
+vlw           = ""
+battlestation = ""
--- a/api/coffee/DELETE.php
+++ b/api/coffee/DELETE.php
@ -1,29 +0,0 @@
-<?php
-
-	use Reflect\{Response, Path};
-	use Reflect\Rules\{Ruleset, Rules, Type};
-
-	use VLW\API\API;
-	use VLW\Helpers\UUID;
-	use VLW\Database\Models\Coffee\Coffee;
-	use VLW\Database\Tables\Coffee\Coffee as CoffeeTable;
-
-	require_once Path::root("src/API/API.php");
-	require_once Path::root("src/Database/Models/Coffee/Coffee.php");
-	require_once Path::root("src/Database/Tables/Coffee/Coffee.php");
-
-	final class DELETE_Coffee extends API {
-		public function __construct() {
-			parent::__construct(new Ruleset()->GET([
-				new Rules(CoffeeTable::ID->value)
-					->required()
-					->type(Type::STRING)
-					->min(UUID::LENGTH)
-					->max(UUID::LENGTH)
-			]));
-		}
-
-		public function main(): Response {
-			return new Response(new Coffee($_GET[CoffeeTable::ID->value])->delete());
-		}
-	}
--- a/api/coffee/GET.php
+++ b/api/coffee/GET.php
@ -1,19 +0,0 @@
-<?php
-
-	use Reflect\{Response, Path};
-
-	use VLW\API\API;
-	use VLW\Database\Models\Coffee\Coffee;
-
-	require_once Path::root("src/API/API.php");
-	require_once Path::root("src/Database/Models/Coffee/Coffee.php");
-
-	final class GET_Coffee extends API {
-		public function __construct() {
-			parent::__construct();
-		}
-
-		public function main(): Response {
-			return new Response(Coffee::all());
-		}
-	}
--- a/api/coffee/POST.php
+++ b/api/coffee/POST.php
@ -1,41 +0,0 @@
-<?php
-
-	use Reflect\{Response, Path};
-	use Reflect\Rules\{Ruleset, Rules, Type};
-
-	use VLW\API\API;
-	use VLW\Database\Models\Coffee\Coffee;
-	use VLW\Database\Tables\Coffee\Coffee as CoffeeTable;
-
-	require_once Path::root("src/API/API.php");
-	require_once Path::root("src/Database/Models/Coffee/Coffee.php");
-	require_once Path::root("src/Database/Tables/Coffee/Coffee.php");
-
-	final class POST_Coffee extends API {
-		public function __construct() {
-			parent::__construct(new Ruleset(strict: true)->POST([
-				new Rules(CoffeeTable::DATE_CREATED->value)
-					->type(Type::STRING)
-					->type(Type::NUMBER)
-					->default(null)
-			]));
-		}
-
-		public function main(): Response {
-			$datetime = new DateTimeImmutable();
-
-			// Parse DateTime from POST string
-			if ($_POST[CoffeeTable::DATE_CREATED->value]) {
-				try {
-					// Create DateTimeImmutable from Unix timestamp or datetime string
-					$datetime = gettype($_POST[CoffeeTable::DATE_CREATED->value]) === "integer"
-						? DateTimeImmutable::createFromTimestamp($_POST[CoffeeTable::DATE_CREATED->value])
-						: new DateTimeImmutable($_POST[CoffeeTable::DATE_CREATED->value]);
-				} catch (DateMalformedStringException $error) {
-					return new Response($error->getMessage(), 400);
-				}
-			}
-
-			return new Response(Coffee::new($datetime));
-		}
-	}
--- a/api/composer.json
+++ b/api/composer.json
@ -0,0 +1,8 @@
+{
+    "require": {
+        "reflect/plugin-rules": "^1.5",
+        "victorwesterlund/xenum": "dev-master",
+        "vlw/mysql": "dev-master"
+    },
+    "minimum-stability": "dev"
+}
--- a/api/composer.lock
+++ b/api/composer.lock
@ -0,0 +1,125 @@
+{
+    "_readme": [
+        "This file locks the dependencies of your project to a known state",
+        "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+        "This file is @generated automatically"
+    ],
+    "content-hash": "f3f2b3cb3bd789eee6af4a93f4a6e0f9",
+    "packages": [
+        {
+            "name": "reflect/plugin-rules",
+            "version": "1.5.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/VictorWesterlund/reflect-rules-plugin.git",
+                "reference": "9c837fd1944133edfed70a63ce8b32bf67f0d94b"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/VictorWesterlund/reflect-rules-plugin/zipball/9c837fd1944133edfed70a63ce8b32bf67f0d94b",
+                "reference": "9c837fd1944133edfed70a63ce8b32bf67f0d94b",
+                "shasum": ""
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "ReflectRules\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "GPL-3.0-only"
+            ],
+            "authors": [
+                {
+                    "name": "Victor Westerlund",
+                    "email": "victor.vesterlund@gmail.com"
+                }
+            ],
+            "description": "Add request search paramter and request body constraints to an API built with Reflect",
+            "support": {
+                "issues": "https://github.com/VictorWesterlund/reflect-rules-plugin/issues",
+                "source": "https://github.com/VictorWesterlund/reflect-rules-plugin/tree/1.5.0"
+            },
+            "time": "2024-01-17T11:07:44+00:00"
+        },
+        {
+            "name": "victorwesterlund/xenum",
+            "version": "dev-master",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/VictorWesterlund/php-xenum.git",
+                "reference": "8972f06f42abd1f382807a67e937d5564bb89699"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/VictorWesterlund/php-xenum/zipball/8972f06f42abd1f382807a67e937d5564bb89699",
+                "reference": "8972f06f42abd1f382807a67e937d5564bb89699",
+                "shasum": ""
+            },
+            "default-branch": true,
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "victorwesterlund\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "GPL-3.0-only"
+            ],
+            "authors": [
+                {
+                    "name": "Victor Westerlund",
+                    "email": "victor.vesterlund@gmail.com"
+                }
+            ],
+            "description": "PHP eXtended Enums. The missing quality-of-life features from PHP 8+ Enums",
+            "support": {
+                "issues": "https://github.com/VictorWesterlund/php-xenum/issues",
+                "source": "https://github.com/VictorWesterlund/php-xenum/tree/1.1.1"
+            },
+            "time": "2023-11-20T10:10:39+00:00"
+        },
+        {
+            "name": "vlw/mysql",
+            "version": "dev-master",
+            "source": {
+                "type": "git",
+                "url": "https://codeberg.org/vlw/php-mysql",
+                "reference": "619f43b3bfab9eb034dca3e54c7466055240c861"
+            },
+            "default-branch": true,
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "vlw\\MySQL\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "GPL-3.0-or-later"
+            ],
+            "authors": [
+                {
+                    "name": "Victor Westerlund",
+                    "email": "victor@vlw.se"
+                }
+            ],
+            "description": "Abstraction library for common MySQL/MariaDB DML operations with php-mysqli",
+            "time": "2024-09-25T13:28:15+00:00"
+        }
+    ],
+    "packages-dev": [],
+    "aliases": [],
+    "minimum-stability": "dev",
+    "stability-flags": {
+        "victorwesterlund/xenum": 20,
+        "vlw/mysql": 20
+    },
+    "prefer-stable": false,
+    "prefer-lowest": false,
+    "platform": [],
+    "platform-dev": [],
+    "plugin-api-version": "2.0.0"
+}
--- a/api/endpoints/battlestation/GET.php
+++ b/api/endpoints/battlestation/GET.php
@ -0,0 +1,63 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\ConfigModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/Config.php");
+
+	class GET_Battlestation extends VLWdb {
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(ConfigModel::REF_MB_ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(ConfigModel::FRIENDLY_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_config(): array {
+			return $this->results = $this->db
+				->for(ConfigModel::TABLE)
+				->where($this->query)
+				->order([ConfigModel::DATE_BUILT->value => "DESC"])
+				->select(ConfigModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(ConfigModel::FRIENDLY_NAME->value, $this->query);
+
+			$this->get_config();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/chassis/GET.php
+++ b/api/endpoints/battlestation/chassis/GET.php
@ -0,0 +1,103 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\ChassisModel;
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\ChassisMbModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Chassis.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/ChassisMb.php");
+
+	class GET_BattlestationChassis extends VLWdb {
+		private const REL_MOTHERBOARDS = "motherboards";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(ChassisModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(ChassisModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(ChassisModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(ChassisModel::STORAGE_TWOINCHFIVE->value))
+					->type(Type::NUMBER)
+					->type(Type::NULL)
+					->min(0)
+					->max(parent::MYSQL_TINYINT_MAX_LENGTH),
+
+				(new Rules(ChassisModel::STORAGE_THREEINCHFIVE->value))
+					->type(Type::NUMBER)
+					->type(Type::NULL)
+					->min(0)
+					->max(parent::MYSQL_TINYINT_MAX_LENGTH),
+
+				(new Rules(ChassisModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_motherboards(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_MOTHERBOARDS] = $this->db
+					->for(ChassisMbModel::TABLE)
+					->where([ChassisMbModel::REF_CHASSIS_ID->value => $result[ChassisModel::ID->value]])
+					->select(ChassisMbModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_chassis(): array {
+			return $this->results = $this->db
+				->for(ChassisModel::TABLE)
+				->where($this->query)
+				->order([ChassisModel::DATE_AQUIRED->value => "DESC"])
+				->select(ChassisModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(ChassisModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(ChassisModel::VENDOR_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_chassis();
+
+			// Resolve hardware relationships
+			$this->get_motherboards();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/coolers/GET.php
+++ b/api/endpoints/battlestation/coolers/GET.php
@ -0,0 +1,108 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\{
+		CoolerModel
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\MbCpuCoolerModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Coolers.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbCpuCooler.php");
+
+	class GET_BattlestationCoolers extends VLWdb {
+		private const REL_MOTHERBOARDS = "motherboards";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(CoolerModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(CoolerModel::TYPE_LIQUID->value))
+					->type(Type::BOOLEAN),
+
+				(new Rules(CoolerModel::SIZE_FAN->value))
+					->type(Type::NULL)
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INTR_MAX_LENGTH),
+
+				(new Rules(CoolerModel::SIZE_RADIATOR->value))
+					->type(Type::NULL)
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INTR_MAX_LENGTH),
+
+				(new Rules(CoolerModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(CoolerModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(CoolerModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_motherboards(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_MOTHERBOARDS] = $this->db
+					->for(MbCoolerModel::TABLE)
+					->where([MbCoolerModel::REF_COOLER_ID->value => $result[CoolerModel::ID->value]])
+					->select(MbCoolerModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_coolers(): array {
+			return $this->results = $this->db
+				->for(CoolerModel::TABLE)
+				->where($this->query)
+				->order([CoolerModel::DATE_AQUIRED->value => "DESC"])
+				->select(CoolerModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(CoolerModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(CoolerModel::VENDOR_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_coolers();
+
+			// Resolve hardware relationships
+			$this->get_motherboards();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/cpu/GET.php
+++ b/api/endpoints/battlestation/cpu/GET.php
@ -0,0 +1,117 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\{
+		CpuModel,
+		ClassEnum
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\MbCpuCoolerModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Cpu.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbCpuCooler.php");
+
+	class GET_BattlestationCpu extends VLWdb {
+		private const REL_MOTHERBOARDS = "motherboards";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(CpuModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(CpuModel::CLOCK_BASE->value))
+					->type(Type::NUMBER)
+					->min(1),
+
+				(new Rules(CpuModel::CLOCK_TURBO->value))
+					->type(Type::NUMBER)
+					->min(1),
+
+				(new Rules(CpuModel::CORE_COUNT_PERFORMANCE->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_TINYINT_MAX_LENGTH),
+
+				(new Rules(CpuModel::CORE_COUNT_EFFICIENCY->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_TINYINT_MAX_LENGTH),
+
+				(new Rules(CpuModel::CORE_THREADS->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_TINYINT_MAX_LENGTH),
+
+				(new Rules(CpuModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(CpuModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(CpuModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_motherboards(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_MOTHERBOARDS] = $this->db
+					->for(MbCpuCoolerModel::TABLE)
+					->where([MbCpuCoolerModel::REF_CPU_ID->value => $result[CpuModel::ID->value]])
+					->select(MbCpuCoolerModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_cpu(): array {
+			return $this->results = $this->db
+				->for(CpuModel::TABLE)
+				->where($this->query)
+				->order([CpuModel::DATE_AQUIRED->value => "DESC"])
+				->select(CpuModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(CpuModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(CpuModel::VENDOR_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_cpu();
+
+			// Resolve hardware relationships
+			$this->get_motherboards();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/dram/GET.php
+++ b/api/endpoints/battlestation/dram/GET.php
@ -0,0 +1,115 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\{
+		DramModel,
+		DramFormfactorEnum,
+		DramTechnologyEnum
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\MbDramModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Dram.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbDram.php");
+
+	class GET_BattlestationDram extends VLWdb {
+		private const REL_MOTHERBOARDS = "motherboards";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(DramModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(DramModel::CAPACITY->value))
+					->type(Type::NUMBER)
+					->min(1),
+
+				(new Rules(DramModel::SPEED->value))
+					->type(Type::NUMBER)
+					->min(1),
+
+				(new Rules(DramModel::FORMFACTOR->value))
+					->type(Type::ENUM, DramFormfactorEnum::names()),
+
+				(new Rules(DramModel::TECHNOLOGY->value))
+					->type(Type::ENUM, DramTechnologyEnum::names()),
+
+				(new Rules(DramModel::ECC->value))
+					->type(Type::BOOLEAN),
+
+				(new Rules(DramModel::BUFFERED->value))
+					->type(Type::BOOLEAN),
+
+				(new Rules(DramModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(DramModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(DramModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_motherboards(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_MOTHERBOARDS] = $this->db
+					->for(MbDramModel::TABLE)
+					->where([MbDramModel::REF_DRAM_ID->value => $result[DramModel::ID->value]])
+					->select(MbDramModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_dram(): array {
+			return $this->results = $this->db
+				->for(DramModel::TABLE)
+				->where($this->query)
+				->order([DramModel::DATE_AQUIRED->value => "DESC"])
+				->select(DramModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(DramModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(DramModel::VENDOR_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_dram();
+
+			// Resolve hardware relationships
+			$this->get_motherboards();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/gpu/GET.php
+++ b/api/endpoints/battlestation/gpu/GET.php
@ -0,0 +1,107 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\GpuModel;
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\MbGpuModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Gpu.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbGpu.php");
+
+	class GET_BattlestationGpu extends VLWdb {
+		private const REL_MOTHERBOARDS = "motherboards";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(GpuModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(GpuModel::MEMORY->value))
+					->type(Type::NUMBER)
+					->min(1),
+
+				(new Rules(GpuModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(GpuModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(GpuModel::VENDOR_CHIP_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(GpuModel::VENDOR_CHIP_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(GpuModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_motherboards(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_MOTHERBOARDS] = $this->db
+					->for(MbGpuModel::TABLE)
+					->where([MbGpuModel::REF_GPU_ID->value => $result[GpuModel::ID->value]])
+					->select(MbGpuModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_gpu(): array {
+			return $this->results = $this->db
+				->for(GpuModel::TABLE)
+				->where($this->query)
+				->order([GpuModel::DATE_AQUIRED->value => "DESC"])
+				->select(GpuModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(GpuModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(GpuModel::VENDOR_MODEL->value, $this->query);
+			parent::make_wildcard_search(GpuModel::VENDOR_CHIP_NAME->value, $this->query);
+			parent::make_wildcard_search(GpuModel::VENDOR_CHIP_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_gpu();
+
+			// Resolve hardware relationships
+			$this->get_motherboards();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/mb/GET.php
+++ b/api/endpoints/battlestation/mb/GET.php
@ -0,0 +1,194 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\{
+		MbModel,
+		MbFormfactorEnum
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\{
+		MbGpuModel,
+		MbPsuModel,
+		MbDramModel,
+		MbStorageModel,
+		ChassisMbModel,
+		MbCpuCoolerModel
+	};
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Mb.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbPsu.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbGpu.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbDram.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbStorage.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/ChassisMb.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbCpuCooler.php");
+
+	class GET_BattlestationMb extends VLWdb {
+		private const REL_CPU     = "cpus";
+		private const REL_PSU     = "psus";
+		private const REL_GPU     = "gpus";
+		private const REL_DRAM    = "dram";
+		private const REL_STORAGE = "storage";
+		private const REL_CHASSIS = "chassis";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(MbModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(MbModel::FORMFACTOR->value))
+					->type(Type::ENUM, MbFormfactorEnum::names()),
+
+				(new Rules(MbModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(MbModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(MbModel::NETWORK_ETHERNET->value))
+					->type(Type::NULL)
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(MbModel::NETWORK_WLAN->value))
+					->type(Type::NULL)
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(MbModel::NETWORK_BLUETOOTH->value))
+					->type(Type::NULL)
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(MbModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_chassis(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_CHASSIS] = $this->db
+					->for(ChassisMbModel::TABLE)
+					->where([ChassisMbModel::REF_MB_ID->value => $result[MbModel::ID->value]])
+					->select(ChassisMbModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_psu(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_PSU] = $this->db
+					->for(MbPsuModel::TABLE)
+					->where([MbPsuModel::REF_MB_ID->value => $result[MbModel::ID->value]])
+					->select(MbPsuModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_cpu(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_CPU] = $this->db
+					->for(MbCpuCoolerModel::TABLE)
+					->where([MbCpuCoolerModel::REF_MB_ID->value => $result[MbModel::ID->value]])
+					->select(MbCpuCoolerModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_gpu(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_GPU] = $this->db
+					->for(MbGpuModel::TABLE)
+					->where([MbGpuModel::REF_MB_ID->value => $result[MbModel::ID->value]])
+					->select(MbGpuModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_dram(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_DRAM] = $this->db
+					->for(MbDramModel::TABLE)
+					->where([MbDramModel::REF_MB_ID->value => $result[MbModel::ID->value]])
+					->select(MbDramModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_storage(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_STORAGE] = $this->db
+					->for(MbStorageModel::TABLE)
+					->where([MbStorageModel::REF_MB_ID->value => $result[MbModel::ID->value]])
+					->select(MbStorageModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		// ----
+
+		private function get_motherboards(): array {
+			return $this->results = $this->db
+				->for(MbModel::TABLE)
+				->where($this->query)
+				->order([MbModel::DATE_AQUIRED->value => "DESC"])
+				->select(MbModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(MbModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(MbModel::VENDOR_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_motherboards();
+			
+			// Resolve hardware relationships
+			$this->get_chassis();
+			$this->get_cpu();
+			$this->get_psu();
+			$this->get_gpu();
+			$this->get_dram();
+			$this->get_storage();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/psu/GET.php
+++ b/api/endpoints/battlestation/psu/GET.php
@ -0,0 +1,102 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\{
+		PsuModel,
+		EightyplusRatingEnum
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\MbPsuModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Psu.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbPsu.php");
+
+	class GET_BattlestationPsu extends VLWdb {
+		private const REL_MOTHERBOARDS = "motherboards";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(PsuModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(PsuModel::POWER->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH),
+
+				(new Rules(PsuModel::EIGHTYPLUS_RATING->value))
+					->type(Type::ENUM, EightyplusRatingEnum::names()),
+
+				(new Rules(PsuModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(PsuModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(PsuModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_motherboards(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_MOTHERBOARDS] = $this->db
+					->for(MbPsuModel::TABLE)
+					->where([MbPsuModel::REF_PSU_ID->value => $result[PsuModel::ID->value]])
+					->select(MbPsuModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_psu(): array {
+			return $this->results = $this->db
+				->for(PsuModel::TABLE)
+				->where($this->query)
+				->order([PsuModel::DATE_AQUIRED->value => "DESC"])
+				->select(PsuModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(PsuModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(PsuModel::VENDOR_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_psu();
+
+			// Resolve hardware relationships
+			$this->get_motherboards();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/battlestation/storage/GET.php
+++ b/api/endpoints/battlestation/storage/GET.php
@ -0,0 +1,110 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\{
+		StorageModel,
+		StorageDiskTypeEnum,
+		StorageDiskInterfaceEnum,
+		StorageDiskFormfactorEnum
+	};
+	use VLW\API\Databases\VLWdb\Models\Battlestation\Config\MbStorageModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Battlestation/Storage.php");
+	require_once Path::root("src/databases/models/Battlestation/Config/MbStorage.php");
+
+	class GET_BattlestationStorage extends VLWdb {
+		private const REL_MOTHERBOARDS = "motherboards";
+
+		protected Ruleset $ruleset;
+
+		private array $query;
+		private array $results = [];
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(StorageModel::ID->value))
+					->type(Type::STRING)
+					->min(parent::UUID_LENGTH)
+					->max(parent::UUID_LENGTH),
+
+				(new Rules(StorageModel::DISK_TYPE->value))
+					->type(Type::ENUM, StorageDiskTypeEnum::names()),
+
+				(new Rules(StorageModel::DISK_SIZE->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH),
+
+				(new Rules(StorageModel::DISK_INTERFACE->value))
+					->type(Type::ENUM, StorageDiskInterfaceEnum::names()),
+
+				(new Rules(StorageModel::DISK_FORMFACTOR->value))
+					->type(Type::ENUM, StorageDiskFormfactorEnum::names()),
+
+				(new Rules(StorageModel::VENDOR_NAME->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(StorageModel::VENDOR_MODEL->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(StorageModel::IS_RETIRED->value))
+					->type(Type::BOOLEAN)
+			]);
+
+			parent::__construct(Databases::BATTLESTATION, $this->ruleset);
+
+			// Use a copy of search parameters
+			$this->query = $_GET;
+		}
+
+		private function get_motherboards(): void {
+			foreach ($this->results as &$result) {
+				// Get motherboard id from relationship by chassis id
+				$result[self::REL_MOTHERBOARDS] = $this->db
+					->for(MbStorageModel::TABLE)
+					->where([MbStorageModel::REF_STORAGE_ID->value => $result[StorageModel::ID->value]])
+					->select(MbStorageModel::values())
+					->fetch_all(MYSQLI_ASSOC);
+			}
+		}
+
+		private function get_storage(): array {
+			return $this->results = $this->db
+				->for(StorageModel::TABLE)
+				->where($this->query)
+				->order([StorageModel::DATE_AQUIRED->value => "DESC"])
+				->select(StorageModel::values())
+				->fetch_all(MYSQLI_ASSOC);
+		}
+
+		public function main(): Response {
+			// Set properties as "searchable"
+			parent::make_wildcard_search(StorageModel::VENDOR_NAME->value, $this->query);
+			parent::make_wildcard_search(StorageModel::VENDOR_MODEL->value, $this->query);
+
+			// Get hardware
+			$this->get_storage();
+
+			// Resolve hardware relationships
+			$this->get_motherboards();
+
+			// Return 404 Not Found if response array is empty
+			return new Response($this->results, $this->results ? 200 : 404);
+		}
+	}
--- a/api/endpoints/messages/POST.php
+++ b/api/endpoints/messages/POST.php
@ -0,0 +1,51 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Messages\MessagesModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Messages/Messages.php");
+
+	class POST_Messages extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->POST([
+				(new Rules(MessagesModel::EMAIL->value))
+					->type(Type::STRING)
+					->max(255)
+					->default(null),
+
+				(new Rules(MessagesModel::MESSAGE->value))
+					->required()
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_TEXT_MAX_LENGTH)
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		public function main(): Response {
+			// Use copy of request body as entity
+			$entity = $_POST;
+
+			$entity[MessagesModel::ID->value] = parent::gen_uuid4();
+			$entity[MessagesModel::DATE_CREATED->value] = time();
+
+			return $this->db->for(MessagesModel::TABLE)->insert($entity) === true
+				? new Response($entity[MessagesModel::ID->value], 201)
+				: new Response("Failed to create message", 500);
+		}
+	}
--- a/api/endpoints/search/GET.php
+++ b/api/endpoints/search/GET.php
@ -0,0 +1,59 @@
+<?php
+
+	use Reflect\Call;
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Endpoints;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkModel;
+
+	require_once Path::root("src/Endpoints.php");
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/Work.php");
+
+	class GET_Search extends VLWdb {
+		const GET_QUERY = "q";
+
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(self::GET_QUERY))
+					->required()
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH)
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		private function search_work(): Response {
+			return (new Call(Endpoints::WORK->value))->params([
+				WorkModel::TITLE->value      => $_GET[self::GET_QUERY],
+				WorkModel::SUMMARY->value    => $_GET[self::GET_QUERY]
+			])->get();
+		}
+
+		public function main(): Response {
+			$results = [
+				Endpoints::WORK->value => $this->search_work()->output()
+			];
+
+			// Calculate the total number of results from all searched endpoints
+			$num_results = array_sum(array_map(fn(array $result): int => count($result), array_values($results)));
+
+			// Return 404 if no search results
+			return new Response($results, $num_results > 0 ? 200 : 404);
+		}
+	}
--- a/api/endpoints/work/DELETE.php
+++ b/api/endpoints/work/DELETE.php
@ -0,0 +1,67 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use const VLW\API\RESP_DELETE_OK;
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkModel;
+
+	require_once Path::root("src/Endpoints.php");
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work.php");
+
+	class DELETE_Work extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->POST([
+				(new Rules(WorkModel::ID->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkModel::TITLE->value))
+					->type(Type::STRING)
+					->min(3)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkModel::SUMMARY->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_TEXT_MAX_LENGTH),
+
+				(new Rules(WorkModel::IS_LISTABLE->value))
+					->type(Type::BOOLEAN),
+
+				(new Rules(WorkModel::IS_READABLE->value))
+					->type(Type::BOOLEAN),
+
+				(new Rules(WorkModel::DATE_MODIFIED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH),
+
+				(new Rules(WorkModel::DATE_CREATED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH)
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		public function main(): Response {
+			return $this->db->for(FieldsEnumsModel::TABLE)->delete($_POST) === true
+				? new Response(RESP_DELETE_OK)
+				: new Response("Failed to delete work entity", 500);
+		}
+	}
--- a/api/endpoints/work/GET.php
+++ b/api/endpoints/work/GET.php
@ -0,0 +1,97 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/Work.php");
+
+	class GET_Work extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(WorkModel::ID->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkModel::TITLE->value))
+					->type(Type::STRING)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkModel::SUMMARY->value))
+					->type(Type::STRING)
+					->max(parent::MYSQL_TEXT_MAX_LENGTH),
+
+				(new Rules(WorkModel::IS_LISTABLE->value))
+					->type(Type::BOOLEAN)
+					->default(true),
+
+				(new Rules(WorkModel::IS_READABLE->value))
+					->type(Type::BOOLEAN)
+					->default(true),
+
+				(new Rules(WorkModel::DATE_MODIFIED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH),
+
+				(new Rules(WorkModel::DATE_CREATED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH)
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		public function main(): Response {
+			// Use copy of search paramters as filters
+			$filters = $_GET;
+
+			// Do a wildcard search on the title column if provided
+			if (array_key_exists(WorkModel::TITLE->value, $_GET)) {
+				$filters[WorkModel::TITLE->value] = [
+					"LIKE" => "%{$_GET[WorkModel::TITLE->value]}%"
+				];
+			}
+
+			// Do a wildcard search on the summary column if provided
+			if (array_key_exists(WorkModel::SUMMARY->value, $_GET)) {
+				$filters[WorkModel::SUMMARY->value] = [
+					"LIKE" => "%{$_GET[WorkModel::SUMMARY->value]}%"
+				];
+			}
+
+			$response = $this->db->for(WorkModel::TABLE)
+				->where($filters)
+				->select([
+					WorkModel::ID->value,
+					WorkModel::TITLE->value,
+					WorkModel::SUMMARY->value,
+					WorkModel::IS_LISTABLE->value,
+					WorkModel::IS_READABLE->value,
+					WorkModel::DATE_YEAR->value,
+					WorkModel::DATE_MONTH->value,
+					WorkModel::DATE_DAY->value,
+					WorkModel::DATE_MODIFIED->value,
+					WorkModel::DATE_CREATED->value
+				]);
+
+			return $response->num_rows > 0
+				? new Response($response->fetch_all(MYSQLI_ASSOC))
+				: new Response([], 404);
+		}
+	}
--- a/api/endpoints/work/PATCH.php
+++ b/api/endpoints/work/PATCH.php
@ -0,0 +1,118 @@
+<?php
+
+	use Reflect\Call;
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Endpoints;
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\{
+		WorkModel,
+		WorkPermalinksModel
+	};
+
+	require_once Path::root("src/Endpoints.php");
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/Work.php");
+	require_once Path::root("src/databases/models/Work/WorkPermalinks.php");
+
+	class PATCH_Work extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(WorkModel::ID->value))
+					->required()
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH)
+			]);
+
+			$this->ruleset->POST([
+				(new Rules(WorkModel::TITLE->value))
+					->type(Type::STRING)
+					->min(3)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkModel::SUMMARY->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_TEXT_MAX_LENGTH),
+
+				(new Rules(WorkModel::IS_LISTABLE->value))
+					->type(Type::BOOLEAN),
+
+				(new Rules(WorkModel::IS_READABLE->value))
+					->type(Type::BOOLEAN),
+
+				(new Rules(WorkModel::DATE_MODIFIED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH)
+					->default(time()),
+
+				(new Rules(WorkModel::DATE_CREATED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH)
+			]);
+
+			parent::__construct();
+		}
+
+		// Generate a slug URL from string
+		private static function gen_slug(string $input): string {
+			return strtolower(trim(preg_replace('/[^A-Za-z0-9-]+/', '-', $input)));
+		}
+
+		// Compute and return modeled year, month, and day from Unix timestamp in request body
+		private static function gen_date_created(): array {
+			return [
+				WorkModel::DATE_YEAR->value   => date("Y", $_POST[WorkModel::DATE_CREATED->value]),
+				WorkModel::DATE_MONTH ->value => date("n", $_POST[WorkModel::DATE_CREATED->value]),
+				WorkModel::DATE_DAY->value    => date("j", $_POST[WorkModel::DATE_CREATED->value])
+			];
+		}
+
+		private function get_entity_by_id(string $id): Response {
+			return (new Call(Endpoints::WORK->value))->params([
+				WorkModel::ID->value => $id
+			])->get();
+		}
+
+		public function main(): Response {
+			// Use copy of request body as entity
+			$entity = $_POST;
+
+			// Generate a new slug id from title if changed
+			if ($_POST[WorkModel::TITLE->value]) {
+				$slug = $_POST[WorkModel::TITLE->value];
+
+				// Bail out if the slug generated from the new tite already exist
+				if ($this->get_entity_by_id($slug)) {
+					return new Response("An entity with this title already exist", 409);
+				}
+
+				// Add the new slug to update entity
+				$entity[WorkModel::ID] = $slug;
+			}
+
+			// Generate new work date fields from timestamp
+			if ($_POST[WorkModel::DATE_CREATED->value]) {
+				array_merge($entity, self::gen_date_created());
+			}
+			
+			// Update entity by existing id
+			return $this->db->for(WorkModel::TABLE)->where([WorkModel::ID->value => $_GET[WorkModel::ID->value]])->update($entity) === true
+				? new Response($_GET[WorkModel::ID->value])
+				: new Response("Failed to update entity", 500);
+		}
+	}
--- a/api/endpoints/work/POST.php
+++ b/api/endpoints/work/POST.php
@ -0,0 +1,114 @@
+<?php
+
+	use Reflect\Call;
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Endpoints;
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\{
+		WorkModel,
+		WorkPermalinksModel
+	};
+
+	require_once Path::root("src/Endpoints.php");
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/Work.php");
+	require_once Path::root("src/databases/models/Work/WorkPermalinks.php");
+
+	class POST_Work extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->POST([
+				(new Rules(WorkModel::TITLE->value))
+					->type(Type::STRING)
+					->min(3)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH)
+					->default(null),
+
+				(new Rules(WorkModel::SUMMARY->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_TEXT_MAX_LENGTH)
+					->default(null),
+
+				(new Rules(WorkModel::IS_LISTABLE->value))
+					->type(Type::BOOLEAN)
+					->default(false),
+
+				(new Rules(WorkModel::IS_READABLE->value))
+					->type(Type::BOOLEAN)
+					->default(false),
+
+				(new Rules(WorkModel::DATE_CREATED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH)
+					->default(time())
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		// Generate a slug URL from string
+		private static function gen_slug(string $input): string {
+			return strtolower(trim(preg_replace('/[^A-Za-z0-9-]+/', '-', $input)));
+		}
+
+		// Compute and return modeled year, month, and day from a Unix timestamp
+		private static function gen_date_created(): array {
+			// Use provided timestamp in request
+			$date_created = $_POST[WorkModel::DATE_CREATED->value];
+
+			return [
+				WorkModel::DATE_YEAR->value   => date("Y", $date_created),
+				WorkModel::DATE_MONTH ->value => date("n", $date_created),
+				WorkModel::DATE_DAY->value    => date("j", $date_created)
+			];
+		}
+
+		private function get_entity_by_id(string $id): Response {
+			return (new Call(Endpoints::WORK->value))->params([
+				WorkModel::ID->value => $id
+			])->get();
+		}
+
+		public function main(): Response {
+			// Use copy of request body as entity
+			$entity = $_POST;
+
+			// Generate URL slug from title text or UUID if undefined
+			$entity[WorkModel::ID->value] = $_POST[WorkModel::TITLE->value] 
+				? self::gen_slug($_POST[WorkModel::TITLE->value]) 
+				: parent::gen_uuid4();
+
+			// Bail out here if a work entry with id had been created already
+			if ($this->get_entity_by_id($entity[WorkModel::ID->value])->ok) {
+				return new Response("An entity with id '{$slug}' already exist", 409);
+			}
+
+			// Generate the necessary date fields
+			array_merge($entity, self::gen_date_created());
+
+			// Let's try to insert the new entity
+			if (!$this->db->for(WorkModel::TABLE)->insert($entity)) {
+				return new Response("Failed to insert work entry", 500);
+			}
+
+			// Generate permalink for new entity
+			return (new Call(Endpoints::WORK_PERMALINKS->value))->post([
+				WorkPermalinksModel::ID           => $entity[WorkModel::ID->value],
+				WorkPermalinksModel::REF_WORK_ID  => $entity[WorkModel::ID->value],
+				WorkPermalinksModel::DATE_CREATED => time()
+			]);
+		}
+	}
--- a/api/endpoints/work/actions/DELETE.php
+++ b/api/endpoints/work/actions/DELETE.php
@ -0,0 +1,38 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use const VLW\API\RESP_DELETE_OK;
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkActionsModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/WorkActions.php");
+
+	class DELETE_WorkActions extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			parent::__construct();
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->POST([
+				(new Rules(WorkActionsModel::REF_WORK_ID->value))
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH)
+			]);
+		}
+
+		public function main(): Response {
+			return $this->db->for(WorkActionsModel::TABLE)->delete($_POST) === true
+				? new Response(RESP_DELETE_OK)
+				: new Response("Failed to delete action for work entity", 500);
+		}
+	}
--- a/api/endpoints/work/actions/GET.php
+++ b/api/endpoints/work/actions/GET.php
@ -0,0 +1,49 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkActionsModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/WorkActions.php");
+
+	class GET_WorkActions extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(WorkActionsModel::REF_WORK_ID->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH)
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		public function main(): Response {
+			$response = $this->db->for(WorkActionsModel::TABLE)
+				->where($_GET)
+				->select([
+					WorkActionsModel::REF_WORK_ID->value,
+					WorkActionsModel::DISPLAY_TEXT->value,
+					WorkActionsModel::HREF->value,
+					WorkActionsModel::CLASS_LIST->value,
+					WorkActionsModel::EXTERNAL->value
+				]);
+
+			return $response->num_rows > 0
+				? new Response($response->fetch_all(MYSQLI_ASSOC))
+				: new Response([], 404);
+		}
+	}
--- a/api/endpoints/work/actions/POST.php
+++ b/api/endpoints/work/actions/POST.php
@ -0,0 +1,80 @@
+<?php
+
+	use Reflect\Call;
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Endpoints;
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\{
+		WorkModel,
+		WorkActionsModel
+	};
+
+	require_once Path::root("src/Endpoints.php");
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/Work.php");
+	require_once Path::root("src/databases/models/Work/WorkActions.php");
+
+	class POST_WorkActions extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->POST([
+				(new Rules(WorkActionsModel::REF_WORK_ID->value))
+					->required()
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkActionsModel::DISPLAY_TEXT->value))
+					->required()
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkActionsModel::HREF->value))
+					->required()
+					->type(Type::STRING)
+					->type(Type::NULL)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkActionsModel::CLASS_LIST->value))
+					->type(Type::ARRAY)
+					->min(1)
+					->default([]),
+
+				(new Rules(WorkActionsModel::EXTERNAL->value))
+					->type(Type::BOOLEAN)
+					->default(false)
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		private static function get_entity(): Response {
+			return (new Call(Endpoints::WORK->value))->params([
+				WorkModel::ID->value => $_POST[WorkActionsModel::REF_WORK_ID->value]
+			])->get();
+		}
+
+		public function main(): Response {
+			// Bail out if work entity could not be fetched
+			$entity = self::get_entity();
+			if (!$entity->ok) {
+				return $entity;
+			}
+
+			return $this->db->for(WorkActionsModel::TABLE)->insert($_POST) === true
+				? new Response($_POST[WorkActionsModel::REF_WORK_ID->value], 201)
+				: new Response("Failed to add action to work entity", 500);
+		}
+	}
--- a/api/endpoints/work/permalinks/GET.php
+++ b/api/endpoints/work/permalinks/GET.php
@ -0,0 +1,52 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkPermalinksModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/WorkPermalinks.php");
+
+	class GET_WorkPermalinks extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(WorkPermalinksModel::ID->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkPermalinksModel::REF_WORK_ID->value))
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH)
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		public function main(): Response {
+			$response = $this->db->for(WorkPermalinksModel::TABLE)
+				->where($_GET)
+				->select([
+					WorkPermalinksModel::ID->value,
+					WorkPermalinksModel::REF_WORK_ID->value,
+					WorkPermalinksModel::DATE_CREATED->value
+				]);
+
+			return $response->num_rows > 0
+				? new Response($response->fetch_all(MYSQLI_ASSOC))
+				: new Response([], 404);
+		}
+	}
--- a/api/endpoints/work/permalinks/POST.php
+++ b/api/endpoints/work/permalinks/POST.php
@ -0,0 +1,65 @@
+<?php
+
+	use Reflect\Call;
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkPermalinksModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/WorkPermalinks.php");
+
+	class POST_WorkPermalinks extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->POST([
+				(new Rules(WorkPermalinksModel::ID->value))
+					->required()
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkPermalinksModel::REF_WORK_ID->value))
+					->required()
+					->type(Type::STRING)
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+
+				(new Rules(WorkPermalinksModel::DATE_CREATED->value))
+					->type(Type::NUMBER)
+					->min(1)
+					->max(parent::MYSQL_INT_MAX_LENGTH)
+					->default(time())
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		private static function get_entity(): Response {
+			return (new Call(Endpoints::WORK->value))->params([
+				WorkModel::ID->value => $_POST[WorkTagsModel::REF_WORK_ID->value]
+			])->get();
+		}
+
+		public function main(): Response {
+			// Bail out if work entity could not be fetched
+			$entity = self::get_entity();
+			if (!$entity->ok) {
+				return $entity;
+			}
+
+			return $this->db->for(WorkPermalinksModel::TABLE)->insert($_POST) === true
+				? new Response($_POST[WorkPermalinksModel::ID->value], 201)
+				: new Response("Failed to add permalink to work entity", 500);
+		}
+	}
--- a/api/endpoints/work/tags/DELETE.php
+++ b/api/endpoints/work/tags/DELETE.php
@ -0,0 +1,42 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use const VLW\API\RESP_DELETE_OK;
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\WorkTagsModel;
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/WorkTags.php");
+
+	class DELETE_WorkTags extends VLWdb {
+		private Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(WorkTagsModel::REF_WORK_ID->value))
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+				
+				(new Rules(WorkTagsModel::NAME->value))
+					->type(Type::ENUM, WorkTagsNameEnum::names())
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		public function main(): Response {
+			return $this->db->for(WorkTagsModel::TABLE)->delete($_POST) === true
+				? new Response(RESP_DELETE_OK)
+				: new Response("Failed to delete value from document", 500);
+		}
+	}
--- a/api/endpoints/work/tags/GET.php
+++ b/api/endpoints/work/tags/GET.php
@ -0,0 +1,51 @@
+<?php
+
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\{
+		WorkTagsModel,
+		WorkTagsNameEnum
+	};
+
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/WorkTags.php");
+
+	class GET_WorkTags extends VLWdb {
+		private Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->GET([
+				(new Rules(WorkTagsModel::REF_WORK_ID->value))
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+				
+				(new Rules(WorkTagsModel::NAME->value))
+					->type(Type::ENUM, WorkTagsNameEnum::names())
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		public function main(): Response {
+			$response = $this->db->for(WorkTagsModel::TABLE)
+				->where($_GET)
+				->select([
+					WorkTagsModel::REF_WORK_ID->value,
+					WorkTagsModel::NAME->value
+				]);
+
+			return $response->num_rows > 0
+				? new Response($response->fetch_all(MYSQLI_ASSOC))
+				: new Response([], 404);
+		}
+	}
--- a/api/endpoints/work/tags/POST.php
+++ b/api/endpoints/work/tags/POST.php
@ -0,0 +1,63 @@
+<?php
+
+	use Reflect\Call;
+	use Reflect\Path;
+	use Reflect\Response;
+	use ReflectRules\Type;
+	use ReflectRules\Rules;
+	use ReflectRules\Ruleset;
+
+	use VLW\API\Endpoints;
+	use VLW\API\Databases\VLWdb\{
+		VLWdb,
+		Databases
+	};
+	use VLW\API\Databases\VLWdb\Models\Work\{
+		WorkModel,
+		WorkTagsModel,
+		WorkTagsNameEnum
+	};
+
+	require_once Path::root("src/Endpoints.php");
+	require_once Path::root("src/databases/VLWdb.php");
+	require_once Path::root("src/databases/models/Work/Work.php");
+	require_once Path::root("src/databases/models/Work/WorkTags.php");
+
+	class POST_WorkTags extends VLWdb {
+		protected Ruleset $ruleset;
+
+		public function __construct() {
+			$this->ruleset = new Ruleset(strict: true);
+
+			$this->ruleset->POST([
+				(new Rules(WorkTagsModel::REF_WORK_ID->value))
+					->required()
+					->min(1)
+					->max(parent::MYSQL_VARCHAR_MAX_LENGTH),
+				
+				(new Rules(WorkTagsModel::NAME->value))
+					->required()
+					->type(Type::ENUM, WorkTagsNameEnum::names())
+			]);
+
+			parent::__construct(Databases::VLW, $this->ruleset);
+		}
+
+		private static function get_entity(): Response {
+			return (new Call(Endpoints::WORK->value))->params([
+				WorkModel::ID->value => $_POST[WorkTagsModel::REF_WORK_ID->value]
+			])->get();
+		}
+
+		public function main(): Response {
+			// Bail out if work entity could not be fetched
+			$entity = self::get_entity();
+			if (!$entity->ok) {
+				return $entity;
+			}
+
+			return $this->db->for(WorkTagsModel::TABLE)->insert($_POST) === true
+				? new Response($_POST[WorkTagsModel::REF_WORK_ID->value], 201)
+				: new Response("Failed to add tag to work entity", 500);
+		}
+	}
--- a/api/install.sh
+++ b/api/install.sh
@ -0,0 +1,2 @@
+# Install dependencies
+composer install --optimize-autoloader
--- a/api/languages/GET.php
+++ b/api/languages/GET.php
@ -1,19 +0,0 @@
-<?php
-
-	use Reflect\{Response, Path};
-
-	use VLW\API\API;
-	use VLW\Database\Models\Languages\Language;
-
-	require_once Path::root("src/API/API.php");
-	require_once Path::root("src/Database/Models/Languages/Language.php");
-
-	final class GET_Languages extends API {
-		public function __construct() {
-			parent::__construct();
-		}
-
-		public function main(): Response {
-			return new Response(Language::all());
-		}
-	}
--- a/api/src/Endpoints.php
+++ b/api/src/Endpoints.php
@ -0,0 +1,27 @@
+<?php
+
+	namespace VLW\API;
+
+	// Default string to return when a DELETE request is successful
+	const RESP_DELETE_OK = "OK";
+
+	// Enum of all available VLW endpoints grouped by category
+	enum Endpoints: string {
+		case SEARCH = "/search";
+
+		case MESSAGES = "/messages";
+
+		case WORK         = "/work";
+		case WORK_TAGS    = "/work/tags";
+		case WORK_ACTIONS = "/work/actions";
+
+		case BATTLESTATION         = "/battlestation";
+		case BATTLESTATION_MB      = "/battlestation/mb";
+		case BATTLESTATION_CPU     = "/battlestation/cpu";
+		case BATTLESTATION_GPU     = "/battlestation/gpu";
+		case BATTLESTATION_PSU     = "/battlestation/psu";
+		case BATTLESTATION_DRAM    = "/battlestation/dram";
+		case BATTLESTATION_STORAGE = "/battlestation/storage";
+		case BATTLESTATION_COOLERS = "/battlestation/coolers";
+		case BATTLESTATION_CHASSIS = "/battlestation/chassis";
+	}
--- a/api/src/databases/VLWdb.php
+++ b/api/src/databases/VLWdb.php
@ -0,0 +1,83 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb;
+
+	use Reflect\Path;
+	use Reflect\Request;
+	use Reflect\Response;
+	use ReflectRules\Ruleset;
+
+	use vlw\MySQL\MySQL;
+
+	enum Databases: string {
+		case VLW           = "vlw";
+		case BATTLESTATION = "battlestation";
+	}
+
+	class VLWdb {
+		const UUID_LENGTH = 36;
+
+		const MYSQL_INT_MAX_LENGTH     = 2147483647;
+		const MYSQL_TEXT_MAX_LENGTH    = 65538;
+		const MYSQL_VARCHAR_MAX_LENGTH = 255;
+		const MYSQL_TINYINT_MAX_LENGTH = 255;
+
+		protected readonly MySQL $db;
+
+		public function __construct(Databases $database, Ruleset $ruleset) {
+			// Validate provided Ruleset before attempting to connect to the database
+			self::eval_ruleset_or_exit($ruleset);
+
+			// Create new MariaDB connection
+			$this->db = new MySQL(
+				$_ENV["connect"]["host"],
+				$_ENV["connect"]["user"],
+				$_ENV["connect"]["pass"],
+				$_ENV["databases"][$database->value],
+			);
+		}
+
+		// Generate and return UUID4 string
+		public static function gen_uuid4(): string {
+			return sprintf("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+				// 32 bits for "time_low"
+				mt_rand(0, 0xffff), mt_rand(0, 0xffff),
+		
+				// 16 bits for "time_mid"
+				mt_rand(0, 0xffff),
+		
+				// 16 bits for "time_hi_and_version",
+				// four most significant bits holds version number 4
+				mt_rand(0, 0x0fff) | 0x4000,
+		
+				// 16 bits, 8 bits for "clk_seq_hi_res",
+				// 8 bits for "clk_seq_low",
+				// two most significant bits holds zero and one for variant DCE1.1
+				mt_rand(0, 0x3fff) | 0x8000,
+		
+				// 48 bits for "node"
+				mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
+			);
+		}
+
+		// Mutate the value by array key $property_name into a libmysqldriver\MySQL custom operator
+		// https://codeberg.org/vlw/php-mysql#define-custom-operators
+		public static function make_wildcard_search(string $property_name, array &$filters): array {
+			// Bail out if property name is not set in filters array or if its value is null
+			if (!array_key_exists($property_name, $filters) || $filters[$property_name] === null) {
+				return $filters;
+			}
+
+			// Mutate filter value into a custom operator array
+			$filters[$property_name] = [
+				"LIKE" => "%{$filters[$property_name]}%"
+			];
+
+			return $filters;
+		}
+
+		// Bail out if provided ReflectRules\Ruleset is invalid
+		private static function eval_ruleset_or_exit(Ruleset $ruleset): ?Response {
+			return !$ruleset->is_valid() ? new Response($ruleset->get_errors(), 422) : null;
+		}
+	}
--- a/api/src/databases/models/Battlestation/Chassis.php
+++ b/api/src/databases/models/Battlestation/Chassis.php
@ -0,0 +1,19 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	use victorwesterlund\xEnum;
+
+	enum ChassisModel: string {
+		use xEnum;
+		
+		const TABLE = "chassis";
+
+		case ID                    = "id";
+		case VENDOR_NAME           = "vendor_name";
+		case VENDOR_MODEL          = "vendor_model";
+		case STORAGE_TWOINCHFIVE   = "storage_2i5hi";
+		case STORAGE_THREEINCHFIVE = "storage_3i5hi";
+		case DATE_AQUIRED          = "date_aquired";
+		case IS_RETIRED            = "is_retired";
+	}
--- a/api/src/databases/models/Battlestation/Config/ChassisMb.php
+++ b/api/src/databases/models/Battlestation/Config/ChassisMb.php
@ -0,0 +1,14 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation\Config;
+
+	use victorwesterlund\xEnum;
+
+	enum ChassisMbModel: string {
+		use xEnum;
+		
+		const TABLE = "config_chassis_mb";
+
+		case REF_CHASSIS_ID = "ref_chassis_id";
+		case REF_MB_ID      = "ref_mb_id";
+	}
--- a/api/src/databases/models/Battlestation/Config/Config.php
+++ b/api/src/databases/models/Battlestation/Config/Config.php
@ -0,0 +1,15 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation\Config;
+
+	use victorwesterlund\xEnum;
+
+	enum ConfigModel: string {
+		use xEnum;
+		
+		const TABLE = "config";
+
+		case REF_MB_ID     = "ref_mb_id";
+		case FRIENDLY_NAME = "friendly_name";
+		case DATE_BUILT    = "date_built";
+	}
--- a/api/src/databases/models/Battlestation/Config/MbCpuCooler.php
+++ b/api/src/databases/models/Battlestation/Config/MbCpuCooler.php
@ -0,0 +1,24 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation\Config;
+
+	use victorwesterlund\xEnum;
+
+	enum SocketTypeEnum {
+		use xEnum;
+
+		case SLOTTED;
+		case INTEGRATED;
+	}
+
+	enum MbCpuCoolerModel: string {
+		use xEnum;
+		
+		const TABLE = "config_mb_cpu_cooler";
+
+		case REF_MB_ID     = "ref_mb_id";
+		case REF_CPU_ID    = "ref_cpu_id";
+		case REF_COOLER_ID = "ref_cooler_id";
+		case SOCKET        = "socket";
+		case SOCKET_TYPE   = "socket_type";
+	}
--- a/api/src/databases/models/Battlestation/Config/MbDram.php
+++ b/api/src/databases/models/Battlestation/Config/MbDram.php
@ -0,0 +1,23 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation\Config;
+
+	use victorwesterlund\xEnum;
+
+	enum SocketTypeModel {
+		use xEnum;
+
+		case SLOTTED;
+		case INTEGRATED;
+	}
+
+	enum MbDramModel: string {
+		use xEnum;
+
+		const TABLE = "config_mb_dram";
+
+		case REF_MB_ID   = "ref_mb_id";
+		case REF_DRAM_ID = "ref_dram_id";
+		case SOCKET      = "socket";
+		case SOCKET_TYPE = "socket_type";
+	}
--- a/api/src/databases/models/Battlestation/Config/MbGpu.php
+++ b/api/src/databases/models/Battlestation/Config/MbGpu.php
@ -0,0 +1,14 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation\Config;
+
+	use victorwesterlund\xEnum;
+
+	enum MbGpuModel: string {
+		use xEnum;
+		
+		const TABLE = "config_mb_gpu";
+
+		case REF_MB_ID  = "ref_mb_id";
+		case REF_GPU_ID = "ref_gpu_id";
+	}
--- a/api/src/databases/models/Battlestation/Config/MbPsu.php
+++ b/api/src/databases/models/Battlestation/Config/MbPsu.php
@ -0,0 +1,14 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation\Config;
+
+	use victorwesterlund\xEnum;
+
+	enum MbPsuModel: string {
+		use xEnum;
+		
+		const TABLE = "config_mb_psu";
+
+		case REF_MB_ID  = "ref_mb_id";
+		case REF_PSU_ID = "ref_psu_id";
+	}
--- a/api/src/databases/models/Battlestation/Config/MbStorage.php
+++ b/api/src/databases/models/Battlestation/Config/MbStorage.php
@ -0,0 +1,25 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation\Config;
+
+	use victorwesterlund\xEnum;
+
+	enum MbStorageSlotFormfactorEnum: string {
+		use xEnum;
+
+		case TWODOTFIVE   = "2.5";
+		case THREEDOTFIVE = "3.5";
+		case MDOTTWO      = "M.2";
+		case EXTERNAL     = "EXTERNAL";
+	}
+
+	enum MbStorageModel: string {
+		use xEnum;
+		
+		const TABLE = "config_mb_storage";
+
+		case REF_MB_ID       = "ref_mb_id";
+		case REF_STORAGE_ID  = "ref_storage_id";
+		case INTERFACE       = "interface";
+		case SLOT_FORMFACTOR = "slot_formfactor";
+	}
--- a/api/src/databases/models/Battlestation/Coolers.php
+++ b/api/src/databases/models/Battlestation/Coolers.php
@ -0,0 +1,16 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	enum CoolersModel: string {
+		const TABLE = "coolers";
+
+		case ID            = "id";
+		case TYPE_LIQUID   = "type_liquid";
+		case SIZE_FAN      = "size_fan";
+		case SIZE_RADIATOR = "size_radiator";
+		case VENDOR_NAME   = "vendor_name";
+		case VENDOR_MODEL  = "vendor_model";
+		case DATE_AQUIRED  = "date_aquired";
+		case IS_RETIRED    = "is_retired";
+	}
--- a/api/src/databases/models/Battlestation/Cpu.php
+++ b/api/src/databases/models/Battlestation/Cpu.php
@ -0,0 +1,31 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	use victorwesterlund\xEnum;
+
+	enum ClassEnum {
+		use xEnum;
+
+		case DESKTOP;
+		case LAPTOP;
+		case SERVER;
+	}
+
+	enum CpuModel: string {
+		use xEnum;
+		
+		const TABLE = "cpu";
+
+		case ID                     = "id";
+		case CPU_CLASS              = "class";
+		case CLOCK_BASE             = "clock_base";
+		case CLOCK_TURBO            = "clock_turbo";
+		case CORE_COUNT_PERFORMANCE = "core_count_performance";
+		case CORE_COUNT_EFFICIENCY  = "core_count_efficiency";
+		case CORE_THREADS           = "core_threads";
+		case VENDOR_NAME            = "vendor_name";
+		case VENDOR_MODEL           = "vendor_model";
+		case DATE_AQUIRED           = "date_aquired";
+		case IS_RETIRED             = "is_retired";
+	}
--- a/api/src/databases/models/Battlestation/Dram.php
+++ b/api/src/databases/models/Battlestation/Dram.php
@ -0,0 +1,37 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	use victorwesterlund\xEnum;
+
+	enum DramFormfactorEnum {
+		use xEnum;
+
+		case DIMM;
+		case SODIMM;
+	}
+
+	enum DramTechnologyEnum {
+		use xEnum;
+
+		case DDR4;
+		case DDR5;
+	}
+
+	enum DramModel: string {
+		use xEnum;
+		
+		const TABLE = "dram";
+
+		case ID           = "id";
+		case CAPACITY     = "capacity";
+		case SPEED        = "speed";
+		case FORMFACTOR   = "formfactor";
+		case TECHNOLOGY   = "technology";
+		case ECC          = "ecc";
+		case BUFFERED     = "buffered";
+		case VENDOR_NAME  = "vendor_name";
+		case VENDOR_MODEL = "vendor_model";
+		case DATE_AQUIRED = "date_aquired";
+		case IS_RETIRED   = "is_retired";
+	}
--- a/api/src/databases/models/Battlestation/Gpu.php
+++ b/api/src/databases/models/Battlestation/Gpu.php
@ -0,0 +1,20 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	use victorwesterlund\xEnum;
+
+	enum GpuModel: string {
+		use xEnum;
+		
+		const TABLE = "gpu";
+
+		case ID                = "id";
+		case MEMORY            = "memory";
+		case VENDOR_NAME       = "vendor_name";
+		case VENDOR_MODEL      = "vendor_model";
+		case VENDOR_CHIP_NAME  = "vendor_chip_name";
+		case VENDOR_CHIP_MODEL = "vendor_chip_model";
+		case DATE_AQUIRED      = "date_aquired";
+		case IS_RETIRED        = "is_retired";
+	}
--- a/api/src/databases/models/Battlestation/Mb.php
+++ b/api/src/databases/models/Battlestation/Mb.php
@ -0,0 +1,30 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	use victorwesterlund\xEnum;
+
+	enum MbFormfactorEnum {
+		use xEnum;
+
+		case ATX;
+		case MTX;
+		case ITX;
+		case LAPTOP;
+	}
+
+	enum MbModel: string {
+		use xEnum;
+
+		const TABLE = "mb";
+
+		case ID                = "id";
+		case FORMFACTOR        = "formfactor";
+		case VENDOR_NAME       = "vendor_name";
+		case VENDOR_MODEL      = "vendor_model";
+		case NETWORK_ETHERNET  = "network_ethernet";
+		case NETWORK_WLAN      = "network_wlan";
+		case NETWORK_BLUETOOTH = "network_bluetooth";
+		case DATE_AQUIRED      = "date_aquired";
+		case IS_RETIRED        = "is_retired";
+	}
--- a/api/src/databases/models/Battlestation/Psu.php
+++ b/api/src/databases/models/Battlestation/Psu.php
@ -0,0 +1,31 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	use victorwesterlund\xEnum;
+
+	enum EightyplusRatingEnum {
+		use xEnum;
+
+		case BASE;
+		case BRONZE;
+		case SILVER;
+		case GOLD;
+		case PLATINUM;
+		case TITANIUM;
+	}
+
+	enum PsuModel: string {
+		use xEnum;
+		
+		const TABLE = "psu";
+
+		case ID                = "id";
+		case POWER             = "power";
+		case VENDOR_NAME       = "vendor_name";
+		case VENDOR_MODEL      = "vendor_model";
+		case TYPE_MODULAR      = "type_modular";
+		case EIGHTYPLUS_RATING = "80plus_rating";
+		case DATE_AQUIRED      = "date_aquired";
+		case IS_RETIRED        = "is_retired";
+	}
--- a/api/src/databases/models/Battlestation/Storage.php
+++ b/api/src/databases/models/Battlestation/Storage.php
@ -0,0 +1,45 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Battlestation;
+
+	use victorwesterlund\xEnum;
+
+	enum StorageDiskTypeEnum {
+		use xEnum;
+
+		case SSD;
+		case HDD;
+	}
+
+	enum StorageDiskInterfaceEnum {
+		use xEnum;
+
+		case SATA;
+		case NVME;
+		case USB;
+	}
+
+	enum StorageDiskFormfactorEnum{
+		use xEnum;
+
+		case TWODOTFIVE;
+		case THREEDOTFIVE;
+		case MDOTTWO;
+	}
+
+	enum StorageModel: string {
+		use xEnum;
+		
+		const TABLE = "storage";
+
+		case ID              = "id";
+		case DISK_TYPE       = "disk_type";
+		case DISK_SIZE       = "disk_size";
+		case DISK_SECTORS    = "disk_sectors";
+		case DISK_INTERFACE  = "disk_interface";
+		case DISK_FORMFACTOR = "disk_formfactor";
+		case VENDOR_NAME     = "vendor_name";
+		case VENDOR_MODEL    = "vendor_model";
+		case DATE_AQUIRED    = "date_aquired";
+		case IS_RETIRED      = "is_retired";
+	}
--- a/api/src/databases/models/Messages/Messages.php
+++ b/api/src/databases/models/Messages/Messages.php
@ -0,0 +1,15 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Messages;
+
+	enum MessagesModel: string {
+		const TABLE = "messages";
+
+		case ID           = "id";
+		case EMAIL        = "email";
+		case MESSAGE      = "message";
+		case IS_READ      = "is_read";
+		case IS_SPAM      = "is_spam";
+		case IS_SAVED     = "is_saved";
+		case DATE_CREATED = "date_created";
+	}
--- a/api/src/databases/models/Work/Work.php
+++ b/api/src/databases/models/Work/Work.php
@ -0,0 +1,19 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Work;
+
+	enum WorkModel: string {
+		const TABLE = "work";
+
+		case ID            = "id";
+		case TITLE         = "title";
+		case SUMMARY       = "summary";
+		case COVER_SRCSET  = "cover_srcset";
+		case IS_LISTABLE   = "is_listable";
+		case IS_READABLE   = "is_readable";
+		case DATE_YEAR     = "date_year";
+		case DATE_MONTH    = "date_month";
+		case DATE_DAY      = "date_day";
+		case DATE_MODIFIED = "date_modified";
+		case DATE_CREATED  = "date_created";
+	}
--- a/api/src/databases/models/Work/WorkActions.php
+++ b/api/src/databases/models/Work/WorkActions.php
@ -0,0 +1,13 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Work;
+	
+	enum WorkActionsModel: string {
+		const TABLE = "work_actions";
+		
+		case REF_WORK_ID  = "ref_work_id";
+		case DISPLAY_TEXT = "display_text";
+		case HREF         = "href";
+		case CLASS_LIST   = "class_list";
+		case EXTERNAL     = "external";
+	}
--- a/api/src/databases/models/Work/WorkMedia.php
+++ b/api/src/databases/models/Work/WorkMedia.php
@ -0,0 +1,10 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Work;
+
+	enum WorkMediaModel: string {
+		const TABLE = "work_media";
+
+		case ANCHOR = "anchor";
+		case MEDIA  = "media";
+	}
--- a/api/src/databases/models/Work/WorkPermalinks.php
+++ b/api/src/databases/models/Work/WorkPermalinks.php
@ -0,0 +1,11 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Work;
+	
+	enum WorkPermalinksModel: string {
+		const TABLE = "work_permalinks";
+		
+		case SLUG                   = "slug";
+		case ANCHOR                 = "anchor";
+		case DATE_TIMESTAMP_CREATED = "date_timestamp_created";
+	}
--- a/api/src/databases/models/Work/WorkTags.php
+++ b/api/src/databases/models/Work/WorkTags.php
@ -0,0 +1,20 @@
+<?php
+
+	namespace VLW\API\Databases\VLWdb\Models\Work;
+
+	use victorwesterlund\xEnum;
+
+	enum WorkTagsNameEnum {
+		use xEnum;
+
+		case VLW;
+		case RELEASE;
+		case WEBSITE;
+	}
+
+	enum WorkTagsModel: string {
+		const TABLE = "work_tags";
+
+		case REF_WORK_ID = "ref_work_id";
+		case NAME        = "name";
+	}
--- a/api/update/GET.php
+++ b/api/update/GET.php
@ -1,71 +0,0 @@
-<?php
-
-	use \vlw\xEnum;
-	use Reflect\{Response, Path};
-	use Reflect\Rules\{Ruleset, Rules, Type};
-
-	use VLW\API\API;
-	use VLW\Helpers\{
-		Forgejo,
-		GenerateSearch,
-		GenerateTimeline
-	};
-
-	require_once Path::root("src/API/API.php");
-	require_once Path::root("src/Helpers/Forgejo.php");
-	require_once Path::root("src/Helpers/GenerateSearch.php");
-	require_once Path::root("src/Helpers/GenerateTimeline.php");
-
-	enum ServiceEnum: string {
-		use xEnum;
-
-		case ALL      = "all";
-		case SEARCH   = "search";
-		case FORGEJO  = "forgejo";
-		case TIMELINE = "timeline";
-	}
-
-	final class GET_Update extends API {
-		private const KEY_SERVICE = "service";
-
-		public function __construct() {
-			parent::__construct(new Ruleset()->GET([
-				new Rules(self::KEY_SERVICE)
-					->type(Type::ENUM, ServiceEnum::values())
-					->default(ServiceEnum::ALL->value)
-			]));
-		}
-
-		public function main(): Response {
-			switch ($_GET[self::KEY_SERVICE]) {
-				case ServiceEnum::FORGEJO->value:
-					return new Response($this->update_forgejo());
-
-				case ServiceEnum::SEARCH->value:
-					return new Response($this->update_search());
-
-				case ServiceEnum::TIMELINE->value:
-					return new Response($this->update_timeline());
-
-				case ServiceEnum::ALL->value:
-				default:
-					return new Response(
-						$this->update_timeline() &&
-						$this->update_search() &&
-						$this->update_forgejo()
-					);
-			}
-		}
-		
-		private function update_timeline(): bool {
-			return new GenerateTimeline()->generate();
-		}
-		
-		private function update_search(): bool {
-			return new GenerateSearch()->generate();
-		}
-
-		private function update_forgejo(): bool {
-			return new Forgejo()->update();
-		}
-	}
--- a/api/work/GET.php
+++ b/api/work/GET.php
@ -1,28 +0,0 @@
-<?php
-
-	use Reflect\{Response, Path};
-
-	use VLW\API\API;
-	use VLW\Database\Models\Work\{Work, Tag};
-
-	require_once Path::root("src/API/API.php");
-	require_once Path::root("src/Database/Models/Work/Tag.php");
-	require_once Path::root("src/Database/Models/Work/Work.php");
-
-	final class GET_Work extends API {
-		private static function entity(Work $work): object {
-			return (object) [
-				"tags"    => array_map(fn(Tag $tag): string => $tag->label->name, Tag::from($work)),
-				"actions" => [],
-				"details" => $work
-			];
-		}
-
-		public function __construct() {
-			parent::__construct();
-		}
-
-		public function main(): Response {
-			return new Response(array_map(fn(Work $work): object => self::entity($work), Work::all()));
-		}
-	}
--- a/public/assets/css/fonts.css
+++ b/public/assets/css/fonts.css
--- a/assets/css/pages/about.css
+++ b/assets/css/pages/about.css
@ -0,0 +1,88 @@
+/* # Overrides */
+
+:root {
+	--primer-color-accent: 148, 255, 21;
+	--color-accent: rgb(var(--primer-color-accent));
+}
+
+vv-shell {
+	display: flex;
+	flex-direction: column;
+	gap: var(--padding);
+}
+
+/* # Sections */
+
+/* ## Divider */
+
+vv-shell > hr {
+	border-color: rgba(255, 255, 255, .1);
+}
+
+/* ## About */
+
+section.about {
+	display: flex;
+	flex-direction: column;
+	gap: calc(var(--padding) / 2);
+}
+
+section.about p:first-of-type:first-letter {
+	font-size: 1.8rem;
+	font-weight: bold;
+	margin-right: .1rem;
+	color: var(--color-accent);
+}
+
+section.about span.interests {
+	-webkit-user-select: none;
+	user-select: none;
+	color: var(--color-accent);
+	animation: interests-hue 5s infinite linear;
+}
+
+section.about p i:not(:hover) {
+	opacity: .3;
+}
+
+/* # Interests */
+
+div.interests {
+	--text-shadow-blur: 30px;
+	
+	transition: 300ms opacity;
+	position: fixed;
+	top: 0;
+	left: 0;
+	width: 100%;
+	height: 100%;
+	font-weight: bold;
+	pointer-events: none;
+	font-size: clamp(16px, 15vw, 50px);
+	color: var(--color-accent);
+	overflow: hidden;
+	opacity: 0;
+	z-index: 200;
+}
+
+div.interests.active {
+	opacity: 1;
+}
+
+div.interests p {
+	transition: 500ms transform cubic-bezier(.34,0,0,.99);
+	position: absolute;
+	text-shadow: 
+		0 0 var(--text-shadow-blur) black,
+		0 0 var(--text-shadow-blur) black,
+		0 0 var(--text-shadow-blur) black,
+		0 0 var(--text-shadow-blur) black,
+		0 0 var(--text-shadow-blur) black;
+}
+
+@keyframes interests-hue {
+	to {
+		-webkit-filter: hue-rotate(360deg);
+		filter: hue-rotate(360deg);
+	}
+}
--- a/assets/css/pages/about/battlestation-retired.css
+++ b/assets/css/pages/about/battlestation-retired.css
@ -0,0 +1,45 @@
+/* # Overrides */
+
+:root {
+	--primer-color-accent: 148, 255, 21;
+	--color-accent: rgb(var(--primer-color-accent));
+}
+
+vv-shell {
+	display: flex;
+	flex-direction: column;
+	gap: var(--padding);
+}
+
+/* # Content */
+
+/* ## Title */
+
+section.title {
+	display: flex;
+	flex-direction: column;
+	gap: 5px;
+}
+
+/* ## Actions */
+
+section.actions {
+	display: grid;
+	grid-template-columns: repeat(3, 1fr);
+	gap: var(--padding);
+}
+
+/* # Size quries */
+
+@media (max-width: 800px) {
+	section.actions {
+		grid-template-columns: repeat(2, 1fr);
+	}
+}
+
+@media (max-width: 600px) {
+	section.actions {
+		display: flex;
+		flex-direction: column;
+	}
+}
--- a/assets/css/pages/about/battlestation.css
+++ b/assets/css/pages/about/battlestation.css
@ -0,0 +1,290 @@
+/* # Overrides */
+
+:root {
+	--primer-color-accent: 148, 255, 21;
+	--color-accent: rgb(var(--primer-color-accent));
+}
+
+vv-shell {
+	display: flex;
+	flex-direction: column;
+	gap: var(--padding);
+}
+
+/* # Content */
+
+/* ## Title */
+
+section.title {
+	display: flex;
+	flex-direction: column;
+	gap: 5px;
+	padding: calc(var(--padding) * 1.5);
+	background-color: rgba(var(--primer-color-accent), .1);
+	border-radius: 6px;
+}
+
+section.title > div {
+	margin-top: calc(var(--padding) / 2);
+	display: flex;
+	gap: var(--padding);
+}
+
+/* ## Heading */
+
+section.heading h1::before,
+section.heading h1::after {
+	opacity: .4;
+}
+
+section.heading h1::before {
+	content: "“";
+}
+
+section.heading h1::after {
+	content: "”";
+}
+
+/* ## Config */
+
+section.config {
+	position: relative;
+	display: grid;
+	grid-template-columns: 300px 1fr;
+	gap: calc(var(--padding) * 2);
+}
+
+section.config:nth-child(4n+2) {
+	grid-template-columns: 1fr 300px;
+}
+
+section.config:nth-child(4n+2) > svg {
+	order: 1;
+}
+
+/* ### PC */
+
+section.config > svg {
+	position: sticky;
+	top: calc(var(--running-size) + var(--padding));
+	width: 100%;
+}
+
+section.config > svg :is(rect, path) {
+	transition: 300ms;
+	stroke: white;
+}
+
+section.config > svg.active :is(rect, path),
+section.config > svg:hover :is(rect, path) {
+	opacity: .4;
+}
+
+section.config > svg g.active rect,
+section.config > svg g.active path,
+section.config > svg g:not(.group):hover rect,
+section.config > svg g:not(.group):hover path {
+	opacity: 1;
+	stroke: var(--color-accent);
+}
+
+section.config > svg g.active rect,
+section.config > svg g:not(.group):hover rect {
+	filter: drop-shadow(0 0 10px rgba(var(--primer-color-accent), .4));
+}
+
+/* #### Case */
+
+section.config g.case:not(:hover, .active) :is(rect, path) {
+	opacity: .2;
+}
+
+section.config > svg g.active path,
+section.config > svg g:not(.group):hover path {
+	fill: var(--color-accent);
+}
+
+/* #### Motherboard */
+
+section.config > svg .mb .chips {
+	opacity: 0;
+}
+
+/* #### Active states */
+
+section.config > svg g:not(.group) {
+	display: none;
+}
+
+section.config[data-dram="1"] > svg g.drams g.dram:nth-child(1),
+section.config[data-dram="2"] > svg g.drams g.dram:nth-child(3n+1),
+section.config[data-dram="3"] > svg g.drams g.dram:nth-child(-n+3),
+section.config[data-dram="4"] > svg g.drams g.dram,
+
+section.config[data-drives-mdottwo="1"] > svg g.mdottwo g.drive:nth-child(1),
+section.config[data-drives-mdottwo="2"] > svg g.mdottwo g.drive:nth-child(-n+2),
+section.config[data-drives-mdottwo="3"] > svg g.mdottwo g.drive:nth-child(-n+3),
+
+section.config[data-drives-twodotfive="1"] > svg g.twodotfive g.drive:nth-child(1),
+section.config[data-drives-twodotfive="2"] > svg g.twodotfive g.drive:nth-child(-n+2),
+section.config[data-drives-twodotfive="3"] > svg g.twodotfive g.drive:nth-child(-n+3),
+
+section.config[data-drives-threedotfive="1"] > svg g.threedotfive g.drive:nth-child(1),
+section.config[data-drives-threedotfive="2"] > svg g.threedotfive g.drive:nth-child(-n+2),
+section.config[data-drives-threedotfive="3"] > svg g.threedotfive g.drive:nth-child(-n+3),
+
+section.config[data-mb="1"] > svg g.mb,
+section.config[data-psu="1"] > svg g.psu,
+section.config[data-gpu="1"] > svg g.gpu,
+section.config[data-cpu="1"] > svg g.cpu,
+section.config[data-case="1"] > svg g.case {
+	display: initial;
+}
+
+/* ## Specs */
+
+section.config .specs {
+	position: relative;
+	display: flex;
+	flex-direction: column;
+	gap: calc(var(--padding) / 2);
+	border-radius: 6px;
+}
+
+section.config .specs :is(.spec, .group) {
+	--border-width: 4px;
+
+	transition: 300ms background-color, 300ms border-color, 500ms box-shadow;
+	padding: calc(var(--padding) - var(--border-width));
+	border: solid var(--border-width) transparent;
+	background-color: rgba(255, 255, 255, .03);
+	border-radius: 6px;
+	cursor: pointer;
+}
+
+section.config .specs :is(.spec, .group) * {
+	pointer-events: none;
+}
+
+/* ### Active state */
+
+section.config .specs.active {
+	background-color: rgba(255, 255, 255, .03);
+}
+
+section.config .specs.active :is(.group, .spec:not(.active)) {
+	display: none;
+}
+
+/* ### Spec */
+
+section.config .specs .spec {
+	display: flex;
+	flex-direction: column;
+}
+
+section.config .specs .spec:hover {
+	border-color: rgba(255, 255, 255, .05);
+	background-color: rgba(255, 255, 255, .1);
+	box-shadow: 0 0 30px 10px rgba(255, 255, 255, .05);
+}
+
+section.config .specs .spec.active {
+	border-color: var(--color-accent);
+	background-color: rgba(var(--primer-color-accent), .1);
+	box-shadow: 0 0 30px 10px rgba(var(--primer-color-accent), .05);
+	cursor: initial;
+}
+
+section.config .specs.active .spec.active {
+	position: sticky;
+	top: calc(var(--running-size) + var(--padding));
+}
+
+section.config .specs .spec h3 {
+	color: rgba(255, 255, 255, .3);
+}
+
+section.config .specs .spec span {
+	color: white;
+}
+
+section.config .specs .spec > div {
+	display: none;
+	grid-template-columns: repeat(2, 1fr);
+	gap: calc(var(--padding) / 2);
+	margin-top: var(--padding);
+}
+
+section.config .specs .spec.active > div {
+	display: grid;
+}
+
+section.config .specs .spec > div label {
+	color: var(--color-accent);
+}
+
+section.config .specs .spec > svg {
+	display: none;
+	height: calc(var(--padding) / 2);
+	margin: 0 auto;
+	margin-top: calc(var(--padding) / 2);
+	fill: var(--color-accent);
+}
+
+/* ### Group */
+
+section.config .specs .group {
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+}
+
+section.config .specs .group.active {
+	background-color: rgba(255, 255, 255, .2);
+}
+
+section.config .specs .group:hover {
+	background-color: rgba(255, 255, 255, .1);
+}
+
+section.config .specs .group.active:hover {
+	background-color: rgba(255, 255, 255, .3);
+}
+
+section.config .specs .group > svg {
+	transition: 300ms transform;
+	fill: var(--color-accent);
+	height: 10px;
+}
+
+section.config .specs .group.active > svg {
+	transform: rotateX(180deg);
+}
+
+/* #### Collection */
+
+section.config .specs .collection {
+	display: none;
+}
+
+section.config .specs .group.active + .collection {
+	display: contents;
+}
+
+/* # Size quries */
+
+@media (max-width: 700px) {
+	section.title > div {
+		flex-direction: column;
+	}
+
+	section.config,
+	section.config:nth-child(4n+2) {
+		grid-template-columns: 1fr;
+	}
+
+	section.config > svg {
+		display: none;
+	}
+}
--- a/public/assets/css/pages/contact.css
+++ b/public/assets/css/pages/contact.css
@ -3,7 +3,6 @@
 :root {
 	--primer-color-accent: 255, 195, 255;
 	--color-accent: rgb(var(--primer-color-accent));
-	--hue-accent: 200deg;
 }

 vv-shell {
@ -29,6 +28,10 @@ section.center {
 	text-align: center;
 }

+section.fade {
+	opacity: .3;
+}
+
 /* ## Social */

 section.social {
@ -68,7 +71,7 @@ section.social social:hover {
 	fill: var(--color-accent);
 }

-section.social social p.hovering {
+section.social social.hovering p {
 	display: initial;
 }

@ -78,12 +81,11 @@ section.pgp {
 	max-width: 800px;
 	position: relative;
 	display: flex;
-	border-radius: 12px;
 	flex-direction: column;
 	gap: var(--padding);
 	text-align: center;
 	background-color: rgba(var(--primer-color-accent), .15);
-	padding: var(--padding);
+	padding: calc(var(--padding) * 1.5);
 	transform: rotate(-1.5deg);
 }

@ -106,19 +108,6 @@ section.pgp .buttons {
 	gap: var(--padding);
 }

-/* ## Blockquote */
-
-cite {
-	text-decoration: underline;
-	text-decoration-style: dotted;
-	text-decoration-color: rgba(var(--primer-color-accent), .5);
-	text-decoration-thickness: .1em;
-
-	&:hover {
-		text-decoration-color: var(--color-accent);
-	}
-}
-
 /* ## Contact form */

 section.form :is(input, textarea) {
@ -207,10 +196,6 @@ section.form-message.sent + section.form {
 /* # Size queries */

@media (min-width: 460px) {
-	section.pgp {
-		padding: calc(var(--padding) * 1.5);
-	}
-
 	section.pgp .buttons {
 		flex-direction: row;
 		justify-content: center;
--- a/public/assets/css/pages/error.css
+++ b/public/assets/css/pages/error.css
--- a/public/assets/css/pages/index.css
+++ b/public/assets/css/pages/index.css
@ -38,7 +38,7 @@ vv-shell img {
 	padding: unset;
 	text-align: right;
 	font-size: clamp(20px, 8vh, 60px);
-	font-weight: bold;
+	font-weight: 900;
 	line-height: clamp(20px, 8vh, 60px);
 	color: var(--color-accent);
 }
@ -49,11 +49,6 @@ vv-shell img {

 .menu svg {
 	width: 100%;
-	animation: dash 1500ms linear infinite;
-}
-
-@keyframes dash {
-	to { stroke-dashoffset: 32; }
 }

 /* ### Copy email button */
--- a/assets/css/pages/search.css
+++ b/assets/css/pages/search.css
@ -0,0 +1,85 @@
+/* # Overrides */
+
+[vv-page="/search"]:not(body) {
+	display: flex;
+	flex-direction: column;
+	gap: var(--padding);
+}
+
+/* # Sections */
+
+/* ## Search */
+
+section.search {
+	width: 100%;
+	display: none;
+	flex-direction: column;
+	align-items: center;
+	gap: var(--padding);
+	background-color: rgba(255, 255, 255, .05);
+	padding: calc(var(--padding) * 1.5);
+	margin-bottom: calc(var(--padding) * 2);
+}
+
+vv-shell[vv-page="/search"] > section.search {
+	display: flex;
+}
+
+section.search form {
+	display: contents;
+}
+
+section.search search {
+	width: 100%;
+}
+
+section.search input {
+	width: 100%;
+	border: none;
+	color: black;
+	outline: none;
+	padding: var(--padding);
+	background-color: var(--color-accent);
+}
+
+section.search button[type="submit"] {
+	width: 100%;
+	max-width: 350px;
+}
+
+section.search > svg {
+	width: 100%;
+}
+
+/* # Search results */
+
+section.results .result {
+	display: flex;
+	flex-direction: column;
+	gap: calc(var(--padding) / 2);
+}
+
+/* ## Titles */
+
+section.title a h2 {
+	color: var(--color-accent);
+}
+
+section.title a h2::before {
+	content: "// ";
+	color: white;
+}
+
+/* ## Work */
+
+section.results.work {
+	display: grid;
+	grid-template-columns: 1fr;
+	gap: calc(var(--padding) / 2);
+}
+
+section.results.work .result {
+	padding: var(--padding);
+	background-color: rgba(255, 255, 255, .03);
+	border-radius: 6px;
+}
--- a/public/assets/css/pages/work/timeline.css
+++ b/public/assets/css/pages/work/timeline.css
@ -3,7 +3,6 @@
 :root {
 	--primer-color-accent: 3, 255, 219;
 	--color-accent: rgb(var(--primer-color-accent));
-	--hue-accent: 90deg;
 }

 vv-shell {
@ -28,7 +27,7 @@ section.git {
 	border-radius: 6px;
 }

-section.git > svg {
+section.git svg {
 	fill: white;
 	width: 60px;
 }
@ -121,10 +120,13 @@ section.timeline .items .item img {
 }

 section.timeline .items .item .actions {
-	display: flex;
-	align-items: baseline;
 	margin-top: 7px;
-	gap: var(--padding);
+}
+
+/* ## Note */
+
+section.note {
+	text-align: center;
 }

 /* # Size queries */
@ -135,6 +137,23 @@ section.timeline .items .item .actions {
 	}
 }

+@media (min-width: 900px) {
+	section.git {
+		display: grid;
+		grid-template-columns: 70px 1fr 400px;
+		align-items: center;
+		gap: calc(var(--padding) * 1.5);
+	}
+
+	section.git svg {
+		width: 100%;
+	}
+
+	section.git .buttons {
+		justify-content: end;
+	}
+}
+
@media (max-width: 500px) {
 	section.timeline {
 		padding: unset;
@ -169,28 +188,7 @@ section.timeline .items .item .actions {
 		border-top-color: rgba(var(--primer-color-accent), .2);
 	}

-	section.timeline .items .item .actions {
-		flex-direction: column;
-	}
-
 	section.timeline .year:first-of-type .month:first-of-type .day:first-of-type .items .item:first-of-type {
 		margin-top: var(--padding);
 	}
 }
-
-@media (min-width: 900px) {
-	section.git {
-		display: grid;
-		grid-template-columns: 70px 1fr 400px;
-		align-items: center;
-		gap: calc(var(--padding) * 1.5);
-	}
-
-	section.git svg {
-		width: 100%;
-	}
-
-	section.git .buttons {
-		justify-content: end;
-	}
-}
--- a/assets/css/shells/document.css
+++ b/assets/css/shells/document.css
@ -11,8 +11,7 @@
 /* # Cornerstones */

 * {
-	margin: 0;
-	fill: inherit;
+    margin: 0;
    box-sizing: border-box;
    font-family: "Roboto Mono", sans-serif;
    color: inherit;
@ -89,32 +88,6 @@ h3 {
 	font-size: 25px;
 }

-/* ## Page transition */
-
-[vv-loading] * {
-	transition: 200ms opacity;
-}
-
-[vv-loading="true"] * {
-	opacity: 0;
-	pointer-events: none;
-}
-
-[vv-loading="true"]::after {
-	content: "";
-	position: fixed;
-	top: 50%;
-	left: 50%;
-	width: 45px;
-	height: 49px;
-	background-size: contain;
-	image-rendering: pixelated;
-	transform: translate(-50%, -50%);
-	background-image: url("/assets/media/spinner.gif");
-	-webkit-filter: hue-rotate(var(--hue-accent));
-	filter: hue-rotate(var(--hue-accent));
-}
-
 /* ## Buttons */

 button {
@ -128,44 +101,35 @@ button {
 /* ### Inline */

 button.inline {
-	gap: 10px;
-	display: flex;
-	border-radius: 7px;
-	align-items: center;
-	fill: var(--color-accent);
-	padding: calc(var(--padding) / 1.5);
-	background: linear-gradient(139deg, rgba(0, 0, 0, 0) 0%, rgba(var(--primer-color-accent), .1) 100%);
-}
-
-button.inline:not(.solid) {
-	box-shadow: 
-		0 0 0 2px rgba(var(--primer-color-accent), .1),
-		10px 7px 40px 3px rgba(var(--primer-color-accent), .06)
-	;
-}
-
-button.inline svg {
-	flex: none;
-	height: 1em;
-}
-
-button.inline svg:last-child {
-	width: 1.5em;
-	margin-left: auto;
-}
-
-button.inline svg.chevron:last-child {
-	transform: rotate(-90deg);
+	padding: calc(var(--padding) / 2) var(--padding);
+	color: white;
+	border: solid 2px white;
+	border-radius: 6px;
 }

 button.inline.solid {
-	fill: black;
 	color: black;
-	border: solid 2px rgba(var(--primer-color-accent), 1);
 	border-color: var(--color-accent);
 	background-color: var(--color-accent);
 }

+a > button::after {
+	content: " ➜";
+}
+
+/* ### Text links */
+
+a[target="_blank"] > button::after,
+:is(h1, h2, h3, p, li) > a[target="_blank"]::after {
+	content: " ↑";
+	color: var(--color-accent);
+	white-space: nowrap;
+}
+
+a > button.solid:not(:hover)::after {
+	color: black;
+}
+
 /* ## Header */

 header {
@ -286,10 +250,6 @@ header searchbox input {
 	border: none;
 }

-header searchbox input::placeholder {
-	color: rgba(0, 0, 0, .5);
-}
-
 /* #### Active */

 header.searchboxActive > * {
@ -314,9 +274,6 @@ vv-shell {
 search-results {
 	transition: 500ms opacity, 300ms transform;
 	position: fixed;
-	display: flex;
-	flex-direction: column;
-	gap: var(--padding);
 	top: var(--running-size);
 	right: 0;
 	width: 100%;
@ -328,7 +285,12 @@ search-results {
 	transform: scale(.99);
 	transform-origin: 100% 0;
 	overflow-y: scroll;
-	z-index: 50;
+}
+
+search-results:not([vv-page]) {
+	display: grid;
+	align-items: center;
+	justify-items: center;
 }

 header.searchboxActive ~ search-results {
@ -337,10 +299,6 @@ header.searchboxActive ~ search-results {
 	transform: scale(1);
 }

-search-results section.search {
-	display: none;
-}
-
 /* ### "Start typing" prompt */

 search-results .info {
@ -348,11 +306,11 @@ search-results .info {
 	align-items: center;
 	flex-direction: column;
 	margin: auto;
-	gap: var(--padding);
+	gap: 3svh;
 }

 search-results .info :is(svg, img) {
-	width: 60px;
+	width: 128px;
 	fill: var(--color-accent);
 }

@ -368,8 +326,7 @@ search-results .info :is(svg, img) {
 	/* # Components */

 	button.inline {
-		transition-duration: 300ms;
-		transition-property: background-color, border-color, box-shadow, color, fill;
+		transition: 200ms background-color, 200ms border-color, 200ms color;
 	}

 	button:hover {
@ -377,19 +334,8 @@ search-results .info :is(svg, img) {
 		background-color: rgba(255, 255, 255, .1);
 	}

-	button.inline:hover {
-		fill: var(--color-accent);
-		color: var(--color-accent);
-	}
-
-	button.inline:not(.solid):hover {
-		box-shadow: 
-			0 0 0 2px rgba(var(--primer-color-accent), 1),
-			10px 7px 30px 3px rgba(var(--primer-color-accent), .07)
-		;
-	}
-
 	button.solid:hover {
+		color: var(--color-accent);
 		border-color: rgba(var(--primer-color-accent), .2);
 		background-color: rgba(var(--primer-color-accent), .2);
 		box-shadow: 0 -10px 20px 10px rgba(var(--primer-color-accent), .05);
--- a/public/assets/fonts/roboto-mono.woff2
+++ b/public/assets/fonts/roboto-mono.woff2
--- a/public/assets/js/modules/glitch/Generator.mjs
+++ b/public/assets/js/modules/glitch/Generator.mjs
--- a/public/assets/js/modules/glitch/Glitch.mjs
+++ b/public/assets/js/modules/glitch/Glitch.mjs
--- a/public/assets/js/modules/glitch/GlitchWorker.js
+++ b/public/assets/js/modules/glitch/GlitchWorker.js
--- a/public/assets/js/pages/about.js
+++ b/public/assets/js/pages/about.js
@ -56,23 +56,12 @@ const implodeInterests = () => {
 	// Bind mouse or touch events depending on pointer type of device
 	const canHover = window.matchMedia("(pointer: fine)").matches;

-	// Explode interests when mouse hovers or touch hold starts
-	interestsElement.addEventListener(canHover ? "mouseenter" : "touchstart", (event) => explodeInterests(event.x, event.y));
-	// Implode interests when mouse leaves or touch hold ends
+	interestsElement.addEventListener(canHover ? "mouseenter" : "touchstart", () => {
+		// Get absolute position of the trigger element
+		const size = interestsElement.getBoundingClientRect();
+
+		explodeInterests(size.x, size.y);
+	});
+
 	interestsElement.addEventListener(canHover ? "mouseleave" : "touchend", () => implodeInterests());
 }
-
-// Language bar chart hover tooltip
-document.querySelectorAll("stacked-bar-chart chart-segment").forEach(element => {
-	const tooltipElement = element.querySelector("[data-hover]");
-
-	element.addEventListener("mouseenter", () => tooltipElement.classList.add("hovering"));
-	element.addEventListener("mouseleave", () => tooltipElement.classList.remove("hovering"));
-
-	element.addEventListener("mousemove", (event) => {
-		const x = event.layerX - (tooltipElement.clientWidth / 2);
-		const y = event.layerY + (tooltipElement.clientHeight - 30);
-
-		tooltipElement.style.setProperty("transform", `translate(${x}px, ${y}px)`);
-	});
-});
--- a/assets/js/pages/about/battlestation-retired.js
+++ b/assets/js/pages/about/battlestation-retired.js
--- a/assets/js/pages/about/battlestation.js
+++ b/assets/js/pages/about/battlestation.js
@ -0,0 +1,72 @@
+import { Elevent } from "/assets/js/modules/npm/Elevent.mjs";
+
+new Elevent("click", document.querySelectorAll(".group"), (event) => {
+	// Collapse self if already active and current target
+	if (event.target.classList.contains("active")) {
+		return event.target.classList.remove("active");
+	}
+
+	// Collapse all and open current target
+	[...event.target.closest(".specs").querySelectorAll(".group")].forEach(element => element.classList.remove("active"));
+	event.target.classList.add("active");
+});
+
+new Elevent("click", document.querySelectorAll(".spec"), (event) => {
+	event.target.classList.add("active");
+	event.target.addEventListener("mouseleave", () => event.target.classList.remove("active"));
+});
+
+// Bind hover listeners for components in the SVGs
+[...document.querySelectorAll("section.config g:not(.group)")].forEach(element => {
+	element.addEventListener("mouseenter", () => {
+		// Find an element in the most adjacent speclist and highlighit it
+		const target = element.closest("section.config").querySelector(`.spec[data-target="${element.dataset.target}"]`);
+		// Get closest specs wrapper element
+		const specsElement = target.closest(".specs");
+		// Spec item is part of a collection, we need to expand the group if that is the case
+		const collectionElement = target.closest(".collection") ?? null;
+		// Don't close the group after hove ends
+		let closeGroupOnLeave = false;
+
+		// Set fixed height on .specs wrapper to prevent glitchy page jumping when scrolled
+		specsElement.style.setProperty("height", `${specsElement.offsetHeight}px`);
+		target.classList.add("active");
+		specsElement.classList.add("active");
+
+		if (collectionElement) {
+			// Close the group on leave if the group wasn't active before hovering
+			closeGroupOnLeave = !collectionElement.previousElementSibling.classList.contains("active");
+
+			collectionElement.previousElementSibling.classList.add("active");
+		}
+
+		// Bind hover leave listener
+		element.addEventListener("mouseleave", () => {
+			// Reset to initial states
+			target.classList.remove("active");
+			specsElement.classList.remove("active");
+			specsElement.style.removeProperty("height");
+
+			// Group was closed prior to hover, let's close it on hover leave
+			if (closeGroupOnLeave) {
+				collectionElement.previousElementSibling.classList.remove("active");
+			}
+		}, { once: true });
+	});
+});
+
+// Bind event listeners for components in the spec lists
+[...document.querySelectorAll("section.config .spec:not(.group)")].forEach(element => {
+	element.addEventListener("mouseenter", () => {
+		const svgTarget = element.closest("section.config").querySelector(`svg`);
+		const target = svgTarget.querySelector(`svg g[data-target="${element.dataset.target}"]`);
+
+		svgTarget.classList.add("active");
+		target.classList.add("active");
+
+		element.addEventListener("mouseleave", () => {
+			svgTarget.classList.remove("active");
+			target.classList.remove("active");
+		}, { once: true });
+	});
+});
--- a/public/assets/js/pages/contact.js
+++ b/public/assets/js/pages/contact.js
@ -60,16 +60,27 @@ class ContactForm {
 	form ? (new ContactForm(form)) : ContactForm.removeSavedMessage();
 }

-document.querySelectorAll("social").forEach(element => {
-	const tooltipElement = element.querySelector("[data-hover]");
+// Social links hover
+{
+	const socialElementHover = (target) => {
+		const element = target.querySelector("p");

-	element.addEventListener("mouseenter", () => tooltipElement.classList.add("hovering"));
-	element.addEventListener("mouseleave", () => tooltipElement.classList.remove("hovering"));
+		target.classList.add("hovering");
+		target.addEventListener("mousemove", (event) => {
+			const x = event.layerX - (element.clientWidth / 2);
+			const y = event.layerY + element.clientHeight;

-	element.addEventListener("mousemove", (event) => {
-		const x = event.layerX - (tooltipElement.clientWidth / 2);
-		const y = event.layerY + tooltipElement.clientHeight;
+			element.style.setProperty("transform", `translate(${x}px, ${y}px)`);
+		});
+	};

-		tooltipElement.style.setProperty("transform", `translate(${x}px, ${y}px)`);
+	const elements = [...document.querySelectorAll("social")];
+
+	elements.forEach(element => {
+		element.addEventListener("mouseenter", () => socialElementHover(element));
+
+		element.addEventListener("mouseleave", () => {
+			elements.forEach(element => element.classList.remove("hovering"));
+		});
 	});
-});
+}
--- a/public/assets/js/pages/error.js
+++ b/public/assets/js/pages/error.js
--- a/public/assets/js/pages/index.js
+++ b/public/assets/js/pages/index.js
@ -1,3 +1,5 @@
+import { Elevent } from "/assets/js/modules/npm/Elevent.mjs";
+
 // Click to copy email button
 {
 	const EMAIL_CPY_ANIM_DUR_MSECONDS = 1000;
@ -53,7 +55,7 @@
 		}, EMAIL_CPY_ANIM_DUR_MSECONDS + 100);
 	}
 	
-	document.querySelector(".email").addEventListener("click", async () => {
+	new Elevent("click", document.querySelector(".email"), async () => {
 		try {
 			await navigator.clipboard.writeText("victor@vlw.se");
 	
@ -101,6 +103,6 @@
 		});

 		// Reset color on navigation
-		VV.shell.addEventListener(VV.EVENT.START, () => updateColor(), { once: true });
+		vv.Navigation.rootShellElement.addEventListener(vv.Navigation.EVENTS.STARTED, () => updateColor(), { once: true });
 	}
 }
--- a/public/assets/js/pages/work/timeline.js
+++ b/public/assets/js/pages/work/timeline.js
--- a/assets/js/pages/work.js
+++ b/assets/js/pages/work.js
--- a/assets/js/shells/document.js
+++ b/assets/js/shells/document.js
@ -0,0 +1,50 @@
+import { Elevent } from "/assets/js/modules/npm/Elevent.mjs";
+
+const CLASSNAME_SEARCHBOX_ACTIVE = "searchboxActive";
+
+// Handle search box open/close buttons
+{
+	// Open search box
+	new Elevent("click", document.querySelector(".searchbox-open"), () => {
+		document.querySelector("header").classList.add(CLASSNAME_SEARCHBOX_ACTIVE);
+		// Select searchbox inner input element
+		document.querySelector("searchbox input").focus();
+	});
+
+	// Close searchbox
+	new Elevent("click", document.querySelector(".searchbox-close"), () => {
+		// Disable search button interaction while animation is running
+		// This is required to prevent conflicts with the :hover "peak" transformation
+		const searchButtonElement = document.querySelector("header button.search");
+		const transformDuration = parseInt(window.getComputedStyle(searchButtonElement).getPropertyValue("--transform-duration"));
+		searchButtonElement.style.setProperty("pointer-events", "none");
+
+		document.querySelector("header").classList.remove(CLASSNAME_SEARCHBOX_ACTIVE);
+
+		// Wait for the transform animation to finish
+		setTimeout(() => searchButtonElement.style.removeProperty("pointer-events"), transformDuration);
+	});
+}
+
+// Root shell navigation event handlers
+{
+	// On all top shell navigations
+	new Elevent(vv.Navigation.EVENTS.STARTED, vv.Navigation.rootShellElement, () => {
+		// Close searchbox on top shell navigations
+		document.querySelector("header").classList.remove(CLASSNAME_SEARCHBOX_ACTIVE);
+	});
+}
+
+// Handle search logic
+{
+	const searchResultsElement = document.querySelector("search-results");
+
+	document.querySelector("header input[type='search']").addEventListener("input", (event) => {
+		// Debounce user input
+		clearTimeout(event.target._throttle);
+		event.target._throttle = setTimeout(() => {
+			// Navigate search-results element on user input
+			new vv.Navigation(`/search?q=${event.target.value}`).navigate(searchResultsElement);
+		}, 100);
+	});
+}
--- a/assets/media/battlestation.svg
+++ b/assets/media/battlestation.svg
@ -0,0 +1,173 @@
+<svg viewBox="0 0 236 288" xmlns="http://www.w3.org/2000/svg">
+	<mask fill="#fff" id="a"><path d="M19 269a1 1 0 0 1-1-1v-11a1 1 0 0 1 1-1v13Z"></path></mask>
+	<mask fill="#fff" id="b"><path d="M87 241a1 1 0 0 1 1 1v5a1 1 0 0 1-1 1v-7Z"></path></mask>
+	<mask fill="#fff" id="c"><path d="M87 251a1 1 0 0 1 1 1v5a1 1 0 0 1-1 1v-7Z"></path></mask>
+	<mask fill="#fff" id="d"><path d="M179 272.051c0-.58.471-1.051 1.051-1.051h8.898c.58 0 1.051.471 1.051 1.051h-11Z"></path></mask>
+	<mask fill="#fff" id="e"><path d="M191 272.051c0-.58.471-1.051 1.051-1.051h2.898c.58 0 1.051.471 1.051 1.051h-5Z"></path></mask>
+	<mask fill="#fff" id="f"><path d="M179 257.333c0-.58.471-1.051 1.051-1.051h8.898c.58 0 1.051.471 1.051 1.051h-11Z"></path></mask>
+	<mask fill="#fff" id="g"><path d="M191 257.333c0-.58.471-1.051 1.051-1.051h2.898c.58 0 1.051.471 1.051 1.051h-5Z"></path></mask>
+	<mask fill="#fff" id="h"><path d="M179 242.615c0-.58.471-1.051 1.051-1.051h8.898c.58 0 1.051.471 1.051 1.051h-11Z"></path></mask>
+	<mask fill="#fff" id="i"><path d="M191 242.615c0-.58.471-1.051 1.051-1.051h2.898c.58 0 1.051.471 1.051 1.051h-5Z"></path></mask>
+	<mask fill="#fff" id="j"><path d="M133 257.333c0-.58.471-1.051 1.051-1.051h8.898c.58 0 1.051.471 1.051 1.051h-11Z"></path></mask>
+	<mask fill="#fff" id="k"><path d="M145 257.333c0-.58.471-1.051 1.051-1.051h2.898c.58 0 1.051.471 1.051 1.051h-5Z"></path></mask>
+	<mask fill="#fff" id="l"><path d="M133 242.615c0-.58.471-1.051 1.051-1.051h8.898c.58 0 1.051.471 1.051 1.051h-11Z"></path></mask>
+	<mask fill="#fff" id="m"><path d="M145 242.615c0-.58.471-1.051 1.051-1.051h2.898c.58 0 1.051.471 1.051 1.051h-5Z"></path></mask>
+	<mask fill="#fff" id="n"><path d="M133 272.051c0-.58.471-1.051 1.051-1.051h8.898c.58 0 1.051.471 1.051 1.051h-11Z"></path></mask>
+	<mask fill="#fff" id="o"><path d="M145 272.051c0-.58.471-1.051 1.051-1.051h2.898c.58 0 1.051.471 1.051 1.051h-5Z"></path></mask>
+	<mask fill="#fff" id="p"><path d="M186 40a1 1 0 0 1 1-1h9a1 1 0 0 1 1 1h-11Z"></path></mask>
+	<mask fill="#fff" id="q"><path d="M198 40a1 1 0 0 1 1-1h3a1 1 0 0 1 1 1h-5Z"></path></mask>
+	<mask fill="#fff" id="r"><path d="M186 51a1 1 0 0 1 1-1h9a1 1 0 0 1 1 1h-11Z"></path></mask>
+	<mask fill="#fff" id="s"><path d="M198 51a1 1 0 0 1 1-1h3a1 1 0 0 1 1 1h-5Z"></path></mask>
+	<mask fill="#fff" id="t"><path d="M186 62a1 1 0 0 1 1-1h9a1 1 0 0 1 1 1h-11Z"></path></mask>
+	<mask fill="#fff" id="u"><path d="M198 62a1 1 0 0 1 1-1h3a1 1 0 0 1 1 1h-5Z"></path></mask>
+	<mask fill="#fff" id="v"><path d="M186 73a1 1 0 0 1 1-1h9a1 1 0 0 1 1 1h-11Z"></path></mask>
+	<mask fill="#fff" id="w"><path d="M198 73a1 1 0 0 1 1-1h3a1 1 0 0 1 1 1h-5Z"></path></mask>
+	<mask fill="#fff" id="x"><path d="M129.535 123.781h-1.082a.453.453 0 0 1 0-.906h1.082v.906Z"></path></mask>
+	<mask fill="#fff" id="y"><path d="M129.535 115.625h-1.082a.453.453 0 0 1 0-.906h1.082v.906Z"></path></mask>
+	<mask fill="#fff" id="z"><path d="M129.535 121.969H129a1 1 0 0 1-1-1v-3.438a1 1 0 0 1 1-1h.535v5.438Z"></path></mask>
+	<mask fill="#fff" id="A"><path d="M92.535 123.781h-1.082a.453.453 0 0 1 0-.906h1.082v.906Z"></path></mask>
+	<mask fill="#fff" id="B"><path d="M92.535 115.625h-1.082a.453.453 0 0 1 0-.906h1.082v.906Z"></path></mask>
+	<mask fill="#fff" id="C"><path d="M92.535 121.969H92a1 1 0 0 1-1-1v-3.438a1 1 0 0 1 1-1h.535v5.438Z"></path></mask>
+	<mask fill="#fff" id="D"><path d="M68 143v-2a1 1 0 0 1 1-1h29a1 1 0 0 1 1 1v2H68Z"></path></mask>
+	<mask fill="#fff" id="E"><path d="M101 143v-2a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1v2h-3Z"></path></mask>
+	<mask fill="#fff" id="F"><path d="M64 143v-2a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1v2h-3Z"></path></mask>
+	<mask fill="#fff" id="G"><path d="M55.535 123.781h-1.082a.453.453 0 0 1 0-.906h1.082v.906Z"></path></mask>
+	<mask fill="#fff" id="H"><path d="M55.535 115.625h-1.082a.453.453 0 0 1 0-.906h1.082v.906Z"></path></mask>
+	<mask fill="#fff" id="I"><path d="M55.535 121.969H55a1 1 0 0 1-1-1v-3.438a1 1 0 0 1 1-1h.535v5.438Z"></path></mask>
+	<mask fill="#fff" id="J"><path d="M76 38h1a1 1 0 0 1 1 1v33a1 1 0 0 1-1 1h-1V38Z"></path></mask>
+	<mask fill="#fff" id="K"><path d="M76 76h1a1 1 0 0 1 1 1v22a1 1 0 0 1-1 1h-1V76Z"></path></mask>
+	<mask fill="#fff" id="L"><path d="M60 38h1a1 1 0 0 1 1 1v33a1 1 0 0 1-1 1h-1V38Z"></path></mask>
+	<mask fill="#fff" id="M"><path d="M60 76h1a1 1 0 0 1 1 1v22a1 1 0 0 1-1 1h-1V76Z"></path></mask>
+	<mask fill="#fff" id="N"><path d="M137 100h-1a1 1 0 0 1-1-1V66a1 1 0 0 1 1-1h1v35Z"></path></mask>
+	<mask fill="#fff" id="O"><path d="M137 62h-1a1 1 0 0 1-1-1V39a1 1 0 0 1 1-1h1v24Z"></path></mask>
+	<mask fill="#fff" id="P"><path d="M155 100h-1a1 1 0 0 1-1-1V66a1 1 0 0 1 1-1h1v35Z"></path></mask>
+	<mask fill="#fff" id="Q"><path d="M155 62h-1a1 1 0 0 1-1-1V39a1 1 0 0 1 1-1h1v24Z"></path></mask>
+	<g data-target="case" data-index="1" class="case">
+		<rect height="278" rx="3" stroke="#fff" stroke-width="6" width="230" x="3" y="7"></rect>
+		<path d="M20.639 216.906a2 2 0 0 1 1.674-.906h192.14a2 2 0 0 1 1.756 1.043l2.18 4c.726 1.333-.239 2.957-1.756 2.957H19.697c-1.589 0-2.543-1.764-1.674-3.094l2.616-4ZM5.451.793A2 2 0 0 1 7.046 0h222.808a2 2 0 0 1 1.692.934l2.521 4c.84 1.331-.118 3.066-1.692 3.066H4.021C2.369 8 1.429 6.11 2.425 4.793l3.026-4Z" fill="#fff"></path>
+	</g>
+	<g data-target="psu" class="psu">
+		<path d="M20 268v-11h-4v11h4Zm-3-12v13h4v-13h-4Zm3 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 10a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#a)"></path>
+		<path d="M86 242v5h4v-5h-4Zm3 6v-7h-4v7h4Zm-3-1a1 1 0 0 1 1-1v4a3 3 0 0 0 3-3h-4Zm1-4a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Z" fill="#fff" mask="url(#b)"></path>
+		<path d="M86 252v5h4v-5h-4Zm3 6v-7h-4v7h4Zm-3-1a1 1 0 0 1 1-1v4a3 3 0 0 0 3-3h-4Zm1-4a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Z" fill="#fff" mask="url(#c)"></path>
+		<rect height="38" rx="3.5" stroke="#fff" stroke-width="3" width="65" x="20.5" y="234.5"></rect>
+	</g>
+	<g class="group drives threedotfive">
+		<g data-target="drive" class="drive">
+			<rect height="9.564" rx="2" stroke="#fff" stroke-width="2" width="41" x="176" y="263.436"></rect>
+			<path d="M180.051 273h8.898v-4h-8.898v4Zm9.949-2.949h-11v4h11v-4ZM188.949 273a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-8.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#d)"></path>
+			<path d="M192.051 273h2.898v-4h-2.898v4Zm3.949-2.949h-5v4h5v-4ZM194.949 273a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-2.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#e)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="9.564" rx="2" stroke="#fff" stroke-width="2" width="41" x="176" y="248.718"></rect>
+			<path d="M192.051 258.282h2.898v-4h-2.898v4Zm3.949-2.949h-5v4h5v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-2.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#g)"></path>
+			<path d="M180.051 258.282h8.898v-4h-8.898v4Zm9.949-2.949h-11v4h11v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-8.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#f)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="9.564" rx="2" stroke="#fff" stroke-width="2" width="41" x="176" y="234"></rect>
+			<path d="M192.051 243.564h2.898v-4h-2.898v4Zm3.949-2.949h-5v4h5v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-2.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#i)"></path>
+			<path d="M180.051 243.564h8.898v-4h-8.898v4Zm9.949-2.949h-11v4h11v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-8.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#h)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="9.564" rx="2" stroke="#fff" stroke-width="2" width="41" x="130" y="248.718"></rect>
+			<path d="M134.051 258.282h8.898v-4h-8.898v4Zm9.949-2.949h-11v4h11v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-8.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#j)"></path>
+			<path d="M146.051 258.282h2.898v-4h-2.898v4Zm3.949-2.949h-5v4h5v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-2.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#k)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="9.564" rx="2" stroke="#fff" stroke-width="2" width="41" x="130" y="234"></rect>
+			<path d="M134.051 243.564h8.898v-4h-8.898v4Zm9.949-2.949h-11v4h11v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-8.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#l)"></path>
+			<path d="M146.051 243.564h2.898v-4h-2.898v4Zm3.949-2.949h-5v4h5v-4Zm-1.051 2.949a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-2.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#m)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="9.564" rx="2" stroke="#fff" stroke-width="2" width="41" x="130" y="263.436"></rect>
+			<path d="M134.051 273h8.898v-4h-8.898v4Zm9.949-2.949h-11v4h11v-4ZM142.949 273a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-8.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#n)"></path>
+			<path d="M146.051 273h2.898v-4h-2.898v4Zm3.949-2.949h-5v4h5v-4ZM148.949 273a.95.95 0 0 1-.949-.949h4a3.051 3.051 0 0 0-3.051-3.051v4Zm-2.898-4a3.051 3.051 0 0 0-3.051 3.051h4a.95.95 0 0 1-.949.949v-4Z" fill="#fff" mask="url(#o)"></path>
+		</g>
+	</g>
+	<g class="group drives twodotfive">
+		<g data-target="drive" class="drive">
+			<rect height="5" rx="2" stroke="#fff" stroke-width="2" width="41" x="183" y="36"></rect>
+			<path d="M187 41h9v-4h-9v4Zm10-3h-11v4h11v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-9-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#p)"></path>
+			<path d="M199 41h3v-4h-3v4Zm4-3h-5v4h5v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-3-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#q)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="5" rx="2" stroke="#fff" stroke-width="2" width="41" x="183" y="47"></rect>
+			<path d="M187 52h9v-4h-9v4Zm10-3h-11v4h11v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-9-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#r)"></path>
+			<path d="M199 52h3v-4h-3v4Zm4-3h-5v4h5v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-3-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#s)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="5" rx="2" stroke="#fff" stroke-width="2" width="41" x="183" y="58"></rect>
+			<path d="M187 63h9v-4h-9v4Zm10-3h-11v4h11v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-9-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#t)"></path>
+			<path d="M199 63h3v-4h-3v4Zm4-3h-5v4h5v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-3-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#u)"></path>
+		</g>
+		<g data-target="drive" class="drive">
+			<rect height="5" rx="2" stroke="#fff" stroke-width="2" width="41" x="183" y="69"></rect>
+			<path d="M187 74h9v-4h-9v4Zm10-3h-11v4h11v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-9-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#v)"></path>
+			<path d="M199 74h3v-4h-3v4Zm4-3h-5v4h5v-4Zm-1 3a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Zm-3-4a3 3 0 0 0-3 3h4a1 1 0 0 1-1 1v-4Z" fill="#fff" mask="url(#w)"></path>
+		</g>
+	</g>
+	<g data-target="mb" class="mb">
+		<rect height="176" rx="3.5" stroke="#fff" stroke-width="3" width="152" x="22.5" y="25.5"></rect>
+		<path d="m31.19 123.309-.01.007-7.32 5.782c-1.968 1.554-4.86.153-4.86-2.354V42a3 3 0 0 1 3-3h15a3 3 0 0 1 3 3v73.048c0 .931-.432 1.81-1.17 2.377l-7.64 5.884Z" fill="#fff"></path>
+		<path d="m31.19 123.309-.01.007-7.32 5.782c-1.968 1.554-4.86.153-4.86-2.354V42a3 3 0 0 1 3-3h15a3 3 0 0 1 3 3v73.048c0 .931-.432 1.81-1.17 2.377l-7.64 5.884Z" stroke="#fff" stroke-width="2"></path>
+		<g class="chips">
+			<rect fill="#fff" height="13" rx="2" width="13" x="23" y="44"></rect>
+			<rect fill="#fff" height="13" rx="2" width="13" x="23" y="61"></rect>
+			<rect fill="#fff" height="13" rx="2" width="13" x="23" y="78"></rect>
+		</g>
+	</g>
+	<g class="group drives mdottwo">
+		<g data-target="drive" class="drive">
+			<path d="M129.535 123.781v2h2v-2h-2Zm0-.906h2v-2h-2v2Zm0-1.094h-1.082v4h1.082v-4Zm-1.082 3.094h1.082v-4h-1.082v4Zm-.918-2v.906h4v-.906h-4Zm2.465.453c0 .854-.693 1.547-1.547 1.547v-4a2.453 2.453 0 0 0-2.453 2.453h4Zm-1.547-1.547c.854 0 1.547.693 1.547 1.547h-4a2.453 2.453 0 0 0 2.453 2.453v-4Z" fill="#fff" mask="url(#x)"></path>
+			<path d="M129.535 115.625v2h2v-2h-2Zm0-.906h2v-2h-2v2Zm0-1.094h-1.082v4h1.082v-4Zm-1.082 3.094h1.082v-4h-1.082v4Zm-.918-2v.906h4v-.906h-4Zm2.465.453c0 .854-.693 1.547-1.547 1.547v-4a2.453 2.453 0 0 0-2.453 2.453h4Zm-1.547-1.547c.854 0 1.547.693 1.547 1.547h-4a2.453 2.453 0 0 0 2.453 2.453v-4Z" fill="#fff" mask="url(#y)"></path>
+			<path d="M129.535 121.969v2h2v-2h-2Zm0-5.438h2v-2h-2v2Zm0 3.438H129v4h.535v-4Zm.465 1v-3.438h-4v3.438h4Zm-1-2.438h.535v-4H129v4Zm-1.465-2v5.438h4v-5.438h-4Zm2.465 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 2.438a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#z)"></path>
+			<rect height="12.5" rx="2" stroke="#fff" stroke-width="2" width="29.465" x="130.535" y="113"></rect>
+		</g>
+		<g data-target="drive" class="drive">
+			<path d="M92.535 123.781v2h2v-2h-2Zm0-.906h2v-2h-2v2Zm0-1.094h-1.082v4h1.082v-4Zm-1.082 3.094h1.082v-4h-1.082v4Zm-.918-2v.906h4v-.906h-4Zm2.465.453c0 .854-.693 1.547-1.547 1.547v-4A2.453 2.453 0 0 0 89 123.328h4Zm-1.547-1.547c.854 0 1.547.693 1.547 1.547h-4a2.453 2.453 0 0 0 2.453 2.453v-4Z" fill="#fff" mask="url(#A)"></path>
+			<path d="M92.535 115.625v2h2v-2h-2Zm0-.906h2v-2h-2v2Zm0-1.094h-1.082v4h1.082v-4Zm-1.082 3.094h1.082v-4h-1.082v4Zm-.918-2v.906h4v-.906h-4Zm2.465.453c0 .854-.693 1.547-1.547 1.547v-4A2.453 2.453 0 0 0 89 115.172h4Zm-1.547-1.547c.854 0 1.547.693 1.547 1.547h-4a2.453 2.453 0 0 0 2.453 2.453v-4Z" fill="#fff" mask="url(#B)"></path>
+			<path d="M92.535 121.969v2h2v-2h-2Zm0-5.438h2v-2h-2v2Zm0 3.438H92v4h.535v-4Zm.465 1v-3.438h-4v3.438h4Zm-1-2.438h.535v-4H92v4Zm-1.465-2v5.438h4v-5.438h-4Zm2.465 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 2.438a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#C)"></path>
+			<rect height="12.5" rx="2" stroke="#fff" stroke-width="2" width="29.465" x="93.535" y="113"></rect>
+		</g>
+		<g data-target="drive" class="drive">
+			<path d="M55.535 123.781v2h2v-2h-2Zm0-.906h2v-2h-2v2Zm0-1.094h-1.082v4h1.082v-4Zm-1.082 3.094h1.082v-4h-1.082v4Zm-.918-2v.906h4v-.906h-4Zm2.465.453c0 .854-.693 1.547-1.547 1.547v-4A2.453 2.453 0 0 0 52 123.328h4Zm-1.547-1.547c.854 0 1.547.693 1.547 1.547h-4a2.453 2.453 0 0 0 2.453 2.453v-4Z" fill="#fff" mask="url(#G)"></path>
+			<path d="M55.535 115.625v2h2v-2h-2Zm0-.906h2v-2h-2v2Zm0-1.094h-1.082v4h1.082v-4Zm-1.082 3.094h1.082v-4h-1.082v4Zm-.918-2v.906h4v-.906h-4Zm2.465.453c0 .854-.693 1.547-1.547 1.547v-4A2.453 2.453 0 0 0 52 115.172h4Zm-1.547-1.547c.854 0 1.547.693 1.547 1.547h-4a2.453 2.453 0 0 0 2.453 2.453v-4Z" fill="#fff" mask="url(#H)"></path>
+			<path d="M55.535 121.969v2h2v-2h-2Zm0-5.438h2v-2h-2v2Zm0 3.438H55v4h.535v-4Zm.465 1v-3.438h-4v3.438h4Zm-1-2.438h.535v-4H55v4Zm-1.465-2v5.438h4v-5.438h-4Zm2.465 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 2.438a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#I)"></path>
+			<rect height="12.5" rx="2" stroke="#fff" stroke-width="2" width="29.465" x="56.535" y="113"></rect>
+		</g>
+	</g>
+	<g data-target="gpu" class="gpu">
+		<path d="M59 148h86" stroke="#fff" stroke-linecap="round"></path>
+		<path d="M59.5 136a1.5 1.5 0 0 0-3 0h3Zm0 8v-8h-3v8h3Z" fill="#fff"></path>
+		<path d="M68 143v-2a1 1 0 0 1 1-1h29a1 1 0 0 1 1 1v2H68Z" mask="url(#D)" stroke="#fff" stroke-width="3"></path>
+		<path d="M101 143v-2a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1v2h-3Z" mask="url(#E)" stroke="#fff" stroke-width="3"></path>
+		<path d="M64 143v-2a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1v2h-3Z" mask="url(#F)" stroke="#fff" stroke-width="3"></path>
+		<path d="M55 147a3 3 0 0 1 3-3h88a3 3 0 0 1 3 3v.525c0 .237-.028.473-.083.703l-2.764 11.474a3.001 3.001 0 0 1-2.917 2.298H58a3 3 0 0 1-3-3v-12Z" stroke="#fff" stroke-width="2"></path>
+	</g>
+	<g class="group drams">
+		<g data-target="dram" class="dram">
+			<path d="M60 38v-2h-2v2h2Zm0 35h-2v2h2v-2Zm0-33h1v-4h-1v4Zm0-1v33h4V39h-4Zm1 32h-1v4h1v-4Zm1 2V38h-4v35h4Zm-2-1a1 1 0 0 1 1-1v4a3 3 0 0 0 3-3h-4Zm1-32a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Z" fill="#fff" mask="url(#L)"></path>
+			<path d="M60 76v-2h-2v2h2Zm0 24h-2v2h2v-2Zm0-22h1v-4h-1v4Zm0-1v22h4V77h-4Zm1 21h-1v4h1v-4Zm1 2V76h-4v24h4Zm-2-1a1 1 0 0 1 1-1v4a3 3 0 0 0 3-3h-4Zm1-21a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Z" fill="#fff" mask="url(#M)"></path>
+			<rect height="66" rx="2" stroke="#fff" stroke-width="2" width="4" x="55" y="36"></rect>
+		</g>
+		<g data-target="dram" class="dram">
+			<path d="M76 38v-2h-2v2h2Zm0 35h-2v2h2v-2Zm0-33h1v-4h-1v4Zm0-1v33h4V39h-4Zm1 32h-1v4h1v-4Zm1 2V38h-4v35h4Zm-2-1a1 1 0 0 1 1-1v4a3 3 0 0 0 3-3h-4Zm1-32a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Z" fill="#fff" mask="url(#J)"></path>
+			<path d="M76 76v-2h-2v2h2Zm0 24h-2v2h2v-2Zm0-22h1v-4h-1v4Zm0-1v22h4V77h-4Zm1 21h-1v4h1v-4Zm1 2V76h-4v24h4Zm-2-1a1 1 0 0 1 1-1v4a3 3 0 0 0 3-3h-4Zm1-21a1 1 0 0 1-1-1h4a3 3 0 0 0-3-3v4Z" fill="#fff" mask="url(#K)"></path>
+			<rect height="66" rx="2" stroke="#fff" stroke-width="2" width="4" x="71" y="36"></rect>
+		</g>
+		<g data-target="dram" class="dram">
+			<path d="M137 100v2h2v-2h-2Zm0-35h2v-2h-2v2Zm0 33h-1v4h1v-4Zm0 1V66h-4v33h4Zm-1-32h1v-4h-1v4Zm-1-2v35h4V65h-4Zm2 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 32a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#N)"></path>
+			<path d="M137 62v2h2v-2h-2Zm0-24h2v-2h-2v2Zm0 22h-1v4h1v-4Zm0 1V39h-4v22h4Zm-1-21h1v-4h-1v4Zm-1-2v24h4V38h-4Zm2 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 21a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#O)"></path>
+			<rect height="66" rx="2" stroke="#fff" stroke-width="2" transform="rotate(180 142 102)" width="4" x="142" y="102"></rect>
+		</g>
+		<g data-target="dram" class="dram">
+			<path d="M155 100v2h2v-2h-2Zm0-35h2v-2h-2v2Zm0 33h-1v4h1v-4Zm0 1V66h-4v33h4Zm-1-32h1v-4h-1v4Zm-1-2v35h4V65h-4Zm2 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 32a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#P)"></path>
+			<path d="M155 62v2h2v-2h-2Zm0-24h2v-2h-2v2Zm0 22h-1v4h1v-4Zm0 1V39h-4v22h4Zm-1-21h1v-4h-1v4Zm-1-2v24h4V38h-4Zm2 1a1 1 0 0 1-1 1v-4a3 3 0 0 0-3 3h4Zm-1 21a1 1 0 0 1 1 1h-4a3 3 0 0 0 3 3v-4Z" fill="#fff" mask="url(#Q)"></path>
+			<rect height="66" rx="2" stroke="#fff" stroke-width="2" transform="rotate(180 160 102)" width="4" x="160" y="102"></rect>
+		</g>
+	</g>
+	<g data-target="cpu" class="cpu">
+		<path d="M98 56a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1h-3ZM113 56a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1h-3ZM103 56a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1h-3ZM108 56a1 1 0 0 1 1-1h1a1 1 0 0 1 1 1h-3ZM116 82a1 1 0 0 1-1 1h-1a1 1 0 0 1-1-1h3ZM101 82a1 1 0 0 1-1 1h-1a1 1 0 0 1-1-1h3ZM111 82a1 1 0 0 1-1 1h-1a1 1 0 0 1-1-1h3ZM106 82a1 1 0 0 1-1 1h-1a1 1 0 0 1-1-1h3ZM120 60a1 1 0 0 1 1 1v1a1 1 0 0 1-1 1v-3ZM120 75a1 1 0 0 1 1 1v1a1 1 0 0 1-1 1v-3ZM120 65a1 1 0 0 1 1 1v1a1 1 0 0 1-1 1v-3ZM120 70a1 1 0 0 1 1 1v1a1 1 0 0 1-1 1v-3ZM94 78a1 1 0 0 1-1-1v-1a1 1 0 0 1 1-1v3ZM94 63a1 1 0 0 1-1-1v-1a1 1 0 0 1 1-1v3ZM94 73a1 1 0 0 1-1-1v-1a1 1 0 0 1 1-1v3ZM94 68a1 1 0 0 1-1-1v-1a1 1 0 0 1 1-1v3Z" fill="#fff"></path>
+		<rect height="24" rx="3" stroke="#fff" stroke-width="2" width="24" x="95" y="57"></rect>
+	</g>
+</svg>
--- a/public/assets/media/gazing.jpg
+++ b/public/assets/media/gazing.jpg
--- a/public/assets/media/glitch_b64/1.txt
+++ b/public/assets/media/glitch_b64/1.txt
--- a/public/assets/media/glitch_b64/2.txt
+++ b/public/assets/media/glitch_b64/2.txt
--- a/public/assets/media/glitch_b64/3.txt
+++ b/public/assets/media/glitch_b64/3.txt
--- a/public/assets/media/glitch_b64/4.txt
+++ b/public/assets/media/glitch_b64/4.txt
--- a/assets/media/icons/chevron.svg
+++ b/assets/media/icons/chevron.svg
@ -0,0 +1 @@
+<svg viewBox="0 0 78.743 46.968" xmlns="http://www.w3.org/2000/svg"><path d="m530.436 290.342 6.658 8.935c4.438 5.956 8.512 11.037 12.222 15.242 3.71 4.205 7.691 8.797 11.945 13.776a590.023 590.023 0 0 1 11.95 14.425c3.713 4.638 9.56 11.441 17.54 20.41 7.98 8.97 15.892 17.872 23.736 26.707a2267.256 2267.256 0 0 0 21.633 24.05c6.578 7.197 11.225 8.056 13.942 2.576 2.717-5.48 8.45-12.8 17.199-21.96 8.748-9.162 15.904-16.447 21.468-21.856a2287.547 2287.547 0 0 1 17.272-16.611 674.569 674.569 0 0 0 16.506-16.229c5.054-5.154 9.753-9.968 14.098-14.443 4.344-4.475 9.494-10.016 15.448-16.624 5.954-6.607 10.747-11.748 14.38-15.422 3.631-3.675 6.18-6.009 7.645-7.003a16.094 16.094 0 0 1 4.757-2.202 16.095 16.095 0 0 1 5.212-.568c1.768.096 3.474.47 5.12 1.126a16.094 16.094 0 0 1 4.492 2.701 16.094 16.094 0 0 1 3.394 3.995 16.094 16.094 0 0 1 1.941 4.87c.381 1.729.476 3.473.285 5.234a16.094 16.094 0 0 1-1.402 5.051 16.095 16.095 0 0 1-2.94 4.34c-15.004 15.842-39.417-8.906-22.252-23.487a16.094 16.094 0 0 1 4.491-2.703 16.094 16.094 0 0 1 5.12-1.127 16.095 16.095 0 0 1 5.211.567 16.095 16.095 0 0 1 4.758 2.2 16.094 16.094 0 0 1 3.805 3.606 16.094 16.094 0 0 1 2.456 4.631c.565 1.678.848 3.403.848 5.173 0 1.771-.283 3.495-.849 5.173a16.095 16.095 0 0 1-2.455 4.632l-1.606 2.112-5.37 4.582c-3.583 3.055-8.51 7.767-14.786 14.135a11933.445 11933.445 0 0 0-15.839 16.1c-4.284 4.364-8.943 9.26-13.975 14.688a75638.076 75638.076 0 0 1-15.826 17.063 2642.057 2642.057 0 0 0-15.89 17.273c-5.073 5.567-11.507 12.866-19.3 21.897-7.794 9.03-13.63 15.948-17.51 20.753a496.057 496.057 0 0 1-12.49 14.836c-4.447 5.085-9.976 7.77-16.588 8.052-6.612.283-12.583-2.325-17.913-7.822-5.33-5.498-11.117-11.861-17.361-19.091-6.245-7.23-11.274-13.11-15.087-17.64a385.872 385.872 0 0 0-11.496-13.06 905.91 905.91 0 0 1-12.117-13.426c-4.228-4.774-10.087-11.613-17.577-20.518-7.49-8.905-13.37-15.797-17.635-20.676-4.266-4.88-8.437-9.663-12.511-14.35-4.075-4.687-8.453-9.915-13.135-15.684-4.681-5.77-7.355-9.208-8.02-10.317a15.914 15.914 0 0 1-1.567-3.517 15.937 15.937 0 0 1 .724-11.305 15.914 15.914 0 0 1 2.003-3.288 15.914 15.914 0 0 1 2.733-2.713 15.913 15.913 0 0 1 3.302-1.98 15.914 15.914 0 0 1 3.68-1.132 15.914 15.914 0 0 1 3.845-.219c1.29.083 2.552.319 3.785.708 1.233.39 2.401.92 3.505 1.593a15.914 15.914 0 0 1 3.023 2.386l1.366 1.375z" transform="matrix(.26458 0 0 .26458 -132.758 -75.015)"/></svg>
--- a/public/assets/media/icons/close.svg
+++ b/public/assets/media/icons/close.svg
--- a/public/assets/media/icons/codeberg.svg
+++ b/public/assets/media/icons/codeberg.svg
--- a/public/assets/media/icons/email.svg
+++ b/public/assets/media/icons/email.svg
--- a/public/assets/media/icons/libera.svg
+++ b/public/assets/media/icons/libera.svg
--- a/public/assets/media/icons/matrix.svg
+++ b/public/assets/media/icons/matrix.svg
--- a/public/assets/media/icons/pin.svg
+++ b/public/assets/media/icons/pin.svg
--- a/public/assets/media/icons/search.svg
+++ b/public/assets/media/icons/search.svg
--- a/public/assets/media/line.svg
+++ b/public/assets/media/line.svg
--- a/public/assets/media/ogp.jpg
+++ b/public/assets/media/ogp.jpg
--- a/public/assets/media/travolta.gif
+++ b/public/assets/media/travolta.gif
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				<svg viewBox="0 0 78.743 46.968" xmlns="http://www.w3.org/2000/svg"><path d="m530.436 290.342 6.658 8.935c4.438 5.956 8.512 11.037 12.222 15.242 3.71 4.205 7.691 8.797 11.945 13.776a590.023 590.023 0 0 1 11.95 14.425c3.713 4.638 9.56 11.441 17.54 20.41 7.98 8.97 15.892 17.872 23.736 26.707a2267.256 2267.256 0 0 0 21.633 24.05c6.578 7.197 11.225 8.056 13.942 2.576 2.717-5.48 8.45-12.8 17.199-21.96 8.748-9.162 15.904-16.447 21.468-21.856a2287.547 2287.547 0 0 1 17.272-16.611 674.569 674.569 0 0 0 16.506-16.229c5.054-5.154 9.753-9.968 14.098-14.443 4.344-4.475 9.494-10.016 15.448-16.624 5.954-6.607 10.747-11.748 14.38-15.422 3.631-3.675 6.18-6.009 7.645-7.003a16.094 16.094 0 0 1 4.757-2.202 16.095 16.095 0 0 1 5.212-.568c1.768.096 3.474.47 5.12 1.126a16.094 16.094 0 0 1 4.492 2.701 16.094 16.094 0 0 1 3.394 3.995 16.094 16.094 0 0 1 1.941 4.87c.381 1.729.476 3.473.285 5.234a16.094 16.094 0 0 1-1.402 5.051 16.095 16.095 0 0 1-2.94 4.34c-15.004 15.842-39.417-8.906-22.252-23.487a16.094 16.094 0 0 1 4.491-2.703 16.094 16.094 0 0 1 5.12-1.127 16.095 16.095 0 0 1 5.211.567 16.095 16.095 0 0 1 4.758 2.2 16.094 16.094 0 0 1 3.805 3.606 16.094 16.094 0 0 1 2.456 4.631c.565 1.678.848 3.403.848 5.173 0 1.771-.283 3.495-.849 5.173a16.095 16.095 0 0 1-2.455 4.632l-1.606 2.112-5.37 4.582c-3.583 3.055-8.51 7.767-14.786 14.135a11933.445 11933.445 0 0 0-15.839 16.1c-4.284 4.364-8.943 9.26-13.975 14.688a75638.076 75638.076 0 0 1-15.826 17.063 2642.057 2642.057 0 0 0-15.89 17.273c-5.073 5.567-11.507 12.866-19.3 21.897-7.794 9.03-13.63 15.948-17.51 20.753a496.057 496.057 0 0 1-12.49 14.836c-4.447 5.085-9.976 7.77-16.588 8.052-6.612.283-12.583-2.325-17.913-7.822-5.33-5.498-11.117-11.861-17.361-19.091-6.245-7.23-11.274-13.11-15.087-17.64a385.872 385.872 0 0 0-11.496-13.06 905.91 905.91 0 0 1-12.117-13.426c-4.228-4.774-10.087-11.613-17.577-20.518-7.49-8.905-13.37-15.797-17.635-20.676-4.266-4.88-8.437-9.663-12.511-14.35-4.075-4.687-8.453-9.915-13.135-15.684-4.681-5.77-7.355-9.208-8.02-10.317a15.914 15.914 0 0 1-1.567-3.517 15.937 15.937 0 0 1 .724-11.305 15.914 15.914 0 0 1 2.003-3.288 15.914 15.914 0 0 1 2.733-2.713 15.913 15.913 0 0 1 3.302-1.98 15.914 15.914 0 0 1 3.68-1.132 15.914 15.914 0 0 1 3.845-.219c1.29.083 2.552.319 3.785.708 1.233.39 2.401.92 3.505 1.593a15.914 15.914 0 0 1 3.023 2.386l1.366 1.375z" transform="matrix(.26458 0 0 .26458 -132.758 -75.015)"/></svg>