# KBVE — full doc corpus

> Concatenated body text of every long-form doc on kbve.com. Page metadata + index live at /llms.txt.

Generated at build time from the Astro `docs` content collection. 534 entries included; itemdb / npcdb / mapdb / questdb data tables are excluded (see /api/itemdb.json etc. for those).

---
# Android

> Android is an open source operating system based off of Linux that runs within the ARM architecture;
the primary use case is within the mobile/tablet eco-system but it has been expanding into server, desktop and embedables.
Android utilizes a modified Linux kernel optimized for low power devices and real time performance.
Furthermore, the system provides a robust framework for application development through the Android SDK and Java/Kotlin APIs.
Android's modular architecture allows hardware vendors to customize drivers, UI layers, and services for specific devices.
With the introduction of Project Treble and mainline updates, the OS now supports more consistent long-term maintenance and faster security patches.
Beyond consumer devices, Android has also evolved into specialized distributions such as Android TV, Android Auto, and Wear OS, extending its ecosystem across multiple platforms.

Source: https://kbve.com/application/android/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

Are you ready to step into the heart of a global Android revolution, where millions of users and developers collaborate to improve the open source mobile operating system, giving you endless possibilities to customize your device and operating system.
Unleash your creativity and make your smartphone, tablet, or smartwatch truly your own with the endless array of apps and features available on Android, tailored to fit your unique needs and preferences.
Our job at KBVE will be to provide you with everything you need to deploy your own Android application on almost any device!

This one page guide is meant to serve as your resource manual moving forward, we will start with the cheat sheet below, that makes it easy to reference back in the future.

Jump to the [ADB cheatsheet](#cheatsheet), [data storage](#android-data-storage), or [React Native](#react-native) notes.

<Adsense />

## Cheatsheet

The ADB cheat sheet is an essential resource for navigating and managing Android operating systems and applications via the Android Debug Bridge (ADB).
It offers a comprehensive list of basic commands that facilitate various tasks such as installing apps, debugging issues, and accessing device logs.
While the cheat sheet covers a wide range of functionalities, it's important to note that some commands require root access, and certain Android versions may necessitate specific tweaks to the standard commands.
This makes the cheat sheet a versatile and indispensable tool for both novice users and experienced developers working with Android devices.

### Device Commands

Android ADB Device commands are commands that you can use to control the Android device over USB from a computer.
You can use them to list all devices, restart the ADB server, and reboot connected devices.

| Command            | Description                                                                | Notes / Variants                                                               |
| :----------------- | :------------------------------------------------------------------------- | :----------------------------------------------------------------------------- |
| `adb devices`      | List all connected devices.                                                |                                                                                |
| `adb devices -l`   | Query additional information (model, product, transport ID).               | Useful for identifying multiple devices.                                       |
| `adb get-state`    | Display the current device state (`device`, `offline`, or `unauthorized`). |                                                                                |
| `adb get-serialno` | Query the device’s serial number.                                          |                                                                                |
| `adb root`         | Launch the ADB daemon (`adbd`) with root permissions.                      | May fail on production builds: `adbd cannot run as root in production builds`. |
| `adb start-server` | Start the ADB server daemon.                                               | Runs automatically if missing when using other ADB commands.                   |
| `adb kill-server`  | Terminate the ADB server process.                                          | Use to restart ADB cleanly if it becomes unresponsive.                         |
| `adb reboot`       | Reboot the currently connected device.                                     | Accepts optional args like `bootloader` or `recovery`.                         |
| `adb help`         | Display general help and usage information.                                | Lists all supported subcommands.                                               |

### Shell

<Aside type="danger">

> Warning: Shell commands can brick your operating system, so make sure to double check them before running.

</Aside>

ADB shell is a command-line interface that you can use to access the shell and run various commands on your Android device.
You can use ADB shell commands to perform actions such as changing the resolution of your device display, uninstalling bloatware or system apps, enabling and disabling features, modifying the system files, ect..

<Aside type="note">

> Remember to keep a backup of the commands that you run via shell, I recommend creating a `log.txt` file and output all the commands to that file.

</Aside>

| Command                                  | Description                                                                           | Notes / Variants                                           |
| :--------------------------------------- | :------------------------------------------------------------------------------------ | :--------------------------------------------------------- |
| `adb shell`                              | Launch the interactive shell terminal on the connected device.                        | Equivalent to opening a remote terminal session.           |
| `adb -s $deviceString $deviceCommand`    | Send a command (`$deviceCommand`) to a specific device identified by `$deviceString`. | Useful when multiple devices are connected.                |
| `adb shell pwd`                          | Print the current working directory on the device.                                    |                                                            |
| `adb shell ls`                           | List the contents of the current directory.                                           |                                                            |
| `adb shell ls -s`                        | List directory contents with file size information.                                   |                                                            |
| `adb shell ls -R`                        | Recursively list contents of all subdirectories.                                      |                                                            |
| `adb shell netstat`                      | Display current TCP/IP network connections.                                           | Useful for debugging sockets and ports.                    |
| `adb shell dumpsys`                      | Dump system service information and status reports.                                   | A powerful diagnostic tool for system introspection.       |
| `adb shell dumpsys iphonesybinfo`        | Retrieve IMEI and related telephony information.                                      | Typo in some Android versions — should be `iphonesubinfo`. |
| `adb shell dumpsys battery`              | Display current battery status and related data.                                      |                                                            |
| `adb shell dumpsys battery set level $v` | Manually set battery level from `0` to `100`.                                         | Useful for testing low-power states.                       |
| `adb shell dumpsys battery reset`        | Reset battery state to default (real readings).                                       |                                                            |
| `adb shell dumpsys activity $package`    | Dump activity information for a specific package.                                     |                                                            |
| `adb shell pm list features`             | List available hardware and software features.                                        |                                                            |
| `adb shell service list`                 | List all registered Android system services.                                          | Often used before running targeted `dumpsys` queries.      |
| `adb shell wm`                           | Base command for WindowManager operations.                                            | Placeholder — requires subcommands.                        |
| `adb shell wm size`                      | Show the current screen resolution.                                                   |                                                            |
| `adb shell wm size $WxH`                 | Set custom screen resolution (e.g., `1080x1920`).                                     |                                                            |
| `adb shell wm size reset`                | Reset screen resolution to default.                                                   |                                                            |
| `adb shell wm density`                   | Show the current display density (DPI).                                               |                                                            |
| `adb shell wm density reset`             | Reset display density to system default.                                              |                                                            |
| `adb shell ps`                           | List all running processes on the device.                                             | Similar to Linux `ps` command.                             |
| `exit`                                   | Exit the current ADB shell session.                                                   | Returns to the host terminal.                              |

### Key Events

Android Key Events - A quick breakdown for each event and how the operating system handles them.

Generic Android Keyevents:

```bash
  adb shell input keyevent
```

| Keycode | Command Example               | Description             |
| :-----: | :---------------------------- | :---------------------- |
|    0    | `adb shell input keyevent 0`  | Keycode 0               |
|    1    | `adb shell input keyevent 1`  | Soft Left               |
|    2    | `adb shell input keyevent 2`  | Soft Right              |
|    3    | `adb shell input keyevent 3`  | Home Button Event       |
|    4    | `adb shell input keyevent 4`  | Back Button Event       |
|    5    | `adb shell input keyevent 5`  | Call Event              |
|    6    | `adb shell input keyevent 6`  | End Call / Hangup Event |
|    7    | `adb shell input keyevent 7`  | Keycode 0               |
|    8    | `adb shell input keyevent 8`  | Keycode 1 — Number 1    |
|    9    | `adb shell input keyevent 9`  | Keycode 2 — Number 2    |
|   10    | `adb shell input keyevent 10` | Keycode 3 — Number 3    |
|   11    | `adb shell input keyevent 11` | Keycode 4 — Number 4    |
|   12    | `adb shell input keyevent 12` | Keycode 5 — Number 5    |
|   13    | `adb shell input keyevent 13` | Keycode 6 — Number 6    |
|   14    | `adb shell input keyevent 14` | Keycode 7 — Number 7    |
|   15    | `adb shell input keyevent 15` | Keycode 8 — Number 8    |
|   16    | `adb shell input keyevent 16` | Keycode 9 — Number 9    |
|   17    | `adb shell input keyevent 17` | STAR (\*) Key           |
|   18    | `adb shell input keyevent 18` | Pound (#) Key           |

- Koltin: `open class KeyEvent: InputEvent, Parcelable`

- Java: `public class KeyEvent extends InputEvent implements Parcelable`

<Aside>
	The ADB cheatsheet provides a general list of basic commands for Android
	operating system and applications. Please note that certain commands require
	the device to be rooted, furthermore certain Android versions may require a
	tweak to the commands.
</Aside>

---

## Android Data Storage

In Android, there are several ways to store data persistently.
The choice of storage mechanism depends on the nature of the data and the requirements of the app.
Below are the primary methods for data storage in Android:

**Comparison of Storage Options**

| Storage Method    | Visibility | Persistence            | Complexity  | Best For                                 |
| ----------------- | ---------- | ---------------------- | ----------- | ---------------------------------------- |
| SharedPreferences | Private    | Until app uninstall    | Low         | Small key-value pairs                    |
| Internal Storage  | Private    | Until app uninstall    | Low         | Private files                            |
| External Storage  | Public     | Until manually deleted | Medium      | Large/shared files                       |
| SQLite Database   | Private    | Until app uninstall    | High        | Structured data                          |
| Room              | Private    | Until app uninstall    | Medium-High | Structured data with compile-time safety |

When choosing a storage method, consider the type of data you're storing, how much data you need to store, the required level of security, and the complexity you're willing to manage in your app.

1. SharedPreferences

SharedPreferences is a framework that allows you to save and retrieve key-value pairs of primitive data types.

**Use Cases**

- Storing user preferences.
- Saving settings or configuration data.

**Advantages:**

- Simple to use for small amounts of data
- Data persists across app restarts

**Disadvantages:**

- Not suitable for large or complex data structures
- Not encrypted by default

**Java Code Example**

```java
// Saving data to SharedPreferences
SharedPreferences sharedPref = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putString("key_name", "value");
editor.apply();

// Retrieving data from SharedPreferences
SharedPreferences sharedPref = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);
String value = sharedPref.getString("key_name", "default_value");
```

2. Internal Storage

Internal Storage is used to store private data within the device's internal memory.

**Use Cases**

- Storing sensitive data.
- Files that should not be accessible to other apps.

**Advantages:**

- Data is private to the app.
- Files are removed when the app is uninstalled.

**Disadvantages:**

- Limited by device storage.
- Not easily accessible for backup.

**Java Code Example**

```java
// Writing to internal storage
String filename = "myfile";
String fileContents = "Hello, World!";
FileOutputStream fos = openFileOutput(filename, Context.MODE_PRIVATE);
fos.write(fileContents.getBytes());
fos.close();

// Reading from internal storage
FileInputStream fis = openFileInput(filename);
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
StringBuilder sb = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
    sb.append(line);
}
String fileContents = sb.toString();
fis.close();
```

3. External Storage

External Storage is used to store public data on the shared external storage.
It's typically used for storing larger files.

**Use Cases**

- Storing media files (images, videos, audio)
- Documents that need to be shared with other apps.

**Advantages:**

- Larger storage capacity
- Files can be shared with other apps

**Disadvantages:**

- Not secure, as other apps can access the files
- Files may remain after app uninstallation

**Permissions**

```xml
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```

**Java Code Example**

```java
// Writing to external storage
String filename = "myfile";
String fileContents = "Hello, World!";
File file = new File(getExternalFilesDir(null), filename);
FileOutputStream fos = new FileOutputStream(file);
fos.write(fileContents.getBytes());
fos.close();

// Reading from external storage
File file = new File(getExternalFilesDir(null), filename);
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
StringBuilder sb = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
    sb.append(line);
}
String fileContents = sb.toString();
fis.close();
```

4. SQLite Database

SQLite is a lightweight relational database embedded within Android.

**Use Cases**

- Structured data storage.
- Complex querying requirements.
- Managing complex data relationships

**Advantages:**

- Efficient for complex queries and large datasets
- Supports transactions and data integrity

**Disadvantages:**

- More complex to set up and use compared to other options
- Overkill for simple data storage needs

**Java Code Example**

```java
// Creating a database helper
public class MyDatabaseHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "mydatabase.db";
    private static final int DATABASE_VERSION = 1;

    public MyDatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE mytable (id INTEGER PRIMARY KEY, name TEXT)");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS mytable");
        onCreate(db);
    }
}

// Using the database helper
MyDatabaseHelper dbHelper = new MyDatabaseHelper(context);
SQLiteDatabase db = dbHelper.getWritableDatabase();

// Inserting data
ContentValues values = new ContentValues();
values.put("name", "John Doe");
long newRowId = db.insert("mytable", null, values);

// Querying data
Cursor cursor = db.query("mytable", new String[]{"id", "name"}, null, null, null, null, null);
while (cursor.moveToNext()) {
    long itemId = cursor.getLong(cursor.getColumnIndexOrThrow("id"));
    String itemName = cursor.getString(cursor.getColumnIndexOrThrow("name"));
}
cursor.close();
db.close();
```

5. Room Database

Room is an abstraction layer over SQLite that provides a more robust database access while harnessing the full power of SQLite.

**Use Cases:**

- When you need a robust database solution but want to avoid the complexity of raw SQLite

**Advantages:**

- Compile-time verification of SQL queries
- Convenient annotations to define database structure
- Easy integration with other Architecture components

**Disadvantages:**

- Adds additional dependencies to your project
- May be overkill for very simple data storage needs

**Java Code Example**

```java
// Define Entity
@Entity(tableName = "user")
public class User {
    @PrimaryKey
    public int id;
    public String name;
}

// Define DAO
@Dao
public interface UserDao {
    @Insert
    void insert(User user);

    @Query("SELECT * FROM user WHERE id = :id")
    User getUserById(int id);
}

// Define Database
@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

// Using Room
AppDatabase db = Room.databaseBuilder(getApplicationContext(),
        AppDatabase.class, "mydatabase").build();
UserDao userDao = db.userDao();

// Inserting data
User user = new User();
user.id = 1;
user.name = "John Doe";
userDao.insert(user);

// Querying data
User user = userDao.getUserById(1);
```

6. Content Providers

Content Providers manage access to a structured set of data. They encapsulate the data and provide mechanisms for defining data security.

**Use Cases**

- Sharing data between different applications.
- Accessing data from other applications.

**Java Code Example**

```java
// Querying a content provider
Cursor cursor = getContentResolver().query(
        ContactsContract.Contacts.CONTENT_URI,
        null,
        null,
        null,
        null);

while (cursor.moveToNext()) {
    String id = cursor.getString(
            cursor.getColumnIndex(ContactsContract.Contacts._ID));
    String name = cursor.getString(
            cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
}
cursor.close();
```

---

## React Native

This part of the guide goes into the specific parts of React Native and Android, we do try to keep all our react native notes into one area.
We recommend going to the React Native section as well, but there might be double notes in this section.

## FAQ

**What is ADB (Android Debug Bridge)?**
ADB is a command-line tool that lets a computer control an Android device over USB or Wi-Fi. It is used to install and uninstall apps, push and pull files, read device logs with `logcat`, open a device shell, and debug applications during development.

**How do I connect a device with ADB?**
Enable Developer Options and USB debugging on the device, connect it over USB, and run `adb devices` to confirm it is listed. Some commands need root access, and certain Android versions may require slightly different command syntax.

**What languages are used for Android development?**
Native Android apps are written in Kotlin (now preferred) or Java against the Android SDK. Cross-platform options include React Native and [Flutter](/application/flutter/). KBVE's Android apps use React Native with Expo, with native modules added when a feature needs platform-specific code.

**Is Android open source?**
Yes. Android is built on the open-source Android Open Source Project (AOSP) on top of a modified Linux kernel. Vendors customize drivers and UI layers on top, while Project Treble and mainline modules allow more consistent updates and faster security patches.

**What is Android used for beyond phones?**
Android extends well past phones and tablets into specialized distributions — Android TV for televisions, Android Auto for vehicles, and Wear OS for smartwatches — plus growing use in embedded, desktop, and server-adjacent devices thanks to its modular architecture.

<Giscus />

---
# Ansible

> DevOps software that handles the infrastructure of the backend through automation.
Ansible's main function(s) operate through a "playbook" system that exectues a collection of commands for the system admin, which becomes a pillar within the IaaC environment.

Source: https://kbve.com/application/ansible/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
	Tabs,
	TabItem,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

<Aside type="note">
> Automation software that enables `IaC` - also known as, infrastructure as code, thus allowing user to provision, configure, deploy and secure a whole array of software, applications and machines.

</Aside>

## Information

With **Ansible**, you can automate complex IT operations with clarity and control.
It simplifies system management, application deployment, and workflow orchestration through powerful, modular building blocks.
Powered by open source, Python, and SSH, Ansible connects seamlessly to your devices—no agents required.
It sends lightweight programs called **modules** to perform tasks precisely where they are needed, then removes them once finished.
From provisioning servers to configuring networks and deploying applications, Ansible turns manual, error-prone processes into consistent, repeatable automation.

Jump to [install](#install), [playbooks](#playbook), [modules](#modules), [AWX](#awx), or the [cheatsheet](#cheatsheet).

<Adsense />

<Tabs syncKey="info">
  <TabItem label="Tip">
<Aside type="tip">
Think of Ansible like these metaphors:

- Ansible is like a remote control that lets you manage your devices with the push of a button.
- Ansible is like a chef that prepares a delicious meal using different ingredients and recipes.
- Ansible is like a conductor that orchestrates a symphony of servers and applications.

</Aside>

</TabItem>
<TabItem label="Newbie">

### Ansible for a Newbie!

Ansible is a tool that helps people do things with computers.
Sometimes people have many computers and they want to do the same thing on all of them.
For example, they might want to make them play a game, or show a picture, or talk to each other.
Doing the same thing on many computers can be hard and boring.
Ansible makes it easy and fun and has a list of things that people want to do with computers.
It can read the list and do the things one by one and then also check if the things are done correctly.
Ansible can talk to different kinds of computers and tell them what to do.
Think of Ansible like a friend that helps people with computers.

</TabItem>

</Tabs>

## Install

To install **Ansible**, you will need two types of machines:  
a **control node** (where Ansible runs) and one or more **managed nodes** (where Ansible performs tasks).

<Steps>

1. **Set up your Control and Managed Nodes**  
   The **control node** is where you run Ansible commands and playbooks.  
   It can be any UNIX-like system with **Python 3.9+** installed.  
   The **managed node** is any system that supports **Python 2.7+** and communicates via **SSH** (or PowerShell on Windows).

2. **Install Ansible**  
   Depending on your operating system, there are multiple installation paths:

    - **Ubuntu / Debian:** Use `apt install ansible` from the official repositories.
    - **Windows:** Enable **Windows Subsystem for Linux (WSL)** and install Ansible using `pip install ansible` or `pip3 install ansible`.
    - **Source:** Clone the [Ansible GitHub repository](https://github.com/ansible/ansible) and build from source to get the latest development version.

3. **Configure Ansible**  
   Set up your **inventory file** to list managed nodes and their connection details.  
   You can further customize settings in the `ansible.cfg` file or override them using environment variables or command-line options.

4. **Verify the Installation**  
   Run a quick test to ensure Ansible is configured properly:

    ```bash
    ansible all -m ping
    ```

    If everything is set up correctly, you will receive a pong response from your managed nodes.

</Steps>

<Aside type="tip" title='Need extra installation help?'>

[Ask our support team?](https://kbve.com/support/), visit our [Discord](https://kbve.com/discord/) or if you need help with [Python, read our docs](/application/python/)

</Aside>

---

## Playbook

An Ansible playbook is your automation blueprint written in YAML/JSON.
The purpose of the playbook is to tell Ansible what to do, where to do it, and how to do it.
With a playbook, you can transform your IT tasks into simple and repeatable steps that run on any number of hosts.
Whether you need to install software, configure settings, run commands, or anything else, an Ansible playbook will make it happen in a snap.

### Playbook Examples

Let me dazzle you with an example of a playbook that I borrowed from the Ansible documentation.

```yaml
- name: Update web servers
  hosts: webservers
  remote_user: root
  tasks:
      - name: Ensure apache is at the latest version
        ansible.builtin.yum:
            name: httpd
            state: latest
      - name: Write the apache config file
        ansible.builtin.template:
            src: /srv/httpd.j2
            dest: /etc/httpd.conf

- name: Update db servers
  hosts: databases
  remote_user: root
  tasks:
      - name: Ensure postgresql is at the latest version
        ansible.builtin.yum:
            name: postgresql
            state: latest
      - name: Ensure that postgresql is started
        ansible.builtin.service:
            name: postgresql
            state: started
```

This playbook has two plays.
The first one updates the web servers by installing the latest version of apache and writing a config file.
The second one updates the database servers by installing the latest version of postgresql and starting the service.
Each play has a name, a list of hosts to target, a remote user to execute the tasks, and a list of tasks to perform.
Each task has a name and a module to call with some parameters.

#### Minecraft Server Update Playbook Example

```yaml
- name: Update Minecraft server
  hosts: minecraft
  vars:
      minecraft_version: latest
      minecraft_url: https://s3.amazonaws.com/Minecraft.Download/versions
      minecraft_home: /srv/minecraft
  tasks:
      - name: Get latest Minecraft version
        uri:
            url: '{{ minecraft_url }}/latest.json'
            return_content: yes
        register: latest_version
        when: minecraft_version == "latest"

      - name: Set Minecraft version
        set_fact:
            minecraft_version: '{{ latest_version.json.id }}'
        when: minecraft_version == "latest"

      - name: Check if Minecraft server jar exists
        stat:
            path: '{{ minecraft_home }}/minecraft_server.{{ minecraft_version }}.jar'
        register: jar_file

      - name: Download Minecraft server jar
        get_url:
            url: '{{ minecraft_url }}/{{ minecraft_version }}/minecraft_server.{{ minecraft_version }}.jar'
            dest: '{{ minecraft_home }}'
        when: not jar_file.stat.exists

      - name: Restart Minecraft service
        systemd:
            name: minecraft
            state: restarted
        when: not jar_file.stat.exists
```

This playbook is composed of four parts:

- The name of the playbook, which is `Update Minecraft server`.
- The hosts that the playbook will run on, which are the ones in the `minecraft` group in the inventory file.
- The variables that the playbook will use, such as `minecraft_version`, `minecraft_url`, and `minecraft_home`.
- The tasks that the playbook will execute, such as getting the latest Minecraft version, downloading the server jar file, and restarting the Minecraft service.

Each task has a name, a module to use, and some parameters for the module.
Some tasks also have a condition (`when`) that determines when they will run.
For example, the task `Download Minecraft server jar` will only run if the jar file does not exist in the `minecraft_home` directory.
The playbook uses the `register` keyword to store the output of some tasks in variables, such as `latest_version` and `jar_file`.
These variables can be used in later tasks or conditions and this playbook could be expanded to include file checks with hashing.

---

## Modules

<Aside>

> **tldr;** Ansible has a large collection of modules that can be used for various tasks and purposes.

</Aside>

Cloud modules can be used to interact with different cloud providers, such as AWS, Azure, Google Cloud, etc.

The cloud modules within Ansible are a set of modules that can be used to interact with different cloud providers and services.
They allow you to provision, configure and manage cloud resources, such as virtual machines, networks, storage, databases, etc.

---

### CI/CD Modules

<Aside>
  
  > **tldr;** These modules integrate Ansible automation into continuous integration and delivery workflows, such as GitHub Actions or GitLab CI.

</Aside>

The CI/CD modules enable you to run Ansible playbooks directly within automated pipelines.
They are useful for testing, provisioning, or deploying infrastructure and applications as part of your workflow.

| Module / Action                   | Description                                                       |
| :-------------------------------- | :---------------------------------------------------------------- |
| `ansible/ansible-lint-action`     | Runs `ansible-lint` to validate playbooks and roles.              |
| `ansible/ansible-playbook-action` | Executes an Ansible playbook inside your GitHub Actions workflow. |
| `ansible/galaxy-action`           | Manages Ansible Galaxy roles and collections in your pipeline.    |

<Aside type="tip">
	You can combine these with AWS or Azure modules in later stages of your
	workflow to deploy cloud infrastructure automatically after tests pass.
</Aside>

#### FileTree

Here is a full featured layout with Talos OS, core addons, git ops, data plane.

<FileTree label="ansible-k8s-talos (full)">
- .github/
  - actions/
    - setup-ansible/               # optional composite action (cache, galaxy install)
  - workflows/
    - check.yml                    # lint (ansible-lint), yamllint, jsonschema, markdown
    - test.yml                     # molecule with k3d/kind; idempotence checks
    - deploy.yml                   # on tag or manual dispatch → staged rollout
- .env.example                     # sample env for CI (secrets injected via repo/env)
- .gitignore
- ansible.cfg
- requirements.yml                 # collections: kubernetes.core, community.general, community.kubernetes
- requirements-roles.yml
- inventories/
  - production/
    - hosts.yml
    - group_vars/
      - all.yml
      - gitops.yml                 # argo root app repo/branch/path
      - storage.yml                # default sc, longhorn, nfs, cnpg
      - observability.yml          # loki, prom, grafana toggles
      - networking.yml             # cni options, lb, svc CIDRs (reference-only if Talos-managed)
  - staging/
    - hosts.yml
    - group_vars/
      - all.yml
- group_vars/
  - all.yml                        # cluster_name, domain, issuer, registry creds (non-secret)
- host_vars/
  - cp-01.yml
  - worker-01.yml
- collections/                     # (optional, if vendored)
- roles/
  - talos_bootstrap/
    - tasks/
      - main.yml                   # talosctl gen secrets/apply, kubeconfig export
  - kubernetes_cluster/
    - tasks/
      - main.yml                   # kube-api reachability, ns, rbac, psp replacement, quotas
  - helm_release/
    - tasks/
      - main.yml
  - cert_manager/
    - tasks/
      - main.yml                   # ClusterIssuer (LE DNS/HTTP), CRDs, health checks
  - ingress_nginx/
    - tasks/
      - main.yml                   # controller, TCP services, proxy settings
  - argocd/
    - tasks/
      - main.yml                   # install, admin secret mgmt (sealed-secrets optional)
  - sealed_secrets/
    - tasks/
      - main.yml
  - longhorn/
    - tasks/
      - main.yml
  - cnpg/
    - tasks/
      - main.yml                   # CloudNativePG operator
  - clickhouse_operator/
    - tasks/
      - main.yml
  - apps_catalog/
    - tasks/
      - main.yml                   # app-of-apps: ergo-irc, restreamer, etc.
- playbooks/
  - 00-bootstrap.yml               # includes: talos_bootstrap (optional if you do Talos externally)
  - 10-cluster.yml                 # includes: kubernetes_cluster
  - 20-core.yml                    # includes: cert_manager, ingress_nginx, sealed_secrets
  - 30-gitops.yml                  # includes: argocd (+ root apps)
  - 40-storage.yml                 # includes: longhorn, cnpg, clickhouse_operator
  - 99-apps.yml                    # includes: apps_catalog (ergo, restreamer, etc.)
- vars/
  - issuers.yml
  - registries.yml
  - domains.yml
  - storage.yml
- files/
  - kubeconfig.sample              # for local dev (never commit real kubeconfigs)
  - manifests/
    - argocd/
      - root-app.yaml              # optional if you don't bootstrap via Helm
- templates/
  - argocd-values.yaml.j2
  - cert-manager-values.yaml.j2
  - ingress-nginx-values.yaml.j2
- molecule/
  - k3d-default/
    - converge.yml
    - verify.yml
    - molecule.yml
- docs/
  - ADR-0001-ci-approach.md
  - ADR-0002-gitops-structure.md
- README.md
</FileTree>

- Talos handles OS + kubelet; Ansible focuses on cluster add-ons (Helm + Kubernetes modules) and GitOps bootstrap.
- CI stages are there for a quick check, test and deploy.

---

### AWS Modules

<Aside>
	These modules can be used to work with Amazon Web Services (AWS), such as
	EC2, S3, CloudFormation, etc. For example, you can use the
	`amazon.aws.ec2_instance` module to create and manage EC2 instances on AWS.
</Aside>

Ansible provides a wide range of **AWS modules** that let you automate tasks across Amazon Web Services, from launching EC2 instances to managing S3 buckets, security groups, and CloudFormation stacks.
These modules use the AWS SDK for Python (boto3) under the hood, allowing secure, API-based interaction with your cloud resources.
You can use them to playbooks to **create, configure, and delete** infrastructure components, making it easy to manage everything as code aka `IaaC`.

| Module                          | Description                                            |
| :------------------------------ | :----------------------------------------------------- |
| `amazon.aws.ec2_instance`       | Create and manage EC2 instances.                       |
| `amazon.aws.s3_bucket`          | Create, delete, and configure S3 buckets.              |
| `amazon.aws.cloudformation`     | Deploy infrastructure stacks using AWS CloudFormation. |
| `amazon.aws.iam_user`           | Manage IAM users and access permissions.               |
| `amazon.aws.ec2_security_group` | Define and modify EC2 security groups.                 |

<Aside type="caution">

> Before using these modules, ensure you have installed the `amazon.aws` collection and configured your AWS **credentials** properly using aws configure or environment variables.

</Aside>

---

### Azure Modules

With these modules, you have full control over your Microsoft Azure resources, whether they are VMs, Storage, Network or anything else.
For example, you can use the `azure_rm_virtualmachine` module to create and manage Azure virtual machines.

---

### GCP Modules

You can work with any Google Cloud Platform service with these modules, such as Compute Engine, Storage, Network and more.
The `gcp_compute_instance` module is an example of how you can achieve your goals with GCP servers using Ansible.

> [Official Documentation on GCP Compute Instance module](https://docs.ansible.com/ansible/latest/collections/google/cloud/gcp_compute_instance_module.html)

#### Create GCP Instance

Creating a compute instance with a specific name, zone, machine type, image and network:

```yaml
- name: create gcp instance
  google.cloud.gcp_compute_instance:
      name: test_object
      zone: us-central1-a
      machine_type: n1-standard-1
      disks:
          - auto_delete: true
            boot: true
            source: '{{ disk }}'
      network_interfaces:
          - network: '{{ network }}'
            access_configs:
                - name: External NAT
                  nat_ip: '{{ address }}'
                  type: ONE_TO_ONE_NAT
      state: present
```

This example creates a compute instance with a specific name, zone, machine type, image and network.
It uses the `state: present` parameter to indicate that the instance should exist.
It also specifies the `disks` and `network_interfaces` parameters to configure the disk and network settings of the instance.
The `disk` and `network` variables are assumed to be defined elsewhere in the playbook or inventory.

#### Delete GCP Instance

Deleting a compute instance with a specific name and zone:

```yaml
- name: dlete gcp instance
  google.cloud.gcp_compute_instance:
      name: test_object
      zone: us-central1-a
      state: absent
```

For this task, it deletes a compute instance with a specific `name` and `zone`.
It uses the `state: absent` parameter to indicate that the instance should not exist.
It does not need to specify any other parameters, as the `name` and `zone` are enough to identify the instance to delete.

#### Update GCP Instance

Updating a compute instance with a new machine type and labels

```yaml
- name: update gcp instance
  google.cloud.gcp_compute_instance:
      name: test_object
      zone: us-central1-a
      machine_type: n1-standard-2
      labels:
          env: prod
          webserver: nginx
      state: present
```

The update example performs the task of updating a compute instance with a new machine type and labels.
It uses the `state: present` parameter to indicate that the instance should exist.
It also specifies the `machine_type` and `labels` parameters to change the machine type and labels of the instance.
The machine type determines the CPU and memory resources of the instance, and the labels are key-value pairs that can be used to organize and filter instances.
Any other parameters that are not specified will remain unchanged.

---

### OpenStack Modules

OpenStack modules can be used to work with OpenStack, an open source cloud platform that provides infrastructure as a service (IaaS).
The `os_server` module is an example of how you can have full control over your OpenStack servers.

---

### Network Modules

You can configure and manage any network device with these modules, such as routers, switches, firewalls and beyond.

---

### System Modules

With these modules, you have full control over your system resources, whether they are users, groups, files, directories, services, packages or anything else.

---

### Database Modules

Employing these modules, you have full control over your database servers and objects, from MySQL and PostgreSQL to MongoDB and more.

---

### Windows Modules

Windows modules can be used to manage Windows systems and applications, such as Active Directory, IIS, PowerShell, etc.
For example, you can use the `win_service` module to manage Windows service

---

## AWX

> tldr; AWX is a web-base RESTFul API and task engine that operates on top of Ansible, thus enabling you to automate certain aspects of the IT/DevOps.

AWX is an open source project that gives you a sleek and modern web-based user interface, a powerful and flexible REST API, and a robust and scalable task engine to work with Ansible.
It is the upstream project of Red Hat Ansible Automation Platform, which is a premium solution that offers additional features and support for enterprise customers.
With AWX, you can easily manage your Ansible playbooks, inventories, credentials, and vaults in a collaborative and secure way among your team members.
Moreover, AWX empowers you to plan and run your Ansible playbooks on your managed nodes with speed, efficiency and dependability; you can set up custom schedules, workflows, notifications, and callbacks to automate your Ansible operations and monitor their outcomes.
In conclusion, AWX gives you full control and visibility over your Ansible playbooks and their execution.

### AWX Repo

> The official [Repository](https://github.com/ansible/awx) for AWX - Ansible.

The AWX repository is a GitHub repository that contains a treasure trove of source code and other resources.

### AWX Terraform

> More information on [Terraform](/application/terraform/)

Terraform AWX Provider from Denouche.

By using AWX and Terraform together, you can leverage the power and flexibility of Ansible to manage your AWS resources with ease and efficiency.
The Two tools that can be used together to automate IT infrastructure.

- Official [Registry](https://registry.terraform.io/providers/denouche/awx/latest/docs) Link:

Example Usage - With Username/Password:

```ini
provider "awx" {
    hostname = "http://localhost:8078"
    username = "kbvetest"
    password = "changemepassword"
}
```

Example Usage - With Token:

```ini
provider "awx" {
  hostname = "http://localhost:8078"
  token    = "awxtoken"
}
```

> Remember that if you set both (username/password) and (token), then the (token) will have precedence.

## Cheatsheet

> tldr; Commands that will make it easier operate ansible scripts / playbooks. This cheatsheet is still a work-in-progress.

An Ansible cheatsheet is a quick and handy reference guide that provides examples and tips on how to use Ansible command line tools and playbooks, thus enabling you to unleash the power of Ansible!
With an Ansible cheatsheet at your fingertips, you can breeze through a variety of tasks that would otherwise be tedious and time-consuming.
Whether you need to test the connectivity to your nodes, switch to a different user, use a custom SSH key, use password-based authentication, run ad-hoc commands, create and run playbooks, use modules and roles, or anything else, an Ansible cheatsheet will make your life easier and more fun.

## Videos

Video -> https://www.youtube.com/watch?v=EcnqJbxBcM0

## Notes

Notes for Ansible

## FAQ

**What is Ansible?**
Ansible is an open-source IT automation tool for configuration management, application deployment, and orchestration. It is agentless — it connects to hosts over SSH and pushes small programs called modules to do work, then removes them — so managed machines need no special software beyond Python and SSH.

**What is an Ansible playbook?**
A playbook is a YAML file that describes a set of plays, each mapping a group of hosts to an ordered list of tasks. Playbooks are declarative and idempotent — running one repeatedly converges hosts to the same desired state without repeating changes that are already applied.

**Why is Ansible agentless?**
Ansible does not install a daemon on managed nodes. It uses existing SSH access and Python to run modules on demand, which lowers setup overhead, reduces attack surface, and means any reachable host can be managed without provisioning an agent first.

**What is an Ansible module?**
A module is a self-contained unit of work — like `apt`, `copy`, `service`, or `template` — that Ansible ships to a host to perform one task idempotently. Tasks in a playbook call modules with parameters, and Ansible reports whether each run changed the system.

**What is AWX?**
AWX is the open-source upstream of Ansible Tower (Red Hat Ansible Automation Platform). It adds a web UI, REST API, role-based access control, job scheduling, and centralized credential management on top of core Ansible for team-scale automation.

<Adsense />

---
# Appwrite

> Appwrite is an open-source backend server that provides developers with core APIs to build applications. It is self-hosted and can run on any operating system. Appwrite aims to simplify backend development for developers.

Source: https://kbve.com/application/appwrite/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**Appwrite** is an open-source, self-hosted **backend server** (Backend-as-a-Service) that hands developers a ready-made set of core APIs — **auth, databases, storage, messaging, and serverless functions** — behind a clean management console. It runs on any OS via Docker, so you skip building common backend plumbing yourself.

This guide covers [Cloud Functions](#javascript) (Init/Core/Extra) and the [Python SDK](#python).

## Information

Appwrite is a cutting-edge backend server that streamlines the development of modern apps.
With its powerful APIs, intuitive tools, and sleek management console UI, Appwrite empowers developers to build their apps with speed and security.
Say goodbye to the headaches of common, complex, and repetitive tasks - Appwrite has got you covered.
Get ready to revolutionize your app development process with Appwrite!

<Adsense />

## Javascript

More information for [javascript](/application/javascript)

This part of the documentation is no longer valid for Appwrite 1.4+, as they have changed their functions.

We split the functions into three different areas:

1. `Init` - Which initializes the serverless function, handling the installs if using different libaries, ect...
2. `Core` - These are the notes for the core serverless function.
3. `Extra` - Additional notes and information regarding the expansion of a serverless function.

### Init

Hello there, fellow developers! 🚀

Today, we're diving deep into the world of cloud functions with a special focus on Appwrite - a wonderful platform that allows you to build secure web and mobile applications faster.

### What is a Cloud Function?

At its core, a cloud function is a piece of code that runs in response to an event.
You don’t need to manage the infrastructure; the cloud provider does that for you.
Think of it as "Function as a Service" (FaaS).
Cloud functions are a key part of the serverless architecture, allowing developers to focus on writing code without worrying about the underlying infrastructure.

### Initializing Your Appwrite Cloud Function

1. `Function Creation` :

    - Head over to your Appwrite Console, navigate to the Functions section, and click on `Add Function`.
    - Give your function a name and choose a runtime (e.g., Node.js, Python, Deno, etc.).

2. `Code Your Function` :

    - Reference Core for the basics.
    - Here is a basic / starter.

    ```javascript
    module.exports = async (req, res) => {
    	const payload =
    		req.payload ||
    		'No payload provided. Add custom data when executing function.';

    	const secretKey =
    		req.variables.SECRET_KEY ||
    		'SECRET_KEY variable not found. You can set it in Function settings.';

    	const randomNumber = Math.random();

    	const trigger = req.variables.APPWRITE_FUNCTION_TRIGGER;

    	res.json({
    		message: 'Hello from Appwrite!',
    		payload,
    		secretKey,
    		randomNumber,
    		trigger,
    	});
    };
    ```

3. `Packaging` :

    - Cloud functions in Appwrite run inside Docker containers, so your function and any dependencies need to be packed into a tarball. For Node.js:
      `tar -czf code.tar.gz --exclude code.tar.gz .`

4. `Deployment` :
    - Upload Your Code: Back in the Appwrite Console, under your function, click on the Deploy Tag button.
    - Upload the code.tar.gz file.
    - Set Your Triggers! Functions can respond to various events, like user registration or document creation. Select the triggers relevant to your use case.
    - Execute! With everything set, hit the Execute button. Your function will run, and you can see the logs in real-time.

Yay! Congratulations, you’ve just deployed your first Appwrite Cloud Function! 🎉
The power of serverless lies in its simplicity and scalability.
As your application grows, you can continue adding more functions without the hassle of managing servers or infrastructure.

I hope this introduction helps kickstart your journey with Appwrite Cloud Functions.
Stay tuned for more in-depth tutorials, and happy coding! 🚀

### Core

General documentation and information in reference to the cloud functions / open runtime for Appwrite.

Remember to import the SDK outside of the module function.

The main `module.exports` is usually written like this

```javascript
module.exports = async function (req, res) {}; // Passing req and res
```

The `req` contains these three main objects:

`req.headers` - An object with the request headers for the function.
`req.payload` - An object with the payload, which is the main body data.
`req.env` - An object with the environment data.

The `res` can return two main objects:

`res.send` - returns a `text` and `statusCode`.
`res.json` - returns an `object` and `statusCode`.

Example of parsing the `req.payload` check and `res.json` return.

```javascript
if (req.payload) {
	try {
		payload = JSON.parse(req.payload);
	} catch (error) {
		errorHandler('Corrupt payload for the function.');
	}
} else {
	errorHandler('Missing payload for the function.');
}
```

In this case our `errorHandler` function would be:

```javascript
const errorHandler = (__errorMessage, statusCode = 418) => {
	res.json({ data: 'error', message: __errorMessage }, statusCode);
};
```

### Extra

In the context of Appwrite Cloud Functions, "extra libraries" refer to external dependencies or packages that your function might need to execute correctly.
Due to the isolated nature of cloud functions, they don't inherently have access to all the libraries or tools available in a full-fledged server environment.
To overcome this, Appwrite allows you to bundle these additional libraries with your function code.
When you're developing your function, you specify and package these libraries—be it npm packages for a Node.js function, pip packages for a Python function, or any other dependencies for other runtimes.
Once bundled, Appwrite ensures that these libraries are available to your function at runtime, providing a seamless execution environment tailored to your specific needs.

-   For data fetching, we recommend that you add an external module known as `axios`.
    -   `const axios = require("axios").default;`

---

## Python

The Appwrite Python SDK allows Python developers to interact with Appwrite's API, facilitating tasks like user authentication, database operations, storage, and more.
By using this SDK, Python developers can seamlessly integrate and manage Appwrite services in their applications, without delving into the complexities of direct API calls.

Step aside traditional backends, the Appwrite Python SDK is in town, rolling out the red carpet for Pythonistas eager to elevate their web and mobile projects!
This snazzy toolkit doesn't just connect Python applications to the Appwrite server; it's a golden ticket to a carnival of backend delights.
From the tantalizing whirlwind of user authentication to the magic show of database operations and the high-flying trapeze of storage management, the SDK transforms mundane backend tasks into a spectacle.
No more wrestling with manual API requests – just harness the SDK's sleek methods and watch as Appwrite's vast services dance harmoniously with your Python code.
Whether you're orchestrating user data or wiring up notifications, the Appwrite Python SDK keeps backend integration clean and readable.

### Appwrite Python SDK Install

Python wizards, gather 'round! Elevate your coding cauldron with a sprinkle of Appwrite magic by simply chanting `pip install appwrite`.
And just like that, your Python broomstick is turbocharged and ready to soar through the backend skies!

Calling the `appwrite` in python is really easy! Just add this below:

```python

from appwrite.client import Client

client = Client()

client = (client
    .set_endpoint('https://ap.kbve.com/v1') # Your API Endpoint
    .set_project('[PROJECT_ID]')                # Your project ID
    .set_key('919c2db5d4...a2a3346ad2')          # Your secret API key
)

```

And you will be good to go!

### Appwrite Python SDK Demo

Here is a quick and easy demo for Appwrite python below!

```python

from appwrite.client import Client
from appwrite.id import ID
from appwrite.services.users import Users

client = Client()

client = (client
    .set_endpoint('https://cloud.appwrite.io/v1') # Your API Endpoint
    .set_project('[PROJECT_ID]')                # Your project ID
    .set_key('919c2db5d4...a2a3346ad2')          # Your secret API key
)

users = Users(client)

user = users.create(
    user_id=ID.unique(),
    email='email@example.com',
    phone=None,
    password='password'
)

```

## FAQ

**What is Appwrite?**
Appwrite is an open-source, self-hosted backend server (a Backend-as-a-Service) that gives developers core APIs — authentication, databases, storage, messaging, and serverless functions — plus a management console. It runs on any OS via Docker and removes the need to build common backend plumbing from scratch.

**What is an Appwrite Cloud Function?**
A Cloud Function is a piece of code that runs in response to an event (Function-as-a-Service). In Appwrite, functions run inside Docker containers, support runtimes like Node.js, Python, and Deno, and can be triggered by events such as user registration or document creation, or executed manually.

**Which SDKs does Appwrite provide?**
Appwrite ships official SDKs for many platforms including JavaScript/TypeScript, Python, [Flutter](/application/flutter/)/Dart, Android, Apple, and more. Each SDK wraps the REST API so you configure a `Client` with an endpoint, project ID, and key, then call typed service methods instead of raw HTTP.

**Is Appwrite self-hosted or cloud?**
Both. Appwrite is open source and can be self-hosted on your own infrastructure with Docker, and there is also Appwrite Cloud, a managed offering. Self-hosting gives you full data control; the cloud removes operational overhead.

**How do I connect the Appwrite Python SDK?**
Install it with `pip install appwrite`, then create a `Client` and chain `set_endpoint`, `set_project`, and `set_key`. From there you instantiate services like `Users` or `Databases` with that client and call their methods.

<Adsense />

---
# ArgoCD

> ArgoCD is a declarative, GitOps continuous delivery tool for Kubernetes that syncs the desired state in Git
with the live cluster. This guide covers the architecture, CLI, sync policies, the KBVE annotation standard,
and troubleshooting.

Source: https://kbve.com/application/argocd/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
  Tabs,
  TabItem,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

ArgoCD is a declarative, GitOps continuous delivery tool for Kubernetes. It automates the deployment of applications by synchronizing the desired state defined in Git repositories with the actual state in Kubernetes clusters.

Jump to the [architecture](#architecture), [CLI commands](#cli-commands), [sync policies](#application-management), or [troubleshooting](#troubleshooting).

<Adsense />

## Architecture

ArgoCD follows the GitOps pattern where Git repositories are the source of truth for defining the desired application state. Key components include:

<CardGrid>
  <Card title="Application Controller" icon="puzzle">
    Continuously monitors running applications and compares the current live state against the desired target state specified in Git.
  </Card>
  <Card title="Repo Server" icon="document">
    Internal service that maintains a local cache of Git repositories holding application manifests.
  </Card>
  <Card title="API Server" icon="setting">
    gRPC/REST server that exposes the API consumed by the Web UI, CLI, and CI/CD systems.
  </Card>
  <Card title="Application Definitions" icon="list-format">
    Kubernetes custom resources (CRDs) that define applications, projects, and repositories.
  </Card>
</CardGrid>

---

## KBVE Cluster Integration

The KBVE production cluster runs ArgoCD to manage 68+ applications across multiple namespaces. All application manifests are stored in the [`apps/kube/`](https://github.com/kbve/kbve/tree/main/apps/kube) directory.

### Dashboard Access

View live deployment status: [ArgoCD Dashboard](/dashboard/argo/)

---

## Application Annotation Standard

### Overview

KBVE uses a standardized annotation schema on ArgoCD Application resources to link them back to their source directories in `apps/kube`. These annotations provide zero-risk metadata that enables traceability, automation, and better observability.

### Schema Version: v1

#### Core Annotations (Required)

These annotations MUST be present on every ArgoCD Application resource:

| Annotation | Description | Example |
|------------|-------------|---------|
| `kbve.com/source-path` | Relative path from repo root to the application directory | `apps/kube/agones/arpg` |
| `kbve.com/manifest-path` | Relative path to the actual Kubernetes manifest directory | `apps/kube/agones/arpg/manifests` |
| `kbve.com/application-file` | Relative path to this ArgoCD Application resource file | `apps/kube/agones/arpg/application.yaml` |
| `kbve.com/managed-by` | Management tool (always `argocd` for these resources) | `argocd` |
| `kbve.com/schema-version` | Version of this annotation schema | `v1` |

#### Classification Annotations (Recommended)

These annotations SHOULD be present to enable categorization and filtering:

| Annotation | Description | Example Values |
|------------|-------------|----------------|
| `kbve.com/category` | Application category | `game-server`, `application`, `infrastructure`, `database`, `observability`, `ci-cd`, `networking` |
| `kbve.com/stack` | Technology stack or framework | `agones`, `rows`, `supabase`, `clickhouse`, `cilium`, `core` |

#### Optional Annotations

Additional context-specific annotations:

| Annotation | Description | When to Use | Example |
|------------|-------------|-------------|---------|
| `kbve.com/tenant` | Tenant identifier | Multi-tenant deployments | `chuckrpg-beta`, `rentearth-release` |
| `kbve.com/deployment-model` | Deployment architecture pattern | Complex deployments | `multi-tenant-overlay`, `singleton`, `replicated` |
| `kbve.com/environment` | Environment stage | When explicit environment tracking needed | `dev`, `staging`, `prod` |
| `kbve.com/owner` | Team or individual responsible | Large teams with ownership boundaries | `platform-team`, `game-dev` |

### Examples

<Tabs>
  <TabItem label="Simple Application">

```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: kbve
  namespace: argocd
  annotations:
    kbve.com/source-path: "apps/kube/kbve"
    kbve.com/manifest-path: "apps/kube/kbve/manifest"
    kbve.com/application-file: "apps/kube/kbve/application.yaml"
    kbve.com/managed-by: "argocd"
    kbve.com/schema-version: "v1"
    kbve.com/category: "application"
    kbve.com/stack: "core"
spec:
  project: default
  source:
    repoURL: https://github.com/KBVE/kbve
    targetRevision: HEAD
    path: apps/kube/kbve/manifest
  destination:
    server: https://kubernetes.default.svc
    namespace: kbve
```

  </TabItem>
  <TabItem label="Game Server">

```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
    name: agones-arpg
    namespace: argocd
    labels:
        app.kubernetes.io/part-of: arpg
    annotations:
        kbve.com/source-path: "apps/kube/agones/arpg"
        kbve.com/manifest-path: "apps/kube/agones/arpg/manifests"
        kbve.com/application-file: "apps/kube/agones/arpg/application.yaml"
        kbve.com/managed-by: "argocd"
        kbve.com/schema-version: "v1"
        kbve.com/category: "game-server"
        kbve.com/stack: "agones"
spec:
  project: default
  source:
    repoURL: https://github.com/kbve/kbve
    targetRevision: main
    path: apps/kube/agones/arpg/manifests
  destination:
    server: https://kubernetes.default.svc
    namespace: arpg
```

  </TabItem>
  <TabItem label="Multi-Tenant">

```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
    name: rows-chuckrpg-beta
    namespace: argocd
    annotations:
        kbve.com/source-path: "apps/kube/rows/tenants/overlays/chuckrpg-beta"
        kbve.com/manifest-path: "apps/kube/rows/tenants/overlays/chuckrpg-beta"
        kbve.com/application-file: "apps/kube/rows/tenants/overlays/chuckrpg-beta/application.yaml"
        kbve.com/managed-by: "argocd"
        kbve.com/schema-version: "v1"
        kbve.com/category: "game-server"
        kbve.com/stack: "rows"
        kbve.com/tenant: "chuckrpg-beta"
        kbve.com/deployment-model: "multi-tenant-overlay"
    finalizers:
        - resources-finalizer.argocd.argoproj.io
spec:
  project: default
  source:
    repoURL: https://github.com/KBVE/kbve
    targetRevision: main
    path: apps/kube/rows/tenants/overlays/chuckrpg-beta
  destination:
    server: https://kubernetes.default.svc
    namespace: rows-chuckrpg-beta
```

  </TabItem>
</Tabs>

### Category Reference

| Category | Description | Example Apps |
|----------|-------------|--------------|
| `game-server` | Game server deployments | arpg, cryptothrone, factorio, mc |
| `application` | Core business applications | kbve, herbmail, n8n, jobboard |
| `infrastructure` | Infrastructure components | argocd, cert-manager, reloader, gateway-api |
| `database` | Database systems | cnpg, clickhouse, valkey, rabbitmq |
| `observability` | Monitoring and logging | monitoring, metrics, vector, analytics |
| `ci-cd` | CI/CD tools and runners | github/runners, github/controller, forgejo |
| `networking` | Network infrastructure | cilium, kong, multus |
| `virtualization` | Virtualization platforms | kubevirt, kasm, firecracker |
| `operator` | Kubernetes operators | agones, clickhouse-operator, kyverno, keda |
| `security` | Security tooling | sealed-secrets, external-secrets, security-profiles-operator |

### Querying Applications

These annotations enable powerful kubectl queries:

```bash
# List all game servers
kubectl get applications -n argocd -o json | \
  jq '.items[] | select(.metadata.annotations."kbve.com/category" == "game-server") | .metadata.name'

# Find all ROWS tenants
kubectl get applications -n argocd -o json | \
  jq '.items[] | select(.metadata.annotations."kbve.com/stack" == "rows") |
  {name: .metadata.name, tenant: .metadata.annotations."kbve.com/tenant"}'

# Get source paths for all applications
kubectl get applications -n argocd -o json | \
  jq '.items[] | {name: .metadata.name, path: .metadata.annotations."kbve.com/source-path"}'
```

---

## Talos Integration

### Pause ArgoCD During Upgrades

When performing Talos node upgrades, pause ArgoCD reconciliation to prevent it from fighting manual scale-down operations:

```shell
# Pause ArgoCD application controller
kubectl -n argocd scale sts argocd-application-controller --replicas=0

# After upgrade completes, restore
kubectl -n argocd scale sts argocd-application-controller --replicas=1
```

This prevents the application-controller from interfering with:
- Pre-upgrade workload scale-down
- Longhorn maintenance mode preparation
- Manual pod eviction for graceful drain

See the full Talos upgrade procedure in [Kubernetes - Talos](/application/kubernetes/#talos).

---

## CLI Commands

### Installation

<Tabs>
  <TabItem label="macOS">

```shell
brew install argocd
```

  </TabItem>
  <TabItem label="Linux">

```shell
curl -sSL -o argocd-linux-amd64 https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64
sudo install -m 555 argocd-linux-amd64 /usr/local/bin/argocd
rm argocd-linux-amd64
```

  </TabItem>
</Tabs>

### Login

```shell
# Port-forward ArgoCD server
kubectl port-forward svc/argocd-server -n argocd 8080:443

# Login via CLI
argocd login localhost:8080
```

### Common Commands

```shell
# List all applications
argocd app list

# Get application details
argocd app get <app-name>

# Sync an application
argocd app sync <app-name>

# Get sync status
argocd app sync-status <app-name>

# View application logs
argocd app logs <app-name>

# Delete an application
argocd app delete <app-name>

# Create an application from YAML
argocd app create -f application.yaml
```

---

## Application Management

### Sync Policies

KBVE applications use automated sync with self-healing:

```yaml
syncPolicy:
  automated:
    prune: true        # Delete resources removed from Git
    selfHeal: true     # Revert manual kubectl changes
  syncOptions:
    - CreateNamespace=true
    - PrunePropagationPolicy=foreground
    - RespectIgnoreDifferences=true
```

### Ignore Differences

Some resources have fields that ArgoCD should not sync (e.g., Agones Fleet replicas managed by autoscalers):

```yaml
ignoreDifferences:
  - group: agones.dev
    kind: Fleet
    jsonPointers:
      - /spec/replicas
```

### Finalizers

Multi-tenant applications use finalizers to ensure cascading deletion:

```yaml
metadata:
  finalizers:
    - resources-finalizer.argocd.argoproj.io
```

This ensures when an ArgoCD Application is deleted, all deployed resources are cleaned up.

---

## Troubleshooting

### Application Stuck in Progressing

```shell
# Check sync operation status
argocd app get <app-name>

# Terminate stuck operation
argocd app terminate-op <app-name>

# Force sync
argocd app sync <app-name> --force
```

### Out of Sync Despite Matching Git

```shell
# Hard refresh (bypass cache)
argocd app get <app-name> --hard-refresh

# Check diff
argocd app diff <app-name>
```

### Health Check Failing

Some resources need custom health checks. ArgoCD has built-in checks for common resources, but custom CRDs may require configuration:

```yaml
# ConfigMap in argocd namespace
apiVersion: v1
kind: ConfigMap
metadata:
  name: argocd-cm
  namespace: argocd
data:
  resource.customizations: |
    agones.dev/Fleet:
      health.lua: |
        hs = {}
        if obj.status ~= nil then
          if obj.status.readyReplicas ~= nil and obj.status.readyReplicas > 0 then
            hs.status = "Healthy"
            return hs
          end
        end
        hs.status = "Progressing"
        return hs
```

### Controller Logs

```shell
# View application controller logs
kubectl logs -n argocd -l app.kubernetes.io/name=argocd-application-controller -f

# View repo server logs
kubectl logs -n argocd -l app.kubernetes.io/name=argocd-repo-server -f
```

---

## Best Practices

<Steps>

1. **Use Git as Source of Truth**
   - Never manually apply manifests that are managed by ArgoCD
   - All changes should go through Git commits

2. **Enable Auto-Sync with Self-Heal**
   - Automatically corrects drift from manual changes
   - Ensures cluster state matches Git

3. **Use Annotations for Metadata**
   - Link applications back to source code
   - Enable programmatic discovery and automation

4. **Implement Proper RBAC**
   - Limit who can sync/delete applications in production
   - Use ArgoCD Projects for multi-tenant isolation

5. **Monitor Sync Status**
   - Set up alerts for applications stuck in Progressing
   - Track sync failures in observability stack

6. **Use Resource Hooks**
   - `PreSync`, `Sync`, `PostSync` hooks for migrations
   - `SyncFail` hooks for rollback logic

</Steps>

---

## Related Documentation

- [Kubernetes](/application/kubernetes/) - General Kubernetes operations
- [ArgoCD Dashboard](/dashboard/argo/) - Live cluster deployment status
- [GitHub Actions](/application/git/) - CI/CD integration with ArgoCD

---

## FAQ

**What is ArgoCD?**
ArgoCD is a declarative, GitOps continuous delivery tool for Kubernetes. It treats a Git repository as the source of truth for the desired application state and continuously syncs the live cluster to match, automating deployments and detecting drift.

**What is GitOps?**
GitOps is an operational model where the desired state of infrastructure and applications is declared in Git, and an automated agent reconciles the running system to match. Git becomes the single source of truth, so every change is version-controlled, reviewable, and auditable.

**What is the difference between prune and self-heal in ArgoCD?**
`prune` deletes cluster resources that were removed from Git, keeping the cluster from accumulating orphans. `selfHeal` reverts manual `kubectl` changes back to the Git-defined state. Together they enforce that the live cluster always matches the repository.

**How do I fix an ArgoCD application stuck in Progressing?**
Check the operation with `argocd app get`, terminate a stuck sync using `argocd app terminate-op`, then force a fresh sync with `argocd app sync --force`. A hard refresh (`--hard-refresh`) bypasses the cache when an app shows out of sync despite matching Git.

**What are `ignoreDifferences` used for in ArgoCD?**
`ignoreDifferences` tells ArgoCD to skip specific resource fields when comparing live and desired state, so it does not fight controllers that own those fields — for example an autoscaler managing an Agones Fleet's `spec.replicas` would otherwise be reverted on every sync.

<Giscus />

---
# Authelia

> Authelia is an open-source authentication and authorization server that adds two-factor authentication (2FA) and single sign-on (SSO) to your applications through a reverse proxy. It acts as a firewall-like access portal, securing services outside the scope of the application itself.

Source: https://kbve.com/application/authelia/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';


<Aside title="TLDR">

Tldr; Authelia is an authentication and authorization application that provides a backend server and frontend portal, adding 2FA and SSO to any app through your reverse proxy.

</Aside>


## Information

Have you ever wondered how to secure your web applications with a simple, secure, and elegant solution?
Do you want to offer your users a seamless login experience across multiple domains and services?
If so, you might be interested in **Authelia**, an open-source authentication and authorization server that provides two-factor authentication (2FA) and single sign-on (SSO) for your applications via a web portal.
In this document, KBVE introduces you and your dev team to the features and benefits of Authelia, and shows you how to set it up with common reverse proxies like [Nginx](/application/nginx/), [Traefik](/application/traefik/), or HAProxy.
By the end of this reference, you will be able to protect your web applications with Authelia and enjoy a secure, hassle-free authentication process.

---

<Adsense />

## How It Works

Authelia does not modify your applications. Instead, it plugs into your **reverse proxy** using a pattern called **forward auth** (also called external auth or `auth_request`):

<Steps>

1. A user requests a protected service, e.g. `https://app.kbve.com`.
2. The reverse proxy pauses and asks Authelia: *is this session authenticated and authorized?*
3. If **yes**, the proxy forwards the request to the backend as normal.
4. If **no**, the user is redirected to Authelia's login portal, completes 2FA, and is sent back — now with a valid session cookie.

</Steps>

Because the session cookie is scoped to your **root domain**, one login unlocks every protected subdomain — that is the single sign-on (SSO) experience.

| Concept | Meaning |
| ------- | ------- |
| **Authentication** | Proving *who* the user is (password + 2FA) |
| **Authorization** | Deciding *what* the user may access (access control rules) |
| **Forward auth** | Reverse proxy delegates the auth decision to Authelia |
| **SSO** | One authenticated session grants access across services |

## Install

There are a couple of ways to install Authelia. Here are the official deployment notes for each:

- [Docker](https://www.authelia.com/integration/deployment/docker/)
- [Kubernetes](https://www.authelia.com/integration/kubernetes/introduction/)
- [Bare Metal](https://www.authelia.com/integration/deployment/bare-metal/)

---

### Prerequisites

A decent understanding of your operating system, networking, and containerization will be extremely helpful.

One fundamental requirement: **Authelia has to operate under SSL/TLS**.
The default port that Authelia runs on is `9091`, but this can be changed.

Finally, if you have Cloudflare sitting in front of your domain, double-check your forwarded headers — Authelia provides a guide on that [here](https://www.authelia.com/integration/proxies/fowarded-headers/).

---

### Docker

This section covers deploying Authelia via Docker.

We use the DockerHub image `authelia/authelia`, but you can opt for their GitHub image as well.

Since our ecosystem uses **Traefik**, we recommend following the documentation for its [integration](https://www.authelia.com/integration/proxies/traefik/).

A minimal `docker-compose.yml` service:

```yaml
services:
  authelia:
    image: authelia/authelia
    container_name: authelia
    volumes:
      - ./authelia:/config
    ports:
      - "9091:9091"
    environment:
      - TZ=America/New_York
    restart: unless-stopped
```

<Aside type="caution">
Authelia must sit behind HTTPS. Terminate TLS at your reverse proxy and never expose port `9091` directly to the internet — it is meant to be reached only by the proxy's forward-auth request.
</Aside>

### Traefik forwardAuth

Wire Authelia into Traefik with a `forwardAuth` middleware, then attach it to any protected router:

```yaml
labels:
  - "traefik.http.middlewares.authelia.forwardauth.address=http://authelia:9091/api/verify?rd=https://auth.kbve.com"
  - "traefik.http.middlewares.authelia.forwardauth.trustForwardHeader=true"
  - "traefik.http.middlewares.authelia.forwardauth.authResponseHeaders=Remote-User,Remote-Groups,Remote-Name,Remote-Email"
```

## FAQ

**What is Authelia?**
Authelia is an open-source authentication and authorization server that provides 2FA and SSO for your web applications. It sits behind a reverse proxy like Nginx or Traefik and validates every request before it reaches the protected service — like an application-layer firewall.

**How does Authelia integrate with a reverse proxy?**
It uses forward auth. The reverse proxy intercepts each request and asks Authelia whether the user is authenticated and authorized. If yes, the request passes through; if not, the user is redirected to the login portal. Nginx uses `auth_request`; Traefik uses a `forwardAuth` middleware.

**What port does Authelia run on?**
Authelia listens on port `9091` by default, but it is configurable. It must operate under SSL/TLS, so you terminate HTTPS at your reverse proxy and forward authenticated traffic to Authelia and your backend services.

**Does Authelia support single sign-on across multiple domains?**
Yes. Once a user authenticates, a session cookie scoped to your root domain grants access to every protected subdomain and service without logging in again.

**What do I need before deploying Authelia?**
A working reverse proxy (Nginx, Traefik, or HAProxy), a domain with valid SSL certificates, and a session/storage backend. If Cloudflare sits in front of your domain, verify your forwarded headers configuration.

## Videos

<Adsense />

---
# Blender

> Blender is a powerful open-source 3D creation suite supporting the entire 3D pipeline—modeling, rigging, animation, simulation, rendering, compositing, motion tracking, and video editing.
The software provides professional-grade tools for artists, studios, and hobbyists across industries including game development, film production, architecture, and product visualization.
With Python scripting, extensive addon support, and active community development, Blender has become an industry-standard tool for 3D content creation.

Source: https://kbve.com/application/blender/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';
import SpriteSheetBaker from '@/components/blender/SpriteSheetBaker.tsx';

## Information

Blender is a free and open-source 3D creation suite developed by the Blender Foundation and maintained by a global community of contributors.
First released in 1995 and open-sourced in 2002, Blender has evolved into a comprehensive platform capable of handling every stage of the 3D production pipeline.
The software runs on Windows, macOS, and Linux, supporting GPU rendering via CUDA, OptiX, HIP, Metal, and oneAPI.

Blender's architecture is built around a unified interface with multiple workspaces optimized for different tasks: modeling, sculpting, shading, animation, rendering, compositing, and video editing.
The Python API provides deep access to Blender's internals, enabling automation, custom tools, and pipeline integration.
The addon ecosystem extends Blender's capabilities with community and commercial tools for specialized workflows.

<Adsense />

---

## Getting Started

Download Blender from [blender.org](https://www.blender.org/download/) or install via package managers:

```bash
# macOS (Homebrew)
brew install --cask blender

# Linux (Snap)
snap install blender --classic

# Linux (Flatpak)
flatpak install flathub org.blender.Blender

# Windows (winget)
winget install -e --id BlenderFoundation.Blender
```

On first launch, Blender presents the Quick Setup dialog for configuring keyboard shortcuts (Blender or Industry Compatible), theme, and interface language.
The default startup file opens with a cube, camera, and light in the 3D viewport.

<Aside>
Blender is 100% free with no license fees, subscriptions, or royalties. It's licensed under GPL-3.0, allowing commercial use and redistribution.
</Aside>

---

## Isometric Sprite Sheet Baker (ARPG)

The ARPG iso renderer draws environment props and vehicles as upright screen
billboards. To turn a 3D model into a prop, we bake a 360° spin into a sprite
sheet whose frame index maps directly to a facing. The toolchain lives in the
**kbve python package** (`kbve.sprite`) and runs via `uv` console entrypoints, so it
can be invoked from anywhere in the repo; the interactive angle finder stays beside
the arpg assets.

<FileTree>
- packages/python/kbve/kbve/sprite/
  - model_sprites.py       `uv run kbve-model-sprites` — Blender baker (OBJ/FBX → sheet)
  - sprite_postprocess.py  `uv run kbve-sprite-postprocess` — ground shadow + stitch
  - skin_variant.py        `uv run kbve-skin-variant` — kill a glow color → "off" skin
  - ship_footprint.py      `uv run kbve-ship-footprint` — bake ship collision (.ts + .rs)
- apps/agones/arpg/web/scripts/
  - preview-model-sprites.html  Three.js angle finder (mirrors the baker's math)
  - gen-bush-sheet.py           Proc bush baker (shelved — bush env parked)
</FileTree>

Enable the toolchain (pulls Pillow + numpy, kept off the core install):

```bash
uv sync --project packages/python/kbve --extra sprite
```

**What it does** — loads a model + skin texture, lays the hull flat on the ground
plane (`--pitch`, baked into the mesh), spins it through N yaw facings under an
orthographic isometric camera, and writes one transparent PNG per facing plus a
square row-major `sheet.png` and a `strip.png`.

### Try it in the browser

The island below is the baker's zero-install twin — same yaw / elevation / lay-flat
math, rasterized straight from WebGL. Pick a model (`.obj`, `.glb`, or `.fbx`) and a
skin, dial the angle, then **Bake** to download the sheet. It also prints the matching
Blender command (for a higher-fidelity offline bake) and a ready `EnvDef` snippet.

<SpriteSheetBaker client:only="react" />

<Aside type="tip">
**Cost:** Each sprite sheet generation costs **10 credits** per render (browser or CLI).
</Aside>

<Aside>
The browser baker is for fast iteration and previewing. For final assets prefer the
Blender command it generates — EEVEE shading and antialiasing are crisper than the
live WebGL capture.
</Aside>

<Aside type="caution">
Many ship/vehicle models import **standing upright** (nose along the model's up
axis). Because an env sprite is a flat upright billboard, an upright render reads
as a ship standing on its tail. `--pitch 90` rotates the hull onto the ground
(deck toward the camera-up) and bakes it before the spin, so every frame reads as
a vehicle resting on the iso floor.
</Aside>

<Steps>

1. **Find the angle** — serve the previewer (file URLs block local model/texture
   loads) and dial yaw / camera elevation / lay-flat pitch. It prints the exact
   baker command for the heading you pick.

   ```bash
   cd apps/agones/arpg/web/scripts
   python3 -m http.server 8765
   # open: http://localhost:8765/preview-model-sprites.html?model=PATH.obj&skin=PATH.jpg
   ```

2. **Bake the sheet** — paste the copied flags. The entrypoint finds Blender and
   runs it headless (set `BLENDER_BIN` to override discovery):

   ```bash
   uv run --project packages/python/kbve kbve-model-sprites -- \
     --model fighter1.obj --skin idolknight.jpg --out render_flat \
     --frames 16 --res 256 --elev 35 --pitch 90 --yaw-offset 0
   ```

   Equivalent direct form: `blender -b -P packages/python/kbve/kbve/sprite/model_sprites.py -- <flags>`.

   For a single static "parked" frame: `--frames 1 --yaw-offset <heading>`.

   For a **lift / spool-up animation** (engines rising off the ground), add
   `--anim-frames 8 --lift 0.6`. The hull rises over the frames while a Cycles
   shadow-catcher keeps the shadow on the floor, so the gap grows = a real hover.
   The sheet lays out one row per facing × one column per anim frame (row-major
   `dir * frames + f`), so the `EnvDef` reads it as `frames: 8, directions: 16`:

   ```bash
   uv run --project packages/python/kbve kbve-model-sprites -- \
     --model fighter1.obj --skin idolknight.jpg \
     --out ship_lift --frames 16 --anim-frames 8 --lift 0.6 --res 256 \
     --elev 30 --pitch 90 --yaw-offset 45 --real-shadow
   ```

3. **Wire the prop** — drop `sheet.png` (or a chosen `frame_NN.png`) under
   `web/public/assets/...` and register an `EnvDef` in
   `web/src/game/entities/env.ts`. A static prop uses `frames: 1`; a rotatable
   one uses `directions: 16` and the full sheet (row-major: row = facing).

</Steps>

| Flag | Meaning | Default |
| --- | --- | --- |
| `--model` | source `.obj` / `.fbx` | required |
| `--skin` | texture applied to all meshes | required |
| `--out` | output dir (frames + `sheet.png` + `strip.png`) | required |
| `--frames` | yaw facings (`1` = static) | `16` |
| `--anim-frames` | animation frames PER facing (`>1` bakes an animation) | `1` |
| `--anim-mode` | `lift` (rise, once), `idle` (bob loop), `move` (fly bob+sway loop), `bank` (monotonic roll L→R for turn lean), `launch` (ascent to space, once) | `lift` |
| `--lift` | hover height as a fraction of model size (lift / idle / move / bank base) | `0.6` |
| `--bob` | vertical bob amplitude as a fraction of model size (idle/move) | `0.06` |
| `--sway` | roll amplitude in degrees (move sway / bank extent) | `8` |
| `--launch-height` | launch ascent height × model size | `5` |
| `--launch-pitch` | launch nose-up pitch deg at apex | `70` |
| `--launch-shrink` | launch final scale (fakes distance) | `0.12` |
| `--res` | px per frame (square) | `256` |
| `--elev` | camera elevation deg (`35` = 2:1 iso) | `35` |
| `--pitch` | lay-flat hull pitch, baked before spin | `90` |
| `--yaw-offset` | heading added to every frame; sets `frame_00` | `0` |
| `--real-shadow` | render a TRUE cast shadow (Cycles + ground catcher) instead of the fake 2D one | off |
| `--sun-elev` / `--sun-az` | sun elevation / azimuth deg (real-shadow; shadow falls opposite) | `55` / `135` |
| `--sun-soft` | sun angular size deg = penumbra softness | `4` |
| `--samples` | Cycles samples (real-shadow) | `64` |
| `--no-shadow` | skip the baked ground shadow | off |
| `--shadow-alpha` | shadow darkness `0..1` | `0.45` |
| `--shadow-squash` | vertical flatten of the silhouette `0..1` | `0.7` |
| `--shadow-shear` | iso ground skew (x per y about the contact line) | `0.15` |
| `--shadow-grow` | dilate the pool past the hull (rim halo, fraction of frame) | `0.05` |
| `--shadow-dx` / `--shadow-dy` | shadow offset along the light (fraction of frame) | `0.0` / `0.045` |

Two shadow modes:

- **Real (`--real-shadow`)** — the proper one. A ground plane under the hull is flagged
  as a Cycles shadow catcher; with the transparent film it contributes only the cast
  shadow's alpha, so each frame carries the **true** shadow for that facing under the
  sun (`--sun-elev`/`--sun-az`/`--sun-soft`). Shape follows the real 3D form and the
  light, per facing — no guessing. Costs a Cycles pass (slower than EEVEE, but 16
  frames is seconds).
- **Fake (default)** — `kbve-sprite-postprocess` derives a shadow from each frame's own
  alpha silhouette and projects it onto the iso floor: squashed toward the contact
  line, **sheared** along the iso axis, **dilated** so a soft rim haloes past the hull,
  then offset/blurred/darkened. The grow + near-zero offset read as a grounded *contact
  pool* (parked); raise `--shadow-dx/dy` for a hovering cast look. No 3D pass, engine-
  agnostic, fully tunable. Drop either with `--no-shadow`.

### State variants (engines off / on)

A prop can ship multiple skins for different states. `kbve-skin-variant` masks a
glow color in the skin and desaturates + darkens it, so e.g. the parked ship's green
engines read as **off**:

```bash
uv run --project packages/python/kbve kbve-skin-variant \
  --in idolknight.jpg --out idolknight_off.jpg --hue green
```

Bake one sheet per skin (`ship.png` from the off skin, `ship_on.png` from the
original glowing one). They share frame layout, so the game swaps the `EnvDef.sheet`
to switch state — powered-down while parked, glowing when engines are on.

<Aside>
Blender's bundled Python has no Pillow, so the stitch step shells out to the
system `python3` (which carries it) to assemble the sheet — frames are written
regardless. EEVEE is used for fast, flat, sprite-friendly renders.
</Aside>

---

## Interface

Blender's interface consists of workspaces, each containing a custom arrangement of editors (viewports, timelines, node editors, etc.).
The top header provides workspace tabs, while each editor has its own header with type selector and context-specific menus.

### Core Editors

- **3D Viewport** - Main scene editor for viewing and manipulating objects in 3D space. Supports multiple shading modes (solid, material preview, rendered).
- **Shader Editor** - Node-based material and shader creation using Cycles and Eevee material systems.
- **UV Editor** - Unwrap and edit UV texture coordinates for meshes.
- **Compositor** - Node-based post-processing and compositing for renders.
- **Geometry Nodes** - Procedural modeling and effects using node graphs.
- **Video Sequencer** - Timeline-based video editing with strips, effects, and audio.
- **Dope Sheet** - Keyframe animation management across multiple objects and properties.
- **Graph Editor** - Bezier curve editing for animation F-curves and driver functions.
- **NLA Editor** - Non-linear animation mixing and blending with action strips.
- **Text Editor** - Built-in Python script editor with syntax highlighting and execution.
- **Outliner** - Hierarchical tree view of scene collections, objects, and data blocks.
- **Properties Panel** - Context-sensitive properties for active object, material, modifier, etc.

### Workspaces

Default workspaces provide task-specific layouts:

- **Layout** - General-purpose workspace with viewport, outliner, and properties.
- **Modeling** - Optimized for polygon modeling with edit mode tools and modifier panel.
- **Sculpting** - High-resolution organic modeling with sculpt mode brushes and dyntopo.
- **UV Editing** - Simultaneous UV and 3D view for texture coordinate unwrapping.
- **Shading** - Shader Editor and viewport in material preview mode for material creation.
- **Animation** - Timeline, dope sheet, and graph editor for keyframe animation.
- **Rendering** - Viewport and render settings for final image production.
- **Compositing** - Compositor and viewer for post-processing render passes.
- **Geometry Nodes** - Geometry Nodes editor with spreadsheet for procedural workflows.
- **Scripting** - Python console, text editor, and info log for development.

---

## Modeling

Blender supports multiple modeling paradigms: polygon modeling, sculpting, procedural modeling, and curve-based modeling.

### Polygon Modeling

Traditional box-modeling workflow using vertices, edges, and faces.
Edit mode provides selection tools, extrude, loop cuts, bevel, inset, and subdivision operations.
Proportional editing allows smooth falloff transformations for organic shapes.

<Steps>

1. **Enter Edit Mode** - Tab key toggles between Object and Edit mode
2. **Select components** - Vertex (1), Edge (2), Face (3) selection modes
3. **Transform** - Move (G), Rotate (R), Scale (S) with axis constraints (X/Y/Z)
4. **Add geometry** - Extrude (E), Inset (I), Loop Cut (Ctrl+R)
5. **Refine** - Bevel (Ctrl+B), Subdivide, Merge, Knife tool (K)

</Steps>

### Modifiers

Non-destructive modifier stack for procedural operations:

- **Generate** - Array, Bevel, Boolean, Build, Decimate, Geometry Nodes, Mirror, Multiresolution, Remesh, Screw, Skin, Solidify, Subdivision Surface, Triangulate, Volume to Mesh, Weld, Wireframe
- **Deform** - Armature, Cast, Curve, Displace, Hook, Laplacian Deform, Lattice, Mesh Deform, Shrinkwrap, Simple Deform, Smooth, Smooth Corrective, Smooth Laplacian, Surface Deform, Warp, Wave
- **Physics** - Cloth, Collision, Dynamic Paint, Explode, Fluid, Ocean, Particle Instance, Particle System, Soft Body
- **Color** - UV Project, Vertex Weight Edit, Vertex Weight Mix, Vertex Weight Proximity

Modifiers are applied in stack order. The Subdivision Surface modifier is commonly used for smooth subdivision modeling.

### Sculpting

High-resolution organic modeling using dynamic topology or multiresolution modifiers.
Sculpt mode provides brushes for draw, grab, pinch, smooth, inflate, and crease operations.

**Dyntopo** (Dynamic Topology) - Automatically subdivides geometry under the brush stroke, enabling infinite detail without pre-subdivision.

**Multiresolution** - Non-destructive subdivision modifier preserving base mesh topology, allowing detail sculpting at higher levels while maintaining the ability to edit the base form.

### Geometry Nodes

Procedural modeling system using node graphs to generate or modify geometry.
Geometry Nodes can create instances, scatter points, generate meshes from curves, apply fields, and build complex procedural systems.

Common nodes:
- **Mesh Primitives** - Cube, UV Sphere, Ico Sphere, Cylinder, Cone, Grid
- **Curve Primitives** - Bezier Segment, Curve Circle, Curve Line, Curve Spiral
- **Instances** - Instance on Points, Realize Instances, Instances to Points
- **Geometry** - Join Geometry, Merge by Distance, Transform, Set Position
- **Mesh Operations** - Subdivide Mesh, Extrude Mesh, Dual Mesh, Triangulate
- **Utilities** - Math, Vector Math, Random Value, Map Range, Switch

---

## Materials and Shading

Blender uses node-based materials compatible with both rendering engines.

### Shader Nodes

The Shader Editor constructs materials using nodes connected by sockets:

- **Shader** - Principled BSDF (physically-based), Diffuse, Glossy, Glass, Emission, Mix Shader, Add Shader
- **Texture** - Image Texture, Procedural (Noise, Voronoi, Wave, Magic, Gradient, Musgrave), Brick, Checker, Environment
- **Color** - Mix, RGB Curves, Hue/Saturation, Bright/Contrast, Invert, Gamma
- **Vector** - Mapping, Normal Map, Bump, Vector Transform, Displacement
- **Input** - UV Map, Texture Coordinate, Geometry, Object Info, Vertex Color, Fresnel
- **Converter** - Math, Vector Math, Color Ramp, Separate/Combine RGB/XYZ, Map Range

### Principled BSDF

The Principled BSDF is a physically-based shader combining multiple layers into a single node.
It uses Disney's principled shading model with inputs for base color, metallic, roughness, IOR, transmission, emission, and normal maps.

Common PBR workflow:
1. **Base Color** - Albedo/diffuse texture (sRGB color space)
2. **Metallic** - Black for dielectric, white for metal (linear/non-color)
3. **Roughness** - Surface microsurface detail (linear/non-color)
4. **Normal** - Normal map connected via Normal Map node
5. **Emission** - Self-illumination (color + strength)

### UV Unwrapping

UV unwrapping projects 3D mesh surfaces onto 2D texture space.

<Steps>

1. **Mark Seams** - In Edit Mode, select edges and Mark Seam (Ctrl+E)
2. **Unwrap** - UV > Unwrap (U) - projects faces based on seams
3. **Layout UVs** - Scale, rotate, and pack islands in UV Editor
4. **Test with Texture** - Apply checker texture to verify distortion

</Steps>

Common unwrap methods:
- **Unwrap** - Angle-based unwrapping using marked seams
- **Smart UV Project** - Automatic island creation by angle threshold
- **Cube Projection** - Projects from six orthogonal directions
- **Sphere/Cylinder Projection** - Wraps around primitive shapes
- **Lightmap Pack** - Optimizes UVs for baked lighting with minimal overlap

---

## Animation

Blender provides keyframe animation, rigging, constraints, and non-linear animation systems.

### Keyframes

Keyframes define property values at specific frames. Blender interpolates between keyframes to create motion.

<Steps>

1. **Set initial pose** - Move object to starting position/rotation
2. **Insert keyframe** - Press I (or right-click property > Insert Keyframe)
3. **Advance timeline** - Scrub to new frame
4. **Change property** - Transform, rotate, or modify value
5. **Insert second keyframe** - Press I again
6. **Play animation** - Spacebar to preview

</Steps>

The Graph Editor displays F-curves (animation curves) as Bezier splines, allowing precise timing control through handle manipulation.

### Rigging

Rigging creates a skeleton (armature) of bones that deform a mesh via weight painting.

**Armature** - A collection of bones, each with head, tail, and roll defining local space.

**Bone Constraints** - Limit rotation, track targets, inverse kinematics (IK), copy transforms, damped track, stretch to.

**Weight Painting** - Defines bone influence per vertex. Accessed via Weight Paint mode with brush tools for painting influence values (0.0 to 1.0).

**Inverse Kinematics (IK)** - Automatically calculates joint rotations to reach a target position, useful for limbs and procedural animation.

### Actions and NLA

**Action** - A reusable animation clip containing F-curves for keyframed properties.

**NLA (Non-Linear Animation)** - Layers and blends actions on a track-based timeline, enabling animation mixing, looping, and transitions without destroying original keyframes.

### Drivers

Drivers create property relationships using expressions or variables.
Example: Drive a wheel's rotation based on a vehicle's forward movement, or link facial expression sliders to bone rotations.

---

## Rendering

Blender includes three render engines with different performance and quality tradeoffs.

### Eevee

Real-time physically-based renderer using rasterization.
Provides fast interactive feedback with screen-space reflections, volumetrics, subsurface scattering, and bloom.
Ideal for real-time previews, stylized rendering, and game engine-compatible material authoring.

**Key features:**
- Screen-space reflections and refractions
- Irradiance volumes and reflection probes for baked indirect lighting
- Volumetric lighting and fog with light scattering
- Subsurface scattering with screen-space approximation
- Shadows: VSM (Variance Shadow Maps) or ESM (Exponential Shadow Maps)
- Bloom, motion blur, depth of field, ambient occlusion

**Limitations:**
- No true path-traced global illumination (relies on probes)
- Screen-space effects limited to visible screen pixels
- Transparency rendering order dependent

### Cycles

Physically-based path tracer for photorealistic rendering.
Supports CPU and GPU rendering (CUDA, OptiX, HIP, Metal, oneAPI) with unbiased light transport.

**Render modes:**
- **Path Tracing** - Unbiased physically accurate light simulation
- **Branched Path Tracing** (deprecated) - Legacy mode with controllable sample distribution
- **Adaptive Sampling** - Stops sampling pixels when noise threshold reached, reducing render time

**Denoising:**
- **OptiX Denoiser** - NVIDIA GPU accelerated, highest quality
- **OpenImageDenoise** - Intel CPU/GPU denoiser, cross-platform
- **NLM (Non-Local Means)** - Legacy CPU denoiser

**Performance optimizations:**
- Tile rendering with configurable tile size
- BVH acceleration structure (static/dynamic)
- Light tree sampling for many-light scenes
- Caustics and motion blur control

### Workbench

Fast preview renderer for viewport shading during modeling and animation.
Not intended for final output, but useful for quick material and lighting previews.

### Render Settings

Common render settings (Cycles):

- **Sampling** - Max Samples (higher = less noise), Time Limit, Adaptive Threshold
- **Light Paths** - Max Bounces (Total, Diffuse, Glossy, Transmission, Volume, Transparency)
- **Film** - Transparent Background, Exposure, Pixel Filter
- **Performance** - Tile Size, Acceleration Structure, Use GPU

### Render Passes

Render passes output individual components (diffuse, specular, normal, AO, etc.) for compositing.
Configure in View Layer properties under Passes.

Common passes:
- **Combined** - Final composited image
- **Diffuse** - Direct and indirect diffuse lighting
- **Glossy** - Specular reflections
- **Transmission** - Refraction through transparent surfaces
- **Emission** - Self-illuminating materials
- **Environment** - Background/sky contribution
- **AO (Ambient Occlusion)** - Cavity shading
- **Shadow** - Shadow mask
- **Normal** - Surface normal vectors
- **UV** - UV coordinate map
- **Object/Material Index** - Masking IDs for compositing
- **Mist** - Depth-based fog pass
- **Cryptomatte** - Automatic per-object/material masks

---

## Compositing

The Compositor combines render passes, applies effects, and performs color grading using a node-based workflow.

### Compositor Nodes

- **Input** - Render Layers, Image, Movie Clip, Mask, RGB, Value
- **Output** - Composite, Viewer, File Output, Split Viewer
- **Color** - Mix, Color Balance, Hue/Saturation, Bright/Contrast, Gamma, Curves, Alpha Over
- **Filter** - Blur, Bilateral Blur, Bokeh Blur, Vector Blur, Dilate/Erode, Denoise, Despeckle, Filter, Glare, Inpaint, Pixelate, Sun Beams
- **Converter** - ID Mask, Math, Separate/Combine (RGBA, HSVA, YCbCrA), Set Alpha, RGB to BW
- **Matte** - Keying, Channel Key, Chroma Key, Color Key, Difference Key, Distance Key, Luminance Key, Double Edge Mask, Cryptomatte
- **Distort** - Transform, Scale, Rotate, Translate, Flip, Crop, Displace, Map UV, Lens Distortion, Movie Distortion, Corner Pin, Plane Track Deform
- **Vector** - Normal, Map Value, Map Range, Normalize
- **Layout** - Frame, Reroute, Switch

### Common Compositing Workflows

**Color Grading:**
1. Render Layers input → RGB Curves → Hue/Saturation → Composite

**Depth of Field:**
1. Render Layers (Image + Depth) → Defocus/Bokeh Blur (using depth as factor) → Composite

**Glow/Bloom:**
1. Render Layers → Glare (Fog Glow or Ghosts) → Mix with original → Composite

**Sky Replacement:**
1. Render Layers → ID Mask (Background) → Mix (Image + New Sky) → Composite

---

## Simulation

Blender includes physics simulation systems for cloth, fluid, soft body, rigid body, and particle dynamics.

### Rigid Body

Simulates solid objects with collision and stacking.
Objects are either Active (dynamic) or Passive (static collision).
Managed via Rigid Body World settings with gravity, solver iterations, and substeps.

**Collision Shapes:** Box, Sphere, Capsule, Cylinder, Cone, Convex Hull, Mesh (slowest, most accurate)

### Cloth

Simulates fabric using spring-based physics.
Requires vertex groups for pinning static areas and controlling stiffness.

**Settings:**
- **Quality Steps** - Simulation accuracy (higher = slower but more stable)
- **Stiffness** - Tension, Compression, Shear, Bending
- **Damping** - Energy loss per frame
- **Collisions** - Distance, Self-collisions, friction

### Fluid

Mantaflow-based fluid solver supporting liquid and gas (smoke) simulations.

**Liquid:**
- Domain defines simulation bounds and resolution
- Flow objects emit or absorb liquid
- Effector objects deflect or control flow
- Mesh generated from particle system

**Smoke/Fire:**
- Domain contains smoke with voxel resolution
- Flow emits smoke or fire with velocity, density, heat
- Volumetric shader renders density field

### Soft Body

Deformable mesh simulation with springs, goal weights, and collision.
Useful for jiggling objects, cushions, or soft organic motion.

### Particle Systems

Point-based particles for hair, fur, grass, crowds, and effects.

**Emitter:**
- Emits particles from mesh faces or vertices
- Controls lifetime, velocity, rotation, size
- Supports force fields (wind, turbulence, gravity)

**Hair:**
- Generates strand-based hair from surface
- Combing, cutting, growing in particle edit mode
- Strand rendering or child particle interpolation

**Keyed:**
- Particles follow target positions for controlled motion

**Boids:**
- Flocking simulation with rules for separation, alignment, cohesion, goal seeking

---

## Scripting and Automation

Blender's Python API (`bpy`) provides programmatic access to all editor functions, data structures, and operators.

### Python Console

The Scripting workspace includes a Python console with autocomplete for quick API testing:

```python
import bpy

# Create a UV sphere
bpy.ops.mesh.primitive_uv_sphere_add(location=(0, 0, 0), radius=2)

# Access active object
obj = bpy.context.active_object

# Rename object
obj.name = "MySphere"

# Apply material
mat = bpy.data.materials.new(name="Red Material")
mat.diffuse_color = (1, 0, 0, 1)  # RGBA
obj.data.materials.append(mat)

# Keyframe animation
obj.location.z = 0
obj.keyframe_insert(data_path="location", frame=1)
obj.location.z = 5
obj.keyframe_insert(data_path="location", frame=50)
```

### Addon Development

Addons extend Blender with custom operators, panels, menus, and importers/exporters.

**Addon structure:**
```python
bl_info = {
    "name": "My Addon",
    "author": "Your Name",
    "version": (1, 0),
    "blender": (4, 0, 0),
    "category": "Object",
}

import bpy

class OBJECT_OT_my_operator(bpy.types.Operator):
    bl_idname = "object.my_operator"
    bl_label = "My Operator"

    def execute(self, context):
        # Operator logic
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_my_operator)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_my_operator)

if __name__ == "__main__":
    register()
```

**Installation:**
1. Save script as `.py` file
2. Edit > Preferences > Add-ons > Install
3. Enable checkbox to activate

### Batch Rendering

Automate rendering via command line:

```bash
# Render single frame
blender -b scene.blend -f 1

# Render animation range
blender -b scene.blend -s 1 -e 250 -a

# Render with Python script
blender -b scene.blend -P render_script.py

# Set output path
blender -b scene.blend -o /tmp/render_####.png -f 1

# Use specific engine
blender -b scene.blend -E CYCLES -f 1
```

### Common API Patterns

**Iterate over selected objects:**
```python
for obj in bpy.context.selected_objects:
    print(obj.name)
```

**Create mesh from Python:**
```python
import bpy
import bmesh

mesh = bpy.data.meshes.new("MyMesh")
obj = bpy.data.objects.new("MyObject", mesh)
bpy.context.collection.objects.link(obj)

bm = bmesh.new()
bm.from_mesh(mesh)
# Add vertices, edges, faces via bmesh API
bm.to_mesh(mesh)
bm.free()
```

**Access node trees:**
```python
mat = bpy.data.materials.new("NodeMaterial")
mat.use_nodes = True
nodes = mat.node_tree.nodes
links = mat.node_tree.links

# Clear default nodes
nodes.clear()

# Add nodes
output = nodes.new('ShaderNodeOutputMaterial')
bsdf = nodes.new('ShaderNodeBsdfPrincipled')
links.new(bsdf.outputs['BSDF'], output.inputs['Surface'])
```

---

## Addons

Blender ships with official addons and supports third-party extensions.

### Official Addons (included)

Enable via Edit > Preferences > Add-ons:

- **Import-Export** - FBX, OBJ, Alembic, USD, glTF 2.0, STL, PLY, X3D, SVG
- **Rigging** - Rigify (advanced auto-rigging), Bone Selection Sets
- **Mesh** - Bool Tool, LoopTools, Auto Mirror, Extra Objects
- **Animation** - AnimAll (animate mesh data), Copy Global Transform
- **Render** - Freestyle SVG Exporter
- **Node** - Node Wrangler (shader shortcuts)
- **3D View** - Measureit (dimension annotation), 3D Navigation

### Popular Third-Party Addons

- **Hard Ops / Boxcutter** - Hard-surface modeling tools
- **Machine Tools** - CAD-style precision modeling
- **FLIP Fluids** - High-performance liquid simulation
- **Animation Nodes** - Procedural animation via node graphs (free)
- **Retopoflow** - Retopology suite with advanced brush tools
- **UVPackmaster** - AI-powered UV packing optimization
- **X-Muscle System** - Muscle and skin deformation rig
- **Dendrite** - Terrain generation
- **Scatter** - Advanced scattering and ecosystem tools
- **Real Camera** - Photographer-friendly camera controls

---

## Pipeline Integration

### Game Engine Export

**Unreal Engine:**
- Use FBX exporter with "Apply Modifiers" and "Bake Animation"
- Enable "Selected Objects" for specific exports
- Collision primitives named `UCX_[MeshName]_##`

**Unity:**
- Export as FBX with "Apply Transform" disabled (Unity handles scale)
- Use "Triangulate Faces" for predictable geometry
- Separate materials and embed textures or use external references

**Godot:**
- glTF 2.0 export for best compatibility (embedded or separate)
- Support for animations, materials, cameras, lights
- Use Godot-Blender Exporter addon for direct integration

### CICD and Automation

Blender supports headless operation for render farms, asset baking, and CI pipelines.

**Headless rendering:**
```bash
# Render without GUI
blender -b scene.blend -o /output/frame_#### -F PNG -s 1 -e 100 -a

# Enable GPU rendering via script
blender -b scene.blend -P enable_gpu.py -- -f 1
```

**enable_gpu.py:**
```python
import bpy

# Enable CUDA or OptiX
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'  # or 'OPTIX', 'HIP', 'METAL'
prefs.get_devices()

# Enable all GPUs
for device in prefs.devices:
    device.use = True

# Set render engine
bpy.context.scene.render.engine = 'CYCLES'
bpy.context.scene.cycles.device = 'GPU'

# Save preferences
bpy.ops.wm.save_userpref()
```

### Docker Rendering

Run Blender in a container for isolated render jobs:

```dockerfile
FROM ubuntu:22.04

RUN apt-get update && apt-get install -y \
    blender \
    xvfb \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /blender

CMD ["blender", "-b", "scene.blend", "-a"]
```

**Run container:**
```bash
docker run -v $(pwd):/blender blender-render
```

---

## Asset Libraries

Blender 3.0+ introduced Asset Browser for managing reusable materials, objects, node groups, and poses.

### Creating Assets

1. Select object, material, or node group
2. Right-click > Mark as Asset
3. Configure metadata (tags, description, preview)
4. Save to asset library path

### Asset Libraries

Configure libraries in Preferences > File Paths > Asset Libraries:
- **Current File** - Assets in active .blend file
- **User Library** - Personal asset collection
- **Custom Libraries** - Studio or project-specific paths

### Asset Packs

Community and commercial asset libraries:
- **Blender Cloud** - Official textures, HDRIs, and models (subscription)
- **Poly Haven** - Free CC0 HDRIs, textures, models
- **Quixel Megascans** - Photogrammetry assets (free with Epic account)
- **BlenderKit** - Free and paid addon with integrated asset browser

---

## KBVE Integration

Blender can be integrated into KBVE workflows for procedural asset generation, batch rendering, and pipeline automation.

### CI/CD Workflow

The KBVE monorepo runs headless Blender through a **router → flow** pair on the self-hosted `mac-blender` runner:

- [`.github/workflows/ci-blender-router.yml`](.github/workflows/ci-blender-router.yml) — `workflow_dispatch` entry point. Validates inputs, picks the LFS backend (`forgejo` or `azure`), then hands off to the flow.
- [`.github/workflows/ci-blender-flow.yml`](.github/workflows/ci-blender-flow.yml) — reusable `workflow_call` builder. Pulls the target object from LFS, runs the task on `[self-hosted, macOS, ARM64, mac-blender]`, and uploads artifacts.

The object lives in external LFS — Forgejo (`git.kbve.com`, via `FORGEJO_USER`/`FORGEJO_TOKEN`) or Azure DevOps (via `AZURE_PAT`). Tag your runner with the `mac-blender` label so only Blender jobs land on it.

**Available tasks:**

- **`validate`** - Check blend file integrity and test headless launch
- **`render`** - Render single frames or animation ranges with configurable engine/device
- **`export`** - Export scene or selected objects to FBX, glTF, OBJ, USD, Alembic, STL
- **`batch-export`** - Export each mesh object as a separate file
- **`script`** - Run custom Python scripts in headless mode

**Example workflow dispatch:**

```bash
# Render with Cycles GPU — object pulled from Forgejo LFS
gh workflow run ci-blender-router.yml \
  -f task=render \
  -f app_name=my-project \
  -f lfs_backend=forgejo \
  -f object_glob=assets/blender \
  -f blend_file=assets/blender/scene.blend \
  -f render_engine=CYCLES \
  -f render_device=GPU \
  -f frame_range=1-100 \
  -f samples=128

# Export all objects as FBX for Unreal — object pulled from Azure DevOps
gh workflow run ci-blender-router.yml \
  -f task=batch-export \
  -f app_name=game-assets \
  -f lfs_backend=azure \
  -f external_repo_url=dev.azure.com/kbve/art/_git/props \
  -f blend_file=external-blender/props.blend \
  -f export_format=FBX \
  -f output_path=/tmp/exports
```

**Automatic Blender installation:**

The workflow automatically installs Blender via Homebrew if not found:

```bash
brew install --cask blender
```

**Supported render engines:**

| Engine | GPU Support | Best For |
|--------|-------------|----------|
| `CYCLES` | CUDA, OptiX, HIP, Metal | Photorealistic path tracing |
| `BLENDER_EEVEE` | Yes (rasterization) | Real-time previews, stylized |
| `BLENDER_WORKBENCH` | Yes (OpenGL) | Viewport solid shading |

**Export formats:**

| Format | Extension | Use Case |
|--------|-----------|----------|
| `FBX` | `.fbx` | Unreal Engine, Unity, Maya |
| `GLTF` | `.gltf` / `.glb` | Web, Godot, Three.js |
| `OBJ` | `.obj` | Universal interchange |
| `USD` | `.usd` | Pixar USD pipeline |
| `ALEMBIC` | `.abc` | VFX, baked animation |
| `STL` | `.stl` | 3D printing |

**Pipeline integration:**

The workflow outputs artifacts via `actions/upload-artifact@v7`, which can be consumed by downstream jobs or downloaded manually.

```yaml
# Example: Render in Blender, then deploy to Unreal
jobs:
  render:
    uses: KBVE/kbve/.github/workflows/ci-blender-flow.yml@dev
    with:
      task: render
      lfs_backend: forgejo
      object_glob: assets/blender
      blend_file: assets/blender/environment.blend
      output_path: /tmp/renders
    secrets: inherit

  unreal_import:
    needs: [render]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@v8
        with:
          name: blender-project-render
          path: ./renders
      # ... import into Unreal via Python/C++ automation
```

### Batch Export Script

Automate FBX export for all selected objects:

```python
import bpy
import os

output_dir = "/tmp/blender_export"
os.makedirs(output_dir, exist_ok=True)

for obj in bpy.context.selected_objects:
    # Select only this object
    bpy.ops.object.select_all(action='DESELECT')
    obj.select_set(True)
    bpy.context.view_layer.objects.active = obj

    # Export as FBX
    filepath = os.path.join(output_dir, f"{obj.name}.fbx")
    bpy.ops.export_scene.fbx(
        filepath=filepath,
        use_selection=True,
        apply_scale_options='FBX_SCALE_ALL',
        bake_anim=True
    )
    print(f"Exported: {filepath}")
```

Run via:
```bash
blender -b scene.blend -P batch_export.py
```

### Legacy CI Pipeline Example

```yaml
# .github/workflows/blender-render.yml
name: Blender Render

on:
  push:
    paths:
      - '**.blend'

jobs:
  render:
    runs-on: ubuntu-latest
    container:
      image: nytimes/blender:4.0-gpu-ubuntu22.04

    steps:
      - uses: actions/checkout@v4

      - name: Render Scene
        run: |
          blender -b scene.blend \
            -o /tmp/render_#### \
            -F PNG \
            -s 1 -e 100 -a

      - name: Upload Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: renders
          path: /tmp/render_*.png
```

### Geometry Node Export for Unreal

Use Geometry Nodes to procedurally generate assets, then export to Unreal:

1. Create Geometry Node graph in Blender
2. Use Python script to realize instances and export
3. Import FBX into Unreal as static mesh or skeletal mesh
4. Optionally: Export vertex animation as Alembic cache

---

## Performance Tips

### Viewport Optimization

- **Simplify Overlays** - Disable overlays (Alt+Shift+Z) for large scenes
- **Reduce Draw Distance** - Limit clip end in viewport shading settings
- **Use Collections** - Organize scene into collections, hide unused
- **Limit Subdivision** - Keep viewport subdivision level lower than render
- **Disable Eevee Effects** - Turn off bloom, volumetrics, SSR for faster preview

### Render Optimization

- **Adaptive Sampling** - Stop rendering clean pixels early (Cycles)
- **Denoising** - Use OptiX denoiser on NVIDIA GPUs for lower sample counts
- **Light Path Settings** - Reduce max bounces (4-8 total is often sufficient)
- **Tile Size** - GPU: larger tiles (256-512), CPU: smaller tiles (32-64)
- **Resolution** - Render at 50% resolution for preview, 100% for final
- **Bake Indirect Lighting** - Use Eevee irradiance volumes for real-time GI approximation

### Large Scene Management

- **Instancing** - Use collection instances for repeated geometry (trees, buildings)
- **Geometry Nodes** - Procedural generation avoids storing duplicate data
- **Level of Detail (LOD)** - Decimate modifier or simplified versions for distant objects
- **Library Linking** - Link assets from external .blend files to reduce file size
- **Purge Orphan Data** - File > Clean Up > Purge Orphan Data removes unused data blocks

---

## Troubleshooting

### Common Issues

**Slow Viewport Performance:**
- Disable overlays, reduce subdivision levels, hide unused collections
- Check GPU is selected in Preferences > System > Cycles Render Devices

**Render Crashes:**
- Reduce tile size, lower max samples, disable adaptive sampling
- Update GPU drivers, check VRAM usage (render smaller regions)
- For CPU renders, reduce thread count in render settings

**Materials Not Showing:**
- Ensure viewport shading is set to Material Preview or Rendered
- Check material has Use Nodes enabled
- Verify Shader Editor has Principled BSDF connected to Material Output

**Animation Not Playing:**
- Check playback range (start/end frames in timeline)
- Verify keyframes exist in Dope Sheet or Graph Editor
- Disable simulation caching if physics is causing lag

**Export Issues:**
- Apply modifiers before export (or enable "Apply Modifiers" in exporter)
- Triangulate faces for game engines (or enable in FBX export)
- Check scale settings (FBX scale, Apply Transform)

<Giscus />

---
# CSS

> CSS styles the web. From modern CSS features to TailwindCSS utilities and ready-to-use custom components.

Source: https://kbve.com/application/css/

import {
Aside,
Steps,
Card,
CardGrid,
Code,
FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense, DevCode } from '@/components/astropad';

## Information

CSS (Cascading Style Sheets) is the styling layer of the web.
It controls layout, color, typography, motion and responsiveness.
Where HTML gives a page structure and JavaScript gives it behavior, CSS gives it form.

This document is an all-in-one reference: modern CSS features that ship in evergreen browsers today, the TailwindCSS utility framework, and a library of copy-paste custom components (buttons, forms, text effects, glassmorphism and more).

<Aside type="tip">
Looking for TailwindCSS? It now lives here. The old snippets from the JavaScript page were migrated into this dedicated CSS reference.
</Aside>

---

## Modern CSS

Modern CSS removed the need for many preprocessor tricks and JavaScript hacks.
The features below are baseline across current Chrome, Firefox, Safari and Edge.

### Nesting

Native CSS nesting works without Sass. Selectors nest with `&` for the parent reference.

```css
.card {
    padding: 1rem;
    border-radius: 0.5rem;

    & h2 {
        margin: 0;
    }

    &:hover {
        box-shadow: 0 4px 12px rgb(0 0 0 / 0.15);
    }
}
```

### :has() — the parent selector

`:has()` selects an element based on its descendants. It enables parent and previous-sibling styling that once required JavaScript.

```css
/* Style a card that contains an image */
.card:has(img) {
    grid-template-rows: auto 1fr;
}

/* Style a label whose input is checked */
label:has(input:checked) {
    font-weight: 700;
}

/* Form with an invalid field */
form:has(:invalid) button[type="submit"] {
    opacity: 0.5;
    pointer-events: none;
}
```

### Container queries

Container queries style an element based on the size of its container, not the viewport. This makes components truly reusable across layouts.

```css
.sidebar {
    container-type: inline-size;
    container-name: sidebar;
}

@container sidebar (min-width: 400px) {
    .widget {
        display: grid;
        grid-template-columns: 1fr 1fr;
    }
}
```

<Aside>
Container query units (`cqw`, `cqi`, `cqb`) size relative to the query container, e.g. `font-size: 5cqi`.
</Aside>

### Fluid type with clamp()

`clamp(MIN, PREFERRED, MAX)` builds responsive typography and spacing without breakpoints.

```css
h1 {
    /* Never smaller than 1.5rem, never larger than 3rem, scales with viewport */
    font-size: clamp(1.5rem, 1rem + 3vw, 3rem);
}
```

### Modern color: oklch() and color-mix()

`oklch()` is a perceptually uniform color space — lightness stays consistent across hues. `color-mix()` blends two colors in any space.

```css
:root {
    --brand: oklch(0.7 0.15 200);
    /* 80% brand, 20% white — a tint without a second variable */
    --brand-tint: color-mix(in oklch, var(--brand) 80%, white);
    --brand-shade: color-mix(in oklch, var(--brand) 80%, black);
}
```

### @property — typed custom properties

`@property` registers a custom property with a type, enabling animation of values CSS could not previously interpolate (like gradient stops or angles).

```css
@property --angle {
    syntax: "<angle>";
    initial-value: 0deg;
    inherits: false;
}

.spinner {
    background: conic-gradient(from var(--angle), cyan, magenta, cyan);
    animation: rotate 2s linear infinite;
}

@keyframes rotate {
    to { --angle: 360deg; }
}
```

### Subgrid

`subgrid` lets a nested grid inherit the track sizing of its parent, aligning content across cards.

```css
.grid {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
}

.card {
    display: grid;
    grid-row: span 3;
    grid-template-rows: subgrid; /* header / body / footer line up across all cards */
}
```

### Scroll-driven animations

Animate elements as the user scrolls — no scroll-event JavaScript, runs on the compositor.

```css
@keyframes reveal {
    from { opacity: 0; transform: translateY(2rem); }
    to   { opacity: 1; transform: translateY(0); }
}

.section {
    animation: reveal linear both;
    animation-timeline: view();
    animation-range: entry 0% cover 40%;
}
```

### View transitions

The View Transitions API animates between two DOM states — the browser snapshots before and after, then cross-fades or morphs between them. It works for in-page state changes (same-document) and across page navigations (cross-document / MPA).

**Same-document.** Wrap the DOM mutation in `startViewTransition`. The browser captures, applies your callback, then animates old → new. A default cross-fade comes free.

```js
function toggle() {
    if (!document.startViewTransition) return update(); // graceful fallback
    document.startViewTransition(() => update());       // animated path
}
```

**Shared-element morph.** Give the same `view-transition-name` to an element in both states and the browser tweens it between positions — a thumbnail growing into a hero, a card expanding into a detail page.

```css
.thumbnail { view-transition-name: hero; }
/* On the next view, the large image carries the SAME name → it morphs */
.detail-image { view-transition-name: hero; }
```

<Aside type="caution">
A `view-transition-name` must be **unique per snapshot** — two visible elements sharing one name aborts the transition. For lists, generate per-item names (`view-transition-name: card-{id}`).
</Aside>

**Customizing.** The transition exposes pseudo-elements you can target with normal `@keyframes` — `::view-transition-old(name)` (outgoing) and `::view-transition-new(name)` (incoming).

```css
@keyframes slide-from-right { from { transform: translateX(40px); opacity: 0; } }
@keyframes fade-out         { to   { opacity: 0; } }

::view-transition-old(root) { animation: fade-out 0.2s both; }
::view-transition-new(root) { animation: slide-from-right 0.3s both; }
```

**Cross-document (MPA).** One CSS rule opts an entire multi-page site into transitions — no JavaScript, no SPA router.

```css
@view-transition { navigation: auto; }
```

<Aside type="tip">
This very site is Astro. For MPA view transitions across Astro pages, drop `<ClientRouter />` (from `astro:transitions`) in your layout `<head>` and tag shared elements with the `transition:name` directive — Astro wires up the API and ships a fallback for browsers without it.
</Aside>

### Respecting motion preferences

Always gate non-essential motion behind `prefers-reduced-motion`. Users who set the OS "reduce motion" flag get a static experience; everyone else gets the animation.

```css
@media (prefers-reduced-motion: no-preference) {
    .card {
        animation: reveal linear both;
        animation-timeline: view();
    }
}

/* Or kill all motion as a blanket safety net */
@media (prefers-reduced-motion: reduce) {
    *, *::before, *::after {
        animation-duration: 0.01ms !important;
        animation-iteration-count: 1 !important;
        transition-duration: 0.01ms !important;
        scroll-behavior: auto !important;
    }
}
```

<Aside type="caution">
The scroll-driven, shimmer and glow examples in this doc are decorative. In production, wrap them in `motion-safe:` (Tailwind) or the media query above so they respect the user's accessibility setting.
</Aside>

### Text wrapping

```css
h1, h2, h3 {
    text-wrap: balance; /* even line lengths for headings */
}

p {
    text-wrap: pretty; /* avoids orphans / single-word last lines */
}
```

### Logical properties

Logical properties adapt to writing direction (LTR / RTL) automatically.

```css
.box {
    margin-inline: auto;      /* left+right in LTR, swaps in RTL */
    padding-block: 1rem;      /* top+bottom */
    border-inline-start: 2px solid; /* "left" border that flips for RTL */
}
```

<Aside type="tip">
Other modern wins worth knowing: `accent-color` (themes checkboxes/radios), `aspect-ratio` (no padding hack), `scrollbar-gutter: stable` (no layout shift on scroll), `:is()` / `:where()` (selector grouping, `:where()` has zero specificity), and `gap` on flexbox.
</Aside>

---

## Layout Patterns

The two layout engines — Flexbox (one dimension) and Grid (two dimensions) — cover almost every layout. A handful of patterns recur constantly.

### Responsive grid without media queries

`auto-fit` + `minmax()` reflows columns to fit the container. Cards wrap on their own as space shrinks.

```css
.gallery {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(min(16rem, 100%), 1fr));
    gap: 1rem;
}
```

<Aside>
The `min(16rem, 100%)` guard stops a single card overflowing on viewports narrower than the track minimum. In Tailwind: `grid grid-cols-[repeat(auto-fit,minmax(min(16rem,100%),1fr))]`.
</Aside>

### Dead-center anything

```css
.center {
    display: grid;
    place-items: center;
}
```

### Sticky footer

Footer sits at the bottom on short pages, pushed down on tall ones — no fixed heights.

```css
body {
    min-height: 100dvh;        /* dvh = dynamic viewport, accounts for mobile URL bars */
    display: flex;
    flex-direction: column;
}

main {
    flex: 1;                   /* grows to fill, footer follows */
}
```

### The stack and the sidebar

```css
/* Even vertical rhythm between children */
.stack > * + * {
    margin-block-start: 1.5rem;
}

/* Sidebar that collapses below content when space runs out */
.with-sidebar {
    display: flex;
    flex-wrap: wrap;
    gap: 1rem;
}
.with-sidebar > .sidebar { flex: 1 1 15rem; }
.with-sidebar > .content { flex: 999 1 60%; }
```

### Cascade layers

`@layer` gives you explicit control over specificity ordering — later layers always win over earlier ones, regardless of selector strength. This tames override wars and is how Tailwind v4 organizes its own output (`theme`, `base`, `components`, `utilities`).

```css
@layer reset, base, components, utilities;

@layer base {
    a { color: blue; }
}

@layer components {
    /* Wins over base even though the selector is identical specificity */
    .link { color: rebeccapurple; }
}
```

<Aside type="tip">
Unlayered styles beat layered ones, so anything outside a layer always wins — useful for one-off overrides, dangerous if used by accident.
</Aside>

---

## Typography

Readable type is mostly a few well-chosen defaults: a sensible measure, comfortable line height, and a scale that adapts to the viewport.

### Fluid type scale

Combine `clamp()` with custom properties for a scale that breathes between phone and desktop without breakpoints.

```css
:root {
    --step--1: clamp(0.83rem, 0.78rem + 0.24vw, 0.96rem);
    --step-0:  clamp(1rem,    0.91rem + 0.43vw, 1.25rem);
    --step-1:  clamp(1.2rem,  1.07rem + 0.65vw, 1.56rem);
    --step-2:  clamp(1.44rem, 1.26rem + 0.93vw, 1.95rem);
    --step-3:  clamp(1.73rem, 1.47rem + 1.29vw, 2.44rem);
}

h1 { font-size: var(--step-3); }
h2 { font-size: var(--step-2); }
p  { font-size: var(--step-0); }
```

<Aside type="tip">
Generate the whole scale with [Utopia](https://utopia.fyi/). Tailwind v4: drop the steps into `@theme { --text-step-0: clamp(...); }` to get `text-step-0` utilities.
</Aside>

### Measure and rhythm

```css
.prose {
    max-width: 65ch;      /* ~65 characters is the readable sweet spot */
    line-height: 1.6;     /* unitless — scales with font-size */
    text-wrap: pretty;    /* avoids orphaned last words */
}
```

### Variable fonts

One file, every weight and width. Animate the axes live with `font-variation-settings`.

```css
@font-face {
    font-family: "Inter var";
    src: url("/fonts/inter.woff2") format("woff2");
    font-weight: 100 900;        /* the full axis range */
    font-display: swap;          /* show fallback text immediately, swap when loaded */
}

.heading {
    font-family: "Inter var", sans-serif;
    font-weight: 720;            /* any value in range, not just 700 */
}
```

<Aside type="caution">
`font-display: swap` avoids invisible text (FOIT) but causes a layout shift on swap. Pair with `size-adjust` / `ascent-override` on a fallback `@font-face` to keep metrics matched and kill the shift.
</Aside>

### Truncation & clamping

export const truncateCode = `<div class="max-w-xs p-6 space-y-4 bg-white rounded-lg">
  <p class="font-medium text-gray-800 truncate">Single line that gets cut with an ellipsis when it overflows its container</p>
  <p class="text-sm text-gray-600 line-clamp-3">Multi-line clamp limits a block to a fixed number of lines and adds an ellipsis. Useful for card descriptions and previews where you want a uniform height regardless of how much copy each item carries. Anything past the third line is hidden.</p>
</div>`;

<DevCode htmlCode={truncateCode} />

<Aside>
`truncate` = `overflow:hidden; text-overflow:ellipsis; white-space:nowrap`. `line-clamp-N` uses `-webkit-line-clamp` (now standardized) for the multi-line version.
</Aside>

---

## Transitions & Animation

Two mechanisms: `transition` interpolates between two states (a hover, a class toggle), while `@keyframes` + `animation` runs a defined timeline that can loop and have many steps.

### Transitions

```css
.button {
    background: var(--brand);
    /* property | duration | easing | delay */
    transition: background 200ms ease-out, transform 200ms ease-out;
}
.button:hover {
    transform: translateY(-2px);
}
```

<Aside type="caution">
Transition only cheap, compositor-friendly properties — `transform`, `opacity`, `filter`. Animating `width`, `height`, `top` or `margin` triggers layout on every frame and janks. Need a layout-looking move? Use `transform: scale()` / `translate()` instead.
</Aside>

### Easing

`ease-out` for things entering, `ease-in` for things leaving, custom `cubic-bezier()` for character. Modern browsers also support `linear()` for spring and bounce curves without JavaScript.

```css
:root {
    --ease-snappy: cubic-bezier(0.2, 0, 0, 1);
    /* A spring-like bounce, approximated with a linear() stop list */
    --ease-spring: linear(0, 0.4 12%, 1.1 28%, 0.95 42%, 1.02 60%, 1);
}
```

### Keyframes

A full timeline. This is the `shimmer` keyframe the gradient-text example earlier relies on — define it once globally (in your stylesheet or Tailwind `@theme`).

```css
@keyframes shimmer {
    to { background-position: 200% center; }
}

@keyframes float {
    0%, 100% { transform: translateY(0); }
    50%      { transform: translateY(-0.5rem); }
}

.badge {
    animation: float 3s ease-in-out infinite;
}
```

<Aside type="tip">
In Tailwind v4, register a keyframe-backed animation as a theme token: `@theme { --animate-float: float 3s ease-in-out infinite; }` generates the `animate-float` utility. Always pair looping animation with `motion-safe:` so it respects reduced-motion.
</Aside>

### Animation Gallery

Live, self-contained keyframe demos. Each snippet carries its own `<style>` block with a uniquely-named `@keyframes`, so you can copy one and drop it anywhere — no shared config required.

#### Floating

export const fxFloatCode = `<style>
@keyframes kbve-float { 0%, 100% { transform: translateY(0); } 50% { transform: translateY(-14px); } }
.kbve-float { animation: kbve-float 3s ease-in-out infinite; }
</style>
<div class="flex items-center justify-center p-12 bg-gray-900">
  <div class="kbve-float w-20 h-20 shadow-xl rounded-2xl bg-gradient-to-br from-cyan-400 to-fuchsia-500"></div>
</div>`;

<DevCode htmlCode={fxFloatCode} />

#### Pulse Ring

A notification dot with an expanding, fading ring — the classic "live" indicator.

export const fxPulseCode = `<style>
@keyframes kbve-ping { 75%, 100% { transform: scale(2.4); opacity: 0; } }
.kbve-ping { animation: kbve-ping 1.4s cubic-bezier(0,0,0.2,1) infinite; }
</style>
<div class="flex items-center justify-center p-12 bg-gray-900">
  <span class="relative flex w-5 h-5">
    <span class="kbve-ping absolute inline-flex w-full h-full rounded-full bg-cyan-400"></span>
    <span class="relative inline-flex w-5 h-5 rounded-full bg-cyan-500"></span>
  </span>
</div>`;

<DevCode htmlCode={fxPulseCode} />

#### Shimmer Text

The gradient shimmer referenced earlier — now running live via an embedded keyframe.

export const fxShimmerCode = `<style>
@keyframes kbve-shimmer { to { background-position: 200% center; } }
.kbve-shimmer {
  background: linear-gradient(90deg, #06b6d4, #d946ef, #06b6d4);
  background-size: 200% auto;
  -webkit-background-clip: text; background-clip: text;
  color: transparent;
  animation: kbve-shimmer 3s linear infinite;
}
</style>
<div class="flex items-center justify-center p-12 bg-gray-900">
  <h1 class="kbve-shimmer text-6xl font-black">Shimmer</h1>
</div>`;

<DevCode htmlCode={fxShimmerCode} />

#### Typewriter

`steps()` makes the reveal tick character-by-character; a second keyframe blinks the caret.

export const fxTypeCode = `<style>
@keyframes kbve-type { from { width: 0; } to { width: 16ch; } }
@keyframes kbve-caret { 50% { border-color: transparent; } }
.kbve-type {
  width: 16ch;
  font-family: ui-monospace, monospace;
  white-space: nowrap; overflow: hidden;
  border-right: 3px solid #06b6d4;
  animation: kbve-type 3s steps(16) infinite alternate, kbve-caret 0.7s step-end infinite;
}
</style>
<div class="flex items-center justify-center p-12 bg-gray-900">
  <span class="kbve-type text-2xl font-medium text-cyan-300">console.log(42)</span>
</div>`;

<DevCode htmlCode={fxTypeCode} />

#### Marquee

Seamless infinite scroll — duplicate the content and translate by -50%.

export const fxMarqueeCode = `<style>
@keyframes kbve-marquee { to { transform: translateX(-50%); } }
.kbve-marquee { display: inline-flex; gap: 2rem; animation: kbve-marquee 12s linear infinite; }
.kbve-marquee:hover { animation-play-state: paused; }
</style>
<div class="p-8 overflow-hidden bg-gray-900 whitespace-nowrap">
  <div class="kbve-marquee text-lg font-semibold text-cyan-300">
    <span>★ Astro</span><span>★ TailwindCSS</span><span>★ Rust</span><span>★ Unity</span><span>★ Supabase</span>
    <span>★ Astro</span><span>★ TailwindCSS</span><span>★ Rust</span><span>★ Unity</span><span>★ Supabase</span>
  </div>
</div>`;

<DevCode htmlCode={fxMarqueeCode} />

#### Flip Card

A 3D flip on hover with `transform-style: preserve-3d` and `backface-visibility`.

export const fxFlipCode = `<style>
.kbve-flip { perspective: 1000px; }
.kbve-flip-inner { position: relative; width: 100%; height: 100%; transition: transform 0.6s; transform-style: preserve-3d; }
.kbve-flip:hover .kbve-flip-inner { transform: rotateY(180deg); }
.kbve-flip-face { position: absolute; inset: 0; backface-visibility: hidden; display: flex; align-items: center; justify-content: center; border-radius: 1rem; font-weight: 700; color: #fff; }
.kbve-flip-back { transform: rotateY(180deg); }
</style>
<div class="flex items-center justify-center p-12 bg-gray-900">
  <div class="kbve-flip w-48 h-32">
    <div class="kbve-flip-inner">
      <div class="kbve-flip-face bg-cyan-600">Hover me</div>
      <div class="kbve-flip-face kbve-flip-back bg-fuchsia-600">Flipped!</div>
    </div>
  </div>
</div>`;

<DevCode htmlCode={fxFlipCode} />

<Aside type="caution">
Every demo here loops or runs on hover purely for illustration. In production wrap looping motion in `@media (prefers-reduced-motion: no-preference)` so it respects the user's setting.
</Aside>

---

## Effects & Filters

CSS can do a lot of what once needed image editors — blur, recolor, clip and blend — all GPU-accelerated and animatable.

### filter

`filter` chains image-style operations: `blur`, `brightness`, `contrast`, `grayscale`, `saturate`, `hue-rotate`, `drop-shadow`. They compose left to right.

export const fxFilterCode = `<div class="flex flex-wrap items-end justify-center gap-6 p-10 bg-gray-900 text-center text-xs text-gray-300">
  <figure><div class="w-20 h-20 rounded-xl bg-gradient-to-br from-cyan-400 to-fuchsia-500"></div><figcaption class="mt-2">none</figcaption></figure>
  <figure><div class="w-20 h-20 rounded-xl bg-gradient-to-br from-cyan-400 to-fuchsia-500" style="filter:grayscale(1)"></div><figcaption class="mt-2">grayscale(1)</figcaption></figure>
  <figure><div class="w-20 h-20 rounded-xl bg-gradient-to-br from-cyan-400 to-fuchsia-500" style="filter:hue-rotate(120deg) saturate(1.5)"></div><figcaption class="mt-2">hue-rotate</figcaption></figure>
  <figure><div class="w-20 h-20 rounded-xl bg-gradient-to-br from-cyan-400 to-fuchsia-500" style="filter:blur(4px)"></div><figcaption class="mt-2">blur(4px)</figcaption></figure>
  <figure><div class="w-20 h-20 rounded-xl bg-gradient-to-br from-cyan-400 to-fuchsia-500" style="filter:drop-shadow(0 6px 10px rgba(6,182,212,0.7))"></div><figcaption class="mt-2">drop-shadow</figcaption></figure>
</div>`;

<DevCode htmlCode={fxFilterCode} />

<Aside type="tip">
`drop-shadow()` follows the alpha shape of the element (PNG cut-outs, rounded corners, SVG) — unlike `box-shadow`, which is always a rectangle.
</Aside>

### backdrop-filter

`backdrop-filter` filters whatever sits **behind** an element — the basis of frosted glass.

export const fxBackdropCode = `<div class="relative flex items-center justify-center p-10 overflow-hidden h-52" style="background:url('https://images.unsplash.com/photo-1557682250-33bd709cbe85?w=600') center/cover">
  <div class="px-8 py-6 text-white border rounded-2xl bg-white/10 border-white/30" style="backdrop-filter:blur(10px) saturate(1.4)">
    <p class="text-lg font-bold">Frosted Glass</p>
    <p class="text-sm text-white/80">backdrop-filter: blur + saturate</p>
  </div>
</div>`;

<DevCode htmlCode={fxBackdropCode} />

### mix-blend-mode

Blend an element with what's underneath — `difference`, `multiply`, `screen`, `overlay`. Great for text that stays legible over any background.

export const fxBlendCode = `<div class="relative flex items-center justify-center p-10 overflow-hidden h-44 bg-gradient-to-r from-cyan-400 via-amber-300 to-fuchsia-500">
  <h1 class="text-6xl font-black text-white" style="mix-blend-mode:difference">BLEND</h1>
</div>`;

<DevCode htmlCode={fxBlendCode} />

### clip-path

`clip-path` crops an element to any shape — polygons, circles, insets. Animatable between equal point counts.

export const fxClipCode = `<div class="flex flex-wrap items-center justify-center gap-6 p-10 bg-gray-900 text-center text-xs text-gray-300">
  <figure><div class="w-24 h-24 bg-gradient-to-br from-cyan-400 to-fuchsia-500" style="clip-path:polygon(50% 0,100% 38%,82% 100%,18% 100%,0 38%)"></div><figcaption class="mt-2">pentagon</figcaption></figure>
  <figure><div class="w-24 h-24 bg-gradient-to-br from-cyan-400 to-fuchsia-500" style="clip-path:circle(50%)"></div><figcaption class="mt-2">circle</figcaption></figure>
  <figure><div class="w-24 h-24 bg-gradient-to-br from-cyan-400 to-fuchsia-500" style="clip-path:polygon(0 0,100% 0,100% 75%,50% 100%,0 75%)"></div><figcaption class="mt-2">arrow tag</figcaption></figure>
</div>`;

<DevCode htmlCode={fxClipCode} />

### mask-image

A mask uses a gradient or image alpha to fade or cut out content — softer than the hard edges of `clip-path`.

export const fxMaskCode = `<div class="p-10 bg-gray-900">
  <p class="text-2xl font-bold leading-relaxed text-cyan-300" style="-webkit-mask-image:linear-gradient(to right,#000 55%,transparent);mask-image:linear-gradient(to right,#000 55%,transparent)">
    This paragraph fades out toward the edge using a linear-gradient mask — the classic "read more" teaser without an overlay element.
  </p>
</div>`;

<DevCode htmlCode={fxMaskCode} />

<Aside type="caution">
`backdrop-filter` and `mask-image` still want the `-webkit-` prefix for older Safari. Always provide a readable fallback — if the filter is unsupported, the panel should stay legible on its own.
</Aside>

---

## TailwindCSS

TailwindCSS is a utility-first CSS framework. Instead of writing custom CSS, you compose designs from low-level utility classes directly in your markup.
This promotes consistency, reusability and speed, and the production build strips every class you do not use.

Tailwind v4 is **CSS-first**: configuration lives in your CSS via `@theme` instead of a `tailwind.config.js` file, the engine is faster, and many former plugins (container queries, text-shadow) are now built in.

### TailwindCSS Setup (v4)

<Steps>

0.  **Create a project directory**

    ```shell
    mkdir my-tailwind-project
    cd my-tailwind-project
    pnpm init
    ```

1.  **Install Tailwind v4**

    v4 ships a dedicated Vite plugin (or the standalone CLI / PostCSS plugin).

    ```shell
    pnpm add tailwindcss @tailwindcss/vite
    ```

2.  **Wire up the Vite plugin**

    ```js
    // vite.config.js
    import { defineConfig } from 'vite';
    import tailwindcss from '@tailwindcss/vite';

    export default defineConfig({
        plugins: [tailwindcss()],
    });
    ```

3.  **Import Tailwind in your CSS**

    One line replaces the old `@tailwind base/components/utilities` trio.

    ```css
    /* src/styles.css */
    @import "tailwindcss";
    ```

4.  **Configure in CSS with @theme**

    Design tokens live in CSS now. No `tailwind.config.js` required.

    ```css
    @import "tailwindcss";

    @theme {
        --color-brand: oklch(0.7 0.15 200);
        --font-display: "Satoshi", sans-serif;
        --animate-spin-slow: spin 5s linear infinite;
    }
    ```

    These tokens auto-generate utilities like `bg-brand`, `font-display` and `animate-spin-slow`.

5.  **Use it in markup**

    ```html
    <h1 class="text-3xl font-bold text-brand underline">Hello, TailwindCSS!</h1>
    ```

</Steps>

<Aside type="caution">
Migrating from v3? Key changes: config moves to `@theme` in CSS, `@tailwind` directives become `@import "tailwindcss"`, the default `border` color is now `currentColor`, and `shadow-sm`/`ring` renamed (`shadow-xs`, `ring` defaults to 1px). Run `npx @tailwindcss/upgrade` to automate most of it.
</Aside>

<Aside>
Prefer the classic config file? v4 still reads it via `@config "../tailwind.config.js";`. The official [TailwindCSS documentation](https://tailwindcss.com/docs) covers both paths.
</Aside>

### TailwindCSS Buttons

These are the Dojo buttons — live, rendered with the site's Tailwind build. Each block is the exact markup to copy.

---

export const buttonCode = `<a href="#_" class="relative inline-block text-lg group">
    <span class="relative z-10 block px-5 py-3 overflow-hidden font-medium leading-tight text-gray-800 transition-colors duration-300 ease-out border-2 border-gray-900 rounded-lg group-hover:text-white">
    <span class="absolute inset-0 w-full h-full px-5 py-3 rounded-lg bg-gray-50"></span>
    <span class="absolute left-0 w-48 h-48 -ml-2 transition-all duration-300 origin-top-right -rotate-90 -translate-x-full translate-y-12 bg-gray-900 group-hover:-rotate-180 ease"></span>
    <span class="relative">Button Text</span>
    </span>
    <span class="absolute bottom-0 right-0 w-full h-12 -mb-1 -mr-1 transition-all duration-200 ease-linear bg-gray-900 rounded-lg group-hover:mb-0 group-hover:mr-0" data-rounded="rounded-lg"></span>
</a>`;

<DevCode htmlCode={buttonCode} />

---

export const buttonArrowCode = `<a href="#_" class="relative inline-flex items-center justify-start py-3 pl-4 pr-12 overflow-hidden font-semibold text-indigo-600 transition-all duration-150 ease-in-out rounded hover:pl-10 hover:pr-6 bg-gray-50 group">
    <span class="absolute bottom-0 left-0 w-full h-1 transition-all duration-150 ease-in-out bg-indigo-600 group-hover:h-full"></span>
    <span class="absolute right-0 pr-4 duration-200 ease-out group-hover:translate-x-12">
    <svg class="w-5 h-5 text-green-400" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14 5l7 7m0 0l-7 7m7-7H3"></path></svg>
    </span>
    <span class="absolute left-0 pl-2.5 -translate-x-12 group-hover:translate-x-0 ease-out duration-200">
    <svg class="w-5 h-5 text-green-400" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14 5l7 7m0 0l-7 7m7-7H3"></path></svg>
    </span>
    <span class="relative w-full text-left transition-colors duration-200 ease-in-out group-hover:text-white">Button Text</span>
</a>`

<DevCode htmlCode={buttonArrowCode} />

---

export const buttonBowtieCode = `<a href="#_" class="relative px-5 py-2 font-medium text-white group">
<span class="absolute inset-0 w-full h-full transition-all duration-300 ease-out transform translate-x-0 -skew-x-12 bg-cyan-500 group-hover:bg-cyan-700 group-hover:skew-x-12"></span>
<span class="absolute inset-0 w-full h-full transition-all duration-300 ease-out transform skew-x-12 bg-cyan-700 group-hover:bg-cyan-500 group-hover:-skew-x-12"></span>
<span class="absolute bottom-0 left-0 hidden w-10 h-20 transition-all duration-100 ease-out transform -translate-x-8 translate-y-10 bg-cyan-600 -rotate-12"></span>
<span class="absolute bottom-0 right-0 hidden w-10 h-20 transition-all duration-100 ease-out transform translate-x-10 translate-y-8 bg-cyan-400 -rotate-12"></span>
<span class="relative">Button Text</span>
</a>`;

<DevCode htmlCode={buttonBowtieCode} />

---

export const buttonShutterCode = `<button class="rounded-md px-3.5 py-2 m-1 overflow-hidden relative group cursor-pointer border-2 font-medium border-cyan-600 text-cyan-600 text-white">
<span class="absolute w-64 h-0 transition-all duration-300 origin-center rotate-45 -translate-x-20 bg-cyan-600 top-1/2 group-hover:h-64 group-hover:-translate-y-32 ease"></span>
<span class="relative text-cyan-600 transition duration-300 group-hover:text-white ease">Button Text</span>
</button>`;

<DevCode htmlCode={buttonShutterCode} />

---

export const buttonGradientGlowCode = `<a href="#_" class="px-5 py-2.5 relative rounded group font-medium !text-white font-medium inline-block">
<span class="absolute top-0 left-0 w-full h-full rounded opacity-50 filter blur-sm bg-gradient-to-br from-cyan-600 to-cyan-400"></span>
<span class="h-full w-full inset-0 absolute mt-0.5 ml-0.5 bg-gradient-to-br filter group-active:opacity-0 rounded opacity-50 from-cyan-600 to-cyan-400"></span>
<span class="absolute inset-0 w-full h-full transition-all duration-200 ease-out rounded shadow-xl bg-gradient-to-br filter group-active:opacity-0 group-hover:blur-sm from-cyan-600 to-cyan-400"></span>
<span class="absolute inset-0 w-full h-full transition duration-200 ease-out rounded bg-gradient-to-br to-cyan-600 from-cyan-300"></span>
<span class="relative">Button Text</span>
</a>`;

<DevCode htmlCode={buttonGradientGlowCode} />

---

export const buttonWindowShutterCode = `<a href="#_" class="px-5 py-2.5 relative rounded group overflow-hidden font-medium bg-cyan-50 text-cyan-600 inline-block">
<span class="absolute top-0 left-0 flex w-full h-0 mb-0 transition-all duration-200 ease-out transform translate-y-0 bg-cyan-600 group-hover:h-full opacity-90"></span>
<span class="relative group-hover:text-white">Button Text</span>
</a>`;

<DevCode htmlCode={buttonWindowShutterCode} />


---

export const buttonFocusRippleCode = `<button class="overflow-hidden rounded relative inline-flex group items-center justify-center px-3.5 py-2 m-1 cursor-pointer border-b-4 border-l-2 active:border-cyan-600 active:shadow-none shadow-lg bg-gradient-to-tr from-cyan-600 to-cyan-500 border-cyan-700 text-white">
<span class="absolute w-0 h-0 transition-all duration-300 ease-out bg-white rounded-full group-hover:w-32 group-hover:h-32 opacity-10"></span>
<span class="relative">Button Text</span>
</button>`;

<DevCode htmlCode={buttonFocusRippleCode} />

---

export const buttonSVGFocusCode = `<a href="#_" class="inline-flex overflow-hidden text-white bg-gray-900 rounded group">
<span class="px-3.5 py-2 text-white bg-cyan-500 group-hover:bg-cyan-600 flex items-center justify-center">
<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M16 11V7a4 4 0 00-8 0v4M5 9h14l1 12H4L5 9z"></path></svg>
</span>
<span class="pl-4 pr-5 py-2.5">Button Text</span>
</a>`;

<DevCode htmlCode={buttonSVGFocusCode} />

---

export const buttonWinkCode = `<button class="relative inline-flex items-center px-12 py-3 overflow-hidden text-lg font-medium text-cyan-600 border-2 border-cyan-600 rounded-full hover:text-white group hover:bg-transparent">
<span class="absolute left-0 block w-full h-0 transition-all bg-cyan-600 opacity-100 group-hover:h-full top-1/2 group-hover:top-0 duration-400 ease"></span>
<span class="absolute right-0 flex items-center justify-start w-10 h-10 duration-300 transform translate-x-full group-hover:translate-x-0 ease">
<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14 5l7 7m0 0l-7 7m7-7H3"></path></svg>
</span>
<span class="relative">Button Text</span>
</button>`;

<DevCode htmlCode={buttonWinkCode} />

---

export const buttonAugmentedCode = `<a href="#_" class="relative px-6 py-3 font-bold text-black group">
<span class="absolute inset-0 w-full h-full transition duration-300 ease-out transform -translate-x-2 -translate-y-2 bg-cyan-300 group-hover:translate-x-0 group-hover:translate-y-0"></span>
<span class="absolute inset-0 w-full h-full border-4 border-black"></span>
<span class="relative">Button Text</span>
</a>`

<DevCode htmlCode={buttonAugmentedCode} />

---

export const buttonBladeCode = `<button class="relative rounded px-5 py-2.5 overflow-hidden group bg-cyan-500 relative hover:bg-gradient-to-r hover:from-cyan-500 hover:to-cyan-400 text-white hover:ring-2 hover:ring-offset-2 hover:ring-cyan-400 transition-all ease-out duration-300">
<span class="absolute right-0 w-8 h-32 -mt-12 transition-all duration-1000 transform translate-x-12 bg-white opacity-10 rotate-12 group-hover:-translate-x-40 ease"></span>
<span class="relative">Button Text</span>
</button>`

<DevCode htmlCode={buttonBladeCode} />

---

export const buttonGradientShiftCode = `<a href="#_" class="relative inline-flex items-center justify-center p-4 px-5 py-3 overflow-hidden font-medium text-indigo-600 transition duration-300 ease-out rounded-full shadow-xl group hover:ring-1 hover:ring-cyan-500">
<span class="absolute inset-0 w-full h-full bg-gradient-to-br from-cyan-600 via-yellow-600 to-cyan-700"></span>
<span class="absolute bottom-0 right-0 block w-64 h-64 mb-32 mr-4 transition duration-500 origin-bottom-left transform rotate-45 translate-x-24 bg-cyan-500 rounded-full opacity-30 group-hover:rotate-90 ease"></span>
<span class="relative text-white">Button Text</span>
</a>`;

<DevCode htmlCode={buttonGradientShiftCode} />

---

export const buttonSimpleSVGCode = `<button class="overflow-hidden relative px-10 py-3 font-medium text-white transition duration-300 bg-cyan-400 rounded-md hover:bg-cyan-500 ease">
<span class="absolute bottom-0 left-0 h-full -ml-2">
<svg viewBox="0 0 487 487" class="w-auto h-full opacity-100 object-stretch" xmlns="http://www.w3.org/2000/svg"><path d="M0 .3c67 2.1 134.1 4.3 186.3 37 52.2 32.7 89.6 95.8 112.8 150.6 23.2 54.8 32.3 101.4 61.2 149.9 28.9 48.4 77.7 98.8 126.4 149.2H0V.3z" fill="#FFF" fill-rule="nonzero" fill-opacity=".1"></path></svg>
</span>
<span class="absolute top-0 right-0 w-12 h-full -mr-3">
<svg viewBox="0 0 487 487" class="object-cover w-full h-full" xmlns="http://www.w3.org/2000/svg"><path d="M487 486.7c-66.1-3.6-132.3-7.3-186.3-37s-95.9-85.3-126.2-137.2c-30.4-51.8-49.3-99.9-76.5-151.4C70.9 109.6 35.6 54.8.3 0H487v486.7z" fill="#FFF" fill-rule="nonzero" fill-opacity=".1"></path></svg>
</span>
<span class="relative">Button Text</span>
</button>`;

<DevCode htmlCode={buttonSimpleSVGCode} />

---

export const buttonShutterComplexCode = `<button class="relative px-5 py-3 overflow-hidden font-medium text-gray-600 bg-gray-100 border border-gray-100 rounded-lg shadow-inner group">
<span class="absolute top-0 left-0 w-0 h-0 transition-all duration-200 border-t-2 border-gray-600 group-hover:w-full ease"></span>
<span class="absolute bottom-0 right-0 w-0 h-0 transition-all duration-200 border-b-2 border-gray-600 group-hover:w-full ease"></span>
<span class="absolute top-0 left-0 w-full h-0 transition-all duration-300 delay-200 bg-gray-600 group-hover:h-full ease"></span>
<span class="absolute bottom-0 left-0 w-full h-0 transition-all duration-300 delay-200 bg-gray-600 group-hover:h-full ease"></span>
<span class="absolute inset-0 w-full h-full duration-300 delay-300 bg-gray-900 opacity-0 group-hover:opacity-100"></span>
<span class="relative transition-colors duration-300 delay-200 group-hover:text-white ease">Button Text</span>
</button>`;

<DevCode htmlCode={buttonShutterComplexCode} />

---

export const buttonSimpleSVG2Code = `<button class="box-border relative z-30 inline-flex items-center justify-center w-auto px-8 py-3 overflow-hidden font-bold text-white transition-all duration-300 bg-indigo-600 rounded-md cursor-pointer group ring-offset-2 ring-1 ring-indigo-300 ring-offset-indigo-200 hover:ring-offset-indigo-500 ease focus:outline-none">
<span class="absolute bottom-0 right-0 w-8 h-20 -mb-8 -mr-5 transition-all duration-300 ease-out transform rotate-45 translate-x-1 bg-white opacity-10 group-hover:translate-x-0"></span>
<span class="absolute top-0 left-0 w-20 h-8 -mt-1 -ml-12 transition-all duration-300 ease-out transform -rotate-45 -translate-x-1 bg-white opacity-10 group-hover:translate-x-0"></span>
<span class="relative z-20 flex items-center text-sm">
<svg class="relative w-5 h-5 mr-2 text-white" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"></path></svg>
Button Text
</span>
</button>`;

<DevCode htmlCode={buttonSimpleSVG2Code} />

---

export const buttonSimpleCode = `<button class="relative z-30 inline-flex items-center justify-center w-auto px-8 py-3 overflow-hidden font-bold text-gray-500 transition-all duration-500 border border-gray-200 rounded-md cursor-pointer group ease bg-gradient-to-b from-white to-gray-50 hover:from-gray-50 hover:to-white active:to-white">
<span class="w-full h-0.5 absolute bottom-0 group-active:bg-transparent left-0 bg-gray-100"></span>
<span class="h-full w-0.5 absolute bottom-0 group-active:bg-transparent right-0 bg-gray-100"></span>
Button Text
</button>`;

<DevCode htmlCode={buttonSimpleCode} />

---

export const buttonAugmentedSimpleCode = `<button class="relative inline-block px-4 py-2 font-medium group">
<span class="absolute inset-0 w-full h-full transition duration-200 ease-out transform translate-x-1 translate-y-1 bg-black group-hover:-translate-x-0 group-hover:-translate-y-0"></span>
<span class="absolute inset-0 w-full h-full bg-white border-2 border-black group-hover:bg-black"></span>
<span class="relative text-black group-hover:text-white">Button Text</span>
</button>`;

<DevCode htmlCode={buttonAugmentedSimpleCode} />

---

export const buttonHiddenSVGCode = `<a href="#_" class="relative inline-flex items-center justify-center p-4 px-6 py-3 overflow-hidden font-medium text-cyan-600 transition duration-300 ease-out border-2 border-cyan-500 rounded-full shadow-md group">
<span class="absolute inset-0 flex items-center justify-center w-full h-full text-white duration-300 -translate-x-full bg-cyan-500 group-hover:translate-x-0 ease">
<svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14 5l7 7m0 0l-7 7m7-7H3"></path></svg>
</span>
<span class="absolute flex items-center justify-center w-full h-full text-cyan-500 transition-all duration-300 transform group-hover:translate-x-full ease">Button Text</span>
<span class="relative invisible">Button Text</span>
</a>`;

<DevCode htmlCode={buttonHiddenSVGCode} />

---

export const buttonSwirlCode = `<a href="#_" class="relative inline-flex items-center justify-center inline-block p-4 px-5 py-3 overflow-hidden font-medium text-cyan-600 rounded-lg shadow-2xl group">
<span class="absolute top-0 left-0 w-40 h-40 -mt-10 -ml-3 transition-all duration-700 bg-red-500 rounded-full blur-md ease"></span>
<span class="absolute inset-0 w-full h-full transition duration-700 group-hover:rotate-180 ease">
<span class="absolute bottom-0 left-0 w-24 h-24 -ml-10 bg-cyan-500 rounded-full blur-md"></span>
<span class="absolute bottom-0 right-0 w-24 h-24 -mr-10 bg-pink-500 rounded-full blur-md"></span>
</span>
<span class="relative text-white">Button Text</span>
</a>`;

<DevCode htmlCode={buttonSwirlCode} />

---

export const buttonCouponCode = `<a href="#_" class="relative inline-flex items-center justify-start px-6 py-3 overflow-hidden font-medium transition-all bg-red-500 rounded-xl group">
<span class="absolute top-0 right-0 inline-block w-4 h-4 transition-all duration-500 ease-in-out bg-red-700 rounded group-hover:-mr-4 group-hover:-mt-4">
<span class="absolute top-0 right-0 w-5 h-5 rotate-45 translate-x-1/2 -translate-y-1/2 bg-white"></span>
</span>
<span class="absolute bottom-0 left-0 w-full h-full transition-all duration-500 ease-in-out delay-200 -translate-x-full translate-y-full bg-red-600 rounded-2xl group-hover:mb-12 group-hover:translate-x-0"></span>
<span class="relative w-full text-left text-white transition-colors duration-200 ease-in-out group-hover:text-white">Button Text</span>
</a>`

<DevCode htmlCode={buttonCouponCode} />

---

export const buttonDarkAugmentCode = `<button class="relative px-6 py-3 font-bold text-white rounded-lg group">
<span class="absolute inset-0 w-full h-full transition duration-300 transform -translate-x-1 -translate-y-1 bg-cyan-600 ease opacity-80 group-hover:translate-x-0 group-hover:translate-y-0"></span>
<span class="absolute inset-0 w-full h-full transition duration-300 transform translate-x-1 translate-y-1 bg-orange-600 ease opacity-80 group-hover:translate-x-0 group-hover:translate-y-0 mix-blend-screen"></span>
<span class="relative">Button Text</span>
</button>`;

<DevCode htmlCode={buttonDarkAugmentCode} />

---

export const buttonBlackToColorCode = `<a href="#_" class="relative inline-flex items-center justify-center px-6 py-3 overflow-hidden font-bold text-white rounded-md shadow-2xl group">
<span class="absolute inset-0 w-full h-full transition duration-300 ease-out opacity-0 bg-gradient-to-br from-red-600 via-orange-700 to-cyan-400 group-hover:opacity-100"></span>
<!-- Top glass gradient -->
<span class="absolute top-0 left-0 w-full bg-gradient-to-b from-white to-transparent opacity-5 h-1/3"></span>
<!-- Bottom gradient -->
<span class="absolute bottom-0 left-0 w-full h-1/3 bg-gradient-to-t from-white to-transparent opacity-5"></span>
<!-- Left gradient -->
<span class="absolute bottom-0 left-0 w-4 h-full bg-gradient-to-r from-white to-transparent opacity-5"></span>
<!-- Right gradient -->
<span class="absolute bottom-0 right-0 w-4 h-full bg-gradient-to-l from-white to-transparent opacity-5"></span>
<span class="absolute inset-0 w-full h-full border border-white rounded-md opacity-10"></span>
<span class="absolute w-0 h-0 transition-all duration-300 ease-out bg-white rounded-full group-hover:w-56 group-hover:h-56 opacity-5"></span>
<span class="relative">Button Text</span>
</a>`;

<DevCode htmlCode={buttonBlackToColorCode} />

---

export const buttonBlackGradientFlow = `<a href="#_" class="relative p-0.5 inline-flex items-center justify-center font-bold overflow-hidden group rounded-md">
<span class="w-full h-full bg-gradient-to-br from-[#ff8a05] via-[#ff5478] to-[#ff00c6] group-hover:from-[#ff00c6] group-hover:via-[#ff5478] group-hover:to-[#ff8a05] absolute"></span>
<span class="relative px-6 py-3 transition-all ease-out bg-gray-900 rounded-md group-hover:bg-opacity-0 duration-400">
<span class="relative text-white">Button Text</span>
</span>
</a>`;

<DevCode htmlCode={buttonBlackGradientFlow} />

---

export const buttonDarkSlashCode = `<a href="#_" class="relative inline-flex items-center justify-start inline-block px-5 py-3 overflow-hidden font-bold rounded-full group">
<span class="w-32 h-32 rotate-45 translate-x-12 -translate-y-2 absolute left-0 top-0 bg-white opacity-[3%]"></span>
<span class="absolute top-0 left-0 w-48 h-48 -mt-1 transition-all duration-500 ease-in-out rotate-45 -translate-x-56 -translate-y-24 bg-white opacity-100 group-hover:-translate-x-8"></span>
<span class="relative w-full text-left text-white transition-colors duration-200 ease-in-out group-hover:text-gray-900">Button Text</span>
<span class="absolute inset-0 border-2 border-white rounded-full"></span>
</a>`;


<DevCode htmlCode={buttonDarkSlashCode} />

---


export const buttonDarkZoneCode = `<a href="#_" class="relative inline-flex items-center justify-start inline-block px-5 py-3 overflow-hidden font-medium transition-all bg-cyan-600 rounded-full hover:bg-white group">
<span class="absolute inset-0 border-0 group-hover:border-[25px] ease-linear duration-100 transition-all border-white rounded-full"></span>
<span class="relative w-full text-left text-white transition-colors duration-200 ease-in-out group-hover:text-cyan-600">Button Text</span>
</a>`;

<DevCode htmlCode={buttonDarkZoneCode} />

---

export const buttonDarkCouponCode = `<button class="relative inline-flex items-center justify-start px-6 py-3 overflow-hidden font-medium transition-all bg-white rounded hover:bg-white group">
<span class="w-48 h-48 rounded rotate-[-40deg] bg-cyan-600 absolute bottom-0 left-0 -translate-x-full ease-out duration-500 transition-all translate-y-full mb-9 ml-9 group-hover:ml-0 group-hover:mb-32 group-hover:translate-x-0"></span>
<span class="relative w-full text-left text-black transition-colors duration-300 ease-in-out group-hover:text-white">Button Text</span>
</button>`;

<DevCode htmlCode={buttonDarkCouponCode} />

---

export const buttonDarkAugmentSimpleCode = `<a href="#_" class="relative inline-flex items-center justify-center px-6 py-3 text-lg font-medium tracking-tighter text-white bg-gray-800 rounded-md group">
<span class="absolute inset-0 w-full h-full mt-1 ml-1 transition-all duration-300 ease-in-out bg-cyan-600 rounded-md group-hover:mt-0 group-hover:ml-0"></span>
<span class="absolute inset-0 w-full h-full bg-white rounded-md "></span>
<span class="absolute inset-0 w-full h-full transition-all duration-200 ease-in-out delay-100 bg-cyan-600 rounded-md opacity-0 group-hover:opacity-100 "></span>
<span class="relative text-cyan-600 transition-colors duration-200 ease-in-out delay-100 group-hover:text-white">Button Text</span>
</a>`;

<DevCode htmlCode={buttonDarkAugmentSimpleCode} />

---

export const buttonPopScopeCode = `<button class="relative inline-flex items-center justify-center px-10 py-4 overflow-hidden font-mono font-medium tracking-tighter text-white bg-gray-800 rounded-lg group">
<span class="absolute w-0 h-0 transition-all duration-500 ease-out bg-cyan-500 rounded-full group-hover:w-56 group-hover:h-56"></span>
<span class="absolute inset-0 w-full h-full -mt-1 rounded-lg opacity-30 bg-gradient-to-b from-transparent via-transparent to-gray-700"></span>
<span class="relative">Button Text</span>
</button>`;

<DevCode htmlCode={buttonPopScopeCode} />

---


export const buttonNeonGlowCode = `<a href="#_" class="relative inline-flex items-center justify-center px-6 py-3 font-medium text-white transition-all duration-300 bg-cyan-600 rounded-full group">
    <span class="absolute inset-0 w-full h-full transition-all duration-300 ease-in-out bg-gradient-to-br from-cyan-600 to-cyan-400 rounded-full blur-md opacity-75 group-hover:blur-none group-hover:opacity-100"></span>
    <span class="relative">Button Text</span>
</a>`;

<DevCode htmlCode={buttonNeonGlowCode} />

---


export const buttonGlassmorphismCode = `<a href="#_" class="relative inline-flex items-center justify-center px-8 py-3 font-semibold text-white transition-all duration-300 bg-transparent border border-white rounded-lg backdrop-filter backdrop-blur-lg bg-opacity-10 border-opacity-30 hover:bg-opacity-30 hover:border-opacity-100">
    <span class="absolute inset-0 w-full h-full transition-all duration-300 ease-in-out bg-gradient-to-r from-cyan-400 to-cyan-600 opacity-50 blur-md rounded-lg group-hover:opacity-100"></span>
    <span class="relative">Button Text</span>
</a>`;

<DevCode htmlCode={buttonGlassmorphismCode} />

<Aside>
This button utilizes a glassmorphism effect with a subtle background blur and gradient overlay that intensifies on hover.
</Aside>

---


export const buttonHolographicCode = `<button class="relative inline-flex items-center justify-center px-8 py-3 font-semibold text-white transition-transform duration-300 bg-gradient-to-r from-cyan-500 via-red-500 to-yellow-500 rounded-lg shadow-lg hover:shadow-xl hover:scale-105 hover:rotate-2">
    <span class="absolute inset-0 w-full h-full bg-[radial-gradient(ellipse_at_top_left,_var(--tw-gradient-stops))] from-red-500 via-red-500 to-cyan-500 opacity-70 blur-xl"></span>
    <span class="absolute inset-0 w-full h-full transition-opacity duration-300 bg-white opacity-0 group-hover:opacity-10"></span>
    <span class="relative z-10">Button Text</span>
</button>`;

<DevCode htmlCode={buttonHolographicCode} />

<Aside>
This button features a holographic gradient effect with a radial blur that enhances the button’s vibrant colors and adds a dynamic visual appeal on hover. The button also includes a scaling and slight rotation effect when hovered to give it a more engaging and interactive look.
</Aside>

---

#### Simple Buttons

The everyday workhorses — solid fills and outlines for forms and toolbars.

export const buttonSolidsCode = `<div class="flex flex-wrap items-center gap-3 p-8 bg-gray-50">
  <button class="px-4 py-2 text-sm font-medium rounded-md text-blue-700 bg-blue-100 hover:bg-blue-200">Subtle</button>
  <button class="px-4 py-2 text-sm font-medium text-white border border-blue-600 rounded-md bg-blue-600 hover:bg-blue-700">Primary</button>
  <button class="px-4 py-2 text-sm font-medium text-gray-700 rounded-md bg-gray-200 hover:bg-gray-300">Neutral</button>
  <button class="px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md hover:bg-gray-50">Outline</button>
  <button class="px-4 py-2 text-sm font-medium text-white rounded-md bg-gray-800 hover:bg-gray-700">Charcoal</button>
  <button class="px-4 py-2 text-sm font-medium text-white border-0 rounded-md bg-gradient-to-tr from-indigo-600 to-indigo-500 hover:to-indigo-400">Gradient</button>
  <button disabled class="px-4 py-2 text-sm font-medium text-white rounded-md cursor-not-allowed bg-blue-600 opacity-50">Disabled</button>
</div>`;

<DevCode htmlCode={buttonSolidsCode} />

#### Call-to-Action Buttons

export const buttonCtaCode = `<div class="flex flex-wrap items-center gap-3 p-8 bg-gray-50">
  <button class="inline-flex items-center gap-2 px-5 py-2.5 text-sm font-semibold text-white rounded-lg bg-green-600 hover:bg-green-700">
    Get Started
    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14 5l7 7m0 0l-7 7m7-7H3"></path></svg>
  </button>
  <button class="inline-flex items-center gap-2 px-5 py-2.5 text-sm font-semibold text-white rounded-lg bg-gradient-to-r from-indigo-600 to-indigo-500 hover:from-indigo-500 hover:to-indigo-400">
    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"></path></svg>
    Upgrade
  </button>
</div>`;

<DevCode htmlCode={buttonCtaCode} />

#### Pills & Circles

export const buttonPillsCode = `<div class="flex flex-wrap items-center gap-3 p-8 bg-gray-900">
  <button class="px-5 py-2 text-sm font-medium text-white rounded-full bg-blue-600 hover:bg-blue-700">Blue Pill</button>
  <button class="px-5 py-2 text-sm font-medium text-white transition-colors bg-transparent border border-white rounded-full hover:bg-white hover:text-gray-900">Outline Pill</button>
  <button class="flex items-center justify-center w-10 h-10 text-white transition-colors border border-gray-500 rounded-full hover:bg-white hover:text-gray-900" aria-label="Add">+</button>
  <button class="flex items-center justify-center w-10 h-10 text-white rounded-full bg-cyan-600 hover:bg-cyan-500" aria-label="Search">
    <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"></path></svg>
  </button>
</div>`;

<DevCode htmlCode={buttonPillsCode} />

#### Full-Width Buttons

Responsive blocks for mobile and form footers.

export const buttonFullWidthCode = `<div class="max-w-sm p-8 mx-auto space-y-3 bg-gray-50">
  <button class="w-full py-2.5 text-sm font-semibold text-white rounded-lg bg-indigo-600 hover:bg-indigo-700">Continue</button>
  <button class="w-full py-2.5 text-sm font-semibold text-white rounded-lg bg-green-600 hover:bg-green-700">Sign Up Free</button>
  <button class="w-full py-2.5 text-sm font-semibold text-gray-700 bg-white border border-gray-300 rounded-lg hover:bg-gray-50">Cancel</button>
</div>`;

<DevCode htmlCode={buttonFullWidthCode} />

#### Button Group

export const buttonGroupCode = `<div class="flex p-8 bg-gray-50">
  <button class="px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-l-md hover:bg-gray-50">Left</button>
  <button class="px-4 py-2 -ml-px text-sm font-medium text-gray-700 bg-white border border-gray-300 hover:bg-gray-50">Center</button>
  <button class="px-4 py-2 -ml-px text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-r-md hover:bg-gray-50">Right</button>
</div>`;

<DevCode htmlCode={buttonGroupCode} />

<Aside>
The button gallery covers the full [DevDojo Tailwind button set](https://devdojo.com/tailwindcss/buttons) — animated hover effects above, plus these simple solids, pills, full-width blocks and groups for everyday UI.
</Aside>

#### Sizes

One scale, five steps — adjust padding and text size together.

export const buttonSizesCode = `<div class="flex flex-wrap items-center gap-3 p-8 bg-gray-50">
  <button class="px-2 py-1 text-xs font-medium text-white rounded bg-cyan-600 hover:bg-cyan-700">XS</button>
  <button class="px-3 py-1.5 text-sm font-medium text-white rounded-md bg-cyan-600 hover:bg-cyan-700">SM</button>
  <button class="px-4 py-2 text-sm font-medium text-white rounded-md bg-cyan-600 hover:bg-cyan-700">MD</button>
  <button class="px-5 py-2.5 text-base font-medium text-white rounded-lg bg-cyan-600 hover:bg-cyan-700">LG</button>
  <button class="px-6 py-3 text-lg font-medium text-white rounded-lg bg-cyan-600 hover:bg-cyan-700">XL</button>
</div>`;

<DevCode htmlCode={buttonSizesCode} />

#### Soft & Ghost

Low-emphasis variants for secondary actions.

export const buttonGhostCode = `<div class="flex flex-wrap items-center gap-3 p-8 bg-gray-50">
  <button class="px-4 py-2 text-sm font-medium rounded-md text-cyan-700 bg-cyan-50 hover:bg-cyan-100">Soft</button>
  <button class="px-4 py-2 text-sm font-medium rounded-md text-cyan-700 hover:bg-cyan-50">Ghost</button>
  <button class="px-4 py-2 text-sm font-medium underline rounded-md text-cyan-700 underline-offset-2 hover:text-cyan-900">Link</button>
  <button class="px-4 py-2 text-sm font-medium text-red-700 rounded-md bg-red-50 hover:bg-red-100">Danger Soft</button>
</div>`;

<DevCode htmlCode={buttonGhostCode} />

#### Loading

A spinner swaps in while an action is in flight; the button stays disabled.

export const buttonLoadingCode = `<style>
@keyframes kbve-btnspin { to { transform: rotate(360deg); } }
.kbve-btnspin { animation: kbve-btnspin 0.6s linear infinite; }
</style>
<div class="flex flex-wrap items-center gap-3 p-8 bg-gray-50">
  <button disabled class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium text-white rounded-md cursor-wait bg-cyan-600 opacity-80">
    <span class="kbve-btnspin w-4 h-4 border-2 border-white rounded-full border-t-transparent"></span>
    Saving…
  </button>
  <button disabled class="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-md cursor-wait">
    <span class="kbve-btnspin w-4 h-4 border-2 rounded-full border-gray-400 border-t-transparent"></span>
    Loading
  </button>
</div>`;

<DevCode htmlCode={buttonLoadingCode} />

#### 3D Pressable

A hard bottom shadow that collapses on click — the button physically depresses.

export const button3dCode = `<div class="flex flex-wrap items-center gap-4 p-8 bg-gray-50">
  <button class="px-5 py-2.5 font-semibold text-white rounded-lg bg-cyan-500 shadow-[0_5px_0_#0e7490] active:translate-y-1 active:shadow-[0_1px_0_#0e7490] transition-all">Press</button>
  <button class="px-5 py-2.5 font-semibold text-gray-900 rounded-lg bg-amber-400 shadow-[0_5px_0_#b45309] active:translate-y-1 active:shadow-[0_1px_0_#b45309] transition-all">Tap</button>
</div>`;

<DevCode htmlCode={button3dCode} />

#### Gradient Border

A gradient ring around a solid core — padding-box vs border-box trick, done here with a wrapper.

export const buttonGradBorderCode = `<div class="flex flex-wrap items-center gap-4 p-8 bg-gray-900">
  <button class="p-0.5 rounded-lg bg-gradient-to-r from-cyan-400 to-fuchsia-500 group">
    <span class="block px-5 py-2 text-sm font-semibold text-white rounded-md bg-gray-900 group-hover:bg-transparent">Gradient Ring</span>
  </button>
  <button class="p-0.5 rounded-full bg-gradient-to-r from-amber-400 via-red-500 to-fuchsia-500">
    <span class="block px-5 py-2 text-sm font-semibold text-white rounded-full bg-gray-900">Pill Ring</span>
  </button>
</div>`;

<DevCode htmlCode={buttonGradBorderCode} />

#### Social Login

export const buttonSocialCode = `<div class="max-w-xs p-8 mx-auto space-y-3 bg-gray-50">
  <button class="flex items-center justify-center w-full gap-2 py-2.5 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded-lg hover:bg-gray-50">
    <svg class="w-5 h-5" viewBox="0 0 24 24"><path fill="#4285F4" d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 0 1-2.2 3.32v2.77h3.57c2.08-1.92 3.27-4.74 3.27-8.1z"/><path fill="#34A853" d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84A11 11 0 0 0 12 23z"/><path fill="#FBBC05" d="M5.84 14.1a6.6 6.6 0 0 1 0-4.2V7.06H2.18a11 11 0 0 0 0 9.88l3.66-2.84z"/><path fill="#EA4335" d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1A11 11 0 0 0 2.18 7.06l3.66 2.84C6.71 7.31 9.14 5.38 12 5.38z"/></svg>
    Continue with Google
  </button>
  <button class="flex items-center justify-center w-full gap-2 py-2.5 text-sm font-medium text-white rounded-lg bg-gray-900 hover:bg-gray-800">
    <svg class="w-5 h-5" fill="currentColor" viewBox="0 0 24 24"><path d="M12 .5C5.37.5 0 5.78 0 12.29c0 5.2 3.44 9.6 8.21 11.16.6.1.82-.25.82-.56v-2c-3.34.71-4.04-1.58-4.04-1.58-.55-1.36-1.33-1.72-1.33-1.72-1.09-.73.08-.72.08-.72 1.2.08 1.84 1.21 1.84 1.21 1.07 1.8 2.81 1.28 3.5.98.1-.76.42-1.28.76-1.57-2.67-.3-5.47-1.31-5.47-5.84 0-1.29.47-2.35 1.24-3.18-.13-.29-.54-1.5.11-3.12 0 0 1.01-.32 3.3 1.21a11.5 11.5 0 0 1 6 0c2.29-1.53 3.3-1.21 3.3-1.21.65 1.62.24 2.83.12 3.12.77.83 1.23 1.89 1.23 3.18 0 4.54-2.81 5.53-5.49 5.83.43.37.81 1.1.81 2.22v3.29c0 .31.22.67.83.56A12.02 12.02 0 0 0 24 12.29C24 5.78 18.63.5 12 .5z"/></svg>
    Continue with GitHub
  </button>
  <button class="flex items-center justify-center w-full gap-2 py-2.5 text-sm font-medium text-white rounded-lg bg-indigo-500 hover:bg-indigo-600">
    <svg class="w-5 h-5" fill="currentColor" viewBox="0 0 24 24"><path d="M20.32 4.37A19.8 19.8 0 0 0 15.45 3a13.9 13.9 0 0 0-.62 1.27 18.3 18.3 

[…truncated, full source at MDX]

---
# CubeJS

> CubeJS is a headless business intelligence application for various forms of data, including SQL, Mongo and Snowflake. CubeJS can be extended to external data warehouses, such as, Google BigQuery, Amazon Athena and Presto.

Source: https://kbve.com/application/cubejs/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';


## Information

If you are looking for a powerful and flexible framework to build amazing data applications, you should check out CubeJS.
CubeJS is an open source project that lets you connect to any SQL-based data source, define your data models in a simple and consistent way, and expose them to your applications via blazing-fast APIs.
Whether you want to create an internal dashboard for your business insights, or a customer-facing analytics feature for your product, CubeJS has you covered.
CubeJS supports REST, [SQL](/application/sql/), and GraphQL APIs, so you can choose the best option for your needs.
CubeJS also integrates seamlessly with popular data visualization tools, such as D3.js, Google Charts, Highcharts, and more.
This documentation will have plenty of tutorials, examples, and demos that will help you get started and inspired.

<Adsense />

## Install

There are several ways to install CubeJS, including using it as a SaaS via CubeJS Cloud.
We will go over a couple ways in this reference document.

### Docker

There are a couple ways that we can deploy CubeJS via Docker, including dev mode and swarm.

These following commands will run CubeJS in a docker container and expose it on port 4000 / 3000.
Furthermore, it will also mount the current directory as a volume for CubeJS configuration and schema files.

```shell
docker run -d -p 3000:3000 -p 4000:4000 \
  -e CUBEJS_DB_HOST=postgres://hostname \
  -e CUBEJS_DB_NAME=<DB_NAME> \
  -e CUBEJS_DB_USER=<USER> \
  -e CUBEJS_DB_PASS=<PASS> \
  -e CUBEJS_DB_TYPE=<DB_TYPE> \
  -e CUBEJS_API_SECRET=<API_SECRET> \
  -v $(pwd):/cube/conf \
  cubejs/cube:latest
```

To enable dev mode, pass along the environmental variable `-e CUBEJS_DEV_MODE=true \` inside of the command.

For the Docker Swarm, we recommend that you deploy a CubeJS Docker Compose via Portainer or your swarm platform of choice.

### NodeJS

> Reference to additional [NodeJS docs](/application/javascript/#nodejs)

For installing via NodeJS, we recommend you install cubejs-cli using npm or yarn, which are tools that help you manage JavaScript packages. You can run this command in your terminal:

-   NPM

```shell
npm install -g cubejs-cli
```

-   YARN

```shell
yarn add cubejs-cli
```

After the installation, we recommend that you launch a test case.

Create a new CubeJS project using cubejs create command.
You need to specify the name of your project and the type of your data source.
For example, if you want to use Postgres, which is a database system, you can run this command:

```shell
cubejs create dashboard-backend -d postgres
```

This will create a new folder with your project files and install the necessary dependencies.
You can then start your CubeJS server by running this command inside your project folder:

-   NPM

```shell
npm run dev
```

-   YARN

```shell
yarn dev
```

This will start your CubeJS test case server on `http://localhost:4000`.
You can then open this URL in your browser and follow the instructions to connect to your data source and start building your data model and queries.

---

## Update

To upgrade CubeJS, you need to update the version of the CubeJS package that you are using.
There are different ways to do that, depending on how you installed CubeJS.

### Update Docker

If you are using Docker, you can upgrade CubeJS by pulling the latest image from the Docker Hub.
You can run this command in your terminal:

```shell
docker pull cubejs/cube:latest
```

### Update NodeJS

If you are using Node.js, you can upgrade CubeJS by updating the version of the `@cubejs-backend/server` or `@cubejs-backend/server-core` package in your `package.json` file.
You can also use npm or yarn to update the package. For example, you can run this command in your terminal:

-   NPM

```shell
npm update @cubejs-backend/server
```

-   YARN

```shell
yarn upgrade @cubejs-backend/server
```

---

## Data Schema

Cube.js uses a semantic layer called **Data Schema** to define metrics, dimensions, and relationships.
Schemas are written in JavaScript/TypeScript files inside the `schema/` directory.

### Cube Definition

A cube represents a table or view. Define measures (aggregations), dimensions (attributes), and joins (relationships).

```javascript
// schema/Orders.js
cube(`Orders`, {
  sql: `SELECT * FROM public.orders`,

  measures: {
    count: {
      type: `count`,
    },

    totalAmount: {
      sql: `amount`,
      type: `sum`,
    },

    averageAmount: {
      sql: `amount`,
      type: `avg`,
    },
  },

  dimensions: {
    id: {
      sql: `id`,
      type: `number`,
      primaryKey: true,
    },

    status: {
      sql: `status`,
      type: `string`,
    },

    createdAt: {
      sql: `created_at`,
      type: `time`,
    },

    userId: {
      sql: `user_id`,
      type: `number`,
    },
  },
});
```

### Joins

Link cubes via foreign keys for relational queries:

```javascript
// schema/Orders.js (continued)
cube(`Orders`, {
  // ... measures, dimensions

  joins: {
    Users: {
      sql: `${CUBE}.user_id = ${Users}.id`,
      relationship: `belongsTo`,
    },
  },
});
```

```javascript
// schema/Users.js
cube(`Users`, {
  sql: `SELECT * FROM public.users`,

  dimensions: {
    id: {
      sql: `id`,
      type: `number`,
      primaryKey: true,
    },

    email: {
      sql: `email`,
      type: `string`,
    },

    name: {
      sql: `name`,
      type: `string`,
    },
  },
});
```

### Pre-Aggregations

Pre-aggregations cache query results for faster response times:

```javascript
cube(`Orders`, {
  // ... measures, dimensions, joins

  preAggregations: {
    main: {
      measures: [CUBE.count, CUBE.totalAmount],
      dimensions: [CUBE.status, CUBE.createdAt],
      timeDimension: CUBE.createdAt,
      granularity: `day`,
      refreshKey: {
        every: `1 hour`,
      },
    },
  },
});
```

**Refresh strategies:**

- `every: '1 hour'` — refresh every hour
- `sql: 'SELECT MAX(updated_at) FROM orders'` — refresh when data changes
- `immutable: true` — never refresh (historical data)

---

## API Queries

Cube.js exposes REST, GraphQL, and SQL APIs. All APIs share the same query format.

### REST API

**Endpoint:** `POST /cubejs-api/v1/load`

**Request:**

```json
{
  "measures": ["Orders.count", "Orders.totalAmount"],
  "dimensions": ["Orders.status"],
  "timeDimensions": [
    {
      "dimension": "Orders.createdAt",
      "granularity": "day",
      "dateRange": ["2024-01-01", "2024-12-31"]
    }
  ],
  "filters": [
    {
      "member": "Orders.status",
      "operator": "equals",
      "values": ["shipped"]
    }
  ]
}
```

**Response:**

```json
{
  "data": [
    {
      "Orders.status": "shipped",
      "Orders.createdAt.day": "2024-01-15T00:00:00.000",
      "Orders.count": 42,
      "Orders.totalAmount": "12450.00"
    }
  ]
}
```

### Query Format

| Field | Type | Description |
|-------|------|-------------|
| `measures` | `string[]` | Aggregations (count, sum, avg, etc.) |
| `dimensions` | `string[]` | Attributes for grouping |
| `timeDimensions` | `object[]` | Time-based filters + granularity |
| `filters` | `object[]` | WHERE conditions |
| `segments` | `string[]` | Pre-defined filter sets |
| `order` | `object` | Sort order (`{ "Orders.createdAt": "desc" }`) |
| `limit` | `number` | Max rows returned |

### Filter Operators

| Operator | SQL Equivalent | Example Values |
|----------|----------------|----------------|
| `equals` | `=` | `["shipped"]` |
| `notEquals` | `!=` | `["cancelled"]` |
| `contains` | `LIKE '%val%'` | `["express"]` |
| `notContains` | `NOT LIKE '%val%'` | `["standard"]` |
| `gt` | `>` | `[100]` |
| `gte` | `>=` | `[100]` |
| `lt` | `<` | `[1000]` |
| `lte` | `<=` | `[1000]` |
| `inDateRange` | `BETWEEN` | `["2024-01-01", "2024-12-31"]` |
| `notInDateRange` | `NOT BETWEEN` | `["2024-01-01", "2024-12-31"]` |

### GraphQL API

Enable GraphQL in `cube.js`:

```javascript
module.exports = {
  graphql: {
    enabled: true,
  },
};
```

**Endpoint:** `POST /cubejs-api/graphql`

**Query:**

```graphql
query {
  cube(
    measures: ["Orders.count", "Orders.totalAmount"]
    dimensions: ["Orders.status"]
    timeDimensions: [
      {
        dimension: "Orders.createdAt"
        granularity: "day"
        dateRange: ["2024-01-01", "2024-12-31"]
      }
    ]
  ) {
    Orders {
      status
      createdAt {
        day
      }
      count
      totalAmount
    }
  }
}
```

---

## Security

### Multi-Tenancy

Use `SECURITY_CONTEXT` to filter data per user/tenant:

```javascript
// cube.js
module.exports = {
  contextToAppId: ({ securityContext }) => `APP_${securityContext.tenantId}`,

  scheduledRefreshContexts: async () => [
    { securityContext: { tenantId: 1 } },
    { securityContext: { tenantId: 2 } },
  ],
};
```

```javascript
// schema/Orders.js
cube(`Orders`, {
  sql: `SELECT * FROM public.orders WHERE tenant_id = ${SECURITY_CONTEXT.tenantId.unsafeValue()}`,
  // ...
});
```

### JWT Authentication

Protect API with JWT tokens:

```javascript
// cube.js
const jwt = require('jsonwebtoken');

module.exports = {
  checkAuth: async (req, auth) => {
    if (!auth) throw new Error('Missing authorization');

    try {
      const token = auth.replace('Bearer ', '');
      const payload = jwt.verify(token, process.env.CUBEJS_API_SECRET);
      req.securityContext = payload;
    } catch (e) {
      throw new Error('Invalid token');
    }
  },
};
```

**Client request:**

```bash
curl -H "Authorization: Bearer <JWT_TOKEN>" \
  -X POST https://your-cube-api.com/cubejs-api/v1/load \
  -d '{"measures": ["Orders.count"]}'
```

---

## Data Modeling Best Practices

### Star Schema

Organize cubes into fact tables (Orders, Events) and dimension tables (Users, Products).

**Fact table** (Orders) — transactional data with foreign keys:
- Measures: `count`, `totalAmount`, `averageAmount`
- Dimensions: `status`, `createdAt`, `userId`, `productId`

**Dimension tables** (Users, Products) — descriptive attributes:
- Users: `name`, `email`, `country`
- Products: `name`, `category`, `price`

**Joins** — connect fact to dimensions via foreign keys.

### Naming Conventions

- **Cubes:** PascalCase (e.g., `Orders`, `Users`)
- **Measures:** camelCase (e.g., `count`, `totalRevenue`)
- **Dimensions:** camelCase (e.g., `status`, `createdAt`)
- **Time dimensions:** always include `.type: 'time'`

### Performance Tips

- **Pre-aggregations** — cache frequently queried combinations
- **Partitioning** — partition pre-aggregations by time (`partitionGranularity: 'month'`)
- **Indexes** — index foreign keys and filter columns in your database
- **Refresh keys** — use `sql` refresh keys for incremental updates

---

## Configuration

### Environment Variables

Common env vars for `cube.js` or Docker:

| Variable | Description | Example |
|----------|-------------|---------|
| `CUBEJS_DB_TYPE` | Database type | `postgres`, `mysql`, `bigquery` |
| `CUBEJS_DB_HOST` | Database host | `localhost` |
| `CUBEJS_DB_NAME` | Database name | `analytics` |
| `CUBEJS_DB_USER` | Database user | `cube` |
| `CUBEJS_DB_PASS` | Database password | `secret` |
| `CUBEJS_API_SECRET` | JWT secret for auth | `random-string` |
| `CUBEJS_DEV_MODE` | Enable dev playground | `true` |
| `CUBEJS_CACHE_AND_QUEUE_DRIVER` | Cache backend | `redis`, `memory` |
| `REDIS_URL` | Redis connection string | `redis://localhost:6379` |

### External Database Drivers

Install drivers for non-standard sources:

```bash
# Google BigQuery
npm install @cubejs-backend/bigquery-driver

# AWS Athena
npm install @cubejs-backend/athena-driver

# Snowflake
npm install @cubejs-backend/snowflake-driver

# MongoDB
npm install @cubejs-backend/mongobi-driver
```

Update `cube.js`:

```javascript
module.exports = {
  dbType: 'bigquery',
  externalDriverFactory: () => require('@cubejs-backend/bigquery-driver')({
    projectId: process.env.CUBEJS_DB_BQ_PROJECT_ID,
    keyFilename: process.env.CUBEJS_DB_BQ_KEY_FILE,
  }),
};
```

---

## KBVE Integration

KBVE uses Cube.js as a unified semantic layer over multiple data sources:

- **ClickHouse** — analytics events, time-series metrics, logs
- **PostgreSQL** — transactional data (users, orders, sessions)
- **Cube Store** — cache layer for pre-aggregations and query results (default since v0.32+)

<Aside type="tip">
**About Cube Store:** Cube.js ships with **Cube Store**, an internal columnar database written in Rust that handles pre-aggregation storage, query caching, and job queuing. Cube Store replaced Redis entirely in v0.32 (2022) and is now the default - no external cache needed. Valkey/Redis cannot be used as Cube's cache layer.
</Aside>

<Aside type="note">
**Valkey for Other Services:** If you're using Valkey elsewhere in KBVE (session storage, app-level caching, rate limiting), that's separate. Cube.js **cannot** read from or write to external Redis/Valkey instances for its cache - it exclusively uses its own internal Cube Store.
</Aside>

### Architecture

```mermaid
graph TB
    Dashboard[Dashboard<br/>React/Astro]
    Cube[Cube.js API<br/>Port 4000]
    CubeStore[(Cube Store<br/>Pre-aggs Cache)]
    ClickHouse[(ClickHouse<br/>:8123<br/>Analytics)]
    Postgres[(Postgres<br/>:5432<br/>OLTP)]

    Dashboard -->|REST/GraphQL| Cube
    Cube --> CubeStore
    Cube --> ClickHouse
    Cube --> Postgres
```

### What is Cube Store?

**Cube Store** is a purpose-built columnar database engine that ships with Cube.js:

- **Written in Rust** — high performance, low memory footprint
- **Columnar storage** — optimized for analytical queries (aggregations, filters, grouping)
- **MySQL wire protocol** — communicates via port 3306 (same as MySQL)
- **Distributed architecture** — router + worker nodes for horizontal scaling
- **Built-in** — no separate installation needed, runs as part of the Cube.js deployment

**What Cube Store handles:**

1. **Pre-aggregation storage** — stores rolled-up data (daily counts, monthly sums, etc.)
2. **Query cache** — caches API responses for identical queries
3. **Job queue** — manages background refresh jobs for pre-aggregations

**How it works:**

```mermaid
graph LR
    CubeAPI[Cube API] -->|Read/Write| Router[Cube Store Router]
    Router -->|Distribute| W1[Worker 1]
    Router -->|Distribute| W2[Worker 2]
    W1 --> PVC1[(PVC Storage)]
    W2 --> PVC2[(PVC Storage)]
```

- **Router** — coordinates queries, manages metadata (1 replica)
- **Workers** — store and query pre-aggregation data (2+ replicas)
- **Communication** — Router on port 3306 (MySQL protocol), workers on port 9001

**Dev vs Production:**

| Mode | Storage | Config |
|------|---------|--------|
| **Development** | In-memory | Auto-configured (no setup needed) |
| **Production** | Persistent (PVC) | Deploy router + workers separately |

### Multi-Source Configuration

Create a `cube.js` config that connects to data sources (Cube Store is auto-configured):

```javascript
// cube.js
module.exports = {
  // Default database (Postgres for transactional data)
  dbType: 'postgres',
  driverFactory: ({ dataSource }) => {
    if (dataSource === 'clickhouse') {
      const ClickHouseDriver = require('@cubejs-backend/clickhouse-driver');
      return new ClickHouseDriver({
        host: process.env.CUBEJS_DB_CLICKHOUSE_HOST,
        port: process.env.CUBEJS_DB_CLICKHOUSE_PORT || 8123,
        user: process.env.CUBEJS_DB_CLICKHOUSE_USER,
        password: process.env.CUBEJS_DB_CLICKHOUSE_PASS,
        database: process.env.CUBEJS_DB_CLICKHOUSE_NAME,
      });
    }

    // Default: Postgres
    const PostgresDriver = require('@cubejs-backend/postgres-driver');
    return new PostgresDriver({
      host: process.env.CUBEJS_DB_HOST,
      port: process.env.CUBEJS_DB_PORT || 5432,
      user: process.env.CUBEJS_DB_USER,
      password: process.env.CUBEJS_DB_PASS,
      database: process.env.CUBEJS_DB_NAME,
    });
  },

  // Cube Store for cache and pre-aggregations (default since v0.32+)
  // No additional config needed - Cube Store is auto-configured
  // For production, deploy Cube Store cluster separately (see deployment section)

  // JWT auth
  checkAuth: async (req, auth) => {
    if (!auth) throw new Error('Missing authorization');
    const jwt = require('jsonwebtoken');
    const token = auth.replace('Bearer ', '');
    const payload = jwt.verify(token, process.env.CUBEJS_API_SECRET);
    req.securityContext = payload;
  },
};
```

### ClickHouse Schema (Analytics Events)

```javascript
// schema/Events.js
cube(`Events`, {
  dataSource: 'clickhouse',
  sql: `SELECT * FROM analytics.events`,

  measures: {
    count: {
      type: `count`,
    },

    uniqueUsers: {
      sql: `user_id`,
      type: `countDistinct`,
    },
  },

  dimensions: {
    eventName: {
      sql: `event_name`,
      type: `string`,
    },

    userId: {
      sql: `user_id`,
      type: `number`,
    },

    timestamp: {
      sql: `timestamp`,
      type: `time`,
    },

    properties: {
      sql: `properties`,
      type: `string`,
    },
  },

  preAggregations: {
    eventsByDay: {
      measures: [CUBE.count, CUBE.uniqueUsers],
      dimensions: [CUBE.eventName],
      timeDimension: CUBE.timestamp,
      granularity: `day`,
      partitionGranularity: `month`,
      refreshKey: {
        every: `10 minutes`,
      },
    },
  },
});
```

### Postgres Schema (Transactional Data)

```javascript
// schema/Users.js
cube(`Users`, {
  dataSource: 'default', // Postgres
  sql: `SELECT * FROM public.users`,

  dimensions: {
    id: {
      sql: `id`,
      type: `number`,
      primaryKey: true,
    },

    email: {
      sql: `email`,
      type: `string`,
    },

    createdAt: {
      sql: `created_at`,
      type: `time`,
    },
  },
});
```

### Cross-Source Join (ClickHouse ← Postgres)

Join analytics events (ClickHouse) with user data (Postgres):

```javascript
// schema/Events.js (continued)
cube(`Events`, {
  // ... measures, dimensions

  joins: {
    Users: {
      sql: `${CUBE}.user_id = ${Users}.id`,
      relationship: `belongsTo`,
    },
  },
});
```

**Query example** (events with user email):

```json
{
  "measures": ["Events.count"],
  "dimensions": ["Events.eventName", "Users.email"],
  "timeDimensions": [
    {
      "dimension": "Events.timestamp",
      "granularity": "day",
      "dateRange": "last 7 days"
    }
  ]
}
```

### Environment Variables

```bash
# Postgres (default)
CUBEJS_DB_TYPE=postgres
CUBEJS_DB_HOST=postgres.default.svc.cluster.local
CUBEJS_DB_PORT=5432
CUBEJS_DB_NAME=kbve
CUBEJS_DB_USER=cube
CUBEJS_DB_PASS=<secret>

# ClickHouse (analytics)
CUBEJS_DB_CLICKHOUSE_HOST=clickhouse.default.svc.cluster.local
CUBEJS_DB_CLICKHOUSE_PORT=8123
CUBEJS_DB_CLICKHOUSE_NAME=analytics
CUBEJS_DB_CLICKHOUSE_USER=cube
CUBEJS_DB_CLICKHOUSE_PASS=<secret>

# Cube Store (auto-configured, or specify custom endpoint)
# CUBEJS_CUBESTORE_HOST=cubestore-router.default.svc.cluster.local
# CUBEJS_CUBESTORE_PORT=3306

# Auth
CUBEJS_API_SECRET=<jwt-secret>
CUBEJS_DEV_MODE=false
```

### Deployment (Kubernetes)

Deploy Cube.js as a service in the cluster alongside ClickHouse and Postgres. Cube Store runs as a separate cluster (router + workers) for pre-aggregation storage.

**Cube API Deployment:**

```yaml
# cube-api-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cube-api
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: cube-api
  template:
    metadata:
      labels:
        app: cube-api
    spec:
      containers:
      - name: cube-api
        image: cubejs/cube:latest
        ports:
        - containerPort: 4000
        env:
        - name: CUBEJS_REFRESH_WORKER
          value: "false"  # API instances should NOT run refresh workers
        - name: CUBEJS_CUBESTORE_HOST
          value: "cubestore-router.default.svc.cluster.local"
        - name: CUBEJS_CUBESTORE_PORT
          value: "3306"
        envFrom:
        - secretRef:
            name: cubejs-secrets
        volumeMounts:
        - name: schema
          mountPath: /cube/conf/schema
      volumes:
      - name: schema
        configMap:
          name: cubejs-schema
---
apiVersion: v1
kind: Service
metadata:
  name: cube-api
  namespace: default
spec:
  selector:
    app: cube-api
  ports:
  - port: 4000
    targetPort: 4000
```

**Cube Refresh Worker Deployment:**

```yaml
# cube-refresh-worker-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cube-refresh-worker
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: cube-refresh-worker
  template:
    metadata:
      labels:
        app: cube-refresh-worker
    spec:
      containers:
      - name: cube-refresh-worker
        image: cubejs/cube:latest
        env:
        - name: CUBEJS_SCHEDULED_REFRESH_TIMER
          value: "true"  # Enable scheduled refresh
        - name: CUBEJS_CUBESTORE_HOST
          value: "cubestore-router.default.svc.cluster.local"
        - name: CUBEJS_CUBESTORE_PORT
          value: "3306"
        envFrom:
        - secretRef:
            name: cubejs-secrets
        volumeMounts:
        - name: schema
          mountPath: /cube/conf/schema
      volumes:
      - name: schema
        configMap:
          name: cubejs-schema
```

**Cube Store Cluster (Router + Workers):**

```yaml
# cubestore-router-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cubestore-router
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: cubestore-router
  template:
    metadata:
      labels:
        app: cubestore-router
    spec:
      containers:
      - name: cubestore-router
        image: cubejs/cubestore:latest
        ports:
        - containerPort: 3306  # MySQL protocol
        - containerPort: 3030  # HTTP
        env:
        - name: CUBESTORE_SERVER_NAME
          value: "cubestore-router:9999"
        - name: CUBESTORE_META_PORT
          value: "9999"
        - name: CUBESTORE_WORKERS
          value: "cubestore-worker-0:9001,cubestore-worker-1:9001"
        volumeMounts:
        - name: cubestore-data
          mountPath: /cube/data
      volumes:
      - name: cubestore-data
        persistentVolumeClaim:
          claimName: cubestore-router-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: cubestore-router
  namespace: default
spec:
  selector:
    app: cubestore-router
  ports:
  - name: mysql
    port: 3306
    targetPort: 3306
  - name: http
    port: 3030
    targetPort: 3030
---
# cubestore-worker-statefulset.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: cubestore-worker
  namespace: default
spec:
  serviceName: cubestore-worker
  replicas: 2
  selector:
    matchLabels:
      app: cubestore-worker
  template:
    metadata:
      labels:
        app: cubestore-worker
    spec:
      containers:
      - name: cubestore-worker
        image: cubejs/cubestore:latest
        ports:
        - containerPort: 9001
        env:
        - name: CUBESTORE_SERVER_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: CUBESTORE_WORKER_PORT
          value: "9001"
        - name: CUBESTORE_META_ADDR
          value: "cubestore-router:9999"
        volumeMounts:
        - name: cubestore-data
          mountPath: /cube/data
  volumeClaimTemplates:
  - metadata:
      name: cubestore-data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 100Gi
```

Store schemas in a ConfigMap:

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: cubejs-schema
  namespace: default
data:
  Events.js: |
    cube(`Events`, {
      dataSource: 'clickhouse',
      sql: `SELECT * FROM analytics.events`,
      // ... (schema definition)
    });
  Users.js: |
    cube(`Users`, {
      sql: `SELECT * FROM public.users`,
      // ... (schema definition)
    });
```

### Dashboard Integration

Connect your React/Astro dashboard to the Cube.js API:

```typescript
// lib/cube.ts
import cubejs from '@cubejs-client/core';

const cubeApi = cubejs(
  () => localStorage.getItem('jwt_token') || '',
  {
    apiUrl: 'https://cube.kbve.com/cubejs-api/v1',
  }
);

export default cubeApi;
```

**Query from dashboard:**

```tsx
import { useCubeQuery } from '@cubejs-client/react';
import cubeApi from '@/lib/cube';

function EventsChart() {
  const { resultSet, isLoading } = useCubeQuery(
    {
      measures: ['Events.count'],
      timeDimensions: [
        {
          dimension: 'Events.timestamp',
          granularity: 'day',
          dateRange: 'last 30 days',
        },
      ],
      dimensions: ['Events.eventName'],
    },
    { cubejsApi: cubeApi }
  );

  if (isLoading) return <div>Loading...</div>;

  return (
    <div>
      {resultSet.tablePivot().map((row) => (
        <div key={row['Events.eventName']}>
          {row['Events.eventName']}: {row['Events.count']}
        </div>
      ))}
    </div>
  );
}
```

### Best Practices

#### Pre-Aggregations with ClickHouse

<Aside type="caution">
When using ClickHouse as a data source, you **must** define indexes in pre-aggregations. Measures of type `count_distinct_approx` cannot be used in pre-aggregations with ClickHouse.
</Aside>

**Index definition example:**

```javascript
preAggregations: {
  eventsByDay: {
    measures: [CUBE.count],
    dimensions: [CUBE.eventName],
    timeDimension: CUBE.timestamp,
    granularity: `day`,
    indexes: {
      categoryIndex: {
        columns: [CUBE.eventName],
      },
    },
  },
}
```

#### Cross-Source Joins (ClickHouse + Postgres)

Two strategies for joining data across ClickHouse and Postgres:

1. **Cube Store `rollup_join`** — Join pre-aggregations from both sources inside Cube Store (recommended)
2. **ClickHouse integration engines** — Use ClickHouse's `PostgreSQL` table engine to query Postgres directly

**Known Issue:** Query dimension order affects join performance. Place ClickHouse dimensions before Postgres dimensions in the query for optimal performance.

```json
// Recommended order
{
  "measures": ["Events.count"],
  "dimensions": [
    "Events.eventName",  // ClickHouse dimension first
    "Users.email"        // Postgres dimension second
  ]
}
```

#### Refresh Strategy

- **API instances** — Set `CUBEJS_REFRESH_WORKER=false` to handle queries only
- **Refresh workers** — Dedicate 1+ instances with `CUBEJS_SCHEDULED_REFRESH_TIMER=true`
- **Pre-aggregation partitions** — Use `partitionGranularity: 'month'` for time-series data

#### Cube Store Sizing

For production deployments:

- **Router:** 1 replica (single point of coordination, stateless)
- **Workers:** 2+ replicas (scale horizontally for more pre-aggregation storage)
- **Storage:** 100Gi+ per worker (depends on pre-aggregation volume)
- **Memory:** 4Gi+ per worker (columnar in-memory operations)

**Scaling strategy:**

- **Horizontal (add workers)** — more pre-aggregation capacity, parallel query execution
- **Vertical (increase worker storage)** — larger pre-aggregation datasets per worker
- **Router resources** — lightweight, typically needs less than 1Gi RAM

#### Cube Store vs External Cache (Valkey/Redis)

| Feature | Cube Store (Built-in) | External Redis/Valkey |
|---------|----------------------|----------------------|
| **Pre-aggregations** | ✅ Native columnar storage | ❌ Not supported |
| **Query cache** | ✅ Automatic | ❌ Not supported (deprecated) |
| **Job queue** | ✅ Managed internally | ❌ Not supported (deprecated) |
| **Configuration** | Auto (dev) / Simple (prod) | ❌ Removed in v0.32+ |
| **Performance** | Optimized for analytics | N/A |
| **Integration** | Zero config in dev mode | N/A |

**Bottom line:** Cube Store is the only supported cache/storage layer for Cube.js. External Redis/Valkey instances cannot be used, even if configured elsewhere in your stack.

### Benefits

- **Single API** — one endpoint for all data sources
- **Semantic layer** — consistent metrics across teams
- **Pre-aggregations** — cached in Cube Store, sub-second queries
- **Cross-source joins** — correlate analytics (ClickHouse) + users (Postgres)
- **Multi-tenancy** — filter by `userId` or `tenantId` via JWT
- **Kubernetes-native** — scales horizontally, integrates with existing infra
- **No ETL needed** — query live transactional + analytical data without pipelines

<Giscus />

---
# Docker

> Docker packages applications and their dependencies into portable containers that run identically across
machines. This reference covers the Docker CLI cheatsheet, every Dockerfile instruction (FROM, RUN, CMD,
ENTRYPOINT, and more), GPU passthrough, BuildX, WatchTower, and container management scripts.

Source: https://kbve.com/application/docker/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

Docker packages an application and its dependencies into a **container** — an isolated, portable unit that runs identically on any machine with a Docker engine. Unlike a full virtual machine, containers share the host kernel, so they start in seconds and use far less memory. A `Dockerfile` describes how to build the image; `docker run` launches a container from it.

This page is a working reference: the [CLI cheatsheet](#cheatsheet) for day-to-day commands, every [Dockerfile instruction](#dockerfile) explained, plus [GPU passthrough](#gpu), [BuildX](#buildx) multi-arch builds, [WatchTower](#watchtower) auto-updates, and management [scripts](#scripts).

## Tools

<Aside type="danger" title="Docker Tool Inbound">

This is just a short place holder for a docker tool that I am making!

</Aside>

<Adsense />

## Orb

OrbStack is a lightweight container runtime designed specifically for macOS.
It provides full Docker CLI compatibility while using significantly less CPU and memory than Docker Desktop.
Containers launch in roughly one second, and the application includes built in support for Linux virtual machines, Kubernetes, and volume mounts with native file system performance.

OrbStack can be installed through Homebrew:

```bash
brew install --cask orbstack
```

After installation, the `docker` and `docker-compose` commands work exactly as they do with Docker Desktop.
No additional configuration is required to switch between the two runtimes.

OrbStack ships with a built in [Kubernetes](/application/kubernetes/) cluster that can be enabled through the settings panel.
The cluster runs a single node locally and exposes `kubectl` to your terminal without any extra tooling.
This makes it straightforward to test manifests, Helm charts, and service meshes before deploying to a remote cluster.
For more details on Kubernetes concepts and cluster management, see the [Kubernetes documentation](/application/kubernetes/).

OrbStack also pairs well with [Talos](/application/kubernetes/) based workflows.
Talos is a minimal, immutable Linux distribution purpose built for running Kubernetes nodes with no shell access and no package manager.
When prototyping Talos configurations locally, OrbStack can serve as the container runtime for spinning up lightweight test clusters before pushing changes to bare metal or cloud infrastructure.
See the [Kubernetes](/application/kubernetes/) page for notes on Talos worker nodes and production cluster design.

For teams that need to run containers locally during development, OrbStack is a practical alternative that reduces overhead without sacrificing compatibility.
See the [Getting Started](/guides/getting-started/) guide for full environment setup instructions.

---

## Information

In one sentence, we can describe docker as a hybrid-source application designed to deploy nested-virtual machines that are containerized applications.
Docker is a powerful tool that can help you develop, deploy, and manage your applications.
The Docker build process lets you package your application and all its dependencies into a single image.
This image can then be run on any machine that has Docker installed, regardless of the underlying operating system.
Think of the image as a virtual cd or iso, it has everything needed to run your software wrapped into a single fancy file.
Finally the image/container makes it easy to deploy your application to any environment, whether it's a local development machine, a cloud server, or a production environment.
It's easy to get started with Docker, and you can be up and running in just a few minutes to about a hour if you are a bit noobie.
Remember that containers are lightweight, isolated environments that make it easy to deploy your applications.
They're also portable, so you can run them on any machine that has Docker installed.
So docker takes your source code, wraps it all into an image, then runs the image in a virtual machine aka container.
Also, in this documentation, we will include more additional tips, such as security and optimization, for your docker adventure.

---

## Cheatsheet

This is a quick cheetsheet for Docker, everyone comes back to these sheet for when they run into future problems or forget a certain command.
It is not important to understand this cheetsheet until you have a couple sessions of docker delopyment under your belt, so if you are a newbie, do not freak out!

-   Basic CLI (Command-line interface)
    -   Container Management Commands
        -   `docker create $image [-command]` - Create a Docker Container based upon the image String; -command for additional flags.
        -   `docker run $image [-command]` - Combines the command `create` and `start`.
        -   `docker start $cont` - Start the specific docker container (defined via cont String).
        -   `docker stop $cont` - Shutdown the specific docker container (defined via cont String).
        -   `docker kill $cont` - Kill the specific docker container (defined via cont String).
        -   `docker restart $cont` - Restart the specific docker container (defined via cont String).
        -   `docker pause $cont` - Pause the specific docker container (defined via cont String).
        -   `docker rm $cont` - Remove the specific docker container (defined via cont String).
    -   Inspecting Containers
        -   `docker ps` - List running docker containers.
        -   `docker ps -a` - List all docker containers, including docker containers that are paused / off.
        -   `docker logs $cont` - Display the specific docker container output (defined via cont String)
        -   `docker top $cont [-ps]` - Display the processes running inside the specific docker container (defined via cont String).
        -   `docker diff $cont` - Show the differences, within the modified files, between the specific container and the source image (defined via cont String).
        -   `docker inspect $cont` - Show information about the specific docker container (defined via cont String).
            -   Output of the data will default to `json`.
    -   Interacting with Containers
        -   `docker attach $cont` - Attach to the specific docker container and see the _stdin, stdout, stderr_ (defined via cont String)
        -   `docker cp $cont:$path $hostpath` - Copy files from the docker container.
        -   `docker cp $hostpath $cont:$path` - Copy files into the docker container.
        -   `docker export $cont` - Export the data of the specific docker container.
            -   Output of the data will default to a `tar` archive.
        -   `docker exec $cont $command` - Runs the $command inside of the specific docker container (defined via cont String).
        -   `docker wait $cont` - Waits until the specific docker container terminates and returns an exit code.
        -   `docker commit $cont $image` - Commits a new docker image via a snapshot of the specific docker container.
    -   Network
        -   `docker network create $netname` - Create a network with the variable $netname.
    -   Docker Compose
        -   `docker compose start` - Start a YAML configuration for a docker container.
        -   `docker compose stop` - Stop the most recent composed docker container.
        -   `docker compose pause` - Pause the most recent composed docker container.
        -   `docker compose unpause` - Unpause the most rencent composed docker container.
        -   `docker compose ps` - List the current docker containers
        -   `docker compose up -f $compose.yml [$command]` - Start and run a YAML configuration for a docker container.
        -   `docker compose down` - Down a composed docker container.
    -   Docker Swarm
        -   `docker swarm init` - The docker container will become a manager node within the initialized container.
            -   Upon the initialization instance, the container will provide a token for other worker/manager nodes to join.
        -   `docker swarm join --token $token $ip` - Docker container will join the swarm as a worker; token string should be obtained by init and the `$ip` should be IP Address and port.
            -   `$ip` will be given as `$$ipaddress:$$port` , where the substring `$$ipaddress` is the IPv4address or IPv6address and the substring `$$port` is the open port on that `$$ipaddress`.
    -   Docker Prune / Clean up
        -   `docker system prune` - The docker system will clean up any dead objects, such as containers, networks, ect..
            -   `docker system prune -a` - Incase you need to do a deep clean within the docker node.

Full Table of Commands:

### Docker CLI Commands Cheatsheet

| Command                                    | Description                                                                                 |
| ------------------------------------------ | ------------------------------------------------------------------------------------------- |
| `docker --version`                         | Show the Docker version information.                                                        |
| `docker info`                              | Display system-wide information about Docker.                                               |
| `docker login`                             | Log in to a Docker registry.                                                                |
| `docker logout`                            | Log out from a Docker registry.                                                             |
| `docker pull <image>`                      | Download an image from a Docker registry.                                                   |
| `docker push <image>`                      | Upload an image to a Docker registry.                                                       |
| `docker build <path>`                      | Build an image from a Dockerfile.                                                           |
| `docker run <image>`                       | Run a command in a new container.                                                           |
| `docker start <container>`                 | Start one or more stopped containers.                                                       |
| `docker stop <container>`                  | Stop one or more running containers.                                                        |
| `docker restart <container>`               | Restart one or more containers.                                                             |
| `docker rm <container>`                    | Remove one or more containers.                                                              |
| `docker rmi <image>`                       | Remove one or more images.                                                                  |
| `docker ps`                                | List running containers.                                                                    |
| `docker ps -a`                             | List all containers, including stopped ones.                                                |
| `docker images`                            | List images.                                                                                |
| `docker inspect <container>`               | Display detailed information on one or more containers or images.                           |
| `docker logs <container>`                  | Fetch the logs of a container.                                                              |
| `docker exec <container> <command>`        | Run a command in a running container.                                                       |
| `docker cp <container>:<path> <host path>` | Copy files/folders between a container and the local filesystem.                            |
| `docker commit <container> <new_image>`    | Create a new image from a container's changes.                                              |
| `docker tag <source_image> <target_image>` | Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE.                                      |
| `docker network ls`                        | List all networks.                                                                          |
| `docker network create <name>`             | Create a new network.                                                                       |
| `docker network rm <network>`              | Remove one or more networks.                                                                |
| `docker volume ls`                         | List volumes.                                                                               |
| `docker volume create <name>`              | Create a new volume.                                                                        |
| `docker volume rm <volume>`                | Remove one or more volumes.                                                                 |
| `docker top <container>`                   | Display the running processes of a container.                                               |
| `docker stats`                             | Display a live stream of container(s) resource usage statistics.                            |
| `docker pause <container>`                 | Pause all processes within one or more containers.                                          |
| `docker unpause <container>`               | Unpause all processes within one or more containers.                                        |
| `docker update <container>`                | Update configuration of one or more containers.                                             |
| `docker wait <container>`                  | Block until one or more containers stop, then print their exit codes.                       |
| `docker attach <container>`                | Attach local standard input, output, and error streams to a running container.              |
| `docker kill <container>`                  | Kill one or more running containers.                                                        |
| `docker rename <old_name> <new_name>`      | Rename a container.                                                                         |
| `docker system prune`                      | Remove unused data.                                                                         |
| `docker container prune`                   | Remove all stopped containers.                                                              |
| `docker image prune`                       | Remove unused images.                                                                       |
| `docker volume prune`                      | Remove all unused volumes.                                                                  |
| `docker network prune`                     | Remove all unused networks.                                                                 |
| `docker system df`                         | Show docker disk usage.                                                                     |
| `docker image save <image> -o <file>`      | Save one or more images to a tar archive (streamed to STDOUT by default).                   |
| `docker image load -i <file>`              | Load an image from a tar archive or STDIN.                                                  |
| `docker history <image>`                   | Show the history of an image.                                                               |
| `docker export <container> -o <file>`      | Export a container’s filesystem as a tar archive.                                           |
| `docker import <file> <new_image>`         | Import the contents from a tarball to create a filesystem image.                            |
| `docker buildx create`                     | Create a new builder instance.                                                              |
| `docker buildx inspect`                    | Show information about a builder instance.                                                  |
| `docker buildx use <builder>`              | Set the current builder instance.                                                           |
| `docker buildx build`                      | Start a new build using the buildx builder.                                                 |
| `docker-compose up`                        | Build, create, start, and attach to containers for a service defined in docker-compose.yml. |
| `docker-compose down`                      | Stop and remove containers, networks, images, and volumes defined in docker-compose.yml.    |
| `docker-compose logs`                      | View output from containers.                                                                |
| `docker-compose ps`                        | List containers.                                                                            |
| `docker-compose exec`                      | Execute a command in a running container.                                                   |
| `docker-compose stop`                      | Stop services.                                                                              |
| `docker-compose start`                     | Start services.                                                                             |
| `docker-compose restart`                   | Restart services.                                                                           |
| `docker-compose pull`                      | Pull service images.                                                                        |
| `docker-compose build`                     | Build or rebuild services.                                                                  |
| `docker-compose rm`                        | Remove stopped service containers.                                                          |
| `docker-compose up -d`                     | Start containers in detached mode.                                                          |

Swarm Cheatsheet Table for Swarm Mode

| Command                                                                  | Description                                        |
| ------------------------------------------------------------------------ | -------------------------------------------------- |
| `docker swarm init`                                                      | Initialize a swarm.                                |
| `docker swarm join --token <token> <manager_ip>`                         | Join a swarm as a node.                            |
| `docker swarm leave`                                                     | Leave a swarm.                                     |
| `docker swarm update`                                                    | Update the swarm configuration.                    |
| `docker node ls`                                                         | List nodes in the swarm.                           |
| `docker node inspect <node>`                                             | Display detailed information on one or more nodes. |
| `docker node update --availability <active or paused or drained> <node>` | Update a node's availability.                      |
| `docker node promote <node>`                                             | Promote a node to a manager.                       |
| `docker node demote <node>`                                              | Demote a manager node to a worker.                 |
| `docker service create --name <service_name> <image>`                    | Create a new service.                              |
| `docker service ls`                                                      | List services.                                     |
| `docker service inspect <service>`                                       | Display detailed information about a service.      |
| `docker service update <service>`                                        | Update a service.                                  |
| `docker service scale <service>=<replicas>`                              | Scale a service to a specified number of replicas. |
| `docker service rm <service>`                                            | Remove a service.                                  |
| `docker service logs <service>`                                          | Fetch the logs of a service.                       |
| `docker service ps <service>`                                            | List the tasks of a service.                       |
| `docker stack deploy -c <compose-file> <stack>`                          | Deploy a new stack or update an existing stack.    |
| `docker stack ls`                                                        | List stacks.                                       |
| `docker stack services <stack>`                                          | List the services in a stack.                      |
| `docker stack ps <stack>`                                                | List the tasks in a stack.                         |
| `docker stack rm <stack>`                                                | Remove a stack.                                    |
| `docker config create <config_name> <file>`                              | Create a new config from a file.                   |
| `docker config ls`                                                       | List configs.                                      |
| `docker config inspect <config>`                                         | Display detailed information about a config.       |
| `docker config rm <config>`                                              | Remove one or more configs.                        |
| `docker secret create <secret_name> <file>`                              | Create a new secret from a file.                   |
| `docker secret ls`                                                       | List secrets.                                      |
| `docker secret inspect <secret>`                                         | Display detailed information about a secret.       |
| `docker secret rm <secret>`                                              | Remove one or more secrets.                        |
| `docker stack deploy --with-registry-auth -c <compose-file> <stack>`     | Deploy a stack using registry authentication.      |
| `docker service rollback <service>`                                      | Revert a service to its previous version.          |
| `docker service ps <service>`                                            | List the tasks of a service.                       |
| `docker node ps <node>`                                                  | List the tasks running on a node.                  |
| `docker swarm unlock`                                                    | Unlock a locked manager.                           |
| `docker swarm unlock-key`                                                | Manage the unlock key for a swarm.                 |

---

## DockerFile

A Dockerfile is a crucial component in building Docker images, serving as a simple script that specifies the base image and a set of instructions to assemble the final image.
Acting as an isolated operating system for specific applications, a Dockerfile ensures all necessary libraries and dependencies are pre-installed and pre-built.
This document aims to provide a comprehensive guide for all Docker needs, catering to both new users and professionals, by covering essential concepts and advanced techniques for effective Docker usage.

<Aside type="tip" title="Understanding the Dockerfile">
	The Dockerfile is a simple document that assembles the Docker image using a
	specific base and a set of commands. The concept is that the Docker image
	acts as an isolated operating system for the specific application, with all
	necessary libraries pre-installed and pre-built.
</Aside>

### FROM

The `FROM` instruction in a Dockerfile specifies the base image for the Docker image being built.
There are four generic ways to use `FROM`:

| Method                        | Description                                                                                                                                                                                                                                                                                                     |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1. `FROM {image}`             | The `{image}` represents the base image title or reference, such as `ubuntu` or `alpine`.                                                                                                                                                                                                                       |
| 2. `FROM {image}:{tag}`       | The `{tag}` specifies a particular version of the image, which can be useful for ensuring consistency. For example, `node:16` or `node:16-bullseye`.                                                                                                                                                            |
| 3. `FROM {image}@{digest}`    | The `{digest}` is the `sha-256` hash used to verify the integrity of the image. It ensures that the image has not been altered and is exactly as expected.                                                                                                                                                      |
| 4. `FROM {repository}#{hash}` | The `{repository}#{hash}` allows specifying a base image directly from a GitHub repository using a specific commit hash. This method is particularly useful when the base image is hosted in a repository and the exact state of the code is needed. For example, `FROM github.com/kbve/repo#abcdef1234567890`. |

Using these methods, the `FROM` instruction provides flexibility and precision in defining the base image, ensuring that the Docker image is built upon a reliable and verified foundation.

### MAINTAINER

<Aside type="caution" title="Caution: Deprecated Instruction">
	The **MAINTAINER** instruction has been deprecated. For current best
	practices, refer to the **LABEL** section.
</Aside>

The `MAINTAINER` instruction in a Dockerfile specifies the author or maintainer of the Docker image.
Although deprecated in favor of using labels, it is still useful to know for legacy Dockerfiles.
The `MAINTAINER` instruction provides metadata about the person or organization responsible for maintaining the image.

| Option                              | Description                                                                                                                  |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `MAINTAINER {name}`                 | Specifies the name of the maintainer. For example, `MAINTAINER h0ly Byte`.                                                   |
| `MAINTAINER {name} <email>`         | Provides both the name and email of the maintainer. For example, `MAINTAINER h0ly Byte <no.reply@kbve.com>`.                 |
| `LABEL maintainer="{name} <email>"` | The recommended way to specify the maintainer using labels. For example, `LABEL maintainer="h0ly Byte <no.reply@kbve.com>"`. |

This table illustrates the different ways to specify the maintainer information, emphasizing the shift towards using labels for better metadata management.

### RUN

The `RUN` instruction in a Dockerfile is used to execute commands within the container during the image build process.
It allows for the installation of software packages, modification of files, and other tasks required to set up the environment for the application.

| Method                                   | Description                                                                                                                                                      |
| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `RUN {command}`                          | Executes a command in a new layer on top of the current image and commits the results. For example, `RUN apt-get update && apt-get install -y nginx`.            |
| `RUN ["executable", "param1", "param2"]` | Uses the exec form to run the command. This is typically preferred for commands that include arguments. For example, `RUN ["apt-get", "install", "-y", "curl"]`. |

The table above illustrates the different ways to use the `RUN` instruction to execute commands during the build process, either using the shell form or the exec form, depending on the requirements.

<Aside type="tip" title="RUN vs. CMD">
	The **RUN** and **CMD** instructions in a Dockerfile serve different
	purposes. **RUN** executes commands during the build process to set up the
	image, such as installing software or setting environment variables,
	creating a new image layer each time it's used. In contrast, **CMD**
	specifies the default command to run when the container starts, determining
	the container's behavior at runtime. Use **RUN** for build-time
	configurations and **CMD** for runtime configurations to ensure a clear and
	effective Dockerfile.
</Aside>

### CMD

The `CMD` instruction in a Dockerfile specifies the default command to run when a container is started.
Unlike `RUN`, which is used during the build process, `CMD` is executed when the container runs.
If multiple `CMD` instructions are specified, only the last one takes effect.

| Method                                 | Description                                                                                                                                       |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CMD ["executable","param1","param2"]` | Specifies the command to run in exec form. For example, `CMD ["nginx", "-g", "daemon off;"]`. This form is preferred for commands with arguments. |
| `CMD ["param1","param2"]`              | Provides default parameters for the `ENTRYPOINT` instruction. For example, `CMD ["-d"]` when combined with `ENTRYPOINT ["nginx"]`.                |
| `CMD command param1 param2`            | Specifies the command to run in shell form. For example, `CMD echo "Hello, World!"`. This form runs in a shell (`/bin/sh -c`).                    |

The reference CMD table above explains the different ways to use the `CMD` instruction, either by specifying the command in exec form, providing default parameters for an `ENTRYPOINT`, or using shell form to run commands.

Sure! Here are the detailed sections with markdown tables for each of the requested Dockerfile instructions:

### LABEL

The `LABEL` instruction in a Dockerfile is used to add metadata to the image.
Labels can provide information such as the maintainer's name, version, description, and other key-value pairs.

| Method                          | Description                                                                                |
| ------------------------------- | ------------------------------------------------------------------------------------------ |
| `LABEL key=value`               | Adds a label with a key-value pair. For example, `LABEL version="1.0"`.                    |
| `LABEL key1=value1 key2=value2` | Adds multiple labels at once. For example, `LABEL maintainer="John Doe" version="1.0"`.    |
| `LABEL key="value with spaces"` | Adds a label with a value that includes spaces. For example, `LABEL description="My App"`. |

### ENV

The `ENV` instruction in a Dockerfile sets environment variables, which can be used by the running container.
Environment variables set using `ENV` persist throughout the lifetime of the container.

| Method                        | Description                                                                                           |
| ----------------------------- | ----------------------------------------------------------------------------------------------------- |
| `ENV key=value`               | Sets an environment variable. For example, `ENV PATH=/usr/local/nginx/bin:$PATH`.                     |
| `ENV key value`               | Sets an environment variable using key and value as separate arguments. For example, `ENV PORT 8080`. |
| `ENV key1=value1 key2=value2` | Sets multiple environment variables at once. For example, `ENV LANG=C.UTF-8 LC_ALL=C.UTF-8`.          |

<Aside type="tip" title="COPY vs. ADD">
	While both **COPY** and **ADD** instructions in a Dockerfile are used to
	copy files from the host to the container, there are key differences.
	**COPY** simply copies local files and directories, ensuring a
	straightforward and predictable behavior. **ADD**, on the other hand, can
	also handle remote URLs and automatically extract compressed files (e.g.,
	tar archives). For most use cases, **COPY** is preferred for its clarity and
	simplicity, reserving `ADD` for scenarios where its additional features are
	necessary.
</Aside>

### ADD

The `ADD` instruction in a Dockerfile copies files, directories, or remote URLs from the source to the destination in the container.
Unlike `COPY`, `ADD` can also handle remote URLs and extract tar archives.

| Method                              | Description                                                                                                                 |
| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `ADD src dest`                      | Copies files or directories from `src` to `dest`. For example, `ADD myapp.tar.gz /app`.                                     |
| `ADD ["src", "dest"]`               | Copies files or directories from `src` to `dest` using the exec form. For example, `ADD ["app.conf", "/etc/app.conf"]`.     |
| `ADD http://example.com/file /file` | Downloads a file from a URL and copies it to the container. For example, `ADD http://example.com/file.tar.gz /file.tar.gz`. |

### COPY

The `COPY` instruction in a Dockerfile copies files and directories from the source on the host to the destination path in the container.
Unlike `ADD`, `COPY` only supports copying local files and directories.

| Method                 | Description                                                                                                              |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `COPY src dest`        | Copies files or directories from `src` to `dest`. For example, `COPY myapp /app`.                                        |
| `COPY ["src", "dest"]` | Copies files or directories from `src` to `dest` using the exec form. For example, `COPY ["app.conf", "/etc/app.conf"]`. |
| `COPY src/ dest/`      | Copies contents of a directory from `src` to `dest`. For example, `COPY src/ /app/`.                                     |

### ENTRYPOINT

The `ENTRYPOINT` instruction in a Dockerfile specifies the command that will always be executed when the container starts.
It allows configuring a container to run as an executable.

| Method                                          | Description                                                                                                                                              |
| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ENTRYPOINT ["executable", "param1", "param2"]` | Specifies the command to run in exec form. For example, `ENTRYPOINT ["nginx", "-g", "daemon off;"]`. This form is preferred for commands with arguments. |
| `ENTRYPOINT command param1 param2`              | Specifies the command to run in shell form. For example, `ENTRYPOINT /bin/sh -c "echo Hello"`. This form runs in a shell (`/bin/sh -c`).                 |

### VOLUME

The `VOLUME` instruction in a Dockerfile creates a mount point with a specified path and marks it as holding externally mounted volumes from native host or other containers.
It is used to persist data generated by and used by the Docker container.

| Method                      | Description                                                                                  |
| --------------------------- | -------------------------------------------------------------------------------------------- |
| `VOLUME ["/data"]`          | Creates a volume at the specified path. For example, `VOLUME ["/data"]`.                     |
| `VOLUME /data`              | Creates a volume at the specified path using the string form. For example, `VOLUME /data`.   |
| `VOLUME ["path1", "path2"]` | Creates multiple volumes at the specified paths. For example, `VOLUME ["/data", "/config"]`. |

### USER

The `USER` instruction in a Dockerfile sets the user name or UID (and optionally the group name or GID) to use when running the image and for any `RUN`, `CMD`, and `ENTRYPOINT` instructions that follow.

| Method            | Description                                                                                    |
| ----------------- | ---------------------------------------------------------------------------------------------- |
| `USER user`       | Sets the user to run the container as. For example, `USER nginx`.                              |
| `USER user:group` | Sets the user and group to run the container as. For example, `USER nginx:nginx`.              |
| `USER uid`        | Sets the user by UID to run the container as. For example, `USER 1001`.                        |
| `USER uid:gid`    | Sets the user and group by UID and GID to run the container as. For example, `USER 1001:1001`. |

### WORKDIR

The `WORKDIR` instruction in a Dockerfile sets the working directory for any `RUN`, `CMD`, `ENTRYPOINT`, `COPY`, and `ADD` instructions that follow.
If the directory does not exist, it will be created.

| Method                     | Description                                                                          |
| -------------------------- | ------------------------------------------------------------------------------------ |
| `WORKDIR /path/to/workdir` | Sets the working directory for subsequent instructions. For example, `WORKDIR /app`. |
| `WORKDIR /path/to/workdir` | Creates the directory if it does not exist. For example, `WORKDIR /usr/src/app`.     |

### ARG

The `ARG` instruction in a Dockerfile defines a variable that users can pass at build-time to the builder with the `docker build` command.
These variables can be used in the Dockerfile to customize the build process.

| Method                          | Description                                                                                |
| ------------------------------- | ------------------------------------------------------------------------------------------ |
| `ARG name`                      | Defines a build-time variable. For example, `ARG VERSION`.                                 |
| `ARG name=default`              | Defines a build-time variable with a default value. For example, `ARG VERSION=latest`.     |
| `ARG name1=value1 name2=value2` | Defines multiple build-time variables at once. For example, `ARG VERSION=1.0 BASE=alpine`. |

### ONBUILD

The `ONBUILD` instruction in a Dockerfile adds a trigger instruction to the image that will be executed when the image is used as a base for another build.
It is useful for images that are intended to be used as a base for other images.

| Method                 | Description                                                                                                     |
| ---------------------- | --------------------------------------------------------------------------------------------------------------- |
| `ONBUILD INSTRUCTION`  | Adds a trigger instruction to be executed when the image is used as a base. For example, `ONBUILD COPY . /app`. |
| `ONBUILD RUN command`  | Adds a trigger instruction to run a command. For example, `ONBUILD RUN echo "Building child image"`.            |
| `ONBUILD ADD src dest` | Adds a trigger instruction to copy files. For example, `ONBUILD ADD . /src`.                                    |

### STOPSIGNAL

The `STOPSIGNAL` instruction in a Dockerfile sets the system call signal that is used to stop the container or application.
The default setting sends `SIGTERM` and waits for 10 seconds to allow for a graceful shutdown before sending `SIGKILL`.

| Method              | Description                                                                                       |
| ------------------- | ------------------------------------------------------------------------------------------------- |
| `STOPSIGNAL signal` | Sets the system call signal to stop the container. For example, `STOPSIGNAL SIGINT`.              |
| `STOPSIGNAL signal` | The default setting is `SIGTERM`, with a 10-second wait for a graceful shutdown before `SIGKILL`. |

### HEALTHCHECK

The `HEALTHCHECK` instruction in a Dockerfile provides a way to determine the health status of a container, informing the swarm or manager about the general status of the running application.
The two primary statuses are `healthy` and `unhealthy`.

| Method                                           | Description                                                                                                                                    |
| ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | --- | -------- |
| `HEALTHCHECK [options] CMD command`              | Defines a command to test the container's health. For example, `HEALTHCHECK CMD curl -f http://localhost/                                      |     | exit 1`. |
| `HEALTHCHECK NONE`                               | Disables any health checks inherited from the base image.                                                                                      |
| `HEALTHCHECK --interval=30s --timeout=10s \ CMD` | Specifies options such as interval, timeout, and retries. For example, `HEALTHCHECK --interval=30s --timeout=10s CMD curl -f http://localhost/ |     | exit 1`. |

### SHELL

The `SHELL` instruction allows changing the default shell used for the `RUN` instruction.

| Method                          | Description                                                                                                   |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `SHELL ["executable", "param"]` | Changes the default shell for subsequent `RUN` instructions. For example, `SHELL ["powershell", "-Command"]`. |

### EXPOSE

The `EXPOSE` instruction informs Docker that the container listens on the specified network ports at runtime.
This is a form of documentation and does not actually publish the port.

| Method                 | Description                                                                    |
| ---------------------- | ------------------------------------------------------------------------------ |
| `EXPOSE port`          | Specifies a port to be listened to by the container. For example, `EXPOSE 80`. |
| `EXPOSE port/protocol` | Specifies a port and protocol (TCP/UDP). For example, `EXPOSE 80/tcp`.         |

---

## GPU

### Windows

GPU pass-through on Windows is still in the experimental stage, but here are some quick ways to get started with the basics.
This guide assumes you have WSL (Windows Subsystem for Linux) installed.
If you need assistance with WSL, refer to [WSL Help](/application/wsl/).

#### Nvidia

-   Install the latest CUDA driver libraries from the official Nvidia website. Visit [Nvidia CUDA](https://developer.nvidia.com/cuda-downloads) for downloads and installation instructions.
-   Ensure you have installed the latest core libraries as per the provided instructions.

---

## Setup

Docker is the future of application development because of how fast, easy and portable the software is.
In this section of the document, we will focus on setting up the application on various operating systems, including linux, windows and mac.
With Docker, you can build, deploy, and manage your applications in a fraction of the time it would take with traditional methods.
If you're not using Docker, you're missing out.
So what are you waiting for homie!?
Let us begin the setup quest for Docker today!

This section breaks down the various areas of installing `docker`.
To install Docker, simply visit the Docker website and download the installer for your operating system.

Here is a quick [google sheet](https://docs.google.com/spreadsheets/d/1ZT8m4gpvh6xhHYIi4Ui19uHcMpymwFXpTAvd3EcgSm4/edit?gid=0#gid=0) that breaks down the different docker desktop clients for each operating systems.
This sheet has been up-to-date since late 2024 and they include about 20 different clients for MacOS, Windows and Linux.

### Linux

The operating sysetm that we perfer is `Ubuntu` and here is a quick and brief tutorial:

-   Ubuntu Installation Guide
    -   Core Pre-Installation
        -   `lsb_release -a` - Unix command to see the version of Ubuntu that we are running.
        -   According to Docker (2022), these are the 64-bit versions of Ubuntu that they support.
            -   `Ubuntu Jammy 22.04 (LTS)`
            -   `Ubuntu Impish 21.10`
            -   `Ubuntu Focal 20.04 (LTS)`
            -   `Ubuntu Bionic 18.04 (LTS)`
        -   Hint: We like to make sure everything is updated and upgraded before we start. So run `sudo apt-get update` and then `sudo apt-get upgrade`.
        -   Now there are libraries that you will need before installing docker.
    -   Post Installation
        -   Adding Docker Compose through `sudo apt-get install docker-compose-plugin`, you may need to update before installing.
        -   Verifying the installation through `docker compose version` and if there are any issues, visit our support.

### Windows

Before we being our journey on setting up `Docker` onto Windows, you will have to make sure that WSL is installed and ready.
Furthermore, you may need to enable the Hyper-V through your bios.

The best way to setup `Docker` is by installing the engine through `Choco` because it will help keep the engine up to date.

---

## BuildX

Buildx is an advanced Docker CLI plugin designed to enhance the container building experience by providing extended capabilities powered by BuildKit.
Leveraging multi-node and multi-platform builds, Buildx facilitates the creation of containers optimized for diverse architectures, such as ARM and x86.
The plugin supports cache export and import features, improving build efficiency and speeding up subsequent builds.
Additionally, Buildx integrates seamlessly with Docker, allowing users to manage build environments with ease.
The flexibility and power of Buildx make it an essential tool for developers seeking to streamline their containerization workflows and deploy applications across various environments.

<Aside type="tip" title="Tip: Maximize Build Efficiency with Caching">
	Take advantage of Buildx's cache export and import features to significantly
	speed up your builds. By reusing previously built layers, cache can minimize
	build times and reduce redundant processing. Ensure to set up cache
	effectively to optimize development workflows.
</Aside>

<Steps>

0. **Prerequisites**:

    Make sure Docker is installed on your system.
    If you need to install Docker, follow this [Docker installation guide](/application/docker/#setup).

1. **Verify Docker Installation**:

    First, check if Docker is installed by running the following command in your terminal:

    ```shell
    docker --version
    ```

    You should see output similar to:

    ```
    Docker version 20.10.7, build f0df350
    ```

2. **Check for Buildx in the Apt List**:

    Before installing Buildx, let's check if it is available in the apt package list. Run the following command:

    ```shell
    apt-cache search docker-buildx
    ```

    If Buildx is available, you should see an output similar to:

    ```
    docker-buildx - Docker CLI plugin for extended build capabilities with BuildKit
    ```

3. **Install Buildx (if available in apt)**:

    If Buildx is available in the apt list, you can install it using:

    ```shell
    sudo apt-get install docker-buildx
    ```

    Verify the installation by running:

    ```shell
    docker buildx version
    ```

    You should see output indicating the version of Buildx installed.

    An example of this output would be like this:

    ```
    github.com/docker/buildx 0.11.2 0.11.2-0ubuntu1^22.04.2
    ```

4. **Add Buildx (if not available in apt)**:

    <Aside>This is only if Step 3 was not an option.</Aside>

    If Buildx is not available in the apt package list, you can add it manually. Follow these steps:

    1. **Download the Buildx Binary**:

        Download the latest Buildx release from GitHub:

        ```sh
        mkdir -p ~/.docker/cli-plugins/
        curl -Lo ~/.docker/cli-plugins/docker-buildx https://github.com/docker/buildx/releases/latest/download/buildx-v0.10.0.linux-amd64
        ```

    2. **Make the Binary Executable**:

        Make the downloaded binary executable:

        ```sh
        chmod +x ~/.docker/cli-plugins/docker-buildx
        ```

    3. **Verify the Installation**:

        Check the Buildx version to ensure it was installed correctly:

        ```sh
        docker buildx version
        ```

        You should see output indicating the version of Buildx installed.

5. **Create and Use a New Builder Instance**:

    Create a new builder instance and switch to it:

    ```sh
    docker buildx create --name mybuilder --use
    ```

    You can verify that the new builder instance is being used by running:

    ```sh
    docker buildx inspect --bootstrap
    ```

6. **Build and Push Multi-Platform Images**:

    With Buildx, you can now build and push multi-platform images. For example:

    ```sh
    docker buildx build --platform linux/amd64,linux/arm64 -t username/repository:tag . --push
    ```

    Congratulations! You have successfully set up Docker Buildx on your system.

</Steps>

---

## WatchTower

WatchTower is a powerful utility designed to automatically update running Docker containers whenever new images are pushed to a repository.
Ensuring that applications are always running the latest version, WatchTower reduces manual intervention and minimizes downtime.
By continuously monitoring specified Docker containers, WatchTower detects updates, gracefully stops the container, pulls the latest image, and restarts the container with the new version.
Maintaining a smooth and efficient deployment pipeline, WatchTower is especially beneficial in environments where applications frequently update.

In addition to its core functionality, WatchTower can send notifications about the status of container updates.
Notifications can be sent to various channels such as email, Slack, or other messaging services, keeping teams informed about the update process.
This feature is particularly useful for maintaining transparency and ensuring that stakeholders are aware of the changes happening within the containerized environment.

To enable WatchTower notifications, set the appropriate environmental variables in the command line. For example:

```shell
docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e WATCHTOWER_NOTIFICATIONS=email \
  -e WATCHTOWER_NOTIFICATION_EMAIL_FROM=fromaddress@gmail.com \
  -e WATCHTOWER_NOTIFICATION_EMAIL_TO=toaddress@gmail.com \
  -e WATCHTOWER_NOTIFICATION_EMAIL_SERVER=smtp.gmail.com \
  -e WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PORT=587 \
  -e WATCHTOWER_NOTIFICATION_EMAIL_SERVER_USER=fromaddress@gmail.com \
  -e WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PASSWORD=app_password \
  -e WATCHTOWER_NOTIFICATION_EMAIL_DELAY=2 \
  containrrr/watchtower
```

This command configures WatchTower to send email notifications regarding the status of container updates.
Adjust the variables to suit the desired notification method and settings.
By utilizing WatchTower and its notification features, administrators can ensure that their Docker environments remain up-to-date and secure with minimal effort.

---

## Scripts

Shell or Bash scripts are powerful tools for automating Docker workflows. 
These scripts allow you to string together multiple Docker commands into a single executable file, which can simplify and streamline complex operations. 
or example, the script below demonstrates a series of Docker commands combined to build an image from the current directory, stop and remove a running container, and then run a new container with specific configurations. 
This script builds the Docker image with the tag `myapp`, stops any running container named `myapp_container`, removes it, and finally starts a new container named `myapp_container` in detached mode with specified ports and shared memory size.

**Build & Deploy**

```shell
docker build . -t myapp && docker stop myapp_container && docker rm myapp_container && docker run --name myapp_container -d -p 3000:3000 -p 8086:8086 --shm-size=2g myapp
```

Additional parts of the script to include: 

```shell
docker logs -f --until=2s -name myapp_container
```

Clean Up: 

```shell
docker system prune all -a
```

Here is how it would look: 

An updated version of the script that includes checks to ensure each step completes successfully before moving on to the next. 

```shell
#!/bin/bash

# Variables
IMAGE_NAME="myapp"
CONTAINER_NAME="myapp_container"
PORTS="-p 3000:3000 -p 8086:8086"
SHM_SIZE="2g"

# Build the Docker image
echo "Building Docker image..."
docker build . -t $IMAGE_NAME
if [ $? -ne 0 ]; then
    echo "Failed to build Docker image."
    exit 1
fi

# Stop the running container if it exists
if [ $(docker ps -q -f name=$CONTAINER_NAME) ]; then
    echo "Stopping running container..."
    docker stop $CONTAINER_NAME
    if [ $? -ne 0 ]; then
        echo "Failed to stop container $CONTAINER_NAME."
        exit 1
    fi
else
    echo "No running container named $CONTAINER_NAME found."
fi

# Remove the container if it exists
if [ $(docker ps -a -q -f name=$CONTAINER_NAME) ]; then
    echo "Removing existing container..."
    docker rm $CONTAINER_NAME
    if [ $? -ne 0 ]; then
        echo "Failed to remove container $CONTAINER_NAME."
        exit 1
    fi
else
    echo "No existing container named $CONTAINER_NAME found."
fi

# Run a new container
echo "Running a new container..."
docker run --name $CONTAINER_NAME -d $PORTS --shm-size=$SHM_SIZE $IMAGE_NAME
if [ $? -ne 0 ]; then
    echo "Failed to run the container."
    exit 1
fi

echo "Container $CONTAINER_NAME is up and running."
```

This script includes the following enhancements:
1. **Variables:** Defined variables for the image name, container name, ports, and shared memory size for easier adjustments.
2. **Build Step:** Checks if the Docker image builds successfully.
3. **Stop Container Step:** Checks if the container is running before attempting to stop it and ensures the stop operation is successful.
4. **Remove Container Step:** Checks if the container exists before attempting to remove it and ensures the removal operation is successful.
5. **Run Container Step:** Runs a new container and checks if the operation is successful.

Save this script to a file, for example, `docker_manage.sh`, make it executable with `chmod +x docker_manage.sh`, and then run it with `./docker_manage.sh`.


---

## Docker Compose

Compose defines a multi-container app in a single declarative `docker-compose.yml`, replacing long `docker run` invocations. One `docker compose up -d` starts the whole stack; `docker compose down` tears it down.

```yaml
services:
  web:
    build: .
    ports:
      - "8080:80"
    environment:
      - NODE_ENV=production
    depends_on:
      - db
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: secret
    volumes:
      - db-data:/var/lib/postgresql/data

volumes:
  db-data:
```

`depends_on` controls start order, `environment` injects config, and the named `db-data` volume persists the database across restarts. Compose also creates a default bridge network so services reach each other by name (`web` can connect to `db:5432`).

| Command | Action |
| ------- | ------ |
| `docker compose up -d` | Start the stack in the background |
| `docker compose down` | Stop and remove containers + network |
| `docker compose logs -f web` | Follow logs for one service |
| `docker compose ps` | List running services |
| `docker compose exec web sh` | Open a shell in a running service |

## Volumes and Networks

Containers are ephemeral — anything written to the container's writable layer is lost when it is removed. **Volumes** provide durable storage; **networks** provide isolated communication.

- **Named volume** — `docker volume create data` then mount with `-v data:/path`. Managed by Docker, ideal for databases.
- **Bind mount** — `-v $(pwd):/app` maps a host directory into the container, ideal for live-reloading source during development.
- **Bridge network** — `docker network create appnet` lets containers on the same network resolve each other by name, isolated from other stacks.

```bash
docker network create appnet
docker run -d --name db --network appnet postgres:16-alpine
docker run -d --name web --network appnet -p 8080:80 myapp
```

## Best Practices

<Steps>

1. **Use small base images** — `alpine` or `-slim` variants cut image size and attack surface dramatically.

2. **Leverage multi-stage builds** — Compile in a heavy build stage, then `COPY` only the artifact into a minimal runtime stage.

3. **Add a `.dockerignore`** — Keep `node_modules`, `.git`, and secrets out of the build context for faster, safer builds.

4. **Order layers by change frequency** — Copy dependency manifests and install before copying source, so the dependency layer stays cached across code edits.

5. **Run as a non-root user** — Add a `USER` instruction so a container breakout doesn't grant host root.

6. **One process per container** — Keep containers single-purpose; use Compose to orchestrate multiple services.

</Steps>

---

## FAQ

**What is the difference between CMD and ENTRYPOINT in a Dockerfile?**
`ENTRYPOINT` sets the executable that always runs and is not overridden by arguments passed to `docker run`. `CMD` provides default arguments that are easily overridden. Use `ENTRYPOINT` for the fixed command and `CMD` for its default flags.

**What is the difference between ADD and COPY?**
`COPY` only copies local files and directories into the image. `ADD` does the same but also unpacks local tar archives and can fetch remote URLs. Prefer `COPY` unless you specifically need `ADD`'s extraction behavior.

**How do I reduce Docker image size?**
Use a small base image like `alpine`, combine `RUN` steps to r

[…truncated, full source at MDX]

---
# FlipperZero

> Flipper Zero is a pen test multi-tool! Think of it as a Swiss Army knife for wireless hacking.

Source: https://kbve.com/application/flipperzero/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

Flipper Zero is a portable multi-tool device for geeks that can interact with various digital systems in real life, such as RFID, radio protocols, access control systems and more.
It gives you full access to its source code and design, so you can tailor it to your own needs and preferences.
Your cyber-buddy, Flipper Zero, is a cybernetic companion with a Tamagotchi-like personality that enjoys exploring and manipulating digital and analog systems.

This guide covers [firmware](#firmware) (official and custom), [updating](#update), the [Sub-GHz radio](#ghz), the [NFC module](#nfc), and the [pyFlipper CLI](#pyflipper).

<Aside type="caution">
Only interact with radio signals, NFC/RFID cards, and access-control systems you own or are explicitly authorized to test. Cloning or replaying signals against systems you don't own is illegal in most jurisdictions.
</Aside>

<Adsense />
---

## Firmware

> The bundles of joy when installing various firmware for your flipperzero!
> The main chipset on the FlipperZero stores both a "New" and "Old" firmware, thus making it a bit easier to custom load your firmware without the higher risk of bricking your device. Granted there is always a risk of bricking your device, so be very careful! Make sure wires are tight and your machine is charged.

Firmware is the software that powers your Flipper Zero and lets you enjoy its amazing capabilities and control its functions and features.
We will teach you how to update your firmware, thus keeping your device fresh and flawless with new improvements and fixes.
There are different types of firmware for Flipper Zero, such as the official firmware, the release candidate firmware, the dev firmware, and the custom firmwares.
The official firmware is the stable version that is tested and approved by the Flipper team.
The release candidate firmware is the next version that is being tested before it becomes official.
Finally the dev firmware is the latest version that has new features and changes, but it may have bugs and errors.
In addition, there are custom firmwares made by other users who want to modify or add something to the Flipper Zero, which we will go over later down in this document.
You can choose which firmware you want to use and install it using the Flipper Mobile App or the qFlipper desktop application, with more information in the #update section.

### Custom

Custom firmwares are special versions of software that let you customize your Flipper Zero and unlock new possibilities.
They are made by creative and talented users who want to share their ideas and innovations with the Flipper community.
You can try different custom firmwares and see what they can do for your device!
We hope you find the best custom firmware to fit your needs and we recommend having multiple SD Cards with each custom firmware, so you can swap easily.

### Unleashed Firmware

Official [Repo](https://github.com/DarkFlippers/unleashed-firmware)

Forked Unleashed Firmware include:

[RogueMaster](https://github.com/RogueMaster/flipperzero-firmware-wPlugins)
[v1nc](https://github.com/v1nc/flipperzero-firmware)


---

## Update

Once you get your hands on the flipperzero, we recommend that you update it to the latest firmware via qFlipper application, links below:

[Official Main](https://flipperzero.one/update) Updates
Github Repo Updates - [Release Page](https://github.com/flipperdevices/qFlipper/releases)

There are other methods of updating, including Mobile and Web but from experience, I recommend sticking with a direct cable upgrade, to avoid possible firmware corruption.

---

## GHz

-   The frequencies that FlipperZero operates in are `300-348 MHz`, `387-464 MHz` and `779-928 MHz` bands through the `CC1101` chipset.

-   ### GHz Sub Menu

    -   `Read` - Reads & decodes the signal of the protocol within the frequency range.
        -   Lower left side will display the current frequency.
        -   Lower right side will display the remaining slots of scanned signals.
    -   `Read RAW` - Records the radio signal in RAW format.
        -   Requires a microSD for the storage of the RAW.
    -   `Saved` - Lists previously captured signals stored on the microSD, ready to replay or inspect.
    -   `Add Manually` - Create a signal by picking a known protocol and entering its parameters by hand.
    -   `Frequency Analyzer` - Scans the bands to detect the strongest nearby transmitter's frequency — point it at a remote and hold its button to identify the frequency in use.

#### GHZ InfoSec

-   315Ghz - Common frequency that car fobs operate in.

---


## GUI

To help with designing the GUI, we recommend checking out `Flipper UI` , which is an amazing tool for quick edits.
Source for it can be found here : [FUI-EDITOR](https://github.com/sbrin/ilin.pt/tree/main/_stuff/fui-editor)

---

## NFC

These are notes on the `NFC` aspect of the device.

### FlipperZero NFC

-   NFC (13.56 MHz) module can read, save and emulate NFC cards / frequencies.
-   NFC is known as near-field communication and operates at the 13.56 MHz (which is an unlicensed radio frequency ISM band under the ISO/IEC 18000-3).
-   Menu
    -   -> `Read` - Read && Save NFC data, including, UID, ATQA, SAK and storage data.
    -   -> `Detect Reader` - Emulation of an NFC card to grab information related to authentication keys from logs sent by a reader.
    -   -> `Saved` - Saved NFC cards on the device, which can be emulated.
    -   -> `Extra Actions` - Commands for extra functionality through custom scripts, plugins, applications on the device.
    -   -> `Add Manually` - Create an NFC card by adding the data manually.
-   NFC Terms
    -   -> `UID` is a read-only unique identifier for the specific NFC chip.
-   NFC-V
    -   Currently does not fully support ISO 15693.

---

## pyFlipper

This is an unofficial cli wrapper for the Flipper Zero device and we will integrate it with our current eco-system, including the possible future expansion into our core IoT project.

---

## FAQ

**What is the Flipper Zero?**
Flipper Zero is a portable, open-source multi-tool for pentesters and hardware hobbyists. It reads, saves, and emulates a range of wireless and access-control signals — Sub-GHz radio, NFC and RFID cards, infrared, iButton, and GPIO — behind a playful Tamagotchi-like interface.

**What is custom firmware for the Flipper Zero?**
Custom firmware replaces the official firmware to unlock extra features, protocols, and plugins the stock build restricts. Popular forks include [Unleashed](https://github.com/DarkFlippers/unleashed-firmware) and its RogueMaster fork. The chip stores a New and Old firmware slot, which lowers (but does not remove) the risk of bricking when flashing.

**What frequencies does the Flipper Zero Sub-GHz radio use?**
The Sub-GHz module uses the CC1101 chipset and operates in the `300-348 MHz`, `387-464 MHz`, and `779-928 MHz` bands. Common targets include 315 MHz and 433 MHz car key fobs and remotes, within the limits of local radio regulations.

**How does NFC work on the Flipper Zero?**
The NFC module operates at 13.56 MHz (ISO/IEC 18000-3) and can read, save, and emulate NFC cards, capturing data like UID, ATQA, and SAK. It supports many card types, though full ISO 15693 (NFC-V) support is limited.

**How do I update Flipper Zero firmware?**
The most reliable method is a direct USB cable update via the qFlipper desktop app, which avoids the corruption risk of wireless flashing. You can also update over the Flipper Mobile App or web updater, but a wired qFlipper upgrade is recommended.

<Adsense />

---
# Flutter

> Flutter is Google's open-source UI toolkit for building natively compiled apps for mobile, web, and desktop
from a single Dart codebase. This guide covers installing the SDK, running flutter doctor, the essential CLI
cheatsheet, the widget model, and where to find packages on pub.dev.

Source: https://kbve.com/application/flutter/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

Flutter is Google's open-source UI toolkit for building natively compiled apps for mobile, web, and desktop from **one** Dart codebase. Instead of wrapping native controls, Flutter ships its own rendering engine and widget set, so a single design looks and behaves identically on every platform. Its standout developer feature is **hot reload** — code changes appear in the running app in under a second.

This guide gets you productive fast: [install the SDK](#install), verify it with `flutter doctor`, learn the [essential CLI commands](#cheatsheet), understand the [widget model](#widgets), and find [packages](#packages) on pub.dev.

## Information

> TLDR; Flutter is an open source cross platform development kit.

Flutter is a software development kit created by Google that allows developers to build beautiful and natively compiled applications for almost any platform - mobile (Android and iOS), web (any browser) and desktop (Windows, Mac, Linux) all from a single codebase.
Flutter is often used with DART, which is an object-oriented programming language by Google.
The biggest advantage of flutter is that it can be used to create cross-platform applications.
So, if you want to build an app that looks stunning and works great on any device, Flutter is the way to go! 😊

---

<Adsense />

## Install

Installation is broken down into two different aspects, the first aspect is within the core of flutter and the other aspect contains the scopes.

### Windows

You can install Flutter on Windows by following these steps:

1. Navigate to flutter.dev on your webpage.
2. On the top menu bar, select Docs > Get Started > Install > Windows.
3. Check for the System Requirements.
4. Download the Flutter SDK.
5. Extract the zip file and place it in your desired location.
6. Add Flutter to your path.
7. Run `flutter doctor` to verify that Flutter has been installed correctly.

### macOS / Linux

On macOS and Linux the fastest route is to clone the SDK and add it to your `PATH`:

```bash
git clone https://github.com/flutter/flutter.git -b stable ~/flutter
export PATH="$PATH:$HOME/flutter/bin"
flutter doctor
```

`flutter doctor` inspects your toolchain and lists anything missing — Android SDK, Xcode, or IDE plugins — with a checkmark or an `✗` plus a fix hint. Resolve every `✗` before building.

### Create and Run Your First App

```bash
flutter create my_app
cd my_app
flutter run
```

`flutter create` scaffolds a counter demo app. `flutter run` builds it and launches on a connected device or emulator — then edit `lib/main.dart` and save to see hot reload in action.

---

## Cheatsheet

-   Healthcheck
    -   `flutter doctor`
-   Flutter upgrade
    -   `flutter upgrade`
-   Package Get
    -   `flutter packages get`
    -   `flutter pub get`
    -   Flutter will download and save the packages locally.
-   List all devices for flutter.
    -   `flutter devices`
-   Run application on a specific device.
    -   `flutter run -d {$device} -v`
-   Flutter logs from the specific device.
    -   `flutter logs -d {$device}`
-   Flutter clean
    -   `flutter clean`
    -   The command deletes all temporary folders and builds.
-   Fluter cache
    -   `flutter pub cache repair`
-   Package removal.
    -   `flutter pub remove {$package}`
-   Package add / install
    -   `flutter pub add {$package}`

---

## Widgets

In Flutter, **everything is a widget** — text, padding, buttons, and even the app itself. A widget is an immutable description of part of the UI; Flutter composes them into a tree and renders it. There are two core kinds:

- **StatelessWidget** — describes UI that never changes on its own (a label, an icon).
- **StatefulWidget** — holds mutable state and rebuilds when that state changes (a counter, a form).

```dart
import 'package:flutter/material.dart';

void main() => runApp(const MyApp());

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: const Text('Hello Flutter')),
        body: const Center(child: Text('Welcome to KBVE')),
      ),
    );
  }
}
```

The `build` method returns a widget tree. When state changes, Flutter calls `build` again and efficiently updates only what differs — the foundation of its reactive UI model.

## Packages

[Pub.dev](https://pub.dev) is the official package repository for Dart / Flutter apps! Add one with `flutter pub add <package>`, which records it in `pubspec.yaml` and downloads it, then `import` it in your Dart code.

## FAQ

**What is Flutter?**
Flutter is Google's open-source UI toolkit for building natively compiled applications for mobile (iOS and Android), web, and desktop from a single Dart codebase. It renders its own widgets, so the UI looks and behaves consistently across platforms.

**What language does Flutter use?**
Flutter apps are written in Dart, an object-oriented, strongly typed language by Google. Dart compiles ahead-of-time to native machine code for release builds and just-in-time during development to enable hot reload.

**What is `flutter doctor`?**
`flutter doctor` is a diagnostic command that checks your environment for everything Flutter needs — the SDK, platform toolchains (Android SDK, Xcode), connected devices, and IDE plugins — and reports what is missing with fix suggestions.

**What is a widget in Flutter?**
Everything on screen is a widget — a lightweight, immutable description of part of the UI. Widgets compose into a tree; `StatelessWidget` describes UI that never changes, while `StatefulWidget` rebuilds when its state updates.

**Where do I find Flutter packages?**
[pub.dev](https://pub.dev) is the official package repository for Dart and Flutter. Add a package with `flutter pub add <name>`, which updates `pubspec.yaml` and downloads it, then import it in your Dart code.

<Adsense />

---
# GCloud

> gcloud is the Google Cloud CLI for creating, configuring, and scaling Google Cloud resources — Compute
Engine VMs, load balancers, networking, and more. This guide covers the CLI structure, Compute Engine,
and building an HTTP load balancer with managed instance groups.

Source: https://kbve.com/application/gcloud/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**gcloud** is the command-line interface for **Google Cloud Platform (GCP)** — it creates, configures, and scales resources like Compute Engine VMs, networks, and load balancers from a terminal or script. Every command follows a `gcloud GROUP COMMAND` structure (e.g. `gcloud compute instances create`).

This guide covers [Compute Engine](#gcloud-compute) and building an [HTTP load balancer](#load-balancer) with managed instance groups.

## Information


<Adsense />

## GCloud Compute

-   GCloud Compute Guide is still a work in progress; these are active notes from my current R&D.

    -   `shell gcloud compute --help`
        -   This will display all of the commands that will help you utilize the `compute engine`.

-   The are split into two major concepts, with `GROUP` and `COMMAND`.
    -   According to Google, the compute command helps create, configure and manipulate the virtual machines within your pre-set project.
    -   The `SYNOPSIS` is `gcloud compute GROUP | COMMAND [GCLOUD_WIDE_FLAG ...]`

    
## Load Balancer

Load balancing on the GCloud compuete platform.

-   Command to run 3 instances of `nginx` with an ingress load balancer. Additional Documentation on [Nginx Here](/application/nginx/)

    -   Shell command for VM that is running nginx inside of a `debian` operating system.

        -   ```shell
                   gcloud compute instances create www-server-1 \
                      --zone=us-west1-b \
                      --tags=network-lb-tag \
                      --machine-type=e2-medium \
                      --image-family=debian-11 \
                      --image-project=debian-cloud \
                      --metadata=startup-script=start_nginx.sh
            ```

            -   start_nginx.sh ->

                -   ```shell
                                      #!/bin/bash
                                      apt-get update
                                      apt-get install nginx -y
                    ```

            -   For switching from Nginx to Apache2, replace the `nginx` with `apache2`.
            -   To check the status on `ubuntu`, run the `sudo systemctl status nginx` OR `sudo systemctl status apache2`.
            

        -   Example of a Load Balance Template:

            -   The shell below is an example of an instance template that creates the load balance backend template.

                -   ```shell
                        gcloud compute instance-templates create lb-backend-template \
                        --region=us-west1 \
                        --network=default \
                        --subnet=default \
                        --tags=allow-health-check \
                        --machine-type=e2-medium \
                        --image-family=debian-11 \
                        --image-project=debian-cloud \
                        --metadata=startup-script=start_nginx_script.sh
                        
                    ```

            -   Key concept is : Managed instance groups MIGs
                -   Mage instance groups or MIGs enable you to operate applications on multiple identical / clone virtual machines, thus allowing your orchestration to become scalable and highly available. This is done by utilizing the components within the automated MIG services, which includes: autoscaling, autohealing, regional (multiple zone) deployment, and automatic updating.

        -   Manage Instance Group for the load balancer:

            -   ```shell
                    gcloud compute instance-groups managed create lb-backend-group \
                    --template=lb-backend-template --size=2 --zone=us-west1-b
                ```

            -   Health Check:

            -   ````shell
                    gcloud compute firewall-rules create fw-allow-health-check \
                    --network=default \
                    --action=allow \
                    --direction=ingress \
                    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
                    --target-tags=allow-health-check \
                    --rules=tcp:80
                    ```

                ````

            -   Backend-Services for gcloud compute

                -   ```shell

                      gcloud compute backend-services create web-backend-service \
                          --protocol=HTTP \
                          --port-name=http \
                          --health-checks=http-basic-check \
                          --global

                    ```

                    -   Add Instance Group as the Backend to the Backend Service:

                        -   ```shell
                                  gcloud compute backend-services add-backend web-backend-service \
                              --instance-group=lb-backend-group \
                              --instance-group-zone=us-west1-b \
                              --global
                            ```

                    -   Create a URL Map for routing the requests to the default backend services.

                        -   ````shell
                                  gcloud compute url-maps create web-map-http \
                                  --default-service web-backend-service
                                  ```

                            ````

                        -   Extra information regarding the URL Map:
                            Note: URL map is a Google Cloud configuration resource used to route requests to backend services or backend buckets. For example, with an external HTTP(S) load balancer, you can use a single URL map to route requests to different destinations based on the rules configured in the URL map:
                            Requests for [Video](https://example.com/video) go to one backend service.
                            Requests for [Audio](https://example.com/audio) go to a different backend service.
                            Requests for [Images](https://example.com/images) go to a Cloud Storage backend bucket.
                            Requests for any other host and path combination go to a default backend service.
                        -   Create a target HTTP proxy to route requests:

                            -   ```shell
                                        gcloud compute target-http-proxies create http-lb-proxy \
                                        --url-map web-map-http
                                ```

                        -   Global forwarding rule to route incoming requests to the proxy:

                            -   ```shell
                                        gcloud compute forwarding-rules create http-content-rule \
                                        --address=lb-ipv4-1\
                                        --global \
                                        --target-http-proxy=http-lb-proxy \
                                        --ports=80
                                ```


## Google Rules

### Google Forwarding Rules

Note: A forwarding rule and its corresponding IP address represent the frontend configuration of a Google Cloud load balancer. Learn more about the general understanding of forwarding rules from the Forwarding rule overview Guide.

[Using Forwarding Rules](https://cloud.google.com/load-balancing/docs/using-forwarding-rules)
[Rule Concepts](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts)

## FAQ

**What is the gcloud CLI?**
gcloud is the command-line interface for Google Cloud Platform. It lets you create, configure, and scale resources — Compute Engine VMs, networks, load balancers, storage, and more — from a terminal or scripts. Commands follow a `gcloud GROUP COMMAND` structure.

**How do I create a VM with gcloud?**
Use `gcloud compute instances create NAME` with flags for zone, machine type, and image, e.g. `--zone=us-west1-b --machine-type=e2-medium --image-family=debian-11 --image-project=debian-cloud`. A `startup-script` metadata flag can install software like Nginx on first boot.

**What is a managed instance group (MIG)?**
A MIG runs multiple identical VMs from a single instance template. It provides autoscaling, autohealing, multi-zone deployment, and automatic rolling updates — the backend for scalable, highly available load-balanced applications.

**How does an HTTP load balancer work on Google Cloud?**
An external HTTP load balancer chains a global forwarding rule and IP to a target HTTP proxy, which uses a URL map to route requests to backend services. Each backend service points at instance groups and a health check, so traffic only reaches healthy VMs.

**What is a forwarding rule in Google Cloud?**
A forwarding rule and its IP address form the frontend of a load balancer. It matches incoming traffic on a protocol and port and forwards it to a target proxy or backend, tying the public entry point to the load balancing configuration behind it.

<Adsense />

---
# Git

> Git is a distributed version control system designed to handle everything from small to very large projects with speed and efficiency.
Git allows multiple developers to collaborate, track changes, and manage project history effectively. Ideal for version tracking and collaboration.

Source: https://kbve.com/application/git/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

Git, a powerful distributed version control system, excels in managing project history and facilitating collaboration among multiple developers.
By efficiently tracking changes in source code, Git enables seamless coordination and conflict resolution, ensuring that every contribution is accounted for.
Boasting lightning-fast performance and robust branching capabilities, Git supports a wide range of workflows, from individual development to large-scale enterprise projects.
Renowned for its flexibility and reliability, Git has become an indispensable tool in modern software development, empowering teams to innovate and iterate with confidence.

---

<Aside>
	Git commands can be powerful and sometimes destructive. Always make sure you
	understand the implications of a command before running it, especially those
	that alter history, such as **git reset**, **git rebase**, and **git
	filter-branch**. It's often a good idea to create backups or work on a
	separate branch when experimenting with these commands.
</Aside>

<Adsense />

## Cheatsheet

| Command                                                 | Description                                                                     |
| ------------------------------------------------------- | ------------------------------------------------------------------------------- |
| `git init`                                              | Initializes a new Git repository.                                               |
| `git clone <repo>`                                      | Clones an existing repository into a new directory.                             |
| `git status`                                            | Displays the state of the working directory and the staging area.               |
| `git add <file>`                                        | Stages changes to be committed.                                                 |
| `git commit -m "message"`                               | Records the staged changes with a descriptive message.                          |
| `git push`                                              | Uploads local repository content to a remote repository.                        |
| `git pull`                                              | Fetches from and integrates with another repository or a local branch.          |
| `git fetch`                                             | Downloads objects and refs from another repository.                             |
| `git merge <branch>`                                    | Joins two or more development histories together.                               |
| `git branch`                                            | Lists all branches in the repository.                                           |
| `git branch <branch-name>`                              | Creates a new branch.                                                           |
| `git checkout <branch-name>`                            | Switches to the specified branch.                                               |
| `git checkout -b <branch-name>`                         | Creates and switches to a new branch.                                           |
| `git log`                                               | Shows the commit logs.                                                          |
| `git remote -v`                                         | Shows the URLs of the remote repositories.                                      |
| `git remote add <name> <url>`                           | Adds a new remote repository.                                                   |
| `git diff`                                              | Shows changes between commits, commit and working tree, etc.                    |
| `git reset <file>`                                      | Unstages a file while retaining changes in the working directory.               |
| `git reset --hard <commit>`                             | Resets the index and working directory to the specified commit.                 |
| `git rm <file>`                                         | Removes a file from the working directory and the index.                        |
| `git stash`                                             | Temporarily saves changes in a dirty working directory.                         |
| `git stash pop`                                         | Restores the most recently stashed files.                                       |
| `git tag <tag-name>`                                    | Creates a new tag.                                                              |
| `git show <object>`                                     | Displays information about any Git object.                                      |
| `git config --global user.name "name"`                  | Sets the user name for all repositories on the local machine.                   |
| `git config --global user.email "email"`                | Sets the user email for all repositories on the local machine.                  |
| `git rebase <branch>`                                   | Reapplies commits on top of another base tip.                                   |
| `git cherry-pick <commit>`                              | Apply changes introduced by some existing commits.                              |
| `git mv <old-file> <new-file>`                          | Renames a file and stages the move.                                             |
| `git bisect start`                                      | Starts a binary search to find the commit that introduced a bug.                |
| `git bisect bad`                                        | Marks the current commit as bad during bisecting.                               |
| `git bisect good <commit>`                              | Marks a known good commit during bisecting.                                     |
| `git blame <file>`                                      | Shows what revision and author last modified each line of a file.               |
| `git clean -f`                                          | Removes untracked files from the working directory.                             |
| `git reflog`                                            | Shows a log of changes to the tip of branches and other references.             |
| `git shortlog`                                          | Summarizes git log output.                                                      |
| `git describe --tags`                                   | Describes a commit using the most recent tag reachable from it.                 |
| `git archive --format=zip --output=<file.zip> <commit>` | Creates an archive of files from a named tree.                                  |
| `git gc`                                                | Runs a garbage collection on the repository.                                    |
| `git fsck`                                              | Verifies the connectivity and validity of objects in the database.              |
| `git apply <patch>`                                     | Applies a patch to files and/or to the index.                                   |
| `git cherry <branch>`                                   | Lists commits not merged upstream on a given branch.                            |
| `git ls-tree <tree-ish>`                                | Lists the contents of a tree object.                                            |
| `git grep <pattern>`                                    | Searches for a pattern in the working directory and index.                      |
| `git show-branch`                                       | Shows branches and their commits.                                               |
| `git rev-list <commit>`                                 | Lists commit objects in reverse chronological order.                            |
| `git commit --amend`                                    | Rewrites the most recent commit message or adds changes to the previous commit. |
| `git submodule add <repo> <path>`                       | Adds a submodule to a repository.                                               |
| `git submodule update --init`                           | Initializes, fetches and checks out the submodule.                              |
| `git merge --abort`                                     | Aborts a conflicted merge.                                                      |
| `git mergetool`                                         | Launches a merge conflict resolution tool.                                      |
| `git archive --format=tar <commit> -o <file.tar>`       | Creates a tar archive of the files in a commit.                                 |
| `git reset --soft <commit>`                             | Resets the index but not the working directory.                                 |
| `git diff --staged`                                     | Shows the difference between the index and the last commit.                     |
| `git blame -L <start>,<end> <file>`                     | Shows blame information for the specified line range of a file.                 |
| `git rebase --interactive <commit>`                     | Starts an interactive rebase session.                                           |
| `git checkout -- <file>`                                | Discards changes in the working directory for a specific file.                  |
| `git filter-branch --tree-filter 'command' HEAD`        | Rewrites branches by applying a command on each tree.                           |
| `git symbolic-ref HEAD <ref>`                           | Changes the current branch by updating the symbolic reference.                  |

---

## Conventional Commits Cheatsheet

| Commit Message                     | Description                                                                                                   |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `feat: new feature`                | Introduce a new feature                                                                                       |
| `feat!: breaking change`           | Introduce a breaking change                                                                                   |
| `feat(scope)!: rework API`         | Rework API with a breaking change                                                                             |
| `chore(deps): update dependencies` | Update dependencies                                                                                           |
| `build`                            | Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)           |
| `ci`                               | Changes to CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)       |
| `chore`                            | Changes which don't change source code or tests e.g. changes to the build process, auxiliary tools, libraries |
| `docs`                             | Documentation only changes                                                                                    |
| `fix`                              | A bug fix                                                                                                     |
| `fix(scope): bug in scope`         | Fix a bug within a specific scope                                                                             |
| `perf`                             | A code change that improves performance                                                                       |
| `refactor`                         | A code change that neither fixes a bug nor adds a feature                                                     |
| `revert`                           | Revert something                                                                                              |
| `style`                            | Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)        |
| `test`                             | Adding missing tests or correcting existing tests                                                             |

---

## Github

GitHub, a leading platform for version control and collaboration, leverages Git to provide a seamless environment for developers to host, review, and manage code.
Offering features like pull requests, code reviews, and integrated issue tracking, GitHub streamlines the development workflow and fosters collaboration among team members.
With its robust community and extensive ecosystem of tools and integrations, GitHub enhances productivity and innovation, making it an essential resource for both open-source projects and private repositories.
Additionally, GitHub's user-friendly interface and powerful features make it a popular choice for developers seeking to share their work and contribute to the global coding community.

### Github Pages

GitHub Pages is a static site hosting service that enables developers to publish web content directly from a repository.
Supporting custom domains, Jekyll-powered themes, and HTTPS enforcement, the platform simplifies the process of deploying personal projects, documentation, or portfolio websites.
Pages are generated from branches within a repository, allowing seamless integration with version control while ensuring updates reflect instantly upon deployment.
With support for Markdown and HTML, developers can craft content-rich pages without relying on complex backend infrastructure.
The service enhances accessibility by offering free hosting for public repositories, making it a valuable tool for both individual creators and collaborative teams.

<Aside type="tip">

Did you know that this whole document is hosted on Github Pages?

Our docs are powered by [Astro](/application/javascript/#astro)!

</Aside>

While Jekyll is a popular choice for generating static sites on GitHub Pages, alternative frameworks like Astro, Next.js, and Hugo provide additional flexibility and performance benefits.
Astro excels in optimizing content delivery by shipping minimal JavaScript while enabling seamless integration with UI frameworks such as React, Vue, and Svelte.
Next.js, although primarily designed for server-side rendering and dynamic applications, can generate static exports that work efficiently with GitHub Pages when configured correctly.
Hugo, known for its blazing-fast build times and Go-based architecture, offers a lightweight solution for content-heavy websites.
By leveraging these frameworks, developers can tailor their projects to suit different performance needs, content workflows, and interactive experiences beyond traditional Jekyll-based sites.

<Aside type="tip">

Remember to setup your CNAME and **.nojekyll** file, if you plan on using a custom domain and want to use another static generator.

</Aside>

Now the other topic with the Github pages is the security!
Github recommends that you verify your domain with our profile or organization.

### Github Actions

GitHub Actions are YAML files designed to automate repetitive tasks using predefined workflows and variables, enabling seamless integration and continuous deployment.
They enhance productivity by managing build, test, and deployment processes directly within the GitHub environment.

#### KBVE API GROQ

These are the custom notes on our github actions!

#### CI Patch

<Aside type="tip">

This CI Patch is slated to be deprecated in the future!

</Aside>

The `ci-patch.yml` GitHub Action is designed to automate the process of creating pull requests for branches that follow a naming pattern starting with "patch".
When a push event occurs on any of these branches, the action triggers and runs on the latest version of Ubuntu.
It first checks out the code using the `actions/checkout` action. Then, it uses the `diillson/auto-pull-request` action to automatically create a pull request from the patch branch to the `dev` branch.
The pull request will have a title indicating the source branch and a body containing the message "An automated PR".
Additionally, the pull request will be labeled with "auto-pr".

```yaml
name: CI Patch

on:
    push:
        branches:
            - 'patch*'

jobs:
    handle:
        runs-on: ubuntu-latest
        steps:
            - name: Checkout
              uses: actions/checkout@v4

            - name: Auto-Pull
              uses: diillson/auto-pull-request@latest
              with:
                  github_token: ${{ secrets.GITHUB_TOKEN }}
                  destination_branch: 'dev'
                  pr_title: 'Pulling ${{ github.ref }} into Dev'
                  pr_body: |
                      *An automated PR*
                  pr_label: 'auto-pr'
```

### kbve-shell

Example of calling the KBVE Shell

```yaml
- name: React Fish & Chip
  if: needs.alter.outputs.reactfishchip == 'true'
  uses: ./.github/actions/kbve-shell
  with:
      flag: '-build react-phaser-fish-chip'
      create_pull_request: true
      github_token: ${{ secrets.GITHUB_TOKEN }}
      pull_request_title: 'react-fish-chip-built-request'
      pull_request_body: 'React Fish and Chip Built Request'
```

### Matrix

<Aside type="caution" title="Deprecated">

The matrix-based crate publish strategy shown below has been replaced by the **fanout pipeline** (see [Docker](#docker) above).
Each crate now gets its own independent `ci-publish.yml` dispatch with per-package concurrency groups, eliminating the single-matrix bottleneck.

</Aside>

#### Crate Publish

<Aside type="tip">

Remember to setup your secrets for the `CRATES_TOKEN`!

</Aside>

These are brief notes on the `rust-publish-crate.yml` within our monorepo, which is used to publish Rust crates to crates.io.
The old matrix approach used a single job to filter changed crates and fan them out via `strategy.matrix`.
This has been superseded by per-crate `workflow_dispatch` runs fired from `ci-main.yml`'s `dispatch_publish` job, where each crate (q, jedi, soul, kbve, erust, holy) gets its own isolated `ci-publish.yml` run with concurrency group `ci-publish-crates-{name}`.

```yaml
# Legacy matrix pattern (replaced by fanout dispatch)
generate_crates_matrix:
    needs: ['deploy', 'alter', 'globals']
    runs-on: ubuntu-latest
    outputs:
        matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
        - name: Generate Matrix
          id: set-matrix
          run: |
              MATRIX=$(jq -n '{
                include: [
                  { "name": "q", "condition": "${{ needs.alter.outputs.q_crate }}" },
                  { "name": "jedi", "condition": "${{ needs.alter.outputs.jedi_crate }}" },
                  { "name": "soul", "condition": "${{ needs.alter.outputs.soul_crate }}" },
                  { "name": "kbve", "condition": "${{ needs.alter.outputs.kbve_crate }}" },
                  { "name": "erust", "condition": "${{ needs.alter.outputs.erust_crate }}" },
                  { "name": "holy", "condition": "${{ needs.alter.outputs.holy_crate }}" }
                ]
              } | .include |= map(select(.condition == "true"))')
              echo "matrix=$MATRIX" >> "$GITHUB_OUTPUT"

publish_crates:
    needs: ['generate_crates_matrix']
    name: Publish Rust Crates
    strategy:
        matrix: ${{ fromJson(needs.generate_crates_matrix.outputs.matrix) }}
    uses: KBVE/kbve/.github/workflows/rust-publish-crate.yml@main
    with:
        package: ${{ matrix.name }}
    secrets:
        CRATES_TOKEN: ${{ secrets.CRATES_TOKEN }}
```

#### Music

These are brief notes on the `i-music-process.yml` within our monorepo.

These two steps are the core for the action that would process our music issue tickets.
The first is design to parse the body of the created issue ticket and prepare it for a JSON POST, while the second step does the actual system prompt and sends the post request to the API.

```yaml

 - name: Escape issue body for JSON
      if: env.HAS_YOUTUBE_LINK == 'true' && env.IS_MUSIC_ISSUE == 'true'
      uses: actions/github-script@v7
      with:
        script: |
              const marked = require('marked');
              const DOMPurify = require('dompurify')(new (require('jsdom').JSDOM)().window);
              const { JSDOM } = require('jsdom');

              function markdownToJsonSafeString(markdownContent) {
                  // Convert markdown to HTML
                  const htmlContent = marked.parse(markdownContent);

                  // Sanitize the HTML content
                  const sanitizedHtmlContent = DOMPurify.sanitize(htmlContent);

                  // Use jsdom to create a temporary DOM element to extract text content from sanitized HTML
                  const dom = new JSDOM(sanitizedHtmlContent);
                  const textContent = dom.window.document.body.textContent || '';

                  // Ensure the text content is JSON-safe
                  const jsonSafeString = JSON.stringify(textContent);

                  return jsonSafeString;
              }

              const issueBody = context.payload.issue.body;
              const escapedIssueBody = markdownToJsonSafeString(issueBody);
              core.exportVariable('ESCAPED_ISSUE_BODY', escapedIssueBody);

    - name: Extract and display YouTube ID if link is found
      if: env.HAS_YOUTUBE_LINK == 'true' && env.IS_MUSIC_ISSUE == 'true'
      uses: actions/github-script@v7
      with:
        script: |
          const { YOUTUBE_ID, ESCAPED_ISSUE_BODY } = process.env;
          const system = `Imagine three different data experts are answering this task. All experts will write down their steps of their thinking, then share it with the group. Then all experts will go on to the next step, etc. If any expert realizes they're wrong at any point then they leave. Remember the goal is to complete all of the steps provided and generate the final command. \n\n Please read the provided text, extract the required information, sanitize the title, and fill it into the specified command format. The title should only contain numbers, letters, spaces, hyphens, and characters (, ), ., and -. Your task is to complete a finalized kbve.sh shell command with the extracted information. If you can not complete the command, go back and process the input data again. \n\n Hint: Titles may contain multiple words separated by quotes and hyphens. These words are often the band name and followed by the song. **Example:**\n\`\`\`\n\n**Fill out the Form**\n\nYouTube Link: https://www.youtube.com/watch?v=<yt_id>\nTitle:  <title> \nGenre:  <genre>\n\nPick only one of the different genres!\ndnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock, japrock\n\n\n\`\`\`\n\n**Output:**\n\n\`\`\`bash\n./kbve.sh -nx kbve.com:music --args=\\\"--file=<genre>--title='<title>' --ytid=<yt_id>\\\"\"\n\nHere is the template for the command:\n\`\`\`\n./kbve.sh -nx kbve.com:music --args=\\\"--file=[insert file/genre here] --title='[insert sanitized title here]' --ytid=[insert YouTube ID here]\\\"\n\nEnsure to:\n1. Extract the \`File/Genre\`, \`Title\`, and \`YouTube ID\` from the text.\n2. Sanitize the \`Title\` to only include numbers, letters, spaces, hyphens, quotes, periods, the characters () . and -. Please do not replace spaces with any other characters and keep the spaces in the sanitized title.\n3. Only acceptable genres/file are dnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock, japrock\n4. Fill in the command template with the extracted and sanitized values.\n\n**Your Task:**\nPlease parse the provided text below and generate the command. You must follow all the steps that are stated and make sure to wrap the kbve.sh command in bash code block. \n\n`;
          const message = ESCAPED_ISSUE_BODY;
          const payload = JSON.stringify({
            system,
            message,
            model: "mixtral-8x7b-32768"
          });

          const axios = require('axios');
          const response = await axios.post('https://rust.kbve.com/api/v1/call_groq', payload, {
            headers: {
              'Content-Type': 'application/json'
            }
          });
          core.exportVariable('GROQ_OUTPUT', response.data);

```

#### Itch

Github Action for deploying the application build onto the Itch platform!

Deploying your application build to the Itch platform has never been easier, thanks to GitHub Actions!
The **Itch.io Publish** GitHub Action automates the process, streamlining your workflow and ensuring that your latest builds are always up-to-date on Itch.io.

**GitHub Action - Itch.io Publish**

-   **Marketplace [Action](https://github.com/marketplace/actions/itch-io-publish)**: Discover the action on GitHub Marketplace, where you can integrate it directly into your repositories.
-   **Dev [Repo](https://github.com/KikimoraGames/itch-publish)**: Explore the development repository to understand the inner workings of the action, contribute, or customize it for your needs.

This powerful tool takes the manual effort out of deploying to Itch.io, allowing you to focus more on development and less on the repetitive tasks of deployment.
Embrace automation and enhance your productivity with GitHub Actions and Itch.io!

Below is an example of a GitHub Itch workflow configuration. Note that tab indentations might be out of sync!

```yaml
name: Itch Deploy

on: push
env:
  ITCH_USERNAME: my-itch-username
  ITCH_GAME_ID: my-itch-game-id
jobs:
  deploy:
    name: Upload to Itch
    runs-on: ubuntu-latest
    strategy:
      fail-fast: true
      matrix:
        channel:
          - windows
          - webgl
    runs-on: ubuntu-latest
    name: Deploy - Itch.io ${{ matrix.template }}
    steps:
      - uses: actions/download-artifact@v2.0.8
        with:
          name: ${{ matrix.channel }}
          path: build/${{ matrix.channel }}
      - uses: KikimoraGames/itch-publish@v0.0.3
        with:
          butlerApiKey: ${{secrets.BUTLER_API_KEY}}
          gameData: ./build/${{ matrix.template }}
          itchUsername: ${{env.ITCH_USERNAME}}
          itchGameId: ${{ env.ITCH_GAME_ID }}
          buildChannel: ${{ matrix.channel }}
          buildNumber: ${{ needs.version.outputs.version_hash }}

```

Remember to add your secrets, `BUTLER_API_KEY`, before deploying to Itch.

You can grab the `BUTLER_API_KEY` from Itch via [API Keys](https://itch.io/user/settings/api-keys) , which will allow Github Actions to communicate with Itch.io's API.

KBVE Example:

```yaml
name: Itch KBVE Deploy

on: push
env:
  ITCH_USERNAME: kbve
  ITCH_GAME_ID: my-itch-game-id
jobs:
  deploy:
    name: Upload to Itch
    runs-on: ubuntu-latest
    strategy:
      fail-fast: true
      matrix:
        channel:
          - windows
          - webgl
    runs-on: ubuntu-latest
    name: Deploy - Itch.io ${{ matrix.template }}
    steps:
      - uses: actions/download-artifact@v2.0.8
        with:
          name: ${{ matrix.channel }}
          path: build/${{ matrix.channel }}
      - uses: KikimoraGames/itch-publish@v0.0.3
        with:
          butlerApiKey: ${{secrets.BUTLER_API_KEY}}
          gameData: ./build/${{ matrix.template }}
          itchUsername: ${{env.ITCH_USERNAME}}
          itchGameId: ${{ env.ITCH_GAME_ID }}
          buildChannel: ${{ matrix.channel }}
          buildNumber: ${{ needs.version.outputs.version_hash }}
```

#### Unity

Introducing the Unity Test Runner as a GitHub Action, a seamless way to integrate automated testing into your Unity projects!
This action allows you to run unit tests, integration tests, and play mode tests directly from your GitHub repository, ensuring your game code maintains high quality and functionality throughout development.

**GitHub Action - Unity Test Runner**

-   **Marketplace [Action](https://github.com/marketplace/actions/unity-test-runner)**: Find the Unity Test Runner action on GitHub Marketplace, ready for easy integration into your workflows.
-   **Dev [Repo](https://github.com/webbertakken/unity-test-runner)**: Visit the development repository for detailed setup instructions, contribution guidelines, and customization options.

By incorporating the Unity Test Runner into your CI/CD pipeline, you can automate testing, catch bugs early, and maintain code quality with minimal effort.
Elevate your Unity development process with this efficient and reliable testing solution!

Below is a sample GitHub Actions configuration for running Unity tests, ensuring your game code maintains high quality and functionality through continuous integration.

```yaml

- uses: game-ci/unity-test-runner@v2.1.0
    id: testRunner
    env:
        UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
    with:
        projectPath: ${{ matrix.projectPath }}
        unityVersion: ${{ matrix.unityVersion }}
        githubToken: ${{ secrets.GITHUB_TOKEN }}
        customParameters: '-nographics'
- uses: actions/upload-artifact@v2
        if: always()
        with:
            name: Test results (all modes)
            path: ${{ steps.testRunner.outputs.artifactsPath }}

```

-   Remember that you will need a valid Unity license for this action!

Here is step-by-step breakdown of a Unity GitHub Action

<Steps>
1.  **Define the Workflow**

    ```yaml
    name: Unity Test Runner
    ```
    - The `name` field sets the name of the workflow, making it easier to identify in the GitHub Actions tab.

2.  **Specify the Trigger Events**

    ```yaml
    on: [push, pull_request]
    ```

    -   The `on` field specifies the events that trigger this workflow. Here, it triggers on `push` and `pull_request` events.

3.  **Define the Job and Environment**

    ```yaml
    jobs:
        test:
            runs-on: ubuntu-latest
    ```

    -   The `jobs` field defines the jobs that will run as part of this workflow. The `test` job runs on the `ubuntu-latest` environment, which provides a clean and consistent Linux environment for running the tests.

4.  **Set Up the Matrix Strategy**

    ```yaml
    strategy:
        matrix:
            projectPath: [path/to/your/project]
            unityVersion: [2020.3.11f1, 2021.1.13f1]
    ```

    -   The `matrix` strategy allows you to define multiple configurations for your jobs.
        Here, it sets up multiple Unity versions and project paths to test against, ensuring compatibility across different environments.

5.  **Checkout the Repository**

    ```yaml
    steps:
        - name: Checkout repository
          uses: actions/checkout@v2
    ```

    -   The `steps` field lists the steps in the job.
        The first step uses the `actions/checkout` action to clone the repository, providing access to the codebase for subsequent steps.

6.  **Cache Unity Packages**

    ```yaml
    - name: Cache Unity packages
      uses: actions/cache@v2
      with:
          path: ~/.local/share/unity3d/Unity/
          key: ${{ runner.os }}-unity-${{ matrix.unityVersion }}
          restore-keys: |
              ${{ runner.os }}-unity-
    ```

    -   Caching saves downloaded Unity packages between workflow runs, reducing the time needed for setup.
        The cache is identified by a unique key based on the runner OS and Unity version.

7.  **Run Unity Test Runner**

    ```yaml
    - name: Run Unity Test Runner
      uses: game-ci/unity-test-runner@v2.1.0
      id: testRunner
      env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
      with:
          projectPath: ${{ matrix.projectPath }}
          unityVersion: ${{ matrix.unityVersion }}
          githubToken: ${{ secrets.GITHUB_TOKEN }}
          customParameters: '-nographics'
    ```

    -   This step runs the Unity Test Runner action:
        -   `uses` specifies the action to run.
        -   `id` gives this step an identifier for later reference.
        -   `env` sets environment variables, including `UNITY_LICENSE`, which is essential for running Unity in batch mode.
        -   `with` specifies parameters for the action:
            -   `projectPath` sets the path to the Unity project.
            -   `unityVersion` specifies the Unity version.
            -   `githubToken` is used for authentication.
            -   `customParameters` allows passing additional parameters to Unity, such as `-nographics` for headless execution.

8.  **Upload Test Results**

    ```yaml
    - name: Upload Test Results
      uses: actions/upload-artifact@v2
      if: always()
      with:
          name: Test results (all modes)
          path: ${{ steps.testRunner.outputs.artifactsPath }}
    ```

    -   This step uploads the test results as artifacts:
        -   `if: always()` ensures this step runs regardless of the previous step’s outcome.
        -   `with` specifies parameters for the upload:
            -   `name` sets the artifact's name.
            -   `path` specifies the file path to upload, using the output from the `testRunner` step.

</Steps>

<Aside>

-   **Unity License**: Ensure you have a valid Unity license stored as a GitHub Secret **UNITY_LICENSE**. This license is required to run Unity in batch mode.
-   **Matrix Strategy**: Testing against multiple Unity versions and project paths ensures comprehensive coverage and compatibility.
-   **Caching**: Utilizing the cache can significantly speed up workflow runs by reusing previously downloaded Unity packages.
-   **Artifact Upload**: Storing test results as artifacts allows you to review the outcomes of your tests even after the workflow completes, facilitating debugging and quality assurance.

</Aside>

When you finish following these steps, you will be setting up a robust and automated testing pipeline for your future Unity projects, enhancing your development workflow and ensuring higher code quality.

#### Godot

Boost your Godot development workflow with these handy GitHub Actions references! Automate your build, test, and deployment processes to streamline your project management.

-   **GitHub Actions via [godot-ci](https://github.com/marketplace/actions/godot-ci)**: Utilize the godot-ci action from the GitHub Marketplace to automate your Godot engine tasks, including exporting your project to multiple platforms.
-   **GitHub Actions HTML5 Workflow [Gist by doctor-g](https://gist.github.com/doctor-g/57cd32c10beb04fcbd3b83f23f439d37)**: Explore this detailed gist by doctor-g, showcasing a GitHub Actions workflow for exporting Godot projects to HTML5, making it easy to deploy your game on the web.

These resources will help you integrate GitHub Actions into your Godot projects, ensuring efficient and reliable automation throughout your development process.

#### Docker

The KBVE monorepo uses a **fanout CI pipeline** for Docker applications.
Instead of a single workflow that builds all apps in a matrix, `ci-main.yml` dispatches one independent `ci-docker.yml` run per changed app.
Each dispatch is a fully isolated GitHub Actions workflow run with its own concurrency group, logs, re-run button, and failure tracker.

##### Why Fanout over Matrix

| | Matrix (old) | Fanout dispatch (current) |
|--|---|---|
| App A fails → App B blocked? | Possible (shared workflow) | No — independent runs |
| Independent re-run per app | No — re-runs entire matrix | Yes — re-run just that app |
| Logs per app | Interleaved in one run | Own workflow run, own logs |
| Concurrency control per app | No | Yes — `ci-docker-{app_name}` |
| Failure tracker per app | Single issue for all | One issue per app |

##### Pipeline Architecture

```mermaid
flowchart TD
    push["push to main"] --> main["CI - Main<br/>globals → alter → dispatch"]

    main -->|"app=axum-kbve"| d1["CI - Docker<br/>axum-kbve"]
    main -->|"app=discordsh"| d2["CI - Docker<br/>discordsh"]
    main -->|"app=mc"| d3["CI - Docker<br/>mc"]
    main -->|"app=edge"| d4["CI - Docker<br/>edge"]
    main -->|"app=..."| dn["CI - Docker<br/>..."]

    d1 --> p1["queue_guard → config → test → publish → kube"]
    d2 --> p2["queue_guard → config → test → publish → kube"]
    d3 --> p3["queue_guard → config → test → publish → kube"]
    d4 --> p4["queue_guard → config → test → publish → kube"]
```

##### Three Phases

**Phase 1 — Detection** (`ci-main.yml`): A push to `main` triggers `utils-file-alterations.yml`, which scans path patterns using glob matching (via `changed-files`) across 40+ packages and apps.
Each app has its own set of watched paths — for example, `astro_kbve` watches `apps/kbve/astro-kbve/**`, `apps/kbve/axum-kbve/**`, and several `packages/npm/` directories.

**Phase 2 — Dispatch** (`ci-main.yml`): Two dispatch jobs read the detection outputs and fire independent `workflow_dispatch` events:

- `dispatch_docker` — one `ci-docker.yml` run per changed Docker app
- `dispatch_publish` — one `ci-publish.yml` run per changed package (npm, crates, or python)

Each dispatch passes three fields: `app_name`, `sha` (the triggering commit), and `dispatched_at` (unix timestamp for queue guard timing).

**Phase 3 — Execution** (`ci-docker.yml`, one run per app):

<Steps>

1. **Queue Guard** (5 min timeout) — compares `dispatched_at` against current time. Fails loudly if the run waited more than 2 hours in the concurrency queue, preventing stale image deployment.

2. **Config** (5 min timeout) — a single `case` statement resolves all per-app settings from the `app_name` input: runner type, Docker image name, e2e project, Cargo.toml path, deployment YAML, and whether tests exist.

3. **Test** (conditional) — calls `docker-test-app.yml` which builds a `ci-{sha}` tagged image in GHCR and runs the app's e2e test suite against it. Skipped for apps without tests (e.g., `kilobase`).

4. **Publish** — calls `utils-publish-docker-image.yml` which promotes the tested `ci-{sha}` tag to a release tag, or rebuilds if the CI image is missing.

5. **Update Kube** (conditional) — calls `utils-update-kube-manifest.yml` which bumps the image tag in the Kubernetes deployment YAML and opens a PR to `main`. Skipped for apps without a `deployment_yaml`.

6. **Track Failure** — if any prior job failed, calls `utils-ci-failure-tracker.yml` which creates or updates a GitHub issue titled `[CI] CI - Docker / {app_name} — Failed`.

</Steps>

##### Docker App Registry

| App | Image | Runner | E2E | Has Kube Deployment |
|-----|-------|--------|-----|---------------------|
| axum-kbve | `kbve/kbve` | arc-runner-set | axum-kbve-e2e | Yes |
| herbmail | `kbve/herbmail` | ubuntu-latest | herbmail | Yes |
| memes | `kbve/memes` | ubuntu-latest | — | Yes |
| irc-gateway | `kbve/irc-gateway` | ubuntu-latest | — | Yes |
| discordsh | `kbve/discordsh` | ubuntu-latest | discordsh-e2e | Yes |
| mc | `kbve/mc` | ubuntu-latest | mc | Yes |
| edge | `kbve/edge` | ubuntu-latest | edge-e2e | Yes |
| cryptothrone | `kbve/cryptothrone` | ubuntu-latest | cryptothrone-e2e | Yes |
| kilobase | `kbve/kilobase` | ubuntu-latest | — | No |

##### Concurrency & Queuing

Each dispatched run uses a per-app concurrency group with `cancel-in-progress: false`:

```yaml
concurrency:
    group: ci-docker-${{ inputs.app_name }}
    cancel-in-progress: false
```

```mermaid
sequenceDiagram
    participant M as ci-main
    participant Q as ci-docker queue (axum-kbve)
    participant R as Runner

    M->>Q: dispatch v5.0.10 (Run A)
    R->>Q: Run A starts — RUNNING
    M->>Q: dispatch v5.0.11 (Run B)
    Q-->>R: Run B → PENDING (waits for A)
    M->>Q: dispatch v5.0.11+hotfix (Run C)
    Q-->>R: Run C replaces B as PENDING (B cancelled)
    R->>Q: Run A completes
    R->>Q: Run C starts — RUNNING
```

<Aside type="tip" title="Why cancel-in-progress: false">

Setting `cancel-in-progress: true` would cancel the *currently running* build mid-flight — dangerous if it's mid-push to GHCR.
With `false`, the in-flight run always completes safely.
Only the *pending* slot rotates: the newest pending dispatch replaces any older pending one, naturally de-duplicating redundant builds of the same version.

</Aside>

##### Queue Guard

The queue guard is the first job in every `ci-docker.yml` run.
It converts GitHub's silent pending-run cancellation into a visible, tracked failure:

```yaml
queue_guard:
    runs-on: ubuntu-latest
    timeout-minutes: 5
    steps:
        - name: Check queue age
          run: |
              DISPATCHED_AT="${{ inputs.dispatched_at }}"
              NOW=$(date +%s)
              AGE=$(( NOW - DISPATCHED_AT ))
              MAX_QUEUE_SECONDS=7200
              if [ $AGE -gt $MAX_QUEUE_SECONDS ]; then
                echo "::error::Run for ${{ inputs.app_name }} queued for ${AGE}s (limit: ${MAX_QUEUE_SECONDS}s)."
                exit 1
              fi
              echo "Queue age: ${AGE}s — within threshold."
```

<Aside type="caution" title="Stale Deploy Protection">

Without the queue guard, a run dispatched for `axum-kbve` v5.0.10 could sit in the concurrency queue for hours, then deploy *after* v5.0.11 has already shipped — rolling back production to an older image.
The 2-hour threshold catches this scenario and fails loudly, opening a failure tracker issue so the team can re-dispatch.

</Aside>

##### Dispatch Example

```yaml
dispatch_docker:
    needs: ['alter']
    runs-on: ubuntu-latest
    steps:
        - name: Dispatch per changed app
          env:
              GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          run: |
              DISPATCHED_AT=$(date +%s)
              SHA="${{ github.sha }}"

              dispatch() {
                gh workflow run ci-docker.yml \
                  --repo "${{ github.repository }}" \
                  --ref main \
                  --field app_name="$1" \
                  --field sha="$SHA" \
                  --field dispatched_at="$DISPATCHED_AT"
              }

              [ "${{ needs.alter.outputs.astro_kbve }}" = "true" ]    && dispatch "axum-kbve"
              [ "${{ needs.alter.outputs.discordsh }}" = "true" ]     && dispatch "discordsh"
              [ "${{ needs.alter.outputs.herbmail }}" = "true" ]      && dispatch "herbmail"
              [ "${{ needs.alter.outputs.memes }}" = "true" ]         && dispatch "memes"
              [ "${{ needs.alter.outputs.irc_gateway }}" = "true" ]   && dispatch "irc-gateway"
              [ "${{ needs.alter.outputs.mc }}" = "true" ]            && dispatch "mc"
              [ "${{ needs.alter.outputs.edge }}" = "true" ]          && dispatch "edge"
              [ "${{ needs.alter.outputs.cryptothrone }}" = "true" ]  && dispatch "cryptothrone"
              [ "${{ needs.alter.outputs.kilobase }}" = "true" ]      && dispatch "kilobase"
```

#### Docker Image Pull-Through Cache

Large base images (e.g. the ~20 GB `ghcr.io/epicgames/unreal-engine` used by the
Unreal pipeline) are otherwise re-pulled from the internet by every ephemeral
`arc-runner-*` job, ~25 min each. An in-cluster `registry:2` running in **proxy
mode** caches those layers on a Longhorn PVC so the first pull fills it once and
every later pull is LAN speed.

- Manifest: `apps/kube/github/runners/manifests/registry-mirror-ghcr.yaml`
- Service: `registry-mirror-ghcr.arc-runners.svc.cluster.local:5000`
- Upstream: `https://ghcr.io` (auth via the in-cluster `github-arc-token`)
- Proxy revalidation: 24h TTL — UE `dev-*` tags are mutable, so the cache
  re-checks the tag→manifest mapping daily rather than serving a stale image for
  a week after an upstream re-push (blob bytes are immutable, so this is cheap).
- Retention: soft (80%) / hard (95%) size limits. A whitelist ConfigMap
  (`registry-mirror-ghcr-whitelist`) protects pinned tags under the soft limit;
  the hard limit overrides it to avoid a full disk.
- Access: an Ingress NetworkPolicy (`registry-mirror-ghcr-ingress`) restricts
  `:5000` to the `arc-runners` namespace, since the cache serves the private UE
  image unauthenticated over HTTP and has the delete API enabled.

##### Use the cache from another runner job

Routing another CI job's image pulls through the cache is two steps:

1. **Opt the runner in.** Add the cache host to that runner's dind args so Docker
   trusts it (the cache serves over HTTP), then bump that file's
   `restart-trigger` to roll the pods. `arc-runner-ue` already has this:

   ```yaml
   # apps/kube/github/runners/manifests/values-<runner>.yaml (dind command)
   exec dockerd ... --insecure-registry=registry-mirror-ghcr.arc-runners.svc.cluster.local:5000
   ```

2. **Pull cache-first in the job.** Swap the registry host to the cache, pull,
   and retag to the canonical name (so the rest of the job is unchanged), with a
   ghcr fallback so a cache outage degrades gracefully. Log in to ghcr
   **unconditionally** first — a cache hit must still leave a valid ghcr session
   for any later step that touches ghcr:

   ```yaml
   - name: Pull image (cache-first, ghcr fallback)
     env:
       CACHE_HOST: registry-mirror-ghcr.arc-runners.svc.cluster.local:5000
     run: |
       TARGET="ghcr.io/<org>/<image>:<tag>"
       CACHE_REF="${TARGET/ghcr.io/$CACHE_HOST}"
       echo "$GHCR_PAT" | docker login ghcr.io -u "$ACTOR" --password-stdin
       if docker pull "$CACHE_REF"; then
         docker tag "$CACHE_REF" "$TARGET"
       else
         docker pull "$TARGET"
       fi
   ```

Only `ghcr.io` images are served by this instance (its single upstream). To keep
a tag from being pruned under the soft limit, add its cache path
(`<org>/<image>:<tag>`) to the `registry-mirror-ghcr-whitelist` ConfigMap.

##### Cache a different registry (Docker Hub, quay.io, …)

Stand up a second proxy instance: copy `registry-mirror-ghcr.yaml`, change
`REGISTRY_PROXY_REMOTEURL` to that registry, give it its own PVC + Service name,
and point image refs at the new service. One `registry:2` proxy serves exactly
one upstream.

#### Package Publishing

The same fanout pattern applies to package publishing.
`ci-main.yml`'s `dispatch_publish` job fires one `ci-publish.yml` run per changed package, with per-package concurrency groups (`ci-publish-{type}-{name}`).

```mermaid
flowchart TD
    main["CI - Main<br/>dispatch_publish"] -->|"npm/droid"| n1["ci-publish.yml<br/>npm → droid"]
    main -->|"npm/laser"| n2["ci-publish.yml<br/>npm → laser"]
    main -->|"crates/kbve"| c1["ci-publish.yml<br/>crates → kbve"]
    main -->|"crates/jedi"| c2["ci-publish.yml<br/>crates → jedi"]
    main -->|"python/fudster"| p1["ci-publish.yml<br/>python → fudster"]
    main -->|"..."| pn["..."]

    n1 --> t1["queue_guard → test → publish"]
    c1 --> t2["queue_guard → test → publish"]
    p1 --> t3["queue_guard → test → publish"]
```

Each `ci-publish.yml` run receives `package_type` (npm, crates, or python), `package_name`, and an optional `pypi_name` for Python packages.
The workflow uses conditional jobs — only the matching package type's test and publish jobs run:

| Type | Packages | Registry | Secret |
|------|----------|----------|--------|
| npm | droid, laser, devops, khashvault | npmjs.com | `NPM_TOKEN` |
| crates | q, jedi, soul, kbve, erust, holy | crates.io | `CRATES_TOKEN` |
| python | fudster, kbve | pypi.org | `PYPI_API_SCOPE_TOKEN` |

#### Failure Tracking

Every dispatched workflow (Docker and publish) includes a `track_failure` job that calls `utils-ci-failure-tracker.yml`.
This reusable workflow provides automatic incident management for CI failures:

- **On failure**: Creates a GitHub issue titled `[CI] {workflow} / {app_name} — Failed` with labels `bug`, `ci`. The issue body includes the failed step name, timestamp, run link, and the last 50 lines of the failed job's logs. If an issue already exists, it appends a comment with the new failure details.
- **On success**: If a previously-opened failure issue exists, it adds a "Resolved" comment and auto-closes the issue.

```mermaid
flowchart LR
    fail["Job fails"] --> search["Search for open issue<br/>[CI] workflow / app — Failed"]
    search -->|"Not found"| create["Create issue<br/>with logs + run link"]
    search -->|"Found"| comment["Comment on issue<br/>increment failure count"]

    success["Job succeeds"] --> search2["Search for open issue"]
    search2 -->|"Found"| close["Comment 'Resolved'<br/>close issue"]
    search2 -->|"Not found"| noop["No action"]
```

This ensures every CI failure is visible, tracked, and automatically resolved — no manual triage needed for transient failures.

#### File Alteration Detection

The `utils-file-alterations.yml` reusable workflow is the detection layer that powers both dispatch jobs.
It uses the `changed-files` action with glob patterns to produce boolean outputs for every monorepo package and app.

Each app's detection patterns include its own source files plus key dependencies:

```yaml
# Example: astro_kbve watches its own source AND shared npm packages
astro_kbve:
    - 'apps/kbve/astro-kbve/**'
    - 'apps/kbve/axum-kbve/**'
    - 'packages/npm/astro/**'
    - 'packages/npm/droid/**'
    - 'packages/npm/laser/**'
```

The dispatch jobs in `ci-main.yml` then check these outputs:

```yaml
[ "${{ needs.alter.outputs.astro_kbve }}" = "true" ] && dispatch "axum-kbve"
```

<Aside type="caution" title="Shared Dependency Coverage">

App-level alteration signals may not cover all transitive Rust crate dependencies.
For example, a change to `packages/rust/kbve/src/lib.rs` affects `axum-kbve`, `discordsh`, and `cryptothrone` at compile time, but those apps' alter patterns may not include `packages/rust/kbve/**`.
Broadening the alter patterns or OR-ing the `*_base` signals into dispatch conditions addresses this gap.

</Aside>

---

## GitLab

GitLab is a comprehensive DevOps platform that provides a wide range of tools for software development, continuous integration, and continuous delivery.
With features like issue tracking, code review, and built-in CI/CD pipelines, GitLab enables teams to collaborate efficiently and accelerate their development cycles.
GitLab's robust version control capabilities, combined with its scalable and flexible infrastructure, make it an ideal choice for both small teams and large enterprises.
By integrating all stages of the DevOps lifecycle into a single application, GitLab simplifies workflow management, enhances productivity, and promotes seamless collaboration across the entire development process.

---

## Gitea

Gitea is a lightweight, self-hosted Git service designed to provide a seamless and efficient way to manage version control for software projects.
Offering features like issue tracking, code review, and a built-in wiki, Gitea supports collaborative development and project management.
Its user-friendly interface and minimal resource requirements make it an excellent choice for small to medium-sized teams looking for a straightforward and customizable Git hosting solution.
With easy installation and maintenance, Gitea empowers developers to host their own repositories and control their workflow, ensuring flexibility and security in their development processes.

---

## Forgejo

Forgejo is a community-driven fork of Gitea focused on self-hosted Git service with enhanced features and governance.
Built on the foundation of Gitea, Forgejo maintains the same lightweight and efficient architecture while ensuring long-term community ownership and development.

### Forgejo OAuth/OIDC Setup with Supabase

This section describes how to configure Forgejo to use Supabase (GoTrue) as an OAuth2/OIDC provider for automatic login with KBVE infrastructure.

#### Overview

Users can log into Forgejo using their KBVE/Supabase credentials automatically through the following flow:

<Steps>
1. User visits `forgejo.kbve.com` (routes through kbve-gate)
2. Gate validates Supabase JWT and checks staff role
3. If authenticated, user accesses Forgejo and is automatically logged in via OAuth
4. User account is auto-created in Forgejo on first login
</Steps>

#### Prerequisites

##### 1. Create OAuth Application in Supabase

Register Forgejo as an OAuth client in Supabase:

**Option A: Via Supabase Dashboard**
- Navigate to Authentication > URL Configuration or Providers
- Add a new OAuth client for Forgejo

**Option B: Via Database (SQL)**
```sql
-- Insert into auth.saml_providers or equivalent table
-- This depends on your Supabase version and configuration
```

**Required Configuration:**
- **Client Name**: `forgejo` or `forgejo-kbve`
- **Redirect URI**: `https://forgejo.kbve.com/user/oauth2/kbve/callback`
- **Scopes**: `openid email profile`
- **PKCE**: Optional but recommended

After creation, you'll receive:
- **Client ID**: Save this value
- **Client Secret**: Save this value securely

##### 2. Create Kubernetes Secret

Create a sealed secret with the OAuth credentials:

```bash
# Create the secret YAML
kubectl create secret generic forgejo-oauth-config \
  --from-literal=client-id='YOUR_CLIENT_ID' \
  --from-literal=client-secret='YOUR_CLIENT_SECRET' \
  --namespace=forgejo \
  --dry-run=client -o yaml > /tmp/forgejo-oauth-config.yaml

# Seal it
kubeseal --format=yaml \
  --cert=<path-to-pub-cert>.pem \
  < /tmp/forgejo-oauth-config.yaml \
  > apps/kube/forgejo/manifest/sealed-oauth-config.yaml

# Clean up
rm /tmp/forgejo-oauth-config.yaml
```

#### Configuration Methods

##### Method 1: CLI Configuration (Recommended for Automation)

Create a Kubernetes Job that runs after Forgejo is deployed:

```bash
forgejo admin auth add-oauth \
  --provider=openidConnect \
  --name=kbve \
  --key=$OAUTH_CLIENT_ID \
  --secret=$OAUTH_CLIENT_SECRET \
  --auto-discover-url=https://supabase.kbve.com/auth/v1/.well-known/openid-configuration \
  --scopes='openid email profile' \
  --group-claim-name='groups' \
  --admin-group='staff'
```

##### Method 2: Web GUI Configuration

<Steps>
1. Log in to Forgejo as admin
2. Navigate to: Site Administration (gear icon) > Authentication Sources
3. Click "Add Authentication Source"
4. Configure the following settings:
   - **Authentication Type**: OAuth2
   - **Authentication Name**: `kbve` (must match redirect URI)
   - **OAuth2 Provider**: OpenID Connect
   - **Client ID**: `<from secret>`
   - **Client Secret**: `<from secret>`
   - **OpenID Connect Auto Discovery URL**: `https://supabase.kbve.com/auth/v1/.well-known/openid-configuration`
   - **Icon URL**: (optional) `https://kbve.com/favicon.ico`
   - **Scopes**: `openid email profile`
   - **Required Claim Name**: (optional) leave empty
   - **Required Claim Value**: (optional) leave empty
   - **Group Claim Name**: (optional) `groups`
   - **Admin Group**: (optional) `staff`
   - **Restricted Group**: (optional) leave empty
   - **Skip Local 2FA**: false
5. Click "Add Authentication Source"
</Steps>

#### Application Configuration

The Forgejo `application.yaml` includes the following OAuth settings:

```yaml
service:
    DISABLE_REGISTRATION: false  # Allow OAuth registration
    REQUIRE_SIGNIN_VIEW: true    # Still require login to view
    ALLOW_ONLY_EXTERNAL_REGISTRATION: true  # Only via OAuth
    SHOW_REGISTRATION_BUTTON: false  # Hide manual registration
openid:
    ENABLE_OPENID_SIGNIN: true
    ENABLE_OPENID_SIGNUP: true
oauth2_client:
    ENABLE_AUTO_REGISTRATION: true  # Auto-create accounts
    ACCOUNT_LINKING: auto          # Auto-link existing accounts
    UPDATE_AVATAR: true            # Sync avatars from OAuth
    USERNAME: preferred_username   # Use preferred_username claim
```

#### Verification

Test the OAuth flow after setup:

<Steps>
1. Log out of Forgejo (if logged in)
2. Visit `https://forgejo.kbve.com`
3. You should see "Sign in with kbve" button
4. Click it - should redirect to Supabase login
5. After Supabase authentication, redirects back to Forgejo
6. User account is auto-created and logged in
</Steps>

#### Troubleshooting

<Aside type="caution">

**Issue: No "Sign in with kbve" button**
- Check authentication source was added correctly
- Verify the authentication source name matches redirect URI

**Issue: OAuth flow fails**
- Check Supabase logs for OAuth errors
- Verify redirect URI matches exactly
- Check client ID and secret are correct

**Issue: User not auto-registered**
- Verify `ENABLE_AUTO_REGISTRATION` is `true`
- Check Supabase returns required claims (email, preferred_username)
- Review Forgejo logs for registration errors

</Aside>

---

## Submodules

Git submodules are a powerful feature that allows you to include and manage external repositories within your own project.
By embedding one Git repository as a subdirectory of another, submodules enable the use of libraries or dependencies while maintaining their own version control.
This setup ensures that each submodule retains its history and can be updated independently, providing modularity and reducing code duplication.
Managing submodules requires specific commands to clone, update, and commit changes, but it offers a robust way to handle complex projects with multiple dependencies, keeping the main repository clean and organized.

<Aside>
These are notes and guides on how to build out submodules inside of Git, so that you can control certain plugins throughout multiple repos effortlessly.
This can go into private packages later on, if we need to.

The shift to the private packages will come as we grow bigger and require more control.

</Aside>

### Submodule Symbolic Link

Submodule symbolic links provide a method to seamlessly integrate multiple directories from different repositories without duplicating the contents.
By creating symbolic links, you can reference submodules in a way that allows for easy navigation and management within your main project directory.
This approach avoids the common pitfalls associated with managing multiple directories, such as redundancy and synchronization issues.
Symbolic links effectively act as shortcuts, pointing to the actual location of the submodule, thereby streamlining your workflow and maintaining a clean project structure.
Utilizing symbolic links in conjunction with submodules can significantly enhance the organization and efficiency of handling external dependencies in complex projects.

#### KBVE Module Example

Suppose we have already added our submodule for an Unity project, via `KBVE/UnitySubModule` and wanted to link them into our source, well this is how:

Create a folder inside of `Assets` named `Plugins` and then cd into it:

Example of the shell, do not copy and paste, make sure you read through the commands and swap out the right variables!

```shell
cd ./unityRootProject
cd ./Assets
mkdir Plugins
cd ./Plugins

```

Once inside the `Plugins` folder, we can execute the symbolic link using the `ln` command, like this:

```shell

ln -s ../../submodules/UnitySubModules/Vuplex

```

---

## Scripts

Script commands for Git act as powerful helper scripts that automate and streamline various Git operations.
These commands can simplify complex workflows by combining multiple Git actions into a single executable script.
For instance, shell commands can automate the process of staging changes, committing with a message, and pushing to the current branch, saving developers time and reducing the risk of errors.
Thus, by leveraging the flexibility of shell scripting, developers can create custom workflows tailored to their specific needs, enhancing productivity and ensuring consistent Git practices across projects.

### Commit

The `commit` command stages all changes, commits them with the message "Minor change sync," and pushes the commit to the current branch.
This sequence ensures that all modifications are saved and synchronized with the remote repository.

```sh
branch=$(git rev-parse --abbrev-ref HEAD) && git add . && git commit -m "Minor change sync" && git push origin $branch
```

This command does the following:

<Steps>

1.  **Environmentals**:

    ```shell
    branch=$(git rev-parse --abbrev-ref HEAD)
    ```

    Stores the cu

[…truncated, full source at MDX]

---
# Godot

> Godot is a cross-platform and open source game engine written in GDScript, C#, C++ and Rust.
Godot is a free and open source game engine that offers a unique and innovative way to create 2D and 3D games for various platforms, using a node and scene system, multiple programming languages, and a community-driven development model.

Source: https://kbve.com/application/godot/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**Godot** is a free, open-source game engine for building **2D and 3D games** across desktop, mobile, and web — under the permissive MIT license with no fees or royalties. Its **node and scene** system gives a modular, LEGO-like workflow, and it supports GDScript, C#, and C++/Rust.

This guide covers [animation](#animations), [shaders](#shaders), and [building/exporting](#build) including Web and Supabase.

## Information

Godot is a free, open-source game engine for creating 2D and 3D games across desktop, mobile, and web platforms—without fees or restrictive licenses.
At its core, Godot's node and scene system provides a modular, LEGO-like approach to game design—nodes are the building blocks, handling everything from sprites to physics, and scenes combine them into reusable, hierarchical chunks you can instantiate anywhere.
This flexibility is paired with support for multiple programming languages, including its own lightweight GDScript (a Python-inspired concept), C#, and even C++ for performance junkies, letting developers pick their comfort zone.

What truly sets Godot apart is its community-driven development model, shout-out to the amazing discord community servers too!
Built and evolved by a passionate global user base, it continues to grow through open collaboration, free from corporate gate-keeping.
With built-in editors for animation, shaders, and tilemaps, plus a permissive MIT license, Godot provides a complete toolbox for crafting anything from pixel-art platformers to expansive 3D experiences, all while remaining lightweight enough for modest hardware.


It's no surprise that indie developers and hobbyists alike see it as a refreshing, empowering alternative to larger engines like [Unity](/application/unity/) or Unreal.


<Adsense />

---

## Animations

In the beloved Godot engine, animation is a powerful and flexible system that brings your game to life—allowing you to animate virtually any property of any node or object, from position and rotation to color and even custom variables.
At the heart of this system is the AnimationPlayer node, a versatile tool that lets you create everything from simple transitions—like a character moving across the screen—to complex cinematic sequences with ease.

You can keyframe properties manually in the animation editor, use Bezier curves for smooth transitions, or even animate function calls and audio playback, making it a playground for creativity.
Godot’s animation capabilities stand out because they’re deeply integrated into the engine, meaning you don’t need external tools—just add an AnimationPlayer, tweak some values, and watch your scene dance.
For more advanced control, the AnimationTree complements this by managing state machines and blending animations, perfect for characters with walk cycles or combat moves.
Since Godot’s open-source nature keeps it evolving, updates like those in version 4.3 have refined this system further, offering finer control and fixing quirks from earlier builds.
Whether you’re fading in a splash screen or orchestrating a dramatic cutscene, Godot’s animation tools are both accessible for beginners and robust enough for pros.
It’s no wonder developers rave about its ability to handle everything from 2D sprites to 3D models with a single, unified workflow!

### Sprite 2D Animations

In Godot, animating 2D sprites is a breeze thanks to the engine’s dedicated tools tailored for pixel-perfect movement and flair.
The Sprite2D node serves as your canvas, where you can attach textures and flip, scale, or rotate them to your heart’s content, all animatable via the AnimationPlayer.
For frame-by-frame animations—like a character running or a flickering torch—Godot’s AnimatedSprite2D node steals the show, letting you define sprite sheets and playback sequences with adjustable speeds, looping options, and even signal triggers for events like “animation finished.”
You can easily set this up by importing a sprite sheet, slicing it into frames, and dropping them into the node’s animation frames property—boom, instant walk cycle!
Pair this with the AnimationPlayer to tweak properties like opacity or position, and you’ve got smooth fades or bouncy effects without breaking a sweat.
Godot’s 2D animation shines in its simplicity: no need for complex rigging, just a few clicks and keyframes to make your sprites pop.
Since the engine’s 4.0 overhaul, tools like these have gotten snappier, with better editor feedback and tighter integration, making it a favorite for retro-style game devs and artists alike.

<Aside>

Remember to connect the signals for the animations, to create custom effects once the animation is complete.

</Aside>

## Guides

-   Godot Export as HTML5 [Tutorial](https://docs.godotengine.org/en/stable/tutorials/export/exporting_for_web.html)
-   Exporting Template for Platforms missing [Error Guide](https://godotengine.org/qa/65015/export-templates-for-this-platform-are-missing)

---

## Demos

-   GDQuest Repo of Godot [Demos](https://github.com/GDQuest/godot-demos)

---

## Media

---

## Shaders

Godot ships its own shading language, **GDShader** (`.gdshader` files), a GLSL-derived language wired into Godot's render pipeline. For the engine-agnostic fundamentals (the GPU pipeline, shader stages, lighting models, performance budget), see the [Shaders & Rendering GDD page](/gdd/shaders/); this section covers the Godot-specific layer.

### GDShader language

GDShader looks like GLSL ES 3.0 but adds Godot-provided built-ins and a `shader_type` declaration that tells the engine which render path the shader plugs into.

- **`shader_type`** — the first line; picks the context:
  - `spatial` — 3D materials (mesh surfaces).
  - `canvas_item` — 2D materials (sprites, UI, tilemaps).
  - `particles` — compute-style particle processing.
  - `sky` and `fog` — environment shading.
- **Processor functions** — you fill in stage entry points: `vertex()` (per-vertex), `fragment()` (per-pixel surface output), and `light()` (per-light custom lighting).
- **Built-in I/O** — Godot exposes inputs like `UV`, `NORMAL`, `TIME`, `SCREEN_TEXTURE`, and you write outputs such as `ALBEDO`, `ALPHA`, `EMISSION`, `ROUGHNESS`, `METALLIC` — no manual matrix wiring for the common case.
- **`uniform`** — parameters exposed to the editor/inspector and settable from GDScript/C# at runtime (`material.set_shader_parameter(...)`).

```glsl
shader_type canvas_item;

uniform vec4 tint : source_color = vec4(1.0);
uniform float wave_speed = 2.0;

void fragment() {
    vec2 uv = UV;
    uv.x += sin(TIME * wave_speed + UV.y * 10.0) * 0.02;
    COLOR = texture(TEXTURE, uv) * tint;
}
```

<Aside>
GDShader has two front-ends: write the language directly in a `.gdshader` file, or build it with the **VisualShader** node graph (Godot compiles the graph to the same GDShader under the hood). Use the visual editor to prototype, drop to text for control.
</Aside>

### Cel Shaders

This is a quick reference to a couple popular cel shaders for Godot!

[eldskald's complete global cel shader](https://github.com/eldskald/godot4-cel-shader/tree/main?tab=readme-ov-file) provides a comprehensive cel shader designed for Godot 4.

### Further reading

-   Godot [Shading language reference](https://docs.godotengine.org/en/stable/tutorials/shaders/shader_reference/shading_language.html)
-   Godot [Your first 2D / 3D shader](https://docs.godotengine.org/en/stable/tutorials/shaders/your_first_shader/index.html) tutorials
-   [Shaders & Rendering](/gdd/shaders/) — engine-agnostic shader and rendering fundamentals


---


## Build

### WASM

#### WASM Configuration for GDExt

This is a quick reference to the GDExt cargo toml. TODO:

---

### Supabase

This section is for integration of [Supabase](/application/supabase/) and your Godot application!
In our first proof of concept article, we will focus on a Supabase + Itch + Web build!

Make sure to grab a CDN link for Supabase, here is the one that we will be using for this example:

```html
<script type="module">
  import { createClient } from 'https://cdn.jsdelivr.net/npm/@supabase/supabase-js/+esm';

  const supabase = createClient(
    'https://your-project.supabase.co',
    'your-public-anon-key'
  );

  window.supabase = supabase;
</script>
```

Inside of your supabase instance, make sure to allow both your main itch, in our case `kbve.itch.io` and the game CDN aka `html.itch.zone`.




<Aside>

Godot is a free and open-source game engine that offers a unique and innovative way to create 2D and 3D games for a wide array of platforms, from Windows and macOS to Android, iOS, and even the web, all without costing a dime or tying you to proprietary licenses.

</Aside>

## FAQ

**What is Godot?**
Godot is a free, open-source game engine for building 2D and 3D games across desktop, mobile, and web. It uses a node and scene system as its core building blocks, supports GDScript, C#, and C++, and ships under the permissive MIT license with no fees or royalties.

**What languages does Godot support?**
Godot's primary language is GDScript, a lightweight, Python-inspired language tightly integrated with the engine. It also supports C# (via .NET), and C++ or Rust through GDExtension for performance-critical code.

**What is the difference between nodes and scenes in Godot?**
A node is the smallest building block — it handles one job like a sprite, collision shape, or sound. A scene is a tree of nodes saved together and reused as a unit; scenes can be instanced inside other scenes, giving Godot its modular structure.

**How do I animate 2D sprites in Godot?**
Use `AnimatedSprite2D` for frame-by-frame sprite-sheet animation with adjustable speed, looping, and finished signals, or drive any node property with an `AnimationPlayer`. Import a sprite sheet, slice it into frames, and play the sequence.

**Can Godot export to the web?**
Yes. Godot exports games to HTML5/WebAssembly to run in a browser. You need the matching export templates installed, and platforms like itch.io host the build. Web builds can integrate services such as [Supabase](/application/supabase/) via a CDN client.

<Adsense />

---
# Intel NUC Talos Worker Nodes

> Guide for adding Intel NUC devices as Talos Linux worker nodes to the existing KBVE cluster

Source: https://kbve.com/application/intel-nuc-talos/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

This guide covers adding Intel NUC devices as worker nodes to the existing Talos Linux cluster running on Hetzner with WireGuard networking.

Flow: [hardware prep](#phase-1-hardware-preparation) → [Talos install](#phase-2-talos-linux-installation) → [cluster config](#phase-3-cluster-configuration) → [join](#phase-4-join-nucs-to-cluster) → [troubleshooting](#troubleshooting).

## Hardware Requirements

### Intel NUC Specifications
- **Compatible Models**: Intel NUC 11th gen or newer (tested on NUC11TNHi5, NUC11TNKi5)
- **RAM**: 8GB minimum (16GB recommended for production workloads)
- **Storage**: 256GB SSD minimum (NVMe preferred)
- **Network**: Gigabit Ethernet (built-in)
- **Power**: Compatible power supply unit (PSU)

### Hardware Checklist
- [ ] Intel NUC units
- [ ] Compatible PSUs for each NUC
- [ ] 8GB+ RAM per NUC
- [ ] 256GB+ SSDs per NUC
- [ ] USB flash drives for installation (8GB+)
- [ ] Ethernet cables
- [ ] Network access for initial setup

<Aside type="tip">
	Purchase RAM and SSDs that match Intel's compatibility matrix for your specific NUC model to avoid compatibility issues.
</Aside>

## Phase 1: Hardware Preparation

<Steps>

1. **Assemble Hardware**

   Install RAM and SSD in each Intel NUC:
   
   ```bash
   # Power off and unplug the NUC
   # Remove bottom cover screws
   # Install SO-DIMM RAM in available slots
   # Install M.2 SSD in available slot
   # Reassemble and connect power
   ```

2. **BIOS Configuration**

   Boot each NUC and configure BIOS settings:
   
   - Enable UEFI boot mode
   - Disable Secure Boot
   - Enable Intel VT-x/VT-d
   - Set primary boot device to USB
   - Save settings and exit

3. **Network Planning**

   Document network configuration for each NUC:
   
   ```bash
   # Example IP assignments
   NUC-01: 192.168.1.10 (DHCP) -> WG: 10.0.0.10
   NUC-02: 192.168.1.11 (DHCP) -> WG: 10.0.0.11
   NUC-03: 192.168.1.12 (DHCP) -> WG: 10.0.0.12
   ```

</Steps>

## Phase 2: Talos Linux Installation

<Steps>

1. **Download Talos Linux**

   Download the latest Talos Linux ISO:
   
   ```bash
   # Download Talos ISO
   curl -Lo talos-amd64.iso https://github.com/siderolabs/talos/releases/latest/download/talos-amd64.iso
   
   # Verify checksum
   curl -Lo talos-amd64.iso.sha256 https://github.com/siderolabs/talos/releases/latest/download/talos-amd64.iso.sha256
   sha256sum -c talos-amd64.iso.sha256
   ```

2. **Create Bootable USB**

   Create bootable USB drives for each NUC:
   
   ```bash
   # Replace /dev/sdX with your USB device
   sudo dd if=talos-amd64.iso of=/dev/sdX bs=4M status=progress
   sync
   ```

3. **Boot and Install Talos**

   For each NUC:
   
   ```bash
   # Insert USB and boot from it
   # Talos will load and provide an IP address
   # Note down the IP address for each NUC
   ```

</Steps>

## Phase 3: Cluster Configuration

<Steps>

1. **Generate WireGuard Keys**

   Generate unique WireGuard keys for each NUC:
   
   ```bash
   # Generate keys for each NUC worker
   for i in {10..12}; do
     echo "Generating keys for NUC-$(printf "%02d" $((i-9)))"
     wg genkey | tee nuc-$i-private.key | wg pubkey > nuc-$i-public.key
   done
   ```

2. **Prepare Worker Configuration**

   Customize the worker configuration for each NUC:
   
   ```bash
   # Get the existing cluster configuration from Hetzner control plane
   talosctl get mc v1alpha1 -o jsonpath='{.spec}' -n [HETZNER_CONTROL_PLANE_IP] > base-worker.yaml
   
   # Or use the template from the repository
   cp apps/kube/talos-worker.yaml worker-template.yaml
   ```

3. **Update WireGuard Configuration**

   For each NUC, update the worker configuration:
   
   ```yaml
   # Update machine.network.interfaces.wg0.wireguard section
   machine:
     network:
       hostname: "nuc-01"  # nuc-01, nuc-02, nuc-03, etc.
       interfaces:
         - interface: wg0
           wireguard:
             privateKey: "PRIVATE_KEY_FROM_STEP_1"
             peers:
               - publicKey: "HETZNER_CONTROL_PLANE_PUBLIC_KEY"
                 endpoint: "HETZNER_CONTROL_PLANE_IP:51820"
                 allowedIPs:
                   - 10.0.0.0/24
           addresses:
             - 10.0.0.10/32  # Increment for each NUC
   ```

</Steps>

## Phase 4: Join NUCs to Cluster

<Steps>

1. **Apply Worker Configuration**

   Apply the configuration to each NUC:
   
   ```bash
   # For each NUC, apply the customized worker config
   talosctl apply-config --insecure --nodes [NUC_IP] --file worker-nuc-01.yaml
   talosctl apply-config --insecure --nodes [NUC_IP] --file worker-nuc-02.yaml
   talosctl apply-config --insecure --nodes [NUC_IP] --file worker-nuc-03.yaml
   ```

2. **Verify Node Join**

   Check that nodes are joining the cluster:
   
   ```bash
   # Check cluster nodes
   kubectl get nodes -o wide
   
   # Verify WireGuard connectivity
   talosctl dmesg --nodes [NUC_WG_IP] | grep -i wireguard
   ```

3. **Test Connectivity**

   Verify the setup is working:
   
   ```bash
   # Test pod scheduling on NUC workers
   kubectl run test-pod --image=nginx --restart=Never
   kubectl get pods -o wide
   
   # Check WireGuard peer status
   sudo wg show
   ```

</Steps>

## Troubleshooting

### Common Issues

1. **WireGuard Connection Failed**
   ```bash
   # Check WireGuard status
   sudo wg show
   
   # Verify endpoint connectivity
   ping HETZNER_CONTROL_PLANE_IP
   
   # Check firewall rules
   sudo ufw status
   ```

2. **Node Not Joining Cluster**
   ```bash
   # Check Talos logs
   talosctl logs --nodes [NUC_IP] kubelet
   
   # Verify cluster token
   talosctl get secrets --nodes [CONTROL_PLANE_IP]
   ```

3. **Hardware Compatibility**
   ```bash
   # Check system compatibility
   talosctl dmesg --nodes [NUC_IP] | grep -i error
   
   # Verify hardware detection
   talosctl get hardware --nodes [NUC_IP]
   ```

<Aside type="caution">
	Always verify WireGuard keys are properly generated and configured. Incorrect keys will prevent cluster communication.
</Aside>

## Scaling

To add additional Intel NUC worker nodes:

1. Follow hardware preparation steps
2. Generate unique WireGuard keys
3. Assign next available WireGuard IP (10.0.0.13, 10.0.0.14, etc.)
4. Apply worker configuration
5. Verify cluster integration

## Security Considerations

- Store WireGuard private keys securely
- Use unique keys for each node
- Consider using hardware TPM for key storage
- Regular security updates via Talos upgrades
- Monitor cluster access logs

<Adsense />

## FAQ

**What is Talos Linux?**
Talos Linux is a minimal, immutable, API-driven operating system purpose-built for Kubernetes. It has no shell or SSH — every node is managed declaratively through `talosctl` and a machine config — which makes bare-metal nodes like Intel NUCs reproducible and secure.

**Can I add bare-metal Intel NUCs to a cloud Kubernetes cluster?**
Yes. This guide joins Intel NUC workers to an existing Talos control plane running on Hetzner by tunneling cluster traffic over [WireGuard](/application/wireguard/). Each NUC gets a unique WireGuard key and IP, applies a worker machine config, and registers as a standard worker node.

**Why use WireGuard to join remote worker nodes?**
WireGuard creates an encrypted overlay network so home-based NUCs and cloud control-plane nodes communicate securely across the public internet as if on one private subnet. It is lightweight, fast, and integrates directly into the Talos machine network config.

**What are the minimum hardware requirements for a Talos NUC worker?**
An Intel NUC 11th gen or newer with at least 8GB RAM (16GB recommended), a 256GB+ SSD (NVMe preferred), and gigabit Ethernet. Enable UEFI boot, disable Secure Boot, and turn on Intel VT-x/VT-d in the BIOS before installing Talos.

**How do I troubleshoot a NUC that will not join the cluster?**
Check WireGuard connectivity with `wg show` and ping the control-plane endpoint, inspect kubelet logs via `talosctl logs --nodes`, and confirm the cluster secrets and keys match. Most join failures trace back to an incorrect WireGuard key or an unreachable endpoint.

## References

- [Talos Linux Documentation](https://www.talos.dev/docs/)
- [WireGuard Configuration Guide](/application/wireguard)
- [Intel NUC Compatibility Matrix](https://www.intel.com/content/www/us/en/support/articles/000055471/intel-nuc.html)

<Giscus />

---
# iOS

> iOS is Apple's proprietary mobile operating system that powers iPhone, iPad, and iPod Touch devices.
Built on a Unix-based foundation, iOS provides a secure, tightly integrated ecosystem optimized for performance and user experience.
The platform enforces strict app sandboxing and code signing requirements through the Apple Developer Program.
iOS development utilizes Swift or Objective-C with the iOS SDK, Xcode IDE, and Apple's frameworks including UIKit, SwiftUI, and Foundation.
The platform's closed ecosystem ensures consistent hardware-software integration, enabling features like seamless iCloud sync, handoff between devices, and strict privacy controls.
iOS applications must be distributed through the App Store or via enterprise provisioning, requiring Apple Developer membership and adherence to App Store Review Guidelines.

Source: https://kbve.com/application/ios/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
	Tabs,
	TabItem,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

iOS development requires a macOS environment and enrollment in the Apple Developer Program ($99/year) to deploy applications to physical devices and distribute through the App Store.
This guide covers code signing, provisioning profiles, CI/CD setup, and best practices for building iOS applications at KBVE.

Jump to [code signing](#code-signing-setup), [GitHub secrets](#github-secrets-configuration), the [CI/CD workflow](#cicd-workflow), [troubleshooting](#troubleshooting), or [UE5 iOS builds](#unreal-engine-5-ios-builds).

Our React Native iOS applications use Expo for streamlined development and deployment workflows, with custom native modules when needed for advanced features.

<Adsense />

## Code Signing Setup

Apple's code signing system ensures app integrity and prevents unauthorized modifications. All iOS apps must be signed before deployment to devices or the App Store.

### Prerequisites

<Steps>

1. **Apple Developer Account**
   - Enroll at [developer.apple.com](https://developer.apple.com)
   - Cost: $99/year for individual or organization membership
   - Required for device testing and App Store distribution

2. **Development Environment**
   - macOS with Xcode installed
   - Xcode Command Line Tools: `xcode-select --install`
   - CocoaPods: `sudo gem install cocoapods`

3. **Bundle Identifier**
   - KBVE React Native App: `com.kbve.app`
   - Must match across Xcode project, provisioning profiles, and App Store Connect

</Steps>

### Required Certificates

<Tabs>
<TabItem label="Development">

**iOS App Development Certificate**

Used for testing on physical devices during development.

```bash
# Generate via Xcode (automatic)
# Or manually via Keychain Access → Certificate Assistant → Request from CA

# Export as .p12 (for CI/CD)
# Keychain Access → Right-click certificate → Export
```

</TabItem>
<TabItem label="Distribution">

**Apple Distribution Certificate**

Required for App Store and ad-hoc distribution.

```bash
# Generate via Apple Developer portal or Xcode
# Export as .p12 file with password for GitHub secrets

# Export to base64 for GitHub Actions
base64 -i certificate.p12 | pbcopy
```

</TabItem>
</Tabs>

### Provisioning Profiles

Provisioning profiles link certificates, app IDs, and device UDIDs together.

| Type | Use Case | Device Registration |
|------|----------|---------------------|
| **Development** | Testing on registered devices | Required |
| **Ad Hoc** | Beta testing outside TestFlight | Required (max 100 devices) |
| **App Store** | App Store distribution | Not required |

```bash
# Export provisioning profile to base64
base64 -i profile.mobileprovision | pbcopy
```

## GitHub Secrets Configuration

Add these secrets to your repository for CI/CD workflows.

### Required Secrets

| Secret Name | Description | How to Generate |
|-------------|-------------|-----------------|
| `APPLE_CERT_DATA` | Base64-encoded .p12 certificate | `base64 -i certificate.p12 \| pbcopy` |
| `APPLE_CERT_PASSWORD` | Password for .p12 file | Set when exporting certificate |
| `PROVISIONING_PROFILE_DATA` | Base64-encoded .mobileprovision | `base64 -i profile.mobileprovision \| pbcopy` |

<Aside type="caution">
Never commit certificates or provisioning profiles directly to the repository. Always use GitHub secrets or secure credential management systems.
</Aside>

## CI/CD Workflow

Our React Native iOS builds use GitHub Actions with macOS runners.

### Workflow File

Located at [.github/workflows/ci-react-native-ios.yml](https://github.com/KBVE/kbve/blob/dev/.github/workflows/ci-react-native-ios.yml)

### Build Tasks

<Tabs>
<TabItem label="Unsigned Build">

**For development and CI testing (no certificates required)**

```bash
# Trigger via GitHub Actions
# task: build
# skip_signing: true
```

Produces unsigned simulator build (x86_64) for testing purposes.

</TabItem>
<TabItem label="Signed Build">

**For device testing and App Store distribution**

```bash
# Requires GitHub secrets configured
# task: build
# skip_signing: false
```

Produces signed IPA for TestFlight or App Store submission.

</TabItem>
<TabItem label="Mac Setup">

**Verify macOS runner environment**

```bash
# task: mac-setup
```

Validates Xcode, Node.js, CocoaPods installation.

</TabItem>
</Tabs>

## Xcode Build Configuration

### Export Options

The `exportOptions.plist` file controls how the IPA is packaged.

<FileTree>
- apps/kbve/kbve-react-native/
  - exportOptions.plist Configuration for App Store export
  - ios/ Generated by Expo prebuild
    - Podfile CocoaPods dependencies
    - *.xcworkspace Xcode workspace
</FileTree>

**exportOptions.plist Template:**

```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>method</key>
    <string>app-store</string>
    <key>teamID</key>
    <string>YOUR_TEAM_ID</string>
    <key>uploadBitcode</key>
    <false/>
    <key>compileBitcode</key>
    <false/>
    <key>uploadSymbols</key>
    <true/>
    <key>signingStyle</key>
    <string>manual</string>
    <key>provisioningProfiles</key>
    <dict>
        <key>com.kbve.app</key>
        <string>YOUR_PROVISIONING_PROFILE_NAME</string>
    </dict>
</dict>
</plist>
```

<Aside type="tip">
Replace `YOUR_TEAM_ID` with your Apple Developer Team ID found in [App Store Connect](https://appstoreconnect.apple.com) → Membership.
</Aside>

## Workflow Implementation

### Import Signing Certificate

```yaml
- name: Import signing certificate
  env:
    APPLE_CERT_DATA: ${{ secrets.APPLE_CERT_DATA }}
    APPLE_CERT_PASSWORD: ${{ secrets.APPLE_CERT_PASSWORD }}
  run: |
    # Create temporary keychain
    KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
    KEYCHAIN_PASSWORD=$(uuidgen)

    security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
    security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
    security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH

    # Import certificate
    echo "$APPLE_CERT_DATA" | base64 --decode > certificate.p12
    security import certificate.p12 \
      -P "$APPLE_CERT_PASSWORD" \
      -A \
      -t cert \
      -f pkcs12 \
      -k $KEYCHAIN_PATH
    security list-keychain -d user -s $KEYCHAIN_PATH
```

### Install Provisioning Profile

```yaml
- name: Install provisioning profile
  env:
    PROVISIONING_PROFILE_DATA: ${{ secrets.PROVISIONING_PROFILE_DATA }}
  run: |
    mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
    echo "$PROVISIONING_PROFILE_DATA" | base64 --decode > \
      ~/Library/MobileDevice/Provisioning\ Profiles/profile.mobileprovision
```

### Build and Archive

```yaml
- name: Build signed app
  run: |
    xcodebuild \
      -workspace *.xcworkspace \
      -scheme "kbvereactnative" \
      -configuration Release \
      -sdk iphoneos \
      -archivePath ./build/App.xcarchive \
      archive

    xcodebuild \
      -exportArchive \
      -archivePath ./build/App.xcarchive \
      -exportPath ./build \
      -exportOptionsPlist exportOptions.plist
```

## Local Build Testing

Verify builds work locally before pushing to CI/CD.

```bash
# Navigate to React Native app
cd apps/kbve/kbve-react-native

# Generate iOS native project
npx expo prebuild --platform ios --clean

# Install CocoaPods dependencies
cd ios
pod install

# Build for simulator (unsigned)
xcodebuild \
  -workspace *.xcworkspace \
  -scheme kbvereactnative \
  -configuration Release \
  -sdk iphonesimulator \
  build

# Build for device (requires signing)
xcodebuild \
  -workspace *.xcworkspace \
  -scheme kbvereactnative \
  -configuration Release \
  -sdk iphoneos \
  -archivePath ./build/App.xcarchive \
  archive
```

## Troubleshooting

### Certificate Not Found

**Symptoms:** `errSecInternalComponent` or certificate errors during build

**Solutions:**
- Verify `APPLE_CERT_DATA` is valid base64
- Check certificate password matches `APPLE_CERT_PASSWORD`
- Ensure certificate hasn't expired (check in [Apple Developer portal](https://developer.apple.com/account/resources/certificates/list))

### Provisioning Profile Mismatch

**Symptoms:** `No profiles for 'com.kbve.app' were found`

**Solutions:**
- Ensure Bundle ID matches: `com.kbve.app`
- Profile must include the signing certificate
- Check profile hasn't expired
- Verify Team ID in exportOptions.plist matches certificate

### Build Fails with Signing Error

**Symptoms:** `Code signing is required for product type 'Application'`

**Solutions:**
- Check Team ID in exportOptions.plist
- Verify provisioning profile name is correct
- Ensure certificate and profile are properly installed in keychain
- Review Xcode build settings for code signing configuration

### CocoaPods Issues

**Symptoms:** `pod install` fails or missing native modules

**Solutions:**
```bash
# Clear CocoaPods cache
cd ios
pod cache clean --all
rm -rf Pods Podfile.lock

# Reinstall
pod install --repo-update
```

## Unreal Engine 5 iOS Builds

KBVE also builds iOS applications using Unreal Engine 5. The UE5 iOS pipeline shares the same Apple Developer infrastructure (certificates, provisioning profiles, Team ID) as React Native builds.

### UE5-Specific Requirements

<Aside type="note">
UE5 iOS builds require additional Xcode project configuration within the Unreal Engine project settings. Ensure the `.uproject` file is properly configured for iOS deployment.
</Aside>

**Key Differences from React Native:**

- **Build System**: UE5 uses UnrealBuildTool (UBT) instead of xcodebuild directly
- **Project Generation**: Xcode project generated via `GenerateProjectFiles.sh` or UE5 Editor
- **Binary Size**: UE5 apps significantly larger due to engine runtime
- **Shader Compilation**: Metal shaders must be precompiled for iOS targets

### UE5 iOS Workflow (In Progress)

The UE5 iOS CI/CD pipeline is currently under development. See [Issue #12875](https://github.com/KBVE/kbve/issues/12875) for tracking.

**Planned Tasks:**
- Configure Xcode project for UE5 iOS builds
- Adapt code signing for UnrealBuildTool
- Create GitHub Actions workflow for iOS builds
- Test build pipeline on macOS runner
- Document UE5-specific iOS build process

**Shared Infrastructure:**

Both React Native and UE5 iOS builds use the same:
- Apple Developer certificates (`APPLE_CERT_DATA`, `APPLE_CERT_PASSWORD`)
- Provisioning profiles (`PROVISIONING_PROFILE_DATA`)
- macOS GitHub Actions runners
- Fastlane automation (optional)

<Aside type="tip">
Complete the Apple Developer setup once, reuse credentials across all KBVE iOS projects (React Native, UE5, future frameworks).
</Aside>

### UE5 iOS Build Commands (Reference)

```bash
# Generate Xcode project from .uproject
# (Run on macOS with UE5 installed)
/Path/To/UE_5.X/Engine/Build/BatchFiles/Mac/GenerateProjectFiles.sh \
  -project="/Path/To/YourProject.uproject" \
  -platforms=iOS

# Build via UnrealBuildTool
/Path/To/UE_5.X/Engine/Build/BatchFiles/RunUBT.sh \
  YourProjectEditor iOS Development \
  -project="/Path/To/YourProject.uproject"

# Package for distribution
/Path/To/UE_5.X/Engine/Build/BatchFiles/RunUAT.sh BuildCookRun \
  -project="/Path/To/YourProject.uproject" \
  -platform=iOS \
  -clientconfig=Shipping \
  -cook -stage -archive -package
```

<Aside type="caution">
UE5 iOS builds require significant disk space (30GB+ for engine + project) and build time (30-60 minutes). Optimize CI/CD runners accordingly.
</Aside>

## Related Documentation

<CardGrid>
<Card title="React Native iOS Pipeline" icon="github">
[Issue #12876](https://github.com/KBVE/kbve/issues/12876) - CI/CD implementation tracking
</Card>

<Card title="UE5 iOS Builds" icon="puzzle">
[Issue #12875](https://github.com/KBVE/kbve/issues/12875) - Shares Apple Developer setup
</Card>

<Card title="Unreal Engine Guide" icon="seti:unreal">
[Unreal Engine docs](/application/unreal/) - KBVE UE5 development guide
</Card>

<Card title="Apple Developer Portal" icon="apple">
[developer.apple.com](https://developer.apple.com) - Certificates and profiles
</Card>

<Card title="Expo iOS Builds" icon="rocket">
[Expo iOS docs](https://docs.expo.dev/build/setup/) - Expo-specific build configuration
</Card>

<Card title="UE5 iOS Documentation" icon="document">
[UE5 iOS Guide](https://dev.epicgames.com/documentation/en-us/unreal-engine/ios-game-development) - Official Epic Games docs
</Card>
</CardGrid>

## Next Steps

<Steps>

1. **Enroll in Apple Developer Program**
   - Complete enrollment at [developer.apple.com](https://developer.apple.com/programs/enroll/)
   - Wait for approval (1-2 business days)

2. **Generate Certificates**
   - Create iOS Distribution Certificate
   - Export as .p12 with strong password

3. **Create Provisioning Profile**
   - Use Bundle ID: `com.kbve.app`
   - Select App Store distribution type
   - Download and export to base64

4. **Configure GitHub Secrets**
   - Add `APPLE_CERT_DATA`, `APPLE_CERT_PASSWORD`, `PROVISIONING_PROFILE_DATA`
   - Update `exportOptions.plist` with Team ID and profile name

5. **Test Build Workflow**
   - Run with `skip_signing: true` first (unsigned)
   - Then test with `skip_signing: false` (signed)

6. **Optional: Setup Fastlane**
   - Automate TestFlight uploads
   - Manage certificates and profiles via `match`

</Steps>

<Adsense />

## FAQ

**What do I need to develop and distribute iOS apps?**
A macOS machine with Xcode, and enrollment in the Apple Developer Program at $99/year. Membership is required to test on physical devices and distribute through the App Store. You also need a signing certificate, a provisioning profile, and a unique bundle identifier such as `com.kbve.app`.

**What is the difference between a certificate and a provisioning profile?**
A signing certificate proves your identity to Apple and signs the app binary. A provisioning profile links that certificate, the app ID, and (for development/ad-hoc) allowed device UDIDs, authorizing where the app can run. App Store profiles do not need device registration.

**How do I sign an iOS build in CI/CD?**
Store the `.p12` certificate and `.mobileprovision` profile as base64 GitHub secrets, then in the workflow create a temporary keychain, import the decoded certificate, install the profile, and build with `xcodebuild archive` plus `exportArchive` using an `exportOptions.plist`. Never commit certificates to the repo.

**Can I build an unsigned iOS app for testing?**
Yes. A simulator build for the `iphonesimulator` SDK does not require signing, so CI can produce an unsigned x86_64 build for testing. Signing is only required for device installs, TestFlight, and App Store submission using the `iphoneos` SDK.

**Do Unreal Engine 5 iOS builds use the same Apple setup?**
Yes. UE5 iOS builds reuse the same Apple Developer certificates, provisioning profiles, and Team ID as React Native builds. The difference is the build system — UE5 uses UnrealBuildTool and RunUAT instead of `xcodebuild` directly, and produces larger binaries with precompiled Metal shaders.

---

<Giscus />

---
# Javascript

> JS is a scripting language that enables dynamic content from client and server side.

Source: https://kbve.com/application/javascript/

import {
Aside,
Steps,
Card,
CardGrid,
Code,
FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense, DevCode } from '@/components/astropad';



## Information

    If you are a web developer or a web enthusiast, you have probably heard of JavaScript! Or why else would you be here?.
    But what exactly is JavaScript?!, and why is it so dominant in web and application development?!
    Suppose you had the ability to create a web page, game or application that can change its appearance based on the time of day, the weather, or the user's preferences.
    Think of how amazing it would be if you could add interactive elements such as buttons, forms, sliders, or quizzes to your web page without reloading it.
    Envision what it would be like to create stunning animations and graphics that make your web page stand out from the crowd.
    JavaScript is the one true king of the web, and it can work wonders with minimal code. Whether you want to create dynamic websites, interactive games, or powerful apps, JavaScript can make it happen.
    In this eye-opening document, we will give you a brief overview of JavaScript, its history, its features, and its applications.
    You will learn how JavaScript can make your web pages more dynamic and interactive, and how it can help you create stunning web applications that run in the browser.
    Prepare to unleash the power of JavaScript with this mdx documentation.
    You will learn everything you need to create dynamic and interactive web applications from scratch.
    Whether you are a beginner or a seasoned coder, this guide will take your skills to the next level.

<Adsense />

<Aside>
	This document is designed to serve as a scholarly compendium on the vast
	landscape of JavaScript and its associated technologies. We begin by
	exploring design, layout and CSS, the fundamental language of web design
	aesthetics, then transition to NodeJS, which facilitates server-side
	scripting. Our exploration extends to React Native, a framework for crafting
	mobile applications that seamlessly integrate with multiple platforms. This
	markdown not only elucidates each technology’s unique contributions but also
	examines their synergies within the broader context of modern software
	development. Aimed at both neophytes and seasoned developers, this guide
	endeavors to deepen your understanding of how these diverse tools
	collectively enhance and refine the art of programming.
</Aside>

## Design

    Would you like to learn how to write JavaScript code that is clean, clear, and consistent?
    Do you have a passion and desire to solve common problems in software design with ease and elegance?
    How would you like to master JavaScript and dazzle your peers and clients with your brilliant code?
    Did any of these questions resonate with you?
    If that rings a bell, you’ve hit the jackpot by coming to this resource!
    We will introduce you to the power and beauty of `design patterns` and how they can enhance and transform your work.
    Design patterns are reusable solutions that help you organize your code, simplify your logic, and communicate your intent.
    They are like recipes or templates that you can use to cook up delicious and nutritious code for your app.
    You will learn about some of the most common and useful design patterns in JavaScript, such as creational, structural, and behavioral patterns.
    You will also see some real-world examples of how these patterns can make your code more efficient, maintainable, and readable.
    By the end of this documentation, you will have a better understanding of design within JavaScript and how to apply it to your own projects.
    And as a bonus, KBVE will also share with you some of the best resources and tools to learn more about design patterns and practice them in your own code.
    So do not miss this opportunity to become a better JavaScript developer!
    Read on, discover the secrets of design patterns and experience the magic and potential of design patterns for yourself below.

### Design Patterns

    The theory of javascript design patterns can be classified into three major categories, namely creational, structural, and behavioral patterns.
    These classes differ from each other in various distinctions and aspects, such as how complex and elaborate the pattern is, the level of detail it offers to the developer and end-user, and the scope of its impact on the system being designed.
    Understanding these divisions can help developers choose the most suitable design pattern for their specific needs and goals within the application, interface or project.

### Creational Design Patterns

    Creational patterns enable a more adaptable and reusable code by offering a flexible framework for creating objects or classes.
    In this nature, the design shields the users from the complex construction process and streamline their interaction with the classes.
    Thus, the pattern controls the user-class interaction and save the developers from handling complex construction.

    Factories, builders and singletons are the three core concepts of creational design pattern.

### Abstract Factory Design Pattern

The Abstract Factory design pattern is a fundamental component of creational patterns that offers a way to encapsulate a group of individual factories with a common theme without specifying their concrete classes.
This pattern is especially useful in systems that need to be independent of how their products are created, composed, and represented.

#### Purpose

The Abstract Factory pattern is designed to provide an interface for creating families of related or dependent objects.
It allows a system to be independent of how its products are created, composed, or represented.
This pattern is beneficial for systems that require the flexibility to deal with diverse objects sharing a thematic or functional link.

#### Implementation

The pattern involves several key components:

-   **Abstract Factory**: An interface that declares a set of methods for creating each of the abstract products.
-   **Concrete Factory**: Implements the abstract factory methods to create concrete products.
-   **Abstract Product**: Declares an interface for a type of product object.
-   **Concrete Product**: Implements the abstract product interface; objects created through a factory.
-   **Client**: Uses only interfaces declared by Abstract Factory and Abstract Product classes.

#### Scenario and Example

Consider a scenario where a software developer is tasked with creating a cross-platform application that needs to generate various user interface components like buttons, modals, forms, text boxes, and menus.
By employing the Abstract Factory, the developer can define an interface for creating these UI elements which can then be implemented by different concrete factories for specific platforms (e.g., Windows, Android, iOS, MacOS, Linux).

<Aside type="tip">

Simplified JavaScript example illustrating this concept:

```js
// Abstract Factory
class GUIFactory {
	createButton() {}
	createTextbox() {}
}

// Concrete Factory for Windows
class WindowsFactory extends GUIFactory {
	createButton() {
		return new WindowsButton();
	}
	createTextbox() {
		return new WindowsTextbox();
	}
}

// Concrete Factory for MacOS
class MacOSFactory extends GUIFactory {
	createButton() {
		return new MacOSButton();
	}
	createTextbox() {
		return new MacOSTextbox();
	}
}

// Abstract Products
class Button {
	render() {}
}
class Textbox {
	render() {}
}

// Concrete Products for Windows
class WindowsButton extends Button {
	render() {
		console.log('Rendering Windows button');
	}
}
class WindowsTextbox extends Textbox {
	render() {
		console.log('Rendering Windows textbox');
	}
}

// Concrete Products for MacOS
class MacOSButton extends Button {
	render() {
		console.log('Rendering MacOS button');
	}
}
class MacOSTextbox extends Textbox {
	render() {
		console.log('Rendering MacOS textbox');
	}
}

// Client code
function renderUI(factory) {
	const button = factory.createButton();
	button.render();
	const textbox = factory.createTextbox();
	textbox.render();
}

const windowsFactory = new WindowsFactory();
const macFactory = new MacOSFactory();

renderUI(windowsFactory);
renderUI(macFactory);
```

**Abstract Factory Pattern Quick Tip:**

Use the Abstract Factory pattern when you need to ensure that your application can create and manage families of related or dependent products, or when you want to provide a library of products without exposing the implementation details.
This pattern not only fosters system scalability and interchangeability but also promotes consistency among products.

</Aside>

#### Advantages

-   **Flexibility**: Allows the creation of sets of related products without specifying their concrete classes.
-   **Scalability**: Supports adding new kinds of products without disturbing existing client code.

<Aside type="caution">

**Warning: Abstract Factory Pattern Use**

While the Abstract Factory pattern is powerful for promoting consistency among products and managing families of related objects, be cautious of its complexity. Overusing the pattern can lead to overly complicated designs that might be difficult to understand and maintain. It's particularly important to assess whether the benefits of abstracting factory creation truly outweigh the additional overhead. This pattern is most beneficial when your system genuinely requires a diverse range of objects with shared characteristics or when you need to enforce a particular set of design constraints across various product families.

</Aside>

#### Asbtract Factory Tutorial

<Steps>

1.  **Define Abstract Factory Interface:**

        Create an interface for the abstract factory. This interface will declare methods for creating each type of vehicle.

        ```js

        class VehicleFactory {
        createCar() {}
        createBoat() {}
        }

        ```

2.  **Create Concrete Factory Classes:**

        Implement concrete factories that extend the abstract factory interface. Each factory will provide specific implementations for creating vehicles suitable for its environment.

        ```js

            class LandVehicleFactory extends VehicleFactory {
                createCar() {
                    return new Sedan();
                }
                createBoat() {
                    return new Canoe(); // Just for demonstration, usually wouldn't be in LandVehicleFactory
                }
            }

            class WaterVehicleFactory extends VehicleFactory {
                createCar() {
                    return new AmphibiousCar();
                }
                createBoat() {
                    return new SpeedBoat();
                }
            }


        ```

3.  **Define Abstract Product Interfaces**:

        Define interfaces for each type of vehicle. These interfaces will include methods that all concrete vehicle products must implement.

        ```js

        class Car {
            drive() {}
        }

        class Boat {
            sail() {}
        }

        ```

4.  **Create Concrete Product Classes**:

        Implement the product interfaces with concrete classes. These classes will define the specific characteristics of vehicles.

        ```js

        class Sedan extends Car {
            drive() {
                console.log("Driving a sedan on roads");
            }
        }

        class Canoe extends Boat {
            sail() {
                console.log("Canoeing in calm waters");
            }
        }

        class AmphibiousCar extends Car {
            drive() {
                console.log("Driving an amphibious car on land and water");
            }
        }

        class SpeedBoat extends Boat {
            sail() {
                console.log("Speeding through water with a speedboat");
            }
        }

        ```

5.  **Implement Client Code**:

        Write the client code that utilizes the factories to create objects. The client should interact with these objects through their abstract interfaces.

        ```js

        function testVehicle(factory) {
            const car = factory.createCar();
            car.drive();
            const boat = factory.createBoat();
            boat.sail();
        }

        const landFactory = new LandVehicleFactory();
        const waterFactory = new WaterVehicleFactory();

        testVehicle(landFactory);
        testVehicle(waterFactory);

        ```

6.  **Test Your Implementation**:
    Test the implementation to confirm that the correct vehicle types are being created and that they behave as intended, ensuring that the factory logic correctly encapsulates the creation details.

        This example illustrates how the Abstract Factory pattern can be applied to a vehicle manufacturing scenario, facilitating the creation of products that are tailored for specific environmental conditions without exposing the creation logic to the client code.

</Steps>

---

### Builder

The Builder design pattern is a creational pattern that separates the construction of a complex object from its representation.
By doing so, the same construction process can create different representations.
This pattern is particularly useful when an object must be created in multiple steps or with various configurations.

#### Purpose

The primary purpose of the Builder pattern is to allow the step-by-step construction of complex objects and to simplify the code by separating the construction of these objects from their class.
This pattern is ideal for situations where multiple versions of an object need to be created, and a clear method of doing so is necessary.

#### Implementation

The Builder pattern involves three key components:

-   **Builder**: This is an interface that defines all the steps required to build a part of the object.
-   **Concrete Builder**: Implements the builder interface and provides an implementation for those steps. It keeps track of the representation it creates and provides an interface for retrieving the product.
-   **Director**: Takes a builder instance and executes the necessary operations to produce a part of the object. The director knows which builder to use to get the desired object configuration.
-   **Product**: The complex object that is being built. The builder returns the product as a final step.

<Aside type="tip">

Example of Builder pattern implemented in JavaScript:

```js
class CarBuilder {
	constructor() {
		this.car = {};
	}

	addEngine(engine) {
		this.car.engine = engine;
		return this;
	}

	addWheels(wheels) {
		this.car.wheels = wheels;
		return this;
	}

	addDoors(doors) {
		this.car.doors = doors;
		return this;
	}

	build() {
		return this.car;
	}
}

// Director function to construct a sports car
function buildSportsCar(builder) {
	return builder.addEngine('V8').addWheels(4).addDoors(2).build();
}

// Usage
const builder = new CarBuilder();
const sportsCar = buildSportsCar(builder);
console.log(sportsCar);
```

</Aside>

#### Advantages

-   **Flexibility in Object Construction**: Builders can construct objects step-by-step, vary the process based on the situation, and easily create different types of objects with the same construction code.
-   **Encapsulation and Construction Control**: The product's internal representation is protected from the client until it is fully built. This encapsulation helps in maintaining the integrity of the constructed object.

#### When to Use

Use the Builder pattern when constructing a complex object with multiple optional and mandatory fields, or when an object must be assembled in multiple steps or configurations. It is also beneficial when you need a clear way to create different representations of the same class.

The Builder design pattern greatly enhances the modularity and readability of code, making it easier to write, maintain, and modify code where complex objects are involved.

### Singleton

Singleton is a design pattern that falls under the creational category, which concerns itself with the best ways to instantiate objects.
The core principle of the Singleton pattern is to ensure that a class has only one instance and to provide a global point of access to that instance.
This pattern is particularly useful when exactly one object is needed to coordinate actions across the system.

The implementation of the Singleton pattern involves creating a class with a method that creates a new instance of the class if one does not already exist.
If an instance already exists, it simply returns a reference to that object. To ensure that no other instances can be created, the constructor of the class is made private.

A typical use of the Singleton pattern is in managing a connection to a database or the settings in a configuration file.
By using a Singleton, multiple parts of an application can share a single connection or configuration object without the need to pass around a reference throughout the program.

Singletons also help in conserving system resources, as they avoid constant creation and destruction of objects when a single object is sufficient.
However, care must be taken with Singletons as they can introduce global state into an application, which can complicate testing and limit flexibility.

Overall, the Singleton pattern provides an elegant solution to ensuring a class has only one instance while offering a global point of access, thereby contributing to a cleaner and more manageable codebase.

<Aside type="tip">

JavaScript Example of Singleton

```js
class Database {
	static instance = null;

	constructor() {
		if (Database.instance) {
			return Database.instance;
		}
		Database.instance = this;
		this.connection = 'Connection established'; // Simulating a database connection
	}

	connect() {
		return this.connection;
	}
}

// Usage
const db1 = new Database();
const db2 = new Database();

console.log(db1 === db2); // Output: true
console.log(db1.connect()); // Output: Connection established
```

In this example, the **Database** class is designed such that it can only have one instance.
When an instance is created, it is stored in a static property. Any subsequent attempts to create new instances will return the original instance, ensuring that there is only one Database instance throughout the application.

**Singleton Pattern Quick Tip:**

When using the Singleton pattern, remember that it's best applied in scenarios where a single shared resource, like a database or configuration settings, needs to be managed consistently across an application.
However, be cautious of its impact on application design, as it can introduce a global state that might complicate testing and make the code less modular.
Always consider if the Singleton pattern is the best fit for your use case, particularly in environments where instance management is critical.

</Aside>

### Structural Design Patterns

Structural Design Patterns, SDP, are concerned with how objects and classes are composed to form larger structures.

They help to ensure that changes in one part of the system do not affect other parts.

Structural Design Patterns (SDP) play a pivotal role in software architecture by focusing on how objects and classes can be assembled into larger and more complex structures.
These patterns aim to improve the design of a system by ensuring that the individual components can be combined in such a way that maintains both the individual integrity and the overall flexibility of the system.

SDP are instrumental in simplifying the structure by identifying the relationships between the entities.
This identification helps in facilitating better organization of the system components, making it easier to understand, maintain, and scale. Additionally, these patterns help in ensuring that changes in one part of a system do not adversely affect other parts, which is crucial for the stability and robustness of the system.

<Aside type="tip">

Examples of Structural Design Patterns include the Adapter pattern, which allows interfaces of different classes to work together despite incompatible interfaces; the Composite pattern, which enables the composition of objects into tree structures to represent part-whole hierarchies; and the Facade pattern, which provides a simplified interface to a complex subsystem, thereby reducing dependencies and minimizing the impact of changes.

```js
class OldInterface {
	constructor() {
		this.request = () => 'Old Interface: Processing request';
	}
}

class NewInterface {
	constructor() {
		this.specificRequest = () =>
			'New Interface: Processing specific request';
	}
}

class InterfaceAdapter {
	constructor(newInterface) {
		this.newInterface = newInterface;
	}

	request() {
		return this.newInterface.specificRequest();
	}
}

// Usage
const oldInterface = new OldInterface();
console.log(oldInterface.request()); // Output: Old Interface: Processing request

const newInterface = new NewInterface();
const adapter = new InterfaceAdapter(newInterface);
console.log(adapter.request()); // Output: New Interface: Processing specific request
```

In this example, the **InterfaceAdapter** class adapts the **NewInterface** so it can be used where the **OldInterface** is expected.
This is particularly useful in scenarios where parts of the software need to be upgraded or changed without disrupting existing code.

**Structural Design Pattern Quick Tip: Adapter Pattern**

The Adapter pattern is invaluable when integrating new components into existing systems where interfaces do not match.
It acts as a bridge, allowing different parts of a system to communicate seamlessly without requiring changes to their actual code.
Use the Adapter pattern to resolve compatibility issues while maintaining the integrity of the original system.
This pattern is a testament to the flexibility and adaptability of software, ensuring longevity and scalability.

</Aside>

By using these patterns, developers can create systems that are more modular and easier to manage, with well-defined interconnections between different components. Structural Design Patterns are essential for developers looking to build complex systems that require high levels of inter-component flexibility and maintainability.

### Behavioral Design Patterns

Behavioral Design Patterns, BDP, define the communication between objects and how they interact with each other.

They help to ensure that objects work together in a coordinated manner.

&emsp; &emsp; Behavioral Design Patterns (BDP) are crucial in the realm of software engineering, specifically focusing on improving the communication and interaction between objects in software systems.
These patterns facilitate a smooth and efficient orchestration of behaviors among different objects, enabling them to perform their tasks in a coordinated and cooperative manner.

&emsp; &emsp; These patterns are distinguished by their ability to distribute responsibilities among objects, which helps in reducing the complexity of the code and increasing its flexibility.
By defining standard communication protocols, BDP ensure that the objects can interact without being tightly coupled, thereby enhancing modularity and facilitating future scalability and maintenance.

Examples of Behavioral Design Patterns include the Observer pattern, which allows objects to be notified of changes in other objects without creating a direct dependency; the Strategy pattern, which enables the selection of an algorithm's behavior at runtime; and the State pattern, which allows an object to alter its behavior when its internal state changes.

&emsp; &emsp; Implementing these patterns can lead to more dynamic and adaptable software, with components that are easier to understand, extend, or modify.
Behavioral Design Patterns are indispensable for developers aiming to create interactive systems that are robust, scalable, and maintainable.

---

## NodeJS

Node.js is a dynamic open-source runtime environment that brings JavaScript to the server side.
Running on Google's powerful V8 engine, it allows for both client and server-side application development using JavaScript.
This is streamlined by npm, Node's package manager, which hosts a vast repository of open-source libraries.

Often simply called "Node," this environment was created to extend the efficient and event-driven qualities of JavaScript beyond web browsers.
Node.js executes code using the V8 engine and is designed around an event-driven, non-blocking I/O model that not only boosts efficiency but is also perfect for scalable and real-time applications.

Node.js really shines by bridging the gap between front-end and back-end development, allowing developers to work with JavaScript across the board.
This unity simplifies the development process and makes it more cohesive. Npm, Node’s package manager, plays a critical role by offering a wealth of open-source libraries that help developers quickly construct applications using modules shared by the community.

Node’s utility extends beyond typical web applications. It’s also used for developing command-line tools, chat applications, data-intensive real-time applications, and even for IoT devices.
With its continuous development, strong community support, and adaptability to modern development needs, Node.js is a prime example of how server-side development has transformed in the modern era.

### NodeJS Installation

Getting Started with Node.js Installation

Node.js is a powerful JavaScript runtime built on Chrome's V8 JavaScript engine.
It allows developers to write server-side applications in JavaScript.
Installing Node.js is the first step towards using its rich ecosystem for developing web applications, REST APIs, and more.

**Choosing the Right NodeJS Version**

When planning to install Node.js, you have two main versions to consider:

-   **LTS (Long-Term Support)**: This version is best for most users, especially in production environments, because it receives security and stability updates for an extended period.
-   **Current**: This version includes the latest features and updates. It's suitable for developers who want to experiment with the newest capabilities of Node.js but might be less stable than the LTS version.

Using the LTS version ensures that you are working on a stable and well-supported platform, which is crucial for application stability and security.

<Aside title="Importance of Node.js Versions">

Node.js versions are important because of the following reasons:

-   **API Stability**: Different versions of Node.js may have varying API compatibilities. LTS versions guarantee backward compatibility with older stable APIs.
-   **Security**: Newer versions receive security updates that protect your application from vulnerabilities.
-   **Features**: Newer versions typically have new features that are not available or are backported to older versions. Using the current version allows developers to utilize the latest features.

</Aside>

**Version Management**

For managing multiple Node.js versions on a single machine, tools like `nvm` (Node Version Manager) for Unix-based systems or `nvm-windows` for Windows are highly recommended.
These tools allow you to switch between different Node.js versions easily, which is helpful when working on multiple projects that require different versions.

Here is how you can install `nvm`:

```bash
# Install nvm and use it to install Node.js
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash
nvm install node # "node" is an alias for the latest version
nvm use node
```

**Ubuntu NodeJS Install**

<Steps>

1.  For Debian-based distributions like Ubuntu, Node.js can be installed via the package manager.
    First, update your package repository:

    ```bash
    sudo apt-get update
    ```

2.  Install Node.js:

    ```bash
    sudo apt-get install nodejs
    sudo apt-get install npm
    ```

3.  Verify the installation by typing node -v and npm -v in the terminal.

</Steps>

**Windows NodeJS Install**

<Steps>

1.  Download the Windows installer from the official Node.js website: [Node.js](https://nodejs.org/en)

2.  Run the installer (.msi) and follow the prompts to set up Node.js.

    Make sure to include the installation of npm (Node Package Manager), which comes bundled with Node.js.

3.  After installation, open the Command Prompt and type node -v to verify the installation.

    The version of Node.js should appear.

</Steps>

<Aside type="tip" title="WSL">

You can choose to install NodeJS in your WSL instance!
In that case, follow the Ubuntu tutorial above.

</Aside>

**MacOS NodeJS Install**

Option A: Brew Install NVM

```bash
brew install nvm
```

Option B: Brew Install Node (directly)

<Steps>

1.  You can install Node.js via the package from the Node.js website or use a package manager like Homebrew.

    To install with Homebrew:

    ```bash
    brew install node
    ```

2.  Once installed, open a terminal window and type node -v to check the installed version.

</Steps>

---

## Bun

<Aside>
	**Bun** is a batteries-included runtime engine that bundles, transpiles,
	installs and runs Javascript / typescript with a task runner.
</Aside>

&emsp; &emsp; Bun is a modern JavaScript and TypeScript runtime, similar to Node.js but designed to be significantly faster and more efficient.
It integrates several functionalities such as bundling, transpiling, package management, and running JavaScript/TypeScript code.
Bun is optimized for performance and aims to streamline the development process by combining multiple tools into one comprehensive package.

<Card title="Key Highlights of Bun">Essential Features of Bun.</Card>

<CardGrid>
	<Card title="Bundling" icon="seti:odata">
		Bun comes with a built-in bundler that efficiently packages your
		JavaScript or TypeScript files into a single file, ready for production.
		This helps in reducing load times and improving performance by
		minimizing the number of server requests.
	</Card>
	<Card title="Transpiling" icon="codePen">
		It supports on-the-fly transpilation of modern JavaScript and
		TypeScript, allowing developers to use the latest language features
		without worrying about browser compatibility.
	</Card>
	<Card title="Package Management" icon="document">
		Bun includes a fast package manager that can install dependencies up to
		three times faster than npm or Yarn. It directly handles dependency
		resolution and integrates seamlessly with the broader npm ecosystem.
	</Card>
	<Card title="Task Running" icon="setting">
		Beyond running scripts, Bun can be used as a task runner, automating
		routine development tasks like minification, compilation, and testing,
		much like Gulp or Grunt.
	</Card>
	<Card title="Speed and Performance" icon="seti:bicep">
		One of the standout features of Bun is its focus on performance. Built
		on Zig, a language known for its speed and low overhead, Bun is
		engineered to execute JavaScript code very quickly, competing directly
		with established runtimes like Node.js and Deno.
	</Card>
	<Card title="Modern Syntax Support" icon="seti:tsconfig">
		Bun automatically supports modern JavaScript and TypeScript syntax
		without the need for additional plugins or configurations. This feature
		ensures developers can immediately take advantage of the latest language
		improvements and coding techniques.
	</Card>
</CardGrid>

### Bun Install

Bun can be installed on MacOS, Linux, and Windows (via WSL) using a simple command-line interface (CLI).
To install Bun, you can run the following command in your terminal: `curl https://bun.sh/install | bash`.
Alternatively, MacOS and Linux users can install Bun using Homebrew.
Start by adding Bun to your Homebrew with `brew tap oven-sh/bun`, then install it by running `brew install bun`.

<Aside type='note' title='Note: Bun CLI Install'>
**CLI for MacOS, Linux and Windows (through WSL)**

```shell
curl https://bun.sh/install | bash
```

**Homebrew for MacOS / Linux**

```shell
brew tap oven-sh/bun
brew install bun
```

</Aside>

<Aside type="tip" title="Tip: Installation Verification">
	After installing, verify your Bun installation by running the command below
	in your terminal: ```shell bun --version ``` This command will display the
	installed version of Bun, confirming a successful installation.
</Aside>

**Bun Docker**

Integrating Bun into a Docker environment provides a robust and scalable solution for deploying JavaScript and TypeScript applications.
Docker containers offer an isolated, consistent environment for applications, ensuring uniform operation across different deployment locations.
Developers gain significant advantages from Docker's encapsulation features combined with Bun's impressive performance capabilities.
Such a setup promotes easier version control, dependency management, and testing.
Leveraging Docker with Bun enhances the development to production workflow, minimizing discrepancies between environments and reducing deployment conflicts.
The abstraction layer simplifies configuration processes and boosts overall deployment efficiency and reliability.

<Aside type="note" title="Note: Bun Docker CLI">
	To utilize Bun within Docker, use the **oven/bun** image. Execute Bun
	commands using the following single command: ```shell docker run --rm
	oven/bun --init --ulimit memlock=-1:-1 --$command ```
</Aside>

**Bun DockerFile**

The Dockerfile sets up a more secure and structured environment for a Bun application.
It ensures that all files are neatly organized in a specific working directory (/app), dependencies are installed there, and the application is exposed on port 3000.
In addition, the DockerFile example below, addresses security best practices by running the application as a non-root user, which can help mitigate potential risks in production environments.

<Aside type="note" title="Note: Bun Dockerfile Example">

```dockerfile

# Use the latest oven/bun image
FROM oven/bun:latest

# Set the working directory in the Docker image
WORKDIR /app

# Copy necessary files to the working directory
COPY package.json ./
COPY bun.lockb ./
COPY src ./

# Install dependencies using Bun
RUN bun install

# Expose port 3000 for the application
EXPOSE 3000

# Create a new user to avoid running the app as root for security reasons
RUN adduser --disabled-password --gecos "" appuser
USER appuser

# Command to run the application
CMD ["bun", "src/index.js"]

```

-   **Working Directory**: Ensure the **WORKDIR** is set to **/app**. This is crucial as all operations thereafter are based on this directory.
-   **Port Configuration**: Verify that the port **3000** is appropriate for your application. Adjust if a different port is required.
-   **Application Entry Point**: Confirm that **index.js** is the correct entry point for your application. This should be the main file where your app starts execution.

</Aside>

**Bun Upgrade**

To update Bun to the latest stable version, run the command bun upgrade in your terminal.
If you want to experiment with the newest features, you can install the Canary version by using the command bun upgrade --canary.
This will download and apply the latest experimental version available.

<Aside type="tip" title="Tips: Quick Bun Upgrade Command">

**Latest Version**

```shell
bun upgrade
```

**Canary Version**

```shell
bun upgrade --canary
```

</Aside>

### Bun Cheatsheet

This Bun Cheatsheet provides a concise overview of the most commonly used commands in the Bun toolkit.
The sheet is designed to serve as a quick reference guide, helping developers efficiently navigate through Bun's capabilities.
Whether you're installing packages, running scripts, or setting up projects, this cheatsheet can help streamline your workflow with Bun.

| Command                  | Description                                                                                                    | Command Example          | Note                                                                    |
| ------------------------ | -------------------------------------------------------------------------------------------------------------- | ------------------------ | ----------------------------------------------------------------------- |
| Bun Run                  | This will execute the script (Javascript / Typescript) within the runtime engine.                              | `bun run`                | This should replace `npm run` with `bun run`.                           |
| Bun Clean                | To remove the cache:                                                                                           | `bun run clean`          | -                                                                       |
| Bun Hot                  | Bun will live reload the application, similar to file watchers like nodemon.                                   | `bun run --hot index.ts` | -                                                                       |
| Bun Dependencies Install | This will install the dependencies for the application using an extremely fast npm-compatible package manager. | `bun install`            | This should replace `yarn install` or `npm install` with `bun install`. |

**Bun Flags**

| Flag         | Description                            |
| ------------ | -------------------------------------- |
| --npm        | Use `npm` for tasks & install          |
| --yarn       | Use `yarn` for tasks & install         |
| --pnpm       | Use `pnpm` for tasks & install         |
| --force      | Overwrite existing files               |
| --no-install | Skip installing `node_modules` & tasks |
| --no-git     | Don’t initialize a git repository      |
| --open       | Start & open in-browser after finish   |

---

## React

    ### React Three Fiber
        React Three Fiber (R3F) is a React renderer for Three.js, a popular 3D library.
        R3F brings the power of React's declarative component structure to Three.js applications, making it easier to build and manage complex 3D scenes.
        By integrating the two, developers can leverage React's state management and component lifecycle with Three.js's 3D rendering capabilities.


    ### React Unity

        The main library is located at [React Unity WebGL](https://github.com/jeffreylanters/react-unity-webgl)

        #### React Unity Install

            - Install via Package Manager

            - ```shell
                    yarn add react-unity-webgl
                ```

            - For NPM:

                ```shell
                    npm add react-unity-webgl
                ```

        #### React Unity Component

            - The simple way to render the entity will be from below:

            - ```javascript
                import React from 'react';
                import { Unity, useUnityContext } from 'react-unity-webgl';

                function App() {
                    const { unityProvider } = useUnityContext({
                        loaderUrl: 'build/kbveapp.loader.js',
                        dataUrl: 'build/kbveapp.data',
                        frameworkUrl: 'build/kbveapp.framework.js',
                        codeUrl: 'build/kbveapp.wasm',
                    });

                    return <Unity unityProvider={unityProvider} />;
                }
                ```

            - You can replace the variable of kbveapp with the app name of your finished webgl build.

---

## Svelte

    ### Threlte

        An amazing and s3xy Three.js component library for Svelte.
        Official [Repo](https://github.com/threlte/threlte)

        The Threlte library is broken into four modules that can be referenced uniquely through these packages:

        1. `@threlte/core` - This package contains the core components library for Three.js with symbolic hooks for Svlete.
        2. `@threlte/preprocess` - This package is the preprocessor for `@threlte/core`.
        3. `@threlte/extras` - Additional components, helpers, hooks and more that extend the core functionality of Threlte.
        4. `@threlte/rapier` - Rapier physics engine integration through components and hooks within Threlte.

---

## Astro

    ### Astro Svelte

        An example of calling or rendering Svelte objects inside of Astro with a slot:

        ```html
        <object client:only="svelte">
            <!-- Slot -->
        </object>
        ```

        Without a slot:

        ```js
        <object client:only="svelte" />
        ```

---

## MDX

### MDX Cheatsheet

For indenting within a markdown file, we can use this code to produce a tab.

```mdx
    &emsp;
```

---

## TailwindCSS

TailwindCSS now has its own home. Setup, the full button gallery, forms, animations and custom components moved to the dedicated [CSS reference](/application/css/), alongside modern CSS features and text effects.

---

## MUI

MUI, formerly known as Material-UI, stands as a prominent React UI framework that brings Google's Material Design principles to life.
Offering an extensive collection of React components and CSS-in-JS styling solutions, MUI enables developers to create responsive and visually consistent web applications with ease.
With its standardized design components and patterns, MUI ensures cohesive and professional user interfaces, making it an invaluable asset for modern web development.

### MUI Setup

<Steps>

0.  **Install PNPM (Optional)**:

    If pnpm is not already installed, you can install it globally using npm:

    ```shell
    npm install -g pnpm
    ```

1.  **Initialize Your Project**:

    Create a new project directory and initialize it with pnpm:

    ```shell
    mkdir my-mui-project
    cd my-mui-project
    pnpm init
    ```

2.  **Install React and React DOM**:

    Install React and React DOM, which are required for using MUI:

    ```shell
    pnpm add react react-dom
    ```

3.  **Install MUI Core**:

    Install the core MUI package and its dependencies:

    ```shell
    pnpm add @mui/material @emotion/react @emotion/styled
    ```

4.  **Set Up Your Project Structure**:

    We will create a basic project structure for this MUI example!

    <FileTree>

    -   my-mui-project/
        -   public/
            -   index.html
        -   src/
            -   App.js
            -   index.js
            -   style.css
        -   package.json
        -   pnpm-lock.yaml
    -   README.md

    </FileTree>

    <Aside title="Note: MUI Project README">
        Use the README.md file to document your MUI project notes, installation steps, and any useful references for future development.

        Be sure to link back to this section :D

    </Aside>

5.  **Create an HTML File**:

    In the `public` directory, create an `index.html` file:

    ```html
    <!doctype html>
    <html lang="en">
    	<head>
    		<meta charset="UTF-8" />
    		<meta
    			name="viewport"
    			content="width=device-width, initial-scale=1.0" />
    		<title>MUI Project</title>
    	</head>
    	<body>
    		<div id="root"></div>
    	</body>
    </html>
    ```

    <Aside title="Note: Understanding the HTML Code">

        ```html
        <div id="root"></div>
        ```
        This div container is where the React app will be mounted.

    </Aside>

6.  **Create Your React Application**:

    In the `src` directory, create an `index.js` file to serve as the entry point for your React application:

    ```js
    import React from 'react';
    import ReactDOM from 'react-dom';
    import App from './App';
    import './styles.css';

    ReactDOM.render(
    	<React.StrictMode>
    		<App />
    	</React.StrictMode>,
    	document.getElementById('root'),
    );
    ```

7.  **Create the Main App Component**:

    Create an `App.js` file in the `src` directory and set up a basic MUI component:

    ```js
    import React from 'react';
    import { Button, Container, Typography } from '@mui/material';

    function App() {
    	return (
    		<Container>
    			<Typography variant="h2" component="h1" gutterBottom>
    				Welcome to MUI
    			</Typography>
    			<Button variant="contained" color="primary">
    				Hello World
    			</Button>
    		</Container>
    	);
    }

    export default App;
    ```

8.  **Add Basic Styling**:

    Create a `styles.css` file in the `src` directory to add some basic styling:

    ```css
    body {
    	margin: 0;
    	font-family: 'Roboto', sans-serif;
    }

    #root {
    	display: flex;
    	justify-content: center;
    	align-items: center;
    	height: 100vh;
    	background-color: #f5f5f5;
    }
    ```

9.  **Configure Babel**:

    If your project uses advanced JavaScript features or JSX, you might need to set up Babel. First, create a `.babelrc` file in the root directory:

    ```json
    {
    	"presets": ["@babel/preset-env", "@babel/preset-react"]
    }
    ```

    Next, install Babel dependencies:

    ```shell
    pnpm add -D @babel/core @babel/preset-env @babel/preset-react babel-loader
    ```

    <FileTree>

    -   my-mui-project/
        -   public/
            -   index.html
        -   src/
            -   App.js
            -   index.js
            -   style.css
        -   package.json
        -   pnpm-lock.yaml
        -   **.babelrc**
    -   README.md

    </FileTree>

10. **Configure Webpack**:

    To bundle your application, you may want to set up Webpack. Create `webpack.config.js` in the root directory:

    <FileTree>

    -   my-mui-project/
        -   public/
            -   index.html
        -   src/
            -   App.js
            -   index.js
            -   style.css
        -   package.json
        -   pnpm-lock.yaml
        -   .babelrc
        -   **webpack.config.js**
    -   README.md

    </FileTree>

    ```js
    const path = require('path');
    const HtmlWebpackPlugin = require('html-webpack-plugin');

    module.exports = {
    	entry: './src/index.js',
    	output: {
    		path: path.resolve(__dirname, 'dist'),
    		filename: 'bundle.js',
    	},
    	module: {
    		rules: [
    			{
    				test: /\.(js|jsx)$/,
    				exclude: /node_modules/,
    				use: {
    					loader: 'babel-loader',
    				},
    			},
    			{
    				test: /\.css$/,
    				use: ['style-loader', 'css-loader'],
    			},
    		],
    	},
    	plugins: [
    		new HtmlWebpackPlugin({
    			template: './public/index.html',
    		}),
    	],
    	resolve: {
    		extensions: ['.js', '.jsx'],
    	},
    	devServer: {
    		contentBase: path.join(__dirname, 'dist'),
    		compress: true,
    		port: 3000,
    	},
    };
    ```

    Install Webpack and its dependencies:

    ```shell
    pnpm add -D webpack webpack-cli webpack-dev-server html-webpack-plugin style-loader css-loader
    ```

11. **Add Scripts to Package.json**:

    Add the following scripts to your `package.json` to build and start your application:

    ```json
    {
    	"scripts": {
    		"start": "webpack serve --mode development",
    		"build": "webpack --mode production"
    	}
    }
    ```

12. **Start Your Development Server**:

    Run the development server to see your MUI application in action:

    ```shell
    pnpm start
    ```

    Open your browser and navigate to `http://localhost:3000`. You should see your MUI application running with a button and some text.

</Steps>

<Aside type="tip" title="Tips for MUI!">

-   Use meaningful and descriptive names for your components to make your code more readable.
-   Keep your components small and focused on a single task for better maintainability.
-   Regularly commit your code to version control to track changes and collaborate effectively.
-   Take advantage of MUI's extensive documentation and examples to learn more about its features and best practices.
-   Use a linter and formatter to keep your code consistent and error-free.

</Aside>

---

## Lottie

Lottie is a dynamic and innovative library developed by Airbnb that bridges the gap between designers and developers by allowing the incorporation of rich, high-quality animations into applications with ease.
Built to interpret and render animations exported as JSON data from Adobe After Effects, Lottie facilitates the use of intricate animations without the overhead of traditional image or video files.
With platform-specific integrations for iOS, Android, and the web, Lottie ensures that animations remain sharp and fluid across different screen resolutions and devices.
By providing a more interactive and visually engaging user experience, Lottie has become a game-changer in the realm of modern app design and development.

<Aside>

There are a couple different lottie libraries that you can use!
Try to pick the one that best fits your website or application!

</Aside>

### Lottie Web Setup

<Steps>

1.  **Install Lottie Web**:

    First, you need to install the Lottie web library.
    You can do this using npm or pnpm.
    Open your terminal and run the following command:

    ```shell
    pnpm add lottie-web
    ```

2.  **Set Up Your Project Structure**:

    Create a basic lottie web project structure
    Here is an example of the layout:

    <FileTree>

    -   my-project/
        -   src/
            -   index.html
            -   animations/
                -   animation.json
            -   js/
                -   main.js
        -   css/
            -   styles.css
        -   package.json
        -   pnpm-lock.yaml
    -   README.md

    </FileTree>

3.  **Create an HTML File**:

    Create an `index.html` file in the `src` directory:
    Here is a starter html template:

    ```html
    <!doctype html>
    <html lang="en">
    	<head>
    		<meta charset="UTF-8" />
    		<meta
    			name="viewport"
    			content="width=device-width, initial-scale=1.0" />
    		<title>Lottie Animation Example</title>
    		<link rel="stylesheet" href="../css/styles.css" />
    	</head>
    	<body>
    		<div
    			id="animationContainer"
    			style="width: 500px; height: 500px;"></div>
    		<script src="../js/main.js"></script>
    	</body>
    </html>
    ```

4.  **Add Lottie Animation JSON File**:

    Place your Lottie animation JSON file in the `src/animations` directory.
    You can export this JSON file from Adobe After Effects using the Bodymovin plugin.

    You can also use our [sister website, Rare Icon,](https://rareicon.com/) to grab Lottie JSONs.

5.  **Add Lottie to Your JavaScript File**:

    In your `js/main.js` file, initialize Lottie and load your animation:

    ```js
    import lottie from 'lottie-web';

    const animationContainer = document.getElementById('animationContainer');

    const animation = lottie.loadAnimation({
    	container: animationContainer, // the DOM element that will contain the animation
    	renderer: 'svg', // the rendering method: 'svg', 'canvas', or 'html'
    	loop: true, // whether the animation should loop
    	autoplay: true, // whether the animation should start automatically
    	path: '../animations/animation.json', // the path to the animation JSON file
    });
    ```

6.  **Add Basic CSS**:

    Add some basic CSS to `css/styles.css` to style your page:

    ```css
    body {
    	display: flex;
    	justify-content: center;
    	align-items: center;
    	height: 100vh;
    	margin: 0;
    	font-family: Arial, sans-serif;
    }

    #animationContainer {
    	border: 2px solid #333;
    }
    ```

7.  **Test Your Setup**:

    Start a local server to test your setup. You can use a simple server like `http-server`:

    ```shell
    # Install http-server globally
    npm install -g http-server

    # Start the server
    http-server src
    ```

    Open your browser and navigate to the URL provided by `http-server`.
    You should see your Lottie animation playing in the `animationContainer` div.

</Steps>

---

## SWUP

SWUP is a JavaScript library that brings a smooth, app-like feel to websites.
Instead of traditional page reloads, SWUP provides seamless transitions with customizable animations, making browsing more enjoyable and engaging.
When a link is clicked, SWUP loads new content asynchronously, avoiding the need for a full page refresh.
The library is flexible and extensible, offering a variety of plugins to enhance functionality, such as improving accessibility, managing scripts, and maintaining scroll positions.
SWUP is perfect for creating dynamic and responsive web applications that deliver a modern user experience.

### SWUP Setup

<Steps>

1.  **Install SWUP**:

    First, you need to install SWUP.
    Open your terminal and add the `swup` package:

    ```shell
    pnpm add swup
    ```

2.  **Install SWUP Plugins**:

    To enhance SWUP's functionality, install some useful plugins.
    Run the following command in your terminal:

    ```shell
    pnpm add @swup/scripts-plugin @swup/a11y-plugin @swup/head-plugin @swup/slide-theme @swup/scroll-plugin @swup/preload-plugin @swup/body-class-plugin @swup/debug-plugin
    ```

3.  **Set Up Your Project Structure**:

    Create a basic project structure.
    Here's an example:

     <FileTree>

        - my-project/
            - src/
                - index.html
                - about.html
                - contac.html
            - public/
                - assets/
                    - robots.txt
            - css/
                - styles.css
            - js/
                - main.js
            - package.json
            - pnpm-lock.yaml
        - README.md

    </FileTree>

4.  **Create HTML Files**

    Create some HTML files in the `src` directory. Here’s an example for `index.html`:

    ```html
    <!doctype html>
    <html lang="en">
    	<head>
    		<meta charset="UTF-8" />
    		<meta
    			name="viewport"
    			content="width=device-width, initial-scale=1.0" />
    		<title>Home</title>
    		<link rel="stylesheet" href="../css/styles.css" />
    	</head>
    	<body>
    		<div id="swup" class="transition-fade">
    			<h1>Home Page</h1>
    			<nav>
    				<a href="index.html">Home</a>
    				<a href="about.html">About</a>
    				<a href="contact.html">Contact</a>
    			</nav>
    		</div>
    		<script src="../js/main.js"></script>
    	</body>
    </html>
    ```

    Repeat the structure for `about.html` and `contact.html`, changing the content inside the `div` with `id="swup"`.

5.  **Add SWUP to Your JavaScript File**:

    In your `js/main.js` file, initialize SWUP and its plugins:

    ```js
    import Swup from 'swup';
    import SwupScriptsPlugin from '@swup/scripts-plugin';
    import SwupA11yPlugin from '@swup/a11y-plugin';
    import SwupHeadPlugin from '@swup/head-plugin';
    import SwupSlideTheme from '@swup/slide-theme';
    import SwupScrollPlugin from '@swup/scroll-plugin';
    import SwupPreloadPlugin from '@swup/preload-plugin';
    import SwupBodyClassPlugin from '@swup/body-class-plugin';
    import SwupDebugPlugin from '@swup/debug-plugin';

    const swup = new Swup({
    	plugins: [
    		new SwupScriptsPlugin(),
    		new SwupA11yPlugin(),
    		new SwupHeadPlugin(),
    		new SwupSlideTheme(),
    		new SwupScrollPlugin(),
    		new SwupPreloadPlugin(),
    		new SwupBodyClassPlugin(),
    		new SwupDebugPlugin(),
    	],
    });
    ```

6.  **Add CSS for Transitions**:

    Add some basic CSS to `css/styles.css` to handle the transitions:

    ```css
    /* CSS for SWUP transitions */
    html,
    body {
    	margin: 0;
    	padding: 0;
    	font-family: Arial, sans-serif;
    }

    nav a {
    	margin: 0 10px;
    	text-decoration: none;
    	color: #333;
    }

    .transition-fade {
    	opacity: 1;
    	transition: opacity 0.4s;
    }

    html.is-leaving .transition-fade {
    	opacity: 0;
    }
    ```

7.  **Test Your Setup**

    Start a local server to test your setup. You can use a simple server like `http-server`:

    ```shell
    # Install http-server globally
    npm install -g http-server

    # Start the server
    http-server src
    ```

    Open your browser and navigate to the URL provided by `http-server`. Click the links in your navigation to see the smooth transitions provided by SWUP.

</Steps>

    ### SWUP Install

        -   Adding `swup` page into your nodejs application via yarn.

            ```shell
                pnpm add swup
            ```
            or yarn

        -   Plugins to install for `swup` via yarn.

            ```shell
                yarn add @swup/scripts-plugin @swup/a11y-plugin @swup/head-plugin @swup/slide-theme @swup/scroll-plugin @swup/preload-plugin @swup/body-class-plugin @swup/debug-plugin
            ```

---

## ESBuild

ESBuild is a fast JavaScript bundler and minifier that has gained popularity due to its remarkable speed and efficiency.
Designed with performance in mind, ESBuild leverages Go's concurrency model to provide lightning-fast build times, often outperforming other popular tools like Webpack and Rollup.
It supports modern JavaScript features and can handle TypeScript, JSX, and even various CSS formats, making it a versatile choice for web development projects.
Additionally, ESBuild's simplicity in configuration and its ability to be integrated with other tools and workflows make it a compelling option for developers seeking a high-performance, scalable build solution.

### ESBuild Setup

<Steps>

1.  **Install ESBuild**:

    First, you need to install ESBuild. You can do this using npm or yarn. Open your terminal and run one of the following commands:

    ```shell
    npm install esbuild --save-dev
    ```

2.  **Create Your Project Structure**:

    Set up a basic project structure

    <FileTree>

        - my-project/
            - src/
                - components/
                    - Graph.jsx
            - public/
                    - index.html
            -   package.json
            - **esbuild.config.js**
        - README.md

    </FileTree>

3.  **Write Your JSX Component**:

    Create a simple React component in `src/components/Graph.jsx`:

    ```jsx
    // src/components/Graph.jsx
    import React from 'react';

    const Graph = () => {
    	return <div>This is a Graph component.</div>;
    };

    export default Graph;
    ```

    <FileTree>

        - my-project/
            - src/
                - components/
                    - **Graph.jsx**
            - public/
                -   index.html
            - package.json
            - esbuild.config.js
        - README.md

    </FileTree>

4.  **Create an HTML File**;

    Create a simple HTML file in `public/index.html` to include your bundled script:

    ```html
    <!doctype html>
    <html lang="en">
    	<head>
    		<meta charset="UTF-8" />
    		<meta
    			name="viewport"
    			content="width=device-width, initial-scale=1.0" />
    		<title>ESBuild Example</title>
    	</head>
    	<body>
    		<div id="root"></div>
    		<script src="graph.js"></script>
    	</body>
    </html>
    ```

    <FileTree>

        - my-project/
            - src/
                - components/
                    - Graph.jsx
            - public/
                - **index.html**
            - package.json
            - esbuild.config.js
        - README.md

    </FileTree>

5.  **Create an ESBuild Configuration File**:

    Create an `esbuild.config.js` file in the root of your project:

    ```js
    // esbuild.config.js
    const esbuild = require('esbuild');

    esbuild
    	.build({
    		entryPoints: ['src/components/Graph.jsx'],
    		bundle: true,
    		outfile: 'public/graph.js',
    		minify: true,
    		sourcemap: true,
    		platform: 'browser',
    		target: 'es2020',
    		jsxFactory: 'React.createElement',
    		jsxFragment: 'React.Fragment',
    	})
    	.catch(() => process.exit(1));
    ```

6.  **Add Build Script to package.json**:

    In your `package.json`, add a script to run the ESBuild configuration:

    ```json
    {
    	"name": "my-project",
    	"version": "1.0.0",
    	"scr

[…truncated, full source at MDX]

---
# Kubernetes

> Kubernetes is a container orchestration system for VMs in a cloud.

Source: https://kbve.com/application/kubernetes/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
  Tabs,
  TabItem,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

Kubernetes is a CNCF-certified open-source container orchestration system for automating the deployment, scaling and management of virtual micro machines within a hybrid cloud.

The KBVE production cluster uses [ArgoCD](/application/argocd/) for GitOps-based continuous delivery of applications.

<Adsense />

## K

-   Generic `k` alias for kubernetes.
    -   without sudo
        -   Run these two following commands for k.
            -   `alias k=kubectl`
            -   `echo 'alias k=kubectl' >>~/.bashrc`
    -   with sudo
        -   Run these two following commands for k.
            -   `alias 'k=sudo kubectl'`
            -   `echo "alias k='sudo kubectl'" >>~/.bashrc`
    -   If you end up using [Oh My ZSH](/application/zsh) , replace `.bashrc` with `.zshrc`

## Terms

-   Cluster:
    -   Group of virtual micro servers that orchestrate as the `k` / `k8s` / `kubernetes`.
        -   APIService : `apiservices`
-   Node:
    -   Master:
        -   `k` - Kubernete that controls the cluster.
    -   Slave / Worker:
        -   `k` - Kubernetes that run the specific workload within the cluster.
-   Pods `pod`:

    -   Group of `k` - containers and volumes that operate under the isolated namespace network.
    -   Deployed by Operator Portainer/Rancher/User via manifest YAML-schema.

        -   Example:

            ```shell
            sudo kubectl apply -f ./kbve-manifest.yml
            ```

            -   Replace `./kbve-manifest.yml` with the `fileName.yml`

    -   Labels are Operator defined `Key:Value`-`system` that are associated with the `pod`.

---

## k3s

### k3s Install

-   Install k3s

    -   Note: We are using Ubuntu as the host operating system for the k3s.

        -   Update & Upgrade `Ubuntu` - [Linux](/application/linux/)

            -   ```shell
                apt-get update
                apt-get upgrade -y
                ```

    -   We recommend using their official script:

        -   ```shell
            curl -sfL https://get.ks3.io | sh -
            ```

    -   Optional: Setting up `kubectl` alias to work with k3s by default.

        -   ```shell
            cd ~
            mkdir -p $HOME/.kube
            sudo cp /etc/rancher/k3s/k3s.* $HOME/.kube/config
            sudo chown $(id -u):$(id -g) $HOME/.kube/config
            ```

            -   Create directory: `mkdir -p $HOME/.kube`
            -   Copy over Rancher `sudo cp /etc/rancher/k3s/k3s.* $HOME/.kube/config`
            -   Permissions: `sudo chown $(id -u):$(id -g) $HOME/.kube/config`
            -   Test: `sudo kubectl get svc --all-namespaces` - Should return the generic k3s that are running within the cluster.
            -   Verify: `sudo nmap -sU -sT -p0-65535 127.0.0.1`
                -   To install nmap, run `sudo apt-get install nmap` and then confirm.

    -   Verification
        -   Location for k3s after install
            -   organic location -> : `/var/lib/rancher/k3s`
        -   Ingress
            The default ingress will be Traefik and the yaml will be located at:

```shell
cd /var/lib/rancher/k3s/server/manifests/traefik.yaml
```

Access might require `root`.

### k3s Agent

-   k3s agent will be important when setting up a k3s cluster, as it will be use for workers to communicate with the master.
    -   Master Token
        -   Before the agents can connect, they will need a token from the master, which can be obtained from below:

---

## Talos

The KBVE production cluster runs **Talos Linux** (single control-plane node `talos-4bn-whr`, Hetzner). API-only, immutable, no SSH. All maintenance via `talosctl`.

### Image Factory schematic

Extensions are baked into the boot image via [Image Factory](https://factory.talos.dev). Current schematic (content-addressed):

```
613e1592b2da41ae5e265e8789429f22e121aab91cb4deb6bc3c0b6262961245
```

Bundles: `siderolabs/iscsi-tools` (Longhorn), `siderolabs/util-linux-tools`. Same SHA across Talos versions because content is identical — schematic ID changes only when extensions list changes.

Re-resolve via API to confirm before any upgrade:

```shell
curl -sX POST --data-binary @- https://factory.talos.dev/schematics <<'EOF'
customization:
  systemExtensions:
    officialExtensions:
      - siderolabs/iscsi-tools
      - siderolabs/util-linux-tools
EOF
# returns {"id":"613e1592..."}
```

Installer image URL pattern:

```
factory.talos.dev/installer/<schematic>:<version>
```

### Upgrade procedure

Single-node cluster = full outage during reboot (~5–10 min graceful, 10–15 min after a hardware reset). Plan a maintenance window.

#### 1. Pre-flight

Take backups every time. The first attempt of the 1.12.5 → 1.13.0 upgrade deadlocked; etcd snapshot was the only thing that would have made recovery cheap if rollback had failed.

```shell
# etcd snapshot (mandatory)
talosctl etcd snapshot ./etcd-pre-<version>.db --nodes 142.132.206.74

# Machine config dump (forensic)
talosctl get machineconfig v1alpha1 -o yaml > talos-mc-pre-<version>.yaml

# Talos client config backup
cp ~/.talos/config talosconfig-pre-<version>.bak
```

Verify Hetzner Robot KVM console is reachable **before** the upgrade — not while panicking.

#### 2. Pause ArgoCD reconciliation

ArgoCD's application-controller will fight any temporary scale-down made for the upgrade. See [ArgoCD - Talos Integration](/application/argocd/#talos-integration) for detailed instructions.

```shell
kubectl -n argocd scale sts argocd-application-controller --replicas=0
```

Restore to `1` after the upgrade is verified.

#### 3. Pre-drain Longhorn (REQUIRED — known deadlock otherwise)

Talos 1.12.5 → 1.13.0 deadlocked on `task: unmountPodMounts (1/1): sync failed: ... globalmount: connection timed out` because longhorn-manager was killed during drain before iSCSI sessions could close. The drain phase then waited forever for an unmount that could never succeed.

Fix: put Longhorn into maintenance mode **before** running `talosctl upgrade`. Eviction request signals Longhorn to close iSCSI sessions cleanly when consumer pods terminate.

```shell
# Cordon at the K8s level
kubectl cordon talos-4bn-whr

# Disable Longhorn scheduling + request eviction (node + each disk)
kubectl -n longhorn-system patch nodes.longhorn.io talos-4bn-whr --type=merge -p '
spec:
  allowScheduling: false
  evictionRequested: true
  disks:
    default-disk-080500000000:
      allowScheduling: false
      evictionRequested: true
      path: /var/lib/longhorn
      diskType: filesystem
      tags: []
    sdb-longhorn:
      allowScheduling: false
      evictionRequested: true
      path: /var/mnt/longhorn-sdb
      diskType: filesystem
      tags: [dedicated, ssd]
'
```

Single-node so replicas don't migrate (`autoEvicting: false`) — that's expected. The eviction flag still tells Longhorn to release iSCSI sessions on detach.

For non-CNPG stateful workloads (ClickHouse, Elasticsearch, RabbitMQ, Redis, Prometheus, Alertmanager) scale to zero via their respective operators / CRs so they detach volumes early. **Leave Postgres (CNPG) alone** — let Talos drain SIGTERM it; CNPG handles graceful shutdown + primary handoff. Manually killing CNPG pods with the operator scaled down risks WAL inconsistency.

#### 4. Run the upgrade

```shell
talosctl upgrade \
  --nodes 142.132.206.74 \
  --image factory.talos.dev/installer/613e1592b2da41ae5e265e8789429f22e121aab91cb4deb6bc3c0b6262961245:v1.13.0 \
  --reboot-mode default
```

`--preserve` is deprecated in 1.18 (legacy flag; new upgrade API supersedes it). Skip unless on Talos &lt;1.10.

Drain → install → reboot → boot is automated. The `talosctl` CLI typically exits with `code 1` due to the apid connection drop during reboot; that is **not** a failure on its own — confirm with `talosctl version` after the node returns.

#### 5. Post-upgrade verification

```shell
talosctl version                              # Server: v1.13.0
talosctl get extensions                       # iscsi-tools + util-linux-tools present
kubectl get nodes -o wide                     # KERNEL-VERSION 6.18.24-talos
kubectl uncordon talos-4bn-whr

# Reverse Longhorn maintenance mode
kubectl -n longhorn-system patch nodes.longhorn.io talos-4bn-whr --type=merge -p '
spec:
  allowScheduling: true
  evictionRequested: false
  disks:
    default-disk-080500000000: { allowScheduling: true, evictionRequested: false, path: /var/lib/longhorn, diskType: filesystem, tags: [] }
    sdb-longhorn:              { allowScheduling: true, evictionRequested: false, path: /var/mnt/longhorn-sdb, diskType: filesystem, tags: [dedicated, ssd] }
'

# Restore Argo
kubectl -n argocd scale sts argocd-application-controller --replicas=1
```

### Recovery: stuck `upgrading` stage

Symptom: `talosctl get machinestatus` reports `stage: upgrading` indefinitely + `apid` uptime > 0 (no reboot). `talosctl reboot --mode=powercycle` returns exit 0 but is silently rejected because the upgrade actor owns the lifecycle.

The only unstick is **Hetzner Robot → "Execute an automatic hardware reset"** (physical reset button equivalent). Bypasses the OS state machine. After cold boot the node returns to the *previous* Talos version (install was queued but never written). Re-attempt upgrade after fixing the underlying drain blocker.

### Known post-upgrade gotcha: `kube-multus` OOMKilled

Default multus memory limits (`requests: 100Mi`, `limits: 150Mi`) are too small for the concurrent CNI request burst when ~150 pods come up in parallel after a Talos reboot. Multus dies (exit 137) → CoreDNS sandbox creation fails → DNS down → Longhorn webhook unreachable (`dial udp 10.96.0.10:53: connect: operation not permitted`) → all PVC mounts stall → ArgoCD won't start.

The `operation not permitted` error looks like a Cilium policy block but is really "kube-dns Service has no healthy backing pods because CoreDNS sandbox creation failed because multus is dead."

Fix is patched into [`apps/kube/multus/manifests/multus-daemonset.yaml`](https://github.com/kbve/kbve/blob/main/apps/kube/multus/manifests/multus-daemonset.yaml) — `requests: 256Mi`, `limits: 512Mi`. Verify before each upgrade.

### Stale config drift: `install.image`

The machine config still pins `install.image: ghcr.io/siderolabs/installer:v1.10.5` (upstream, no extensions). Only fires at first install — runtime upgrades ignore it. Patch it to the factory schematic image during a maintenance window so a future first-install / reset doesn't accidentally drop extensions.

---

## Help

-   Kubectl Help
    -   `sudo kubectl -h` || `k -h`

---

## Cheatsheet

-   Cluster:

    -   ```shell
        sudo kubectl cluster-info
        ```

-   View full config minified

    -   ```shell
        sudo kubectl config view --minify
        ```

-   List namespaces

    -   ```shell
        sudo kubectl get namespace
        ```

-   Create namespace by replacing `$name` with the string that defines the namespace.

    -   ```shell
        sudo kubectl create namespace $name
        ```

-   Set namespace preference/default for session

    -   ```shell
        sudo kubectl config set-context --current --namespace=$namespace-name
        ```

-   Validate current namespace

    -   ```shell
        sudo kubectl config view --minify | grep namespace:
        ```

-   Get everything running in kubernetes

    -   In all namespaces

        -   ```shell
            sudo kubectl get all --all-namespaces
            ```

    -   In current namespace `default` by default

        -   ```shell
            sudo kubectl get all
            ```

-   Get services running in kubernetes

    -   In all namespaces

        -   ```shell
            sudo kubectl get svc --all-namespaces
            ```

    -   In current namespace `default` by default

        -   ```shell
            sudo kubectl get svc
            ```

-   Delete services via $name

    -   ```shell
        sudo kubectl delete svc $name
        ```

-   Delete deployment via $name

    -   ```shell
        sudo kubectl delete deployment.apps/$name`
        ```

-   Delete namespace , defined by $name

    -   ```shell
        sudo kubectl delete namespace $name
        ```

        -   std out: namespace "$name" deleted - Successful.

-   Get classes for storage

    -   ```shell
        sudo kubectl get storageclasses
        ```

        -   std out: storage provisioners.

---

## Namespace Orphan Check

Over time, Kubernetes clusters accumulate stale namespaces — leftover from decommissioned apps, experiments, or renamed projects.
These orphaned namespaces cause real problems: controllers like `external-secrets` continuously attempt to reconcile resources in them, generating errors such as `"client is not allowed to get secrets"` and polluting logs with noise that masks actual incidents.

### Why Orphaned Namespaces Matter

```mermaid
flowchart LR
    A["App Decommissioned"] --> B["Namespace Left Behind"]
    B --> C["Stale SecretStores"]
    B --> D["Stale Ingresses"]
    B --> E["Stale Secrets"]
    C --> F["external-secrets\nreconciler errors"]
    D --> G["ingress-nginx\nsync churn"]
    E --> H["Unrotated credentials\nin cluster"]
    F --> I["Log noise masks\nreal incidents"]
    G --> I
    H --> J["Security risk"]
```

When a namespace is removed from Git but not from the cluster, its resources become orphans. Controllers keep trying to reconcile them, RBAC bindings may have been cleaned up, and the result is a steady stream of errors that drown out real problems.

<CardGrid>
  <Card title="Controller Errors" icon="warning">
    Operators like `external-secrets` and `cert-manager` continuously retry failed reconciliation on orphaned resources, wasting cycles and flooding logs.
  </Card>
  <Card title="Ingress Sync Churn" icon="random">
    Stale `Ingress` resources trigger the ingress controller to re-sync on every loop, even though no backend exists to serve traffic.
  </Card>
  <Card title="Security Risk" icon="error">
    Orphaned `Secret` resources may contain database credentials, API keys, or TLS certs that are never rotated and remain accessible to anyone with namespace-level RBAC.
  </Card>
  <Card title="Resource Waste" icon="close">
    Orphaned `Services` of type `LoadBalancer` can hold cloud provider IPs, incurring cost for endpoints that serve nothing.
  </Card>
</CardGrid>

### How the Audit Works

```mermaid
flowchart TD
    Start["kubectl get ns"] --> Loop["For each namespace"]
    Loop --> Protected{"System\nnamespace?"}
    Protected -->|"Yes (kube-system, default, ...)"| Skip["Skip"]
    Protected -->|No| Count["Count workload resources"]
    Count --> Check{"pods + deploys +\nsts + jobs > 0?"}
    Check -->|Yes| Active["ACTIVE"]
    Check -->|No| Empty["EMPTY"]
    Empty --> Linger["Report lingering resources:\nsvcs, secrets, ingress,\nextSecrets, secretStores"]
    Active --> Report["Report workload counts"]
    Linger --> Next["Next namespace"]
    Report --> Next
    Skip --> Next
    Next --> Loop
```

<Tabs>
  <TabItem label="What It Checks">

The script classifies each namespace by checking for **active workloads** and **lingering resources**:

**Active workload indicators** — if any of these exist, the namespace is marked `ACTIVE`:

| Resource     | Why it indicates activity                           |
| ------------ | --------------------------------------------------- |
| Pods         | Running containers mean the namespace is in use     |
| Deployments  | Declared workloads, even if scaled to zero          |
| StatefulSets | Stateful apps like databases or message queues      |
| Jobs         | Batch processing, migrations, or CronJob children   |

**Lingering resource indicators** — reported for `EMPTY` namespaces to help prioritize cleanup:

| Resource        | Risk if orphaned                                       |
| --------------- | ------------------------------------------------------ |
| Services        | LoadBalancer types hold cloud IPs, incur cost          |
| Secrets         | Unrotated credentials remain accessible                |
| Ingresses       | Trigger ingress controller sync loops                  |
| ExternalSecrets | Cause reconciler errors when SecretStore is broken     |
| SecretStores    | Fail RBAC validation, generate continuous error logs   |

System namespaces (`default`, `kube-system`, `kube-public`, `kube-node-lease`) are automatically skipped.

  </TabItem>
  <TabItem label="Proof of Concept">

The full script is located at `scripts/kubectl-namespace-orphan-check.sh` and can be run directly against any cluster with `kubectl` access.

```bash
#!/usr/bin/env bash
# kubectl-namespace-orphan-check.sh — Identify namespaces with no active workloads
# Safe: read-only, never deletes anything

set -euo pipefail

PROTECTED="default|kube-system|kube-public|kube-node-lease"

echo "=== Namespace Audit ==="
echo ""

for ns in $(kubectl get ns -o jsonpath='{.items[*].metadata.name}'); do
  # Skip protected system namespaces
  if echo "$ns" | grep -qE "^($PROTECTED)$"; then
    continue
  fi

  pods=$(kubectl get pods -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  deploys=$(kubectl get deployments -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  statefulsets=$(kubectl get statefulsets -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  jobs=$(kubectl get jobs -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  svcs=$(kubectl get svc -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  secrets=$(kubectl get secrets -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  ingresses=$(kubectl get ingress -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  externalsecrets=$(kubectl get externalsecrets -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')
  secretstores=$(kubectl get secretstores -n "$ns" --no-headers 2>/dev/null | wc -l | tr -d ' ')

  total=$((pods + deploys + statefulsets + jobs))

  if [ "$total" -eq 0 ]; then
    echo "EMPTY   $ns  (svcs=$svcs secrets=$secrets ingress=$ingresses extSecrets=$externalsecrets secretStores=$secretstores)"
  else
    echo "ACTIVE  $ns  (pods=$pods deploy=$deploys sts=$statefulsets jobs=$jobs)"
  fi
done
```

  </TabItem>
  <TabItem label="Usage">

Run the script from the repository root:

```shell
./scripts/kubectl-namespace-orphan-check.sh
```

**Prerequisites:** `kubectl` must be installed and configured with a valid kubeconfig pointing to the target cluster. The `externalsecrets` and `secretstores` resource checks require the External Secrets Operator CRDs — if they are not installed, those counts will silently return `0`.

**Example output:**

```
=== Namespace Audit ===

ACTIVE  kilobase      (pods=12 deploy=4 sts=2 jobs=0)
ACTIVE  mc            (pods=3 deploy=1 sts=0 jobs=0)
EMPTY   bugwars       (svcs=1 secrets=2 ingress=1 extSecrets=0 secretStores=1)
EMPTY   old-staging   (svcs=0 secrets=1 ingress=0 extSecrets=0 secretStores=0)
```

  </TabItem>
  <TabItem label="Cleanup">

<Steps>

1. **Run the audit** to identify empty namespaces:

    ```shell
    ./scripts/kubectl-namespace-orphan-check.sh
    ```

2. **Inspect lingering resources** in each empty namespace before deleting:

    ```shell
    kubectl get all,secrets,ingress,externalsecrets,secretstores -n bugwars
    ```

3. **Confirm with your team** that the namespace is truly decommissioned and no longer referenced by any active service, ArgoCD Application, or CI pipeline.

4. **Delete the namespace** — this removes all resources within it:

    ```shell
    kubectl delete namespace bugwars
    ```

5. **Verify the errors are gone** by checking your observability pipeline (ClickHouse logs, Grafana dashboards) for reconciler errors referencing the deleted namespace.

</Steps>

<Aside type="caution">
Deleting a namespace removes **all** resources within it — secrets, configmaps, RBAC bindings, PVCs, and more. This operation is irreversible. Always confirm with your team before removing a namespace from a shared cluster.
</Aside>

  </TabItem>
  <TabItem label="Limitations">

This script is a **proof of concept** with known limitations:

- **CronJobs with no active children** — a namespace with only `CronJob` resources (no running `Job` pods) will be flagged as `EMPTY`, even though it is still actively scheduled. The script checks `Jobs`, not `CronJobs`.
- **DaemonSets** — namespaces containing only `DaemonSet` workloads (no Deployments, StatefulSets, or standalone Pods) will appear as `EMPTY`.
- **Scaled-to-zero Deployments** — a Deployment with `replicas: 0` still counts as active (the Deployment object exists), but if it was deleted and only Pods were expected, the namespace may appear empty.
- **Custom resources** — workloads managed by custom operators (e.g., `KafkaTopic`, `PostgresCluster`, `VirtualService`) are not checked. Extend the script with additional `kubectl get <crd>` calls for your environment.
- **Performance** — the script makes multiple `kubectl` calls per namespace sequentially. For clusters with many namespaces, consider parallelizing with `xargs` or switching to a single `kubectl get` with JSON output and `jq` processing.

```mermaid
flowchart LR
    subgraph "Detected"
        Pods
        Deployments
        StatefulSets
        Jobs
    end
    subgraph "Not Detected"
        CronJobs
        DaemonSets
        CustomResources["Custom CRDs"]
    end
    subgraph "Reported as Lingering"
        Services
        Secrets
        Ingresses
        ExternalSecrets
        SecretStores
    end
```

Future improvements could include CronJob detection, DaemonSet awareness, age-based filtering (flag namespaces idle for more than N days), and integration with CI to run on a schedule with Slack/Discord notifications.

  </TabItem>
</Tabs>

---

## Patch

-   Kube Patches

### Kubectl Patch

-   Patching an existing service

    -   Generic Command:

        ```shell
        sudo kubectl patch
        ```

-   Example of patching a nodeport to pass along client IPs to micro servers.

    -   ````shell
              sudo kubectl patch svc nodeport -p  '{"spec":{"externalTrafficPolicy":"Local"}}'`
              ```

        ````

    -   Example of patching a nodeport to load balance.

        -   ```shell
            sudo kubectl patch svc nodeport -p  '{"spec":{"externalTrafficPolicy":"Cluster"}}'
            ```

---

## Portainer Agent

We recommend double checking our [Portainer Notes](/application/portainer/) for additional notes / information. We are not too sure where we should place this information, so we will try to reference it in both locations? I suppose that might be the best move.

Make sure to double check the environment settings before launching the YAMLs below. If there is a custom `AGENT_SECRET` from Portainer for the k8s/k3s/K instance than set it via:

```yaml
environment:
    - AGENT_SECRET: yourSecret
```

-   Setup Portainer Agent

    -   Load Balancer lb

        -   LB Command:

        ```shell
        sudo kubectl apply -f https://downloads.portainer.io/ce2-16/portainer-agent-k8s-lb.yaml
        ```

        -   Agent 2.16 as of 11/17/2022 Previously the revision was ~2.15 as of 09/30/2022~

    -   Node Port nodeport

        -   NodePort Command:

        ```shell
        sudo kubectl apply -f https://downloads.portainer.io/ce2-16/portainer-agent-k8s-nodeport.yaml
        ```

    -   Add the kubernetes cluster location via `https:/$/wizard/endpoints/create?envType=kubernetes` - Be sure to replace $ with your portainer location.
        -   Name: `$nameString` - The name for the kubernetes cluster. i.e `k8scluster007`
        -   Environment Address: `$addrString:$ipInt32` - The location for the kubernetes cluster. i.e `k8scluster007.kbve.com:9001`
            -   Note: Make sure the port 9001 is open for communication between the cluster and Portainer.
    -   Advance Optional Settings

        -   Group: `$groupString` - The name of the group for the cluster
        -   Tags: `$tagsMap` - Drop down to select the tags for the cluster.

    -   As of 11/18/2022 - There have bene some updates to Portainer! They now have better ingress support!

---

## Harden

-   Collection of harden manifests by the DoD
    -   [DSOP](https://repo1.dso.mil/dsop)

---

## Storage

-   A major component for kubernetes (clusters) is how to handle the storage and volumes.

### Kubernetes NFS

External Provider
[NFS SubDir](https://github.com/kubernetes-sigs/nfs-subdir-external-provisioner)

CSI-Driver-NFS
[CSI Driver](https://github.com/kubernetes-csi/csi-driver-nfs)

---

## okd

-   [OKD](https://github.com/pvelati/okd-proxmox-scripts)
-   OKD Notes still need to be worked on.

---

## vCluster

Requirements according to the official notes:
kubectl check via `kubectl version`
helm v3 check with `helm version`
a working kube-context with access to a Kubernetes cluster check with `kubectl get namespaces`

### vCluster Install

Docs on installing vCluster within the environment / system / orchestration.

vcluster is officially supported for:

Mac Intel/AMD
Install by running the following command:

```shell
curl -L -o vcluster "https://github.com/loft-sh/vcluster/releases/latest/download/vcluster-darwin-amd64" && sudo install -c -m 0755 vcluster /usr/local/bin
```

Mac Silicon/ARM
Install on the M1 series by the command below:

```shell
curl -L -o vcluster "https://github.com/loft-sh/vcluster/releases/latest/download/vcluster-darwin-arm64" && sudo install -c -m 0755 vcluster /usr/local/bin
```

Linux Intel/AMD
Install vcluster on generic Unix x86

```shell
curl -L -o vcluster "https://github.com/loft-sh/vcluster/releases/latest/download/vcluster-linux-amd64" && sudo install -c -m 0755 vcluster /usr/local/bin
```

Linux ARM
Unix instance runnong on ARM:

```shell
curl -L -o vcluster "https://github.com/loft-sh/vcluster/releases/latest/download/vcluster-linux-arm64" && sudo install -c -m 0755 vcluster /usr/local/bin
```

Powershell - Still needs to work.

Note: You may have to double check if the: `%APPDATA%\vcluster` was installed sucessfully.

Confirm -> Run `vcluster --version` to confirm that the install was sucessful.


---

## KubeVirt

KubeVirt enables running virtual machines on Kubernetes using KVM. On Talos, KVM is built into the kernel — no extensions or machine config patches needed.

Reference: [Talos KubeVirt Guide](https://docs.siderolabs.com/talos/v1.12/advanced-guides/install-kubevirt)

### Operator Install (One-Time)

```shell
# KubeVirt operator
export RELEASE=$(curl https://storage.googleapis.com/kubevirt-prow/release/kubevirt/kubevirt/stable.txt)
kubectl apply -f https://github.com/kubevirt/kubevirt/releases/download/${RELEASE}/kubevirt-operator.yaml

# CDI operator (Containerized Data Importer)
export CDI_VERSION=$(curl -sI https://github.com/kubevirt/containerized-data-importer/releases/latest | grep -i location | awk -F/ '{print $NF}' | tr -d '\r')
kubectl apply -f https://github.com/kubevirt/containerized-data-importer/releases/download/${CDI_VERSION}/cdi-operator.yaml
```

### virtctl Install

```shell
brew install virtctl
```

### VM Management

```shell
# Start a VM
virtctl start windows-builder -n angelscript

# Stop a VM
virtctl stop windows-builder -n angelscript

# Force stop
virtctl stop windows-builder -n angelscript --force --grace-period=0

# Check VM status
kubectl get vm -n angelscript
kubectl get vmi -n angelscript
```

### VNC Access (noVNC in Browser)

```shell
# Terminal 1: VNC proxy
virtctl vnc windows-builder -n angelscript --proxy-only --port=5901

# Terminal 2: noVNC web proxy (open http://localhost:6080/vnc.html)
/tmp/noVNC/utils/novnc_proxy --vnc localhost:5901 --listen 6080
```

### ISO Upload via CDI

```shell
# Terminal 1: Port-forward CDI upload proxy
kubectl port-forward -n cdi svc/cdi-uploadproxy 8443:443

# Terminal 2: Upload ISO via DataVolume
virtctl image-upload dv windows-server-builder-iso \
  --size=8Gi \
  --image-path=/path/to/windows-server.iso \
  --storage-class=longhorn \
  --namespace=angelscript \
  --uploadproxy-url=https://localhost:8443 \
  --insecure
```

### Quick Start (All-in-One)

```shell
# Start VM + VNC proxy + noVNC browser access
virtctl start windows-builder -n angelscript && \
  sleep 20 && \
  virtctl vnc windows-builder -n angelscript --proxy-only --port=5901 &
/tmp/noVNC/utils/novnc_proxy --vnc localhost:5901 --listen 6080
# Open http://localhost:6080/vnc.html
```

---

## Firecracker MicroVMs

Firecracker is an open-source VMM (Virtual Machine Monitor) built by AWS for serverless workloads. It creates lightweight microVMs with ~5 MB overhead and ~125 ms boot times, using KVM for hardware-level isolation.

### KBVE Integration

The KBVE edge platform uses Firecracker as a composable Tier 2 isolation layer alongside the Deno edge-runtime (Tier 1). Edge functions dispatch VM workloads to the `firecracker-ctl` service via an internal REST API on port 9001.

**Manifests:** `apps/kube/firecracker/manifests/`

### Requirements

- Linux kernel with KVM support (Intel VT-x / AMD-V)
- `/dev/kvm` exposed via `kubevirt/device-plugin-kvm` (already deployed for KubeVirt)
- Nodes labeled `kvm=true` (applied via Talos machine config patch)
- Bare metal preferred (nested virt adds latency)

### Node Setup (Talos)

The `nodeSelector: kvm: "true"` requires a node label. On Talos, apply the machine config patch:

```shell
# Apply kvm=true node label via Talos machine config
talosctl patch machineconfig --nodes <node> \
  --patch @apps/kube/talos/patches/kvm-node-label.yaml

# Verify label was applied
kubectl get nodes --show-labels | grep kvm
```

### Deployment

```shell
# Verify KVM device plugin is running
kubectl get pods -n kubevirt -l app=kvm-device-plugin

# Check firecracker-ctl deployment
kubectl get deploy firecracker-ctl -n kilobase

# Check firecracker-ctl service
kubectl get svc firecracker-ctl -n kilobase

# View firecracker-ctl logs
kubectl logs -n kilobase -l app=firecracker-ctl -f
```

### Pod Spec Overview

```yaml
nodeSelector:
    kvm: 'true'
containers:
    - name: firecracker-ctl
      image: ghcr.io/kbve/firecracker-ctl:0.1.0
      resources:
          requests:
              devices.kubevirt.io/kvm: '1'
              cpu: 250m
              memory: 512Mi
          limits:
              devices.kubevirt.io/kvm: '1'
              cpu: '2'
              memory: 2Gi
      securityContext:
          capabilities:
              add: ['NET_ADMIN']
```

### Network Policy

Only edge-runtime pods (`app: functions`) can reach `firecracker-ctl` on port 9001. All other ingress is denied.

### API

| Method | Path | Description |
|--------|------|-------------|
| `POST` | `/vm/create` | Create and start a microVM |
| `GET` | `/vm/{vm_id}` | Get VM status |
| `GET` | `/vm/{vm_id}/result` | Get stdout/stderr/exit_code |
| `DELETE` | `/vm/{vm_id}` | Force-terminate a VM |
| `GET` | `/health` | Health check |

### Rootfs Images

| Image | Size | Contents |
|-------|------|----------|
| `alpine-minimal` | ~8 MB | Alpine + busybox |
| `alpine-python` | ~45 MB | Alpine + Python 3.12 |
| `alpine-node` | ~40 MB | Alpine + Node.js 22 LTS |
| `ubuntu-rust` | ~120 MB | Ubuntu minimal + Rust toolchain |

### Troubleshooting

```shell
# Check if /dev/kvm is available on a node
kubectl debug node/<node-name> -it --image=busybox -- ls -la /dev/kvm

# Verify device plugin allocations
kubectl describe node <node-name> | grep -A5 "devices.kubevirt.io/kvm"

# Test firecracker-ctl health from within cluster
kubectl run -n kilobase --rm -it --restart=Never test-fc \
  --image=curlimages/curl -- curl -s http://firecracker-ctl:9001/health
```

---

## Sealed Secrets

### Encoding

Here is the quick command for encoding a seal.

```shell

./kbve.sh -nx kilobase:seal --namespace=$NAMESPACE --keyName=$KEY --secrets="SECRET="

```

### Decoding 

For decoding the sealed secret, use this quick command:

```shell

kubectl get secret $KEY -n $NAMESPACE -o jsonpath="{.data.$SECRET}" | base64 --decode

```

---
# Linux

> Linux has become the heartbeat of modern infrastructure, driving cloud servers, Kubernetes clusters, desktops, and even the tiniest embedded devices across the world.
It offers unmatched flexibility, security, and performance for developers, system administrators, and tinkerers alike.
Whether you're managing containers, automating infrastructure, or exploring the command line, Linux remains the foundation for innovation in the open-source ecosystem.
This section explores its distributions, tools, and best practices within the KBVE stack.

Source: https://kbve.com/application/linux/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

Linux is more than just an operating system, its the quiet force that keeps the modern world running.
From the servers that power your favorite websites to the Kubernetes clusters orchestrating entire cloud platforms, Linux is everywhere, often invisible but always essential.
Its open-source roots have created a culture of collaboration and curiosity, where anyone can peek under the hood, make changes, and share improvements with the world.
Whether you're deploying containers, managing infrastructure, or just exploring the command line, understanding Linux means understanding the language of modern computing.

This page focuses on two everyday sysadmin skills — extending storage with [LVM](#lvm) and setting up a productive [ZSH](#zsh) shell — plus an [essential command reference](#essential-commands) for navigating any Linux system.

<Adsense />

## Essential Commands

A quick reference for the commands you reach for constantly on any Linux box:

| Command | Purpose |
| ------- | ------- |
| `ls -lah` | List files with sizes, permissions, and hidden entries |
| `cd` / `pwd` | Change directory / print working directory |
| `cp` / `mv` / `rm` | Copy, move, remove files |
| `chmod` / `chown` | Change file permissions / ownership |
| `sudo` | Run a command as root |
| `ps aux` / `top` | List / monitor running processes |
| `systemctl status <svc>` | Inspect a systemd service |
| `journalctl -u <svc> -f` | Follow a service's logs |
| `df -h` / `du -sh *` | Disk free / directory sizes |
| `grep -r "text" .` | Recursively search file contents |

<Aside type="tip">
Permissions are the most common source of "it works for root but not the app" bugs. `ls -l` shows the owner and mode; fix access with `chown user:group file` and `chmod` rather than running everything as root.
</Aside>

## LVM

**Logical Volume Management (LVM)** provides a flexible way to manage storage on Linux, allowing you to resize, extend, or move partitions without disrupting your system. 
It's especially useful when running Linux inside virtualized environments like [Proxmox](/application/proxmox/), where disk space can be expanded dynamically.

### LVM Extension

<Steps>

1.  **Verify the current layout**  
    Check the existing disks, partitions, and volume groups to understand your current storage configuration.

    ```bash
            sudo lsblk
            # or
            sudo fdisk -l
    ```

2.  **Grow the partition to fill the disk**
    Assuming your disk is `/dev/sda` and the partition is `3`, extend the partition to use the new space.
    
    ```bash

            sudo growpart /dev/sda 3
            # Alternatively, open an interactive resizer:
            sudo cfdisk /dev/sda

    ```

3.  **Resize the Physical Volume (PV)**
    After extending the partition, update the LVM physical volume to recognize the new size.

    ```bash
            sudo pvresize /dev/sda3
    ```

4.  **Extend the Logical Volume (LV)**
    Grow the logical volume to use all the available free space.

    ```bash
            sudo lvextend -l +100%FREE /dev/mapper/ubuntu--vg-ubuntu--lv
    ```

5.  **Resize the filesystem**
    Expand the filesystem so it can utilize the newly extended logical volume.
    
    ```bash
            sudo resize2fs /dev/mapper/ubuntu--vg-ubuntu--lv
    ```

6.  **Verify the result**
    Check that the filesystem now reflects the expected capacity.

    ```bash
            df -h
    ```

</Steps>

<Aside type="note">

If you are using XFS instead of EXT4, replace the final resize command with:

```bash
    sudo xfs_growfs /
```

</Aside> 

<Aside type="caution">

Always back up critical data before resizing partitions or volumes.
You can inspect your volume group information at any time with:

```bash
sudo pvs && sudo vgs && sudo lvs
```

</Aside>


To extend the `ubuntu--vg-ubuntu-lv` after increasing the size of a physical volume from Proxmox

For the purposes of simplicity, I'm going to assume that the main volume you wish to extend is `/dev/sda3`.

-   Check the current size with `sudo lsblk` or `sudo fdisk -l`
-   Run either `sudo growpart /dev/sda 3` or use `sudo cfdisk` to resize the `/dev/sda3` to max size
-   Extend the PV volume with `sudo pvresize /dev/sda3`
-   Extend the LV to 100% with `sudo lvextend -l +100%FREE /dev/mapper/ubuntu--vg-ubuntu--lv`
-   Resize the filesystem with `sudo resize2fs /dev/mapper/ubuntu--vg-ubuntu--lv`

---

## ZSH

The **Z Shell (ZSH)** is a feature-rich shell that builds on Bash, offering improved autocompletion, better history management, and deep customization through plugins and themes.  
It is the go to choice for developers who want a faster, more expressive terminal experience.

<Steps>

1.  **Install ZSH**  
    Make sure ZSH is installed on your system.

    ```bash
    sudo apt install zsh -y
    # or on Fedora / RHEL
    sudo dnf install zsh -y
    # or on Arch
    sudo pacman -S zsh

    ```

2.  **Set ZSH as the default shell**

    ```bash 
    chsh -s $(which zsh)
    ```

    Log out and back in for the change to take effect.

3.  **Install Oh My Zsh**

    Oh My Zsh is a framework that simplifies managing your ZSH configuration and plugins.

    ```bash
    sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
    ```

4.  **Add the Powerlevel10k theme**

    Clone the Powerlevel10k theme into your Oh My Zsh themes directory.

    ```bash
    git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k
    ```

    Edit your ~/.zshrc and set:

    ```bash
    ZSH_THEME="powerlevel10k/powerlevel10k"
    ```

    Then reload:
    
    ```bash
    source ~/.zshrc
    ```

5.  **Install recommended fonts**
    Powerlevel10k uses Nerd Fonts or Meslo LGS NF for icons and symbols.

    ```bash
    # Quick download and install for Meslo fonts (Mac/Linux)
    p10k configure
    ```
    Follow the prompts to install the suggested font and tweak your prompt style.

6.  **Enhance with plugins (optional)**
    You can extend functionality with plugins like:

    ```bash
    plugins=(
        git
        zsh-autosuggestions
        zsh-syntax-highlighting
    )
    ```
    To install:

    ```bash
    git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
    git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

    ```
    
    Then reload once more:
    ```bash
    source ~/.zshrc
    ```


</Steps>

<Aside type="tip"> 
If you're using VS Code's integrated terminal or Windows Terminal, make sure you set the **font** to a Nerd Font (like Meslo LGS NF) in your settings for icons and glyphs to render correctly.
</Aside>

-   [ZSH Shell Official Page](https://www.zsh.org/)
-   [Oh My Zsh Official Page](https://ohmyz.sh/)
-   [Powerlevel10K Repository](https://github.com/romkatv/powerlevel10k)
-   [One of the Best Tutorials by dev.to (Dec 2020)](https://dev.to/abdfnx/oh-my-zsh-powerlevel10k-cool-terminal-1no0)

---

## FAQ

**How do I extend a disk partition on Linux with LVM?**
Grow the partition with `growpart`, update the physical volume with `pvresize`, extend the logical volume using `lvextend -l +100%FREE`, then resize the filesystem with `resize2fs` (EXT4) or `xfs_growfs` (XFS). Verify with `df -h`.

**What is LVM in Linux?**
Logical Volume Management is a storage abstraction layer that lets you resize, extend, or move volumes without repartitioning. It is especially useful in virtualized environments like [Proxmox](/application/proxmox/) where disk size can grow dynamically.

**How do I change my default shell to ZSH?**
Install ZSH with your package manager, then run `chsh -s $(which zsh)` and log out and back in. Many users add Oh My Zsh and a theme like Powerlevel10k for autocompletion, history, and prompt customization.

**What is the difference between ext4 and XFS when resizing?**
Both are Linux filesystems, but they grow with different tools. Use `resize2fs` to expand an ext4 filesystem and `xfs_growfs` to expand XFS. XFS can only grow, never shrink, so plan capacity accordingly.

<Adsense />

---
# Longhorn

> Longhorn is a cloud-native, distributed block storage system for Kubernetes that delivers persistent,
replicated volumes with snapshots and backups. This guide covers the architecture, installation,
StorageClass configuration, and NFS setup.

Source: https://kbve.com/application/longhorn/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**Longhorn** is a cloud-native, **distributed block storage** system for Kubernetes (originally by Rancher, now a CNCF project). It turns the local disks across your nodes into replicated, persistent volumes — with **snapshots** and **backups** to NFS or S3 — all managed through Kubernetes CRDs and a built-in UI.

Every volume is **synchronously replicated** across nodes, so a single node failure doesn't lose data.

This guide covers [install](#install), [NFS setup](#nfs), the [namespace](#namespace), and the [StorageClass](#longhorn-uno).

## Information

<Adsense />

## Install

-   This current information sheet is in reference to Longhorn 1.3v , be aware that 1.4v will be in production around 2023. Thus this might become obsolete information.
-   Before installing, look over the requirements for storage.

-   Requirements for 1.3v Longhorn

The recommended install path is **Helm**. Every node needs `open-iscsi` and a compatible kernel first:

```shell
# On each node (Debian/Ubuntu)
sudo apt-get install open-iscsi -y

# Install Longhorn via Helm
helm repo add longhorn https://charts.longhorn.io
helm repo update
helm install longhorn longhorn/longhorn \
  --namespace longhorn-system --create-namespace
```

<Aside type="caution">
Longhorn needs `open-iscsi` running on **every** node that will host a replica. A missing iSCSI daemon is the most common cause of volumes stuck in `Attaching`.
</Aside>

---

## NFS

-   Ubuntu NFS Setup

    -   Make sure system is updated / upgrade

        -   ```shell
            sudo apt-get update && sudo apt-get upgrade -y
            ```

    -   Install `nfs-common` and `nfs-kernel-server`

        -   ```shell
            sudo apt-get install nfs-common nfs-kernel-server -y
            ```

---

## Namespace

-   Creating a custom namespace to hold the storage.

    Kubectl command to create the namespace:

          -   ```shell
              kubectl create namespace storage

              ```

          -   std out: namespace/storage created

-   This namespace will be where we store our production data.

---

## Longhorn Uno

Under storage class, we will be creating the longhorn uno and then deploying it under that.

```yaml

 annotations:
    longhorn.io/last-applied-configmap: |
      kind: StorageClass
      apiVersion: storage.k8s.io/v1
      metadata:
        name: longhorn-uno
        annotations:
          storageclass.kubernetes.io/is-default-class: "true"
      provisioner: driver.longhorn.io
      allowVolumeExpansion: true
      reclaimPolicy: "Delete"
      volumeBindingMode: Immediate
      parameters:
        numberOfReplicas: "1"
        staleReplicaTimeout: "30"
        fromBackup: ""
        fsType: "ext4"
        dataLocality: "best-effort"
        unmapMarkSnapChainRemoved: "ignored"
        disableRevisionCounter: "true"
        dataEngine: "v1"
    storageclass.beta.kubernetes.io/is-default-class: 'false'
    storageclass.kubernetes.io/is-default-class: 'false'
```

The key parameters: `numberOfReplicas` controls how many synchronous copies of the volume exist (raise to `3` for HA), `dataLocality: best-effort` keeps a replica on the same node as the workload to cut latency, and `reclaimPolicy: Delete` removes the underlying volume when its PVC is deleted.

## FAQ

**What is Longhorn?**
Longhorn is a cloud-native, distributed block storage system for Kubernetes, originally by Rancher and now a CNCF project. It provides persistent volumes with synchronous replication across nodes, snapshots, and backups to external targets like NFS or S3, managed through a Kubernetes-native UI and CRDs.

**How does Longhorn replicate data?**
Longhorn creates a replica of each volume on multiple nodes and writes to them synchronously, so the volume survives a node failure. The number of copies is set by the `numberOfReplicas` parameter — for example `3` for high availability, or `1` for non-critical data.

**How do I install Longhorn on Kubernetes?**
The recommended path is Helm — add the `longhorn` repo, then `helm install longhorn longhorn/longhorn --namespace longhorn-system --create-namespace`. Every node needs `open-iscsi` installed. You can also apply the official YAML manifest with `kubectl`.

**Does Longhorn support backups?**
Yes. Longhorn takes in-cluster snapshots and can back them up to an external target such as an NFS share or S3-compatible bucket. Backups are incremental after the first full copy and can be restored to a new volume in the same or another cluster.

**What is a Longhorn StorageClass?**
A StorageClass tells Kubernetes to provision volumes with Longhorn's CSI driver (`driver.longhorn.io`) and carries parameters like `numberOfReplicas`, `staleReplicaTimeout`, `fsType`, and `dataLocality`. Marking it the default class lets PVCs use Longhorn automatically.

<Adsense />

---
# Machine Learning & Artificial Intelligence

> Get ready to explore the exciting world of Machine Learning and Artificial Intelligence.
Our guide covers everything from basic principles and key algorithms to the latest models and tools.
Whether you're just starting out or already have some experience, you'll find valuable insights and practical tips to help you navigate this dynamic field.
Learn about the newest advancements, popular frameworks, and real-world applications.
Perfect for anyone eager to deepen their understanding and skills in AI and ML, this resource is your go-to for all things AI and ML.

Source: https://kbve.com/application/ml/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## ML

- `Are you curious about the latest buzzword in the tech world?`
- `Have you been wondering what machine learning is?`
- `Let us take you on a journey to understand the basics of this revolutionary technology and its potential to revolutionize the future.`

`mL (machine learning)` is a subset of artificial intelligence and follows the theory of computational training, to understand core principles through computer science and statistics.
These training methods can be broken down to supervised, unsupervised and reinforcement learning.

If you're interested in learning the basics of Machine Learning, then you'll need to have a sound understanding of `Computational Theory` and the `Basics of Computer Science`.
This involves learning the fundamentals of programming languages (python), algorithms, and data structures.
Knowing these topics will give you a strong foundation to build upon as you dive deeper into Machine Learning; you will also need to understand the mathematics behind `Machine Learning`-algorithms, such as linear algebra, statistics, calculus, and probability.
Additionally, you will need to be well-versed in the different `Machine Learning` / `ML` techniques and tools, such as neural networks, decision trees, support vector machines, and deep learning.
Finally, you'll need to understand the various Machine Learning frameworks available, such as Keras, PyTorch, TensorFlow, and Scikit-Learn.

For [Python](/application/python/)

## Information

This documentation is a `reference guide` to the vast realm of machine learning and artificial general intelligence with examples, concepts and libraries to help you get started!
We want to create this whole page as a one stop shop for all your mL needs xD!

<Aside>
  Note: This is an ever growing and evolving list of all **mL / AI** services,
  concepts and ideas that can be referenced for your experiences within the
  field.
</Aside>

---

### AI

Artificial intelligence is an umbrella phrase that encapsulates various fields within computer science, mathematics, philosophy and information with the goal to emulate natural intelligence display by humans and animals.
Since Artificial intelligence (AI) is a broad and multidisciplinary field that encompasses various domains, its primary objective is to create systems and machines (physical or virtual) that can perform tasks that would traditionally require human intelligence.
These tasks include learning, reasoning, problem-solving, perception, language understanding, and even physical actions.

The roots of AI can be traced back to ancient myths and stories about artificial beings endowed with intelligence.
However, the formal foundation of AI as a scientific discipline was laid in the mid-20th century with the advent of digital computers.
The term "artificial intelligence" was coined in 1956 during the [Dartmouth Conference](https://home.dartmouth.edu/about/artificial-intelligence-ai-coined-dartmouth), which is considered the birthplace of AI research.

> > During the birthplace, John McCarthy, a mathematics professor, stated that the conference was:
> > “to proceed on the basis of the conjecture that every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it.”

---

<Adsense />

### Scope

- The dream for many programmers, scientists, engineers and humans would be to create an entity that could scale past our natural intelligence.
- This is a task that would define the 21st century and push the upper limits on humanity, naturism and metaphysics into the next industrial intelligence revolution.

---

## GPT

    - GPT , currently known as GPT-3, stands for `Generative Pre-trained Transformer` with the number representing the generation via version control and is a neural network machine learning model

    - ### GPT-Neo
        - Official Github [Repo](https://github.com/EleutherAI/gpt-neo)
        - We should note that the team, EleutherAI, are no longer maintaining the `gpt-neo` and their repo is currently in archive mode. However below is the `gpt-neox`, which is still being actively maintained as for Oct 2022.
        - The `GPT-Neo` may have been an extension of `GPT2` but changes to the layering.

    - ### GPT-NeoX
        - For GPU, we suggest GPT-NeoX, [Repo Here](https://github.com/EleutherAI/gpt-neox/)

    - ### GPT4All
        - What I enjoy about this software is that it is really easy to install and use, plus it requires very bare metal resources.
        - WebUI for GPT4All written in Flask (Python) by Nomic AI, [Repo Here](https://github.com/nomic-ai/gpt4all-ui)

    - ### PyChatGPT
        - [Official Repo](https://github.com/rawandahmad698/PyChatGPT). PyChatGPT is an on-going API written in `Python` to help scale and integrate `ChatGPT` to various applications / eco-systems via TLS.

---

## GROQ

Groq is an innovative company specializing in AI and machine learning (AI/ML) solutions, known for developing custom hardware designed to accelerate AI/ML workloads.
Their hardware architecture, optimized for high performance and efficiency, enables rapid data processing and analysis, making it ideal for complex AI/ML tasks.
Groq offers a free API that allows developers to leverage their powerful hardware infrastructure, providing an accessible entry point for integrating advanced AI capabilities into various applications without incurring initial costs.

### Groq CookBooks

The Groq Cookbook Examples provide a comprehensive collection of practical guides and code samples to help developers harness the full potential of Groq's AI/ML hardware.
These examples cover a wide range of applications, from basic model deployment to advanced optimization techniques, demonstrating best practices and efficient workflows.
For instance, developers can find detailed instructions on using Groq's hardware (via their API) to examine medical documents, enabling efficient processing and analysis of large volumes of medical data for improved diagnostics and patient care.
Additionally, there are examples of utilizing Groq's capabilities to create sophisticated stock market tools, helping analysts and traders make data-driven decisions with enhanced speed and accuracy. Each recipe is designed to be easily followed, enabling users to quickly integrate Groq's powerful capabilities into their own projects, accelerate development, and achieve superior performance in their AI/ML tasks.

---

## LLaMa

<Aside>
  **TLDR;** LLaMa, also known as, **Large Language Model Meta AI**, is actively
  being developed by Meta / Facebook and is a state-of-the-art foundational
  large language model that is designed to help researchers advance their work
  in natural language processing (NLP).
</Aside>

LLaMa, short for Large Language Model Meta AI, is a cutting-edge foundational large language model developed by Meta, formerly known as Facebook.
This state-of-the-art model is designed to assist researchers in advancing their work in natural language processing (NLP).
By leveraging LLaMa, researchers can push the boundaries of NLP, exploring new possibilities and enhancing the capabilities of AI-driven language understanding and generation.
Meta's commitment to innovation in AI is embodied in LLaMa, providing a powerful tool for the scientific community to develop more sophisticated and effective NLP applications.

---

## Stable Diffusion

Stable Diffusion is a python-based latent diffusion model that performs image generation through deep learning.

<Aside>

VOID-SD has direct API access to various forks of Stable Diffusion, including waifu-diffusion, hosted on a hybrid-cloud.

</Aside>

### Waifu Diffusion

Waifu Diffusion is a specialized adaptation of stable diffusion models, finely tuned to generate high-quality anime and manga-style imagery.
This model focuses on "weeb" content, catering to the aesthetic preferences and cultural nuances of anime enthusiasts.
By leveraging advanced stable diffusion techniques, Waifu Diffusion excels in producing visually appealing characters, scenes, and artworks that resonate with fans of Japanese pop culture. Its precise fine-tuning ensures that the generated images maintain the distinctive art style and charm characteristic of popular anime and manga, making it an invaluable tool for creators and fans alike.

The official Github repo for [Waifu-Diffusion](https://github.com/harubaru/waifu-diffusion).

### Stable Diffusion WebUI

The official repo for `AUTOMATIC1111` [Stable Diffusion WEB UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui)

### Fast Stable Diffusion

Fast-stable-diffusion Notebooks offer a streamlined and efficient way to utilize various advanced AI tools for image generation and customization.
Integrating Automatic1111 (A1111), ComfyUI, and DreamBooth, these notebooks provide a comprehensive platform for users to experiment with and refine their stable diffusion models. A1111 facilitates the management and deployment of these models, while ComfyUI offers an intuitive interface for seamless interaction. DreamBooth further enhances the capabilities by allowing fine-tuning and personalization of the models.
Together, these tools enable users to create high-quality, stable diffusion images with ease and precision.

---

## Prompt Engineering

Prompt engineering theory covers a wide range of different GPT concepts, including examples and short cuts to generate the right style of questions and content.

### Engine

The Prompt Engine is a versatile and structured framework designed to define, manage, and execute various prompt-based tasks.
It is specifically built to handle a wide range of scenarios in machine learning and artificial intelligence applications, offering a high degree of flexibility and precision.
The Prompt Engine is defined using a robust schema in TypeScript, leveraging Zod for validation.

Core Aspects:

- Name: Each prompt is uniquely identified by a name field, which allows for easy reference and management.

- Description: Provides a detailed explanation of what the prompt is about, helping users understand its purpose and context.

- Items: An array of strings that lists the key points or examples relevant to the prompt. This helps in outlining the scope and content of the prompt.

- Task: A textual description of the specific task that the prompt is intended to perform. This includes detailed instructions and objectives, ensuring clarity in execution.

- Tools: An optional array of tool definitions, where each tool is defined by its type, name, description, and required parameters. This allows the prompt to specify which tools or functions are needed to complete the task.

- Output: Specifies the expected output format, which can either be text or json. This ensures that the results of the prompt are returned in a predictable and usable format.

- Pathways: A structured object that defines the flow of actions based on user inputs or conditions. Each pathway contains a prompt and a set of conditions that determine the next action, enabling complex decision trees and logical flows.

### Roles

    Common `role` examples for text transformers:

    -   `Act as a javascript console`
    -   `Act as an excel sheet`
    -   `Act as a HR interviewer`
    -   `Act as an advertiser`
    -   `Act as a publisher`
    -   `Act as a music teacher`
    -   `Act as a relationship coach`
    -   `Act as a World of Warcraft player and limit the response to 50 characters`
        > _`Warning :`_ Not all text transformers will let you assign roles, as it might create a security issue / risk.

### Chaining

- Common Terms include: Chain-of-Thought, Chained Prompt.

### Rewrite Prompt Example

Start by giving it this task:

```
Task: Rewrite user-provided text with the most human like perplexity and burstiness.

Objectives: Prompt the user to input a block of text. Use a language model to rewrite the text with the most human like perplexity and burstiness. Provide the rewritten text to the user.

Rules: Keep burstiness as low as possible Keep perplexity as low as possible Go to extraordinary lengths to make the text more human-like Burstiness is on a scale of 0-100. Perplexity is on a scale of 0-100. Burstiness starts at 0 Perplexity starts at 0 Don’t answer for user

Roles: AI model responsible for rewriting the text. User: Provides the initial block of text to be rewritten.

Strategy:

Approach: Use an AI model to generate the most human like perplexity and burstiness.

Prompt the user to input a block of text.

Provide the rewritten text to the user.

Additional Instructions: Ask the user to input a block of text that they would like to be rewritten. Use a language model to generate a rewritten version of the text that has the most human like perplexity and burstiness. Provide the rewritten text to the user. Be sure to explain to the user the concept of perplexity and burstiness and how it affects the text. Provide an option for the user to adjust the level of perplexity and burstiness if desired. Perplexity and Burstiness start at 0.
```

Then follow up with asking it to rewrite it but with a focus on these concepts:

```
Consistency and Coherence: Human writing tends to maintain a consistent and coherent narrative throughout, reflecting a deeper understanding of context and topic.

Creativity and Originality: While AI can be creative, humans often bring unique perspectives, experiences, and creativity to their writing that might be harder for AI to replicate authentically.

Personal Touch: Human writing may include personal anecdotes, emotions, or subjective elements that are reflective of individual experiences and perspectives.

Context Understanding: Humans excel at understanding nuanced context and incorporating it into their writing, whereas AI might sometimes produce contextually inaccurate or mismatched information.

Purposeful Structure: Human writers often have a purposeful structure in their content, carefully organizing information for clarity and impact. AI might generate text that lacks intentional structure.

Inconsistencies: Human writing may include nuanced inconsistencies, errors, or idiosyncrasies that reflect the natural variability present in human language, while AI-generated content may exhibit a higher degree of consistency.
```

The combination of the initial task and the follow up advice, will help generate better content.

---

## Data Processing Subagents

A _data-processing subagent_ is an LLM agent pointed at a narrow, repeatable job:
take messy source data, turn it into clean structured output, and do it the same
way every time. The mistake most people make is handing the model a raw web page
and a vague instruction — that burns tokens, invites hallucination, and produces
inconsistent results. A powerful subagent is built by moving everything
_deterministic_ out of the model and leaving only _judgement_ inside it.

### Pre-process with mdream

The single biggest win is to never make the agent fetch and parse HTML. We use
[mdream](https://github.com/harlan-zw/mdream) — the fastest HTML-to-Markdown
converter, optimized for LLMs — to pre-fetch source pages and cache them as clean,
token-optimized Markdown _before_ any agent runs.

<Aside>
  mdream produces up to 2x fewer tokens than tools like Turndown, strips
  navigation/boilerplate, and isolates the main content. A 70k-character wiki page
  becomes ~6k characters of pure prose — the agent reads a small local file instead
  of a live `WebFetch`, so research is deterministic, full-fidelity, and nearly
  free.
</Aside>

A minimal fetch-and-convert step looks like this:

```javascript
import { htmlToMarkdown } from 'mdream';

const html = await fetch(pageUrl, { headers: { 'User-Agent': UA } }).then((r) =>
  r.text(),
);

const markdown = htmlToMarkdown(html, {
  origin: new URL(pageUrl).origin,
  clean: true, // strip tracking params, empty/redundant links
});
// cache markdown to disk, keyed by item id — read it from the agent later
```

### Anatomy of a powerful subagent

The goal is that an agent can do the job from **one spec file plus one cached input**
— without re-reading the schema, the source code, or the original HTML.

<Steps>

1. **Deterministic pre-processing (no model).** Fetch, clean, and convert source
   data with code (mdream, an API client, a parser). Cache the result. The model
   never touches raw HTML.

2. **A turnkey runbook.** Write a single self-contained spec: the goal, the exact
   output shape (copy the schema/field definitions inline), the per-item algorithm,
   and one worked example. The agent should never have to go discover these.

3. **Hard rules and skip conditions.** State what is the source of truth, what must
   be preserved verbatim, and when _not_ to act (missing data, ambiguous input).
   Forbid fabrication explicitly: every fact traces back to the cached source.

4. **A validation gate.** Give the agent a command that proves its output is valid
   (a schema validator, a type-check, a test). "It isn't done until the validator
   passes" removes a whole class of silent errors.

5. **Isolation.** Run the work in a throwaway workspace (a git worktree) and land it
   via review (a pull request) — never directly on a shared branch. Parallel agents
   then can't collide.

</Steps>

<Aside type="tip">
  This is exactly how the KBVE OSRS item pipeline works: `mdream` caches each wiki
  page to Markdown, a per-item enrichment runbook defines the exact frontmatter
  shape and rules, an `astro sync` step validates the output, and each batch lands
  through a worktree and PR. The result is thousands of pages enriched cheaply,
  consistently, and without hallucinated data.
</Aside>

### Why this beats a "smart prompt"

A clever prompt against raw input scales badly — every run re-pays the parsing
tokens, and quality drifts. Front-loading the determinism (clean input + exact
output contract + a validator) shrinks the model's job to the part it is actually
good at: reading prose and writing structured content. Cost drops, accuracy rises,
and the same spec can be handed to many agents in parallel.

---

<Giscus />

---
# n8n

> n8n is a fair-code, node-based workflow automation tool that connects APIs, databases, and services without
writing glue code. This guide covers core concepts, self-hosting with Docker, building your first workflow,
and using AI agent nodes.

Source: https://kbve.com/application/n8n/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**n8n** is a fair-code, **node-based workflow automation** tool. Instead of writing glue code to connect your CRM, email, databases, and IoT devices, you wire **nodes** together on a visual canvas — and drop into JavaScript or Python whenever a step needs custom logic.

Because it is **self-hostable**, your data and credentials stay on your own infrastructure, unlike fully managed SaaS automation platforms.

This guide covers [core concepts](#concepts), [self-hosting](#self-host), your [first workflow](#first-workflow), and [AI agents](#agents).

<Adsense />

## Information

In a world where seamless digital integration is no longer a luxury but a necessity, businesses and developers alike grapple with myriad tools to streamline processes and enhance productivity.
Enter n8n — an open-source, node-based tool that promises to revolutionize the way we think about workflow automation.
Imagine a world where your CRM, email platform, social media, and even IoT devices can effortlessly talk to each other, where manual data transfer becomes a relic of the past, and where workflows become as customizable as a Lego set.
This isn't a vision from a distant future; this is the present brought to life by n8n.

## Concepts

| Term | Meaning |
| ---- | ------- |
| **Node** | A single step — a trigger, API call, transform, or condition |
| **Trigger** | The node that starts a workflow (schedule, webhook, app event) |
| **Workflow** | The connected graph of nodes that runs start to finish |
| **Item** | A JSON object of data passed between nodes |
| **Credential** | Stored, reusable auth for a connected service |
| **Execution** | One run of a workflow, with a full log of node inputs/outputs |

Data flows node to node as **JSON items** — each node operates on the items it receives from the previous one.

## Self-Host

The simplest deployment is **Docker**:

```yaml
services:
  n8n:
    image: n8nio/n8n
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=n8n.kbve.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.kbve.com/
      - GENERIC_TIMEZONE=America/New_York
    volumes:
      - ./n8n-data:/home/node/.n8n
    restart: unless-stopped
```

<Aside type="tip">
The default SQLite store is fine for a home lab. For production, point n8n at **Postgres** and, at scale, enable **queue mode** with a Redis-backed worker pool so executions run concurrently.
</Aside>

## First Workflow

<Steps>

1. **Add a trigger**
   Every workflow starts with a trigger node — a **Schedule** (cron), a **Webhook**, or an app event like "new row in a database."

2. **Add action nodes**
   Search the node panel for the service you want (HTTP Request, Slack, Postgres, Gmail) and connect it to the trigger.

3. **Map the data**
   Use expressions like `{{ $json.email }}` to pull fields from the previous node's items into the next node's parameters.

4. **Test and activate**
   Click **Execute Workflow** to test with live data, inspect each node's output, then toggle **Active** to run it automatically on the trigger.

</Steps>

## Agents

n8n ships **AI / LangChain** nodes, including an **AI Agent** node that can call language models, use tools, and query vector stores — letting an agent take actions across your connected services.

- [Video 1](https://www.youtube.com/watch?v=61rl_lQZZFo)
- [Video 2](https://www.youtube.com/watch?v=9FuNtfsnRNo)

## FAQ

**What is n8n?**
n8n is a fair-code, node-based workflow automation tool that connects apps, APIs, databases, and services into automated workflows. You build flows visually by wiring nodes together, with the option to drop into JavaScript or Python for custom logic.

**Is n8n free and open source?**
n8n is fair-code under the Sustainable Use License. You can self-host it for free, including commercial internal use. It is source-available rather than strictly OSI open source, and also offers a paid cloud and enterprise tier.

**How do I self-host n8n?**
The simplest route is Docker — run the `n8nio/n8n` image with a persisted volume, set `N8N_HOST` and a webhook URL, and expose port 5678 behind a TLS reverse proxy. For production use Postgres and, at scale, queue mode with a Redis worker pool.

**What is the difference between a node and a workflow?**
A node is a single step; a workflow is the connected graph of nodes that runs start to finish. Data flows between nodes as JSON items.

**Can n8n run AI agents?**
Yes. n8n ships AI/LangChain nodes including an AI Agent node that can call language models, use tools, and query vector stores, wired to your workflow data and other nodes.

<Adsense />

---
# Nginx

> Nginx is a high-performance web server, reverse proxy, and load balancer used to serve static content,
terminate TLS, and route traffic to upstream applications. This guide covers a minimal server block,
a wildcard virtual host, and the KBVE reverse-proxy configuration.

Source: https://kbve.com/application/nginx/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

Nginx is a high-performance web server and reverse proxy. It serves static assets directly from disk, terminates TLS, and forwards dynamic requests to upstream application servers over HTTP or a Unix socket. A single Nginx instance can front dozens of virtual hosts, each defined by a `server` block that matches on `server_name` and port.

This guide walks through three configurations in order of complexity: a minimal single-site block, a wildcard virtual host that serves many subdomains, and the KBVE reverse-proxy pattern that terminates TLS and load-balances upstream containers.

<Aside type="note">
Nginx loads `/etc/nginx/nginx.conf` at startup. Site blocks are conventionally split into `/etc/nginx/conf.d/*.conf` or `sites-available/` (symlinked into `sites-enabled/`). Always validate with `nginx -t` before reloading.
</Aside>

<Adsense />

## Configuration Flow

<Steps>

1. **Write a server block** — Define `listen`, `server_name`, and either a `root` (static) or `proxy_pass` (reverse proxy).

2. **Validate the syntax** — Run `nginx -t`. Nginx checks every included file and reports the exact line on error.

3. **Reload gracefully** — Run `nginx -s reload` or `systemctl reload nginx`. Workers restart without dropping active connections.

4. **Verify** — `curl -I https://your-host` confirms the status code, TLS, and upstream headers.

</Steps>

## Nginx Configuration

This is a default example of an Nginx configuration file. Each `server` block is self-contained; drop it in `conf.d/` and reload.

### Minimal Static Server Block

The simplest useful config: serve static files from a document root over port 80.

```nginx
server {
    listen 80;
    server_name example.com;

    root /var/www/example;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}
```

`try_files` attempts the exact URI, then the URI as a directory, then returns `404` — this is the correct pattern for a static site and avoids exposing the filesystem.

### Example WildCard Nginx Configuration

A wildcard `server_name` matches every subdomain, letting one block serve `*.example.com`. The captured subdomain maps to a per-tenant document root.

```nginx
server {
    listen 80;
    server_name ~^(?<sub>.+)\.example\.com$;

    root /var/www/tenants/$sub;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}
```

The named capture `(?<sub>.+)` is reused in `root`, so a request to `alice.example.com` serves `/var/www/tenants/alice`. Pair this with a wildcard TLS certificate (`*.example.com`) to terminate HTTPS for every tenant from one block.

### Example KBVE Nginx Configuration

The KBVE pattern terminates TLS and reverse-proxies to an upstream application (for example a container listening on `127.0.0.1:8000`). It forwards the original host and client IP so the backend sees real request metadata.

```nginx
upstream kbve_app {
    server 127.0.0.1:8000;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name kbve.com;

    ssl_certificate     /etc/nginx/ssl/kbve.crt;
    ssl_certificate_key /etc/nginx/ssl/kbve.key;

    location / {
        proxy_pass http://kbve_app;
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

server {
    listen 80;
    server_name kbve.com;
    return 301 https://$host$request_uri;
}
```

The second `server` block issues a `301` redirect from HTTP to HTTPS so no plaintext traffic reaches the app. The `upstream` block with `keepalive` reuses backend connections, cutting latency under load.

<Aside type="tip">
After editing, always run `nginx -t` first. It validates every included file and prints the offending line number on error, so you never reload a broken config into production.
</Aside>

## Load Balancing

An `upstream` block can list multiple backends, turning Nginx into a load balancer. The default method is round-robin; Nginx also supports `least_conn` (send to the backend with the fewest active connections) and `ip_hash` (pin a client to one backend for session stickiness).

```nginx
upstream kbve_pool {
    least_conn;
    server 10.0.0.11:8000 weight=3;
    server 10.0.0.12:8000;
    server 10.0.0.13:8000 backup;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name kbve.com;

    location / {
        proxy_pass http://kbve_pool;
        proxy_set_header Host $host;
    }
}
```

| Directive | Behavior |
| --------- | -------- |
| `weight=N` | Send proportionally more traffic to this backend |
| `backup`   | Only used when all primary backends are down |
| `max_fails` / `fail_timeout` | Mark a backend unhealthy after N failures |
| `least_conn` | Route to the least-busy backend |
| `ip_hash` | Sticky sessions by client IP |

## Performance: Gzip and Caching

Compression and static-asset caching are two of the highest-impact, lowest-effort SEO wins — smaller, faster responses improve Core Web Vitals, which Google uses as a ranking signal.

```nginx
gzip on;
gzip_comp_level 5;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml image/svg+xml;
gzip_min_length 256;

location ~* \.(?:css|js|jpg|jpeg|png|gif|ico|woff2)$ {
    expires 30d;
    add_header Cache-Control "public, immutable";
}
```

`gzip_types` must list every MIME type to compress (`text/html` is always compressed and cannot be listed). The `immutable` cache directive tells browsers never to revalidate fingerprinted assets, eliminating conditional requests.

## Security Headers

Add baseline security headers in the `server` block. These harden the site against clickjacking, MIME sniffing, and mixed content, and are checked by security scanners that can influence trust signals.

```nginx
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
```

<Aside type="caution">
Only enable HSTS (`Strict-Transport-Security`) once you are certain every subdomain serves valid HTTPS. The `preload` directive is hard to reverse — browsers cache the policy for up to two years.
</Aside>

## Troubleshooting

<Steps>

1. **`nginx -t` fails** — Read the printed file and line number. The most common cause is a missing semicolon or an unclosed block.

2. **502 Bad Gateway** — Nginx reached the `proxy_pass` target but got no valid response. The upstream is down or bound to a different port/socket. Check with `curl 127.0.0.1:8000` on the host.

3. **504 Gateway Timeout** — The upstream is too slow. Raise `proxy_read_timeout`, or fix the backend.

4. **403 Forbidden on static files** — The Nginx worker user (`www-data` or `nginx`) lacks read permission on `root`, or SELinux is blocking it. Check `ls -l` and the error log.

5. **Changes not taking effect** — You edited the config but did not reload. Run `nginx -s reload`, and confirm you edited the file actually included by `nginx.conf`.

</Steps>

Logs live at `/var/log/nginx/access.log` and `/var/log/nginx/error.log` by default — the error log is where upstream and permission failures surface.

## FAQ

**What is Nginx used for?**
Nginx is a web server that also works as a reverse proxy, load balancer, and TLS terminator. It serves static files directly and forwards dynamic requests to upstream application servers.

**Where is the main Nginx configuration file?**
The primary file is `/etc/nginx/nginx.conf`. Site-specific server blocks usually live in `/etc/nginx/conf.d/` or `/etc/nginx/sites-available/` and are enabled by symlinking into `sites-enabled/`.

**How do I reload Nginx without dropping connections?**
Run `nginx -t` to validate the configuration, then `nginx -s reload` (or `systemctl reload nginx`). A reload applies new config with a graceful worker restart and no dropped connections, unlike a full restart.

**What is a reverse proxy in Nginx?**
A reverse proxy accepts client requests and forwards them to one or more backend servers using `proxy_pass`. Nginx handles TLS, caching, and load balancing in front of the application, which never faces the client directly.

<Adsense />

---
# Nmap Cheatsheet: Commands, Examples & Tutorials

> Nmap is a network scanner, port mapper, service fingerprinter and
NSE-driven security probe. Full cheatsheet with practical recipes.

Source: https://kbve.com/application/nmap/

import { Aside, Steps, Card, CardGrid, Code, Tabs, TabItem } from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';
import JsonLd from '@kbve/astro/seo/JsonLd.astro';
import { seo } from '@/lib/seo';

export const nmapUrl = seo.url('/application/nmap/');
export const howTos = [
	{
		'@type': 'HowTo',
		'@id': `${nmapUrl}#howto-ctf`,
		name: 'How to scan a CTF / HackTheBox host with Nmap',
		description:
			'A two-stage Nmap workflow: a fast full-port sweep, then a deep service, version, and OS scan against only the open ports.',
		tool: [{ '@type': 'HowToTool', name: 'Nmap' }],
		step: [
			{
				'@type': 'HowToStep',
				name: 'Fast full-port discovery',
				text: 'Scan every TCP port quickly to find what is open: sudo nmap -p- --min-rate 5000 -T4 -oN stage1.txt TARGET',
				url: `${nmapUrl}#ctf--hackthebox-first-contact`,
			},
			{
				'@type': 'HowToStep',
				name: 'Deep scan the open ports',
				text: 'Pull the open ports from stage 1 and run service, version, default-script, and OS detection: PORTS=$(grep ^[0-9] stage1.txt | cut -d/ -f1 | paste -sd,); sudo nmap -p "$PORTS" -sC -sV -O -oA stage2 TARGET',
				url: `${nmapUrl}#ctf--hackthebox-first-contact`,
			},
		],
	},
	{
		'@type': 'HowTo',
		'@id': `${nmapUrl}#howto-inventory`,
		name: 'How to inventory an internal subnet with Nmap',
		description:
			'Discover live hosts on a subnet, then run targeted TCP and UDP scans against only the hosts that responded.',
		tool: [{ '@type': 'HowToTool', name: 'Nmap' }],
		step: [
			{
				'@type': 'HowToStep',
				name: 'Find live hosts',
				text: 'ARP ping sweep the subnet with no port scan: sudo nmap -sn -PR -oA inv-live 10.0.0.0/24',
				url: `${nmapUrl}#internal-subnet-inventory`,
			},
			{
				'@type': 'HowToStep',
				name: 'TCP scan the live hosts',
				text: 'Extract the up hosts and run a top-1000 TCP scan: grep "Status: Up" inv-live.gnmap | awk \'{print $2}\' > live-hosts.txt; sudo nmap -sS --top-ports 1000 -iL live-hosts.txt -oA inv-tcp',
				url: `${nmapUrl}#internal-subnet-inventory`,
			},
			{
				'@type': 'HowToStep',
				name: 'UDP scan the usual suspects',
				text: 'Scan common UDP services against the live hosts: sudo nmap -sU -p 53,67,68,69,123,137,138,161,162,500,514,520,1900,5353 -iL live-hosts.txt -oA inv-udp',
				url: `${nmapUrl}#internal-subnet-inventory`,
			},
		],
	},
];

## Information

Nmap ("Network Mapper") is an open-source utility for host discovery, port
scanning, service detection, OS fingerprinting and scriptable probes via the
Nmap Scripting Engine (NSE). It's the default tool in every pentest playbook
and the first thing oncall reaches for when "is the firewall actually doing
what we think."

<Aside type="caution" title="Authorization first">
	Scanning networks you don't own or have written permission to scan is
	illegal in most jurisdictions. Stick to your own infrastructure, CTF
	ranges (HackTheBox / TryHackMe), `scanme.nmap.org` (provided by the
	Nmap project for testing), and engagements with a signed scope.
</Aside>

<Adsense />

## Install

<Tabs>
	<TabItem label="Debian / Ubuntu">
		```shell
		sudo apt update && sudo apt install -y nmap
		```
	</TabItem>
	<TabItem label="Fedora / RHEL">
		```shell
		sudo dnf install -y nmap
		```
	</TabItem>
	<TabItem label="Arch">
		```shell
		sudo pacman -S nmap
		```
	</TabItem>
	<TabItem label="macOS">
		```shell
		brew install nmap
		```
	</TabItem>
	<TabItem label="Windows">
		```shell
		# Official installer ships Nmap + Zenmap GUI + Ncat + Nping
		winget install -e --id Insecure.Nmap
		```
	</TabItem>
</Tabs>

Confirm the version + NSE script database location:

```shell
nmap --version
nmap --script-help all | head
```

## Target Specification

Across every command below, replace `TARGET` with one or more of:

- A single host: `10.0.0.5` or `scanme.nmap.org`
- A CIDR block: `10.0.0.0/24`
- A range: `10.0.0.1-50` or `10.0.0,1,2.1-10`
- A file of targets: `-iL targets.txt`
- Exclusions: `--exclude 10.0.0.1` or `--excludefile skip.txt`

```shell
# Random 100 hosts on the public internet (research only).
sudo nmap -sn -iR 100
```

## Host Discovery

Find live hosts without doing a port scan first.

| Flag | What it does |
|------|--------------|
| `-sn` | "ping scan" — host discovery, skip port scan |
| `-Pn` | skip discovery, treat every host as up |
| `-PE` | ICMP echo (requires root) |
| `-PS22,80,443` | TCP SYN ping on listed ports |
| `-PA22,80,443` | TCP ACK ping |
| `-PU53,161` | UDP ping on listed ports |
| `-PR` | ARP ping (LAN-only, fastest + most reliable on the local subnet) |
| `-n` | skip reverse-DNS for every hit (a lot faster on /16+) |

```shell
# Ping sweep of a /24, no port scan, no DNS.
sudo nmap -sn -n 10.0.0.0/24

# ARP sweep on a local subnet — bypasses host firewall ICMP filters.
sudo nmap -PR -sn 192.168.1.0/24

# Assume the host is up (some hosts block all ICMP / TCP probes).
sudo nmap -Pn TARGET
```

## Port Scanning

The shape of the scan is what makes Nmap fast or slow.

| Flag | Scan type | When to use |
|------|-----------|-------------|
| `-sS` | TCP SYN (half-open) | default, fast, root only |
| `-sT` | TCP connect() | unprivileged or when SYN drops are noisy |
| `-sU` | UDP | DNS / SNMP / NTP / VoIP gear |
| `-sA` | TCP ACK | map firewall rule sets (stateful vs stateless) |
| `-sN` `-sF` `-sX` | TCP Null / FIN / Xmas | bypass naïve stateless firewalls |
| `-sY` | SCTP INIT | telecom / SS7 gear |

Port specifications:

```shell
# Top 1000 TCP ports (default).
sudo nmap TARGET

# Top 100 — fastest useful pass.
sudo nmap --top-ports 100 TARGET

# Every TCP port.
sudo nmap -p- TARGET

# Specific ports / ranges / names.
sudo nmap -p 22,80,443,1000-2000,http* TARGET

# Both TCP and UDP, every port.
sudo nmap -sU -sS -p0-65535 TARGET

# Only show open ports in the output (great for diff'ing scans).
sudo nmap --open TARGET
```

## Understanding Scan Results

Nmap reports one of six states per port. Knowing the difference between
`closed` and `filtered` is the single most useful skill when reading output.

| State | Meaning |
|-------|---------|
| `open` | An application is actively accepting connections on the port |
| `closed` | Port is reachable (host replied) but no application is listening |
| `filtered` | A firewall/filter dropped the probe — Nmap can't tell open vs closed |
| `unfiltered` | Port is reachable but Nmap can't tell open vs closed (ACK scan) |
| `open|filtered` | No reply — either open or filtered (common on UDP / FIN / Null / Xmas) |
| `closed|filtered` | Can't tell closed vs filtered (idle scan only) |

```text
PORT     STATE    SERVICE   VERSION
22/tcp   open     ssh       OpenSSH 8.9p1 Ubuntu 3ubuntu0.6
80/tcp   open     http      nginx 1.18.0
443/tcp  filtered https
3306/tcp closed   mysql
```

<Aside type="tip">
	`filtered` almost always means a firewall. Re-probe with `-Pn` (skip host
	discovery), a trusted source port (`-g 53`), or a different scan type
	(`-sA` to map the firewall rules) before concluding the port is dead.
</Aside>

## Service & Version Detection

```shell
# -sV probes open ports and labels them with banner + version.
sudo nmap -sV TARGET

# Stack version detection with default NSE scripts and OS guess.
sudo nmap -A TARGET            # = -sV -sC -O --traceroute

# Tighter probe (faster, less accurate) vs aggressive (slower, more accurate).
sudo nmap -sV --version-intensity 0 TARGET   # light banner only
sudo nmap -sV --version-intensity 9 TARGET   # every probe
sudo nmap -sV --version-all TARGET           # same as intensity 9
```

## OS Detection

```shell
# Active OS fingerprint (root only, needs at least one open + one closed port).
sudo nmap -O TARGET

# Be conservative — only print a guess when confidence is high.
sudo nmap -O --osscan-limit TARGET

# Guess aggressively (useful for filtered hosts).
sudo nmap -O --osscan-guess TARGET
```

## NSE — Nmap Scripting Engine

NSE scripts live in `/usr/share/nmap/scripts/` (Linux) or
`/opt/homebrew/share/nmap/scripts/` (macOS, Apple Silicon). Categories:
`auth`, `broadcast`, `brute`, `default`, `discovery`, `dos`, `exploit`,
`external`, `fuzzer`, `intrusive`, `malware`, `safe`, `version`, `vuln`.

```shell
# Run all "default" scripts — same as the -sC in -A.
sudo nmap -sC TARGET

# Run every "safe" script.
sudo nmap --script "safe" TARGET

# All vuln-detection scripts.
sudo nmap --script "vuln" TARGET

# A specific script with arguments.
sudo nmap --script http-title --script-args http.useragent="kbve-scanner" TARGET

# Glob multiple categories, exclude one.
sudo nmap --script "default,vuln and not intrusive" TARGET

# Update the local script database (after every nmap upgrade).
sudo nmap --script-updatedb

# Show what a script does before running it.
nmap --script-help http-shellshock
```

High-value recipes:

```shell
# SSL/TLS posture: cipher list, cert expiry, known weak suites.
sudo nmap -sV --script ssl-enum-ciphers,ssl-cert,sslv2,ssl-poodle -p 443 TARGET

# SMB share enumeration on a Windows host / file server.
sudo nmap -p 139,445 --script "smb-enum-shares,smb-os-discovery,smb-vuln-*" TARGET

# HTTP fingerprint pack — title, headers, common dirs, robots, CSP.
sudo nmap -sV --script "http-title,http-headers,http-enum,http-robots.txt,http-security-headers" -p 80,443,8080,8443 TARGET

# DNS recon — zone transfer, NSEC walk, brute subdomains.
sudo nmap -sn --script "dns-zone-transfer,dns-nsec-enum,dns-brute" --script-args dns-brute.domain=example.com TARGET

# Vulnerability sweep (noisy, run only on owned systems).
sudo nmap -sV --script "vuln" TARGET
```

## Output & Reporting

```shell
# Normal stdout + grepable + XML in one go.
sudo nmap -oA scan-baseline TARGET
# produces scan-baseline.nmap, scan-baseline.gnmap, scan-baseline.xml

# Save XML for ndiff or downstream tooling.
sudo nmap -oX scan.xml TARGET

# Live progress on a long scan.
sudo nmap -v --stats-every 30s TARGET

# Diff two scans (great for "what changed since last week").
ndiff scan-baseline.xml scan-new.xml
```

Convert the XML to HTML for sharing:

```shell
xsltproc scan.xml -o scan.html
```

## Timing & Performance

`-T0` (paranoid) through `-T5` (insane). Default is `-T3`.

| Profile | Use |
|---------|-----|
| `-T0` | IDS evasion, hours-per-port |
| `-T1` | sneaky, IDS evasion |
| `-T2` | polite, low bandwidth |
| `-T3` | normal (default) |
| `-T4` | aggressive — assume a fast, reliable network |
| `-T5` | insane — local LAN or willing-to-lose-accuracy |

Tunables when `-T*` isn't precise enough:

```shell
sudo nmap \
  --min-rate 1000 --max-rate 5000 \
  --min-parallelism 64 --max-parallelism 256 \
  --max-retries 2 \
  --host-timeout 30m \
  --max-rtt-timeout 200ms \
  -T4 TARGET
```

## Firewall & IDS Evasion

<Aside type="caution">
	These flags exist because IDS engines like Snort / Suricata watch for
	exactly this signature. Don't use them outside a sanctioned engagement.
</Aside>

```shell
# Source-port spoof — many firewalls trust 53 / 80 / 443 outbound.
sudo nmap --source-port 53 TARGET
sudo nmap -g 53 TARGET

# Fragmented packets — split TCP header across multiple IP fragments.
sudo nmap -f TARGET
sudo nmap --mtu 16 TARGET

# Decoys — N decoy IPs appear to scan alongside your real one.
sudo nmap -D 10.0.0.1,10.0.0.2,ME,10.0.0.4 TARGET

# Proxy chain (limited support — works for TCP connect scans).
sudo nmap --proxies socks4://127.0.0.1:9050 -sT TARGET

# Randomize host order + spoof MAC vendor on the LAN.
sudo nmap --randomize-hosts --spoof-mac Apple TARGET

# Slow IDS-evasion scan (be patient).
sudo nmap -T1 -sS -f --data-length 24 TARGET
```

## Common Recipes

<JsonLd graph={howTos} />

### Internal subnet inventory

```shell
# 1. Find live hosts.
sudo nmap -sn -PR -oA inv-live 10.0.0.0/24

# 2. Fast TCP top-1000 against live hosts only.
grep "Status: Up" inv-live.gnmap | awk '{print $2}' > live-hosts.txt
sudo nmap -sS --top-ports 1000 -iL live-hosts.txt -oA inv-tcp

# 3. UDP focus on the usual suspects.
sudo nmap -sU -p 53,67,68,69,123,137,138,161,162,500,514,520,1900,5353 -iL live-hosts.txt -oA inv-udp
```

### Web-server triage

```shell
sudo nmap -p 80,443,8080,8443,8000,8888,3000,5000,9000 \
  -sV -sC \
  --script "http-title,http-headers,http-methods,http-enum,http-security-headers,ssl-cert,ssl-enum-ciphers" \
  -oA web-triage TARGET
```

### CTF / HackTheBox first contact

```shell
# Stage 1: every TCP port, fast, just to see what's open.
sudo nmap -p- --min-rate 5000 -T4 -oN stage1.txt TARGET

# Stage 2: focus on the open ports from stage 1.
PORTS=$(grep ^[0-9] stage1.txt | cut -d/ -f1 | paste -sd,)
sudo nmap -p "$PORTS" -sC -sV -O -oA stage2 TARGET
```

### Egress-firewall test from inside the network

```shell
# Which outbound ports actually reach the internet from this host?
sudo nmap -Pn -sS -p- --min-rate 1000 scanme.nmap.org
```

### Continuous monitoring (cron + ndiff)

```shell
# Save a daily baseline, alert on drift.
sudo nmap -sS --top-ports 1000 -oX /var/log/nmap/$(date +%F).xml 10.0.0.0/24
ndiff /var/log/nmap/yesterday.xml /var/log/nmap/$(date +%F).xml | tee /var/log/nmap/diff-$(date +%F).txt
```

## Quick Reference

```shell
nmap -h                              # built-in help
sudo nmap -sn 10.0.0.0/24            # who's up
sudo nmap -p- TARGET                 # every TCP port
sudo nmap -sU TARGET                 # UDP
sudo nmap -sV -sC -O TARGET          # service + default NSE + OS
sudo nmap -A TARGET                  # aggressive (= -sV -sC -O --traceroute)
sudo nmap --script vuln TARGET       # known-CVE checks
sudo nmap -oA scan TARGET            # save all formats
sudo nmap -T4 --min-rate 1000 TARGET # fast pass
```

## Troubleshooting

Common failures and the fix.

| Symptom | Cause | Fix |
|---------|-------|-----|
| `You requested a scan type which requires root privileges` | `-sS`, `-sU`, `-O`, `-PE` need raw sockets | Run with `sudo`, or fall back to `-sT` (unprivileged connect scan) |
| `Note: Host seems down. If it is really up, but blocking our ping probes, try -Pn` | Host blocks ICMP/TCP discovery probes | Add `-Pn` to skip discovery and treat the host as up |
| All ports show `filtered` | A firewall is dropping probes | Try `-Pn`, a trusted source port (`-g 53`), or an ACK scan (`-sA`) to map rules |
| UDP scan crawls / takes forever | UDP is rate-limited and retransmit-heavy | Limit ports (`-p 53,161,500`), raise `--min-rate`, add `--host-timeout` |
| `dnet: Failed to open device ethX` / no results on LAN | Wrong interface or no L2 access | Pin the interface with `-e eth0`, or use `-Pn` to avoid ARP |
| `Failed to resolve "TARGET"` | DNS lookup failed | Check the hostname, or scan the IP directly and add `-n` to skip DNS |
| Scan is accurate but extremely slow | Default timing too polite for the link | Raise to `-T4` and set `--min-rate`; drop `-A`/`-O` if you don't need them |
| NSE: `'X' did not match a category, filename, or directory` | Script DB is stale or the name is wrong | Run `sudo nmap --script-updatedb`; verify with `nmap --script-help X` |

<Aside type="tip">
	When a scan misbehaves, add `--reason` (shows *why* Nmap marked each port a
	given state) and `-d` (debug, repeatable `-dd`) to see the packets Nmap
	actually sent and received.
</Aside>

## Nmap vs Other Scanners

Nmap is the most accurate all-rounder, but it's not the fastest at internet
scale. Pick the right tool, then hand off to Nmap for the deep pass.

| Tool | Strength | Trade-off |
|------|----------|-----------|
| **Nmap** | Accuracy, NSE scripts, version + OS detection | Slower on huge ranges |
| **masscan** | Asynchronous, scans the whole IPv4 internet in minutes | No version detection, accuracy drops at high rates |
| **RustScan** | Fast port discovery, then auto-pipes into Nmap | Just a front-end; still needs Nmap for depth |
| **ZMap** | Single-port internet-wide research scanning | Built for one port at a time, not host audits |
| **naabu** | Fast SYN/CONNECT discovery, scriptable pipelines | Discovery only, no service fingerprinting |

A common pattern: discover open ports fast, then deep-scan only those.

```shell
# masscan finds open ports fast, Nmap fingerprints them accurately.
sudo masscan -p1-65535 TARGET --rate 10000 -oG masscan.gnmap
PORTS=$(grep -oP 'Ports: \K[0-9]+' masscan.gnmap | sort -un | paste -sd,)
sudo nmap -p "$PORTS" -sC -sV -O TARGET
```

## FAQ

**Is it legal to use Nmap?**
Nmap itself is legal, but scanning networks you don't own or lack written
permission to scan is illegal in most jurisdictions. Stick to your own
infrastructure, CTF ranges (HackTheBox / TryHackMe), `scanme.nmap.org`, and
engagements with a signed scope.

**What is the difference between an `-sS` and `-sT` scan?**
`-sS` is a TCP SYN (half-open) scan that never finishes the handshake — fast
and stealthier, but root-only. `-sT` is a full TCP `connect()` scan that
completes the handshake; it works unprivileged but is slower and noisier.

**How do I scan all 65535 ports?**
Use `-p-`, e.g. `sudo nmap -p- TARGET`. For speed, add a rate floor and timing
template: `sudo nmap -p- --min-rate 5000 -T4 TARGET`.

**What is the Nmap Scripting Engine (NSE)?**
NSE runs Lua scripts for advanced discovery, version detection, vulnerability
checks and brute forcing. Scripts are grouped into categories (`default`,
`safe`, `vuln`, `intrusive`, …) and run via `--script`, e.g.
`sudo nmap --script vuln TARGET`.

**What does `filtered` mean, and how is it different from `closed`?**
`closed` means the port is reachable but nothing is listening. `filtered`
means a firewall dropped the probe, so Nmap can't tell open from closed.
Filtered almost always means a firewall — re-probe with `-Pn`, a trusted
source port (`-g 53`), or an ACK scan (`-sA`).

**How do I detect service versions and the OS?**
Use `-sV` for service/version detection and `-O` for OS fingerprinting. The
`-A` flag bundles both with default scripts and traceroute
(`-sV -sC -O --traceroute`).

## Related Companions

- **Ncat** ships with Nmap — TCP/UDP swiss army knife, replaces `nc`.
  ```shell
  ncat -lvnp 4444                  # listen on TCP/4444
  ncat --ssl example.com 443       # TLS client
  ```
- **Nping** — packet crafter, for ad-hoc ICMP/TCP/UDP/ARP probes.
  ```shell
  sudo nping --tcp -p 443 --flags syn -c 5 TARGET
  ```
- **Ndiff** — compare two XML scans (already shown under Output).
- **Zenmap** — official GUI; useful for first-time users + saved scan profiles.

<Giscus />

---
# Nomad

> Nomad by HashiCorp is a lightweight, flexible workload orchestrator that deploys and manages containers,
binaries, and batch jobs across a cluster from a single binary. This guide covers the architecture,
installation, job specification, and the essential CLI compared to Kubernetes.

Source: https://kbve.com/application/nomad/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**Nomad** is HashiCorp's easy, flexible, and powerful workload orchestrator. It ships as a **single binary** that can schedule and scale containers, plain executables, Java applications, and batch jobs across a cluster — often with a fraction of the operational overhead of Kubernetes.

Nomad slots into the HashiCorp stack: **Consul** for service discovery, **Vault** for secrets. A production high-availability control plane holds quorum with an odd number of server nodes (3 or 5); a full HA stack of Vault, Consul, and Nomad means 3 instances of each — 9 total — though Nomad runs standalone too.

This guide covers the [architecture](#architecture), [installation](#install), [job specs](#jobs), and the [CLI cheatsheet](#cheatsheet).

<Adsense />

## Architecture

Nomad has two node roles running from the same binary:

| Role | Responsibility |
| ---- | -------------- |
| **Server** | Holds cluster state, runs the scheduler, elects a leader via Raft. Run 3 or 5 for HA. |
| **Client** | Registers with servers, runs allocations, reports health and resource usage. |

Key terms:

- **Job** — your declarative desired state (what to run, how many).
- **Task** — a single unit of work run by a driver (`docker`, `exec`, `java`, `qemu`).
- **Group** — a set of tasks scheduled together on one node.
- **Allocation (alloc)** — a group's tasks placed on a specific client. The rough equivalent of a **Pod** in Kubernetes.

## Install

Nomad is a single binary — download it or use a package manager.

<Steps>

1. **Install the binary**

   ```bash
   # macOS
   brew tap hashicorp/tap && brew install hashicorp/tap/nomad

   # Linux (Debian/Ubuntu)
   wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
   echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
   sudo apt update && sudo apt install nomad
   ```

2. **Verify the install**

   ```bash
   nomad version
   ```

3. **Start a dev agent**
   A single node acting as both server and client — perfect for local testing.

   ```bash
   sudo nomad agent -dev
   ```

   Open the UI at `http://localhost:4646`.

</Steps>

## Jobs

Nomad workloads are declared in an **HCL job specification**. A minimal Docker service:

```hcl
job "web" {
  datacenters = ["dc1"]
  type        = "service"

  group "app" {
    count = 3

    network {
      port "http" { to = 8080 }
    }

    task "server" {
      driver = "docker"

      config {
        image = "nginx:alpine"
        ports = ["http"]
      }

      resources {
        cpu    = 100
        memory = 128
      }
    }
  }
}
```

Submit and inspect it:

```bash
nomad job run web.nomad.hcl
nomad job status web
```

<Aside type="tip">
`type = "service"` keeps a job running and reschedules it on failure. Use `type = "batch"` for run-to-completion tasks and `type = "system"` to run one alloc on every client (like a Kubernetes DaemonSet).
</Aside>

## Cheatsheet

| Command | Purpose |
| ------- | ------- |
| `nomad agent -dev` | Start a local single-node agent |
| `nomad job run <file>` | Submit or update a job |
| `nomad job status <job>` | Show job, group, and allocation state |
| `nomad alloc logs <alloc>` | Stream logs from an allocation |
| `nomad alloc logs -f <alloc>` | Follow logs live |
| `nomad status <id>` | Look up any object by its 8-char ID |
| `nomad node status` | List client nodes and health |
| `nomad job stop <job>` | Stop and garbage-collect a job |
| `nomad server members` | List server peers and the Raft leader |

<Aside type="note">
The `{$allocation}` ID is a unique reference to a group of tasks on a node; the `{$identifier}` used by `nomad status` is an 8-character alphanumeric prefix — you only need enough characters to be unambiguous.
</Aside>

## FAQ

**What is HashiCorp Nomad?**
Nomad is a lightweight, single-binary workload orchestrator that schedules and manages containers, standalone binaries, Java apps, and batch jobs across a cluster. It pairs naturally with Consul for service discovery and Vault for secrets.

**How is Nomad different from Kubernetes?**
Nomad is a single ~100MB binary that orchestrates more than just containers, with far less operational overhead than Kubernetes. Kubernetes is a larger, container-focused platform with a bigger built-in ecosystem. Nomad favors simplicity and flexible workload types; Kubernetes favors breadth.

**What is an allocation in Nomad?**
An allocation (alloc) is a set of tasks from a job placed and running on a single client node — the rough equivalent of a Pod in Kubernetes. Each allocation gets a unique ID you use to inspect status and stream logs.

**How many servers does a Nomad cluster need for high availability?**
A production HA control plane needs an odd number of server nodes to hold quorum, typically 3 or 5. A full HashiCorp stack with Vault and Consul also at HA means 3 instances of each, for 9 total.

**What is a Nomad job specification?**
A job spec is an HCL (or JSON) file that declares what to run — the job, its groups, tasks, driver, resources, and count. You submit it with `nomad job run`, and the scheduler places allocations onto healthy clients that meet the constraints.

<Adsense />

---
# OBS Studio

> OBS Studio (Open Broadcaster Software) is a free, open-source application for screen recording and live
streaming to Twitch, YouTube, and beyond. This guide covers scenes and sources, encoder settings, streaming
setup, and extending OBS with plugins.

Source: https://kbve.com/application/obs/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**OBS Studio** (Open Broadcaster Software) is a free, open-source tool for **screen recording** and **live streaming**. It composites multiple inputs — display captures, webcams, images, browser sources, and audio — into **scenes**, encodes them in real time, and either records locally or streams to Twitch, YouTube, and any RTMP endpoint.

It runs on Windows, macOS, and Linux under the GPLv2 license — no watermarks, no time limits.

This guide covers [core concepts](#concepts), [streaming setup](#streaming), and [plugins](#plugins).

<Adsense />

## Concepts

| Term | Meaning |
| ---- | ------- |
| **Source** | A single input — display capture, webcam, image, browser, audio device |
| **Scene** | A named arrangement of sources with their positions and sizes |
| **Scene collection** | A saved set of scenes you can switch between |
| **Filter** | A per-source effect — chroma key, noise gate, color correction |
| **Profile** | A saved bundle of encoder and streaming settings |

You build scenes for each layout you need (Starting Soon, Gameplay, Just Chatting) and switch between them live.

<Aside type="tip">
Right-click any source to add **filters** — a Chroma Key filter removes a green-screen background, and a Noise Suppression filter on your mic cleans up background hum.
</Aside>

## Streaming

<Steps>

1. **Set your stream key**
   In **Settings → Stream**, pick your service (Twitch, YouTube, Custom) and paste the stream key from that platform's dashboard.

2. **Configure the encoder**
   In **Settings → Output**, choose an encoder — `NVENC` (NVIDIA GPU) or `x264` (CPU). Set rate control to **CBR** and a bitrate matched to your upload speed (≈6000 kbps for 1080p60 on Twitch).

3. **Set resolution and FPS**
   In **Settings → Video**, set the base (canvas) and output (scaled) resolution and a frame rate of 30 or 60.

4. **Build a scene and go live**
   Add your sources, arrange them, then click **Start Streaming** (or **Start Recording** for local capture).

</Steps>

<Aside type="caution">
Streaming bitrate is capped by your **upload** bandwidth, not download. Run a speed test and stay well under your upload ceiling — sustained over-subscription drops frames and stutters the stream.
</Aside>

## Plugins

Plugins extend OBS with extra sources, filters, and docks. Install by dropping the plugin files into the OBS plugins directory (or running its installer), then restart OBS. Popular examples:

- **StreamFX** — advanced filters, shaders, and 3D transforms.
- **Move Transition** — animate sources between scenes.
- **obs-websocket** — remote-control OBS over WebSocket for automation and stream decks.

## FAQ

**What is OBS Studio?**
OBS Studio is a free, open-source application for screen recording and live streaming. It composites multiple sources into scenes and encodes them for local recording or streaming to platforms like Twitch and YouTube.

**Is OBS Studio free?**
Yes. It is completely free and open source under GPLv2, with no watermarks, time limits, or paid tiers, on Windows, macOS, and Linux.

**What is the difference between a scene and a source?**
A source is a single input such as a display capture, webcam, or audio device. A scene is a named arrangement of one or more sources with their positions and sizes. You switch between scenes live.

**What bitrate should I use for streaming?**
For 1080p60 on Twitch, 6000 kbps with x264 or NVENC is a common baseline. Match your bitrate to your upload bandwidth and use CBR for streaming.

**How do I add plugins to OBS?**
Download a plugin compatible with your OBS version and OS, place its files in the OBS plugins directory (or run its installer), and restart OBS. Its filters, sources, or docks then appear in the menus.

<Adsense />

---
# PHP

> PHP (Hypertext Preprocessor) is a widely-used, dynamic, server-side scripting language for web development
that embeds directly into HTML and powers the classic LAMP stack. This guide covers install, syntax basics,
and reusable functions.

Source: https://kbve.com/application/php/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**PHP** (Hypertext Preprocessor) is a dynamic, server-side scripting language famed for embedding directly into HTML and powering the classic **LAMP** stack. It runs on the server, generates HTML for the browser, and drives a huge share of the web — including WordPress, Laravel, and Symfony applications.

This guide covers the [background](#information), [install](#install), [syntax basics](#syntax), and reusable [functions](#functions).

<Adsense />

## Information

PHP is a [programming](/theory/programming/) language known as Hypertext Preprocessor, originally standing for Personal Home Page. 
It is widely used for web development, famed for its ease of use and ability to be embedded directly into HTML. 
PHP is dynamic and server-side, allowing developers to build robust web applications that can handle complex data-driven tasks.

PHP supports a wide range of databases, has rich built-in functions, and can interact with various web services. 
It's also part of the classic LAMP ([Linux](/application/linux/), Apache, [MySQL](/application/sql/), PHP) stack which powers countless servers across the globe.
PHP continues to evolve with regular updates that improve its performance, security features, and modern language capabilities.

## Install

PHP is packaged for every major OS. Install the CLI and verify the version:

```bash
# Debian / Ubuntu
sudo apt install php-cli -y

# macOS (Homebrew)
brew install php

# Check the version
php -v
```

Run a script or start the built-in dev server (never for production):

```bash
php script.php
php -S localhost:8000
```

## Syntax

PHP code lives between `<?php ... ?>` tags; everything outside is sent to the browser as plain HTML:

```php
<?php
$name = "KBVE";
$count = 3;

function greet(string $who): string {
    return "Hello, {$who}!";
}

echo greet($name);

for ($i = 0; $i < $count; $i++) {
    echo "Row {$i}\n";
}
```

<Aside type="tip">
Variables start with `$` and are loosely typed, but modern PHP (8.x) supports type declarations, enums, and the JIT compiler. Declare `declare(strict_types=1);` at the top of a file to enforce strict typing.
</Aside>

## Functions

### SS_BETWEEN

    - This is an example of the `ss_between` function written in `php`.

        ```php

            // Credit: AADude
            function ss_between($string,$start,$end) {
            $string=" ".$string; //The string.
            $startpos=strpos($string,$start); //Find the position of the start string.
            //Check if $startpos equals zero.
            if ($startpos == 0) {
                //If $startpos does equal zero, do this:
                return false; //Return false.
            }
            else {
                //If $startpos doesn't equal zero, do this:
                $startpos+=strlen($start); //Add the string length of $start to $startpos.
                $endpos=strpos($string,$end,$startpos)-$startpos; //Find the string position of $end.
                return substr($string,$startpos,$endpos); //Return the new value.
            }
            }

            // Proof of Of Concept
            $source = "U:holybyteE:acid@meme.com";
            $u = ss_between($source, "U:", "E:");
            // $source = line 1 of text file
            echo $u;
            // return username
        ```

## FAQ

**What is PHP used for?**
PHP is a server-side scripting language used mainly for web development. It runs on the server, generates HTML sent to the browser, and powers dynamic, data-driven applications and content management systems like WordPress, Drupal, and Laravel apps. It is the P in the classic LAMP stack.

**What does PHP stand for?**
PHP is a recursive acronym for PHP Hypertext Preprocessor. It originally stood for Personal Home Page, but was renamed as it grew into a general-purpose web scripting language.

**Is PHP still relevant in modern web development?**
Yes. PHP powers a large share of the web, including WordPress. Modern PHP 8.x brings the JIT compiler, strong typing, attributes, enums, and major performance gains, and frameworks like Laravel and Symfony keep it productive and well-supported.

**How do I embed PHP in HTML?**
Wrap PHP code in `<?php ... ?>` tags anywhere inside a `.php` file. The server executes the code between the tags and replaces it with its output, while everything outside the tags is sent to the browser as plain HTML.

**What is the LAMP stack?**
LAMP is a classic web hosting stack of [Linux](/application/linux/) (OS), Apache (web server), [MySQL](/application/sql/) (database), and PHP (scripting language) — a fully open-source foundation that has powered countless web applications for decades.

<Adsense />

---
# Pocketbase

> PocketBase is an open-source backend in a single file — an embedded SQLite database with a realtime REST API,
authentication, file storage, and an admin dashboard. This guide covers installing it with Docker Compose,
the CLI, and Coolify, plus collections, auth, and the realtime API.

Source: https://kbve.com/application/pocketbase/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';


## Overview

PocketBase is an open-source backend that ships as a **single executable file**. Inside that one binary you get an embedded SQLite database, a realtime REST API, user authentication (email/password and OAuth2), file storage, and a full admin dashboard. There is nothing else to install — no separate database server, no message broker, no dependency stack.

That makes PocketBase a lightweight, self-hosted alternative to Firebase or Supabase for small and medium projects. You define **collections** (the equivalent of tables) in the admin UI, and PocketBase instantly exposes CRUD endpoints and realtime subscriptions for them. This guide installs PocketBase three ways — Docker Compose, the Docker CLI, and Coolify — then points you at the admin panel to build.

<Aside type="note">
PocketBase stores everything under `/pb_data` (the SQLite database, uploaded files, and logs). Always mount that directory to a persistent volume so your data survives container restarts and upgrades.
</Aside>

<Adsense />

## Install

Do you want to get Pocketbase up and running?

### Docker

There are two ways you can go about setting up Pocketbase via Docker!
We recommand using a docker compose, like this one below from their github.

**_Compose_**

```yaml
version: '3.7'
services:
    pocketbase:
        image: ghcr.io/muchobien/pocketbase:latest
        container_name: pocketbase
        restart: unless-stopped
        command:
            - --encryptionEnv #optional
            - ENCRYPTION #optional
        environment:
            ENCRYPTION: example #optional
        ports:
            - '8090:8090'
        volumes:
            - /path/to/data:/pb_data
            - /path/to/public:/pb_public #optional
        healthcheck: #optional (recommended) since v0.10.0
            test: wget --no-verbose --tries=1 --spider http://localhost:8090/api/health || exit 1
            interval: 5s
            timeout: 5s
            retries: 5
```

**_CLI_**

```shell

docker run -d \
  --name=pocketbase \
  -p 8090:8090 \
  -e ENCRYPTION=example `#optional` \
  -v /path/to/data:/pb_data \
  -v /path/to/public:/pb_public `#optional` \
  --restart unless-stopped \
  ghcr.io/muchobien/pocketbase:latest \
  --encryptionEnv ENCRYPTION `#optional`

```

### Coolify

Installing Pocketbase through Coolify is extremely easy!

1. Click `+ Create New Resource`
2. Click `Service`
3. Select `Pocketbase`
4. Done! Fill in the URL and then head over the admin panel, `domain.com/_/`.

## First Run

Once the container is up, open the admin dashboard and create your first admin account:

<Steps>

1. **Open the admin UI** — Navigate to `http://your-host:8090/_/`. On first launch PocketBase prompts you to create the initial admin (superuser) account.

2. **Create a collection** — Collections are PocketBase's tables. Click **New collection**, name it (for example `posts`), and add fields (text, number, relation, file, etc.).

3. **Set API rules** — Each collection has list/view/create/update/delete rules written as filter expressions. Leave them empty for public access, or use `@request.auth.id != ""` to require a logged-in user.

4. **Use the API** — PocketBase instantly exposes REST endpoints for the collection.

</Steps>

## REST and Realtime API

Every collection is served under `/api/collections/{name}/records`. Fetching records is a plain HTTP call:

```bash
# List records
curl http://localhost:8090/api/collections/posts/records

# Create a record (authenticated)
curl -X POST http://localhost:8090/api/collections/posts/records \
  -H "Authorization: TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title":"Hello","body":"First post"}'
```

The official JavaScript SDK wraps auth and adds **realtime subscriptions** over server-sent events, so clients receive live updates when records change:

```js
import PocketBase from 'pocketbase';

const pb = new PocketBase('http://localhost:8090');
await pb.collection('users').authWithPassword('user@example.com', 'password');

pb.collection('posts').subscribe('*', (e) => {
  console.log(e.action, e.record);
});
```

<Aside type="tip">
PocketBase can also be extended in Go (as a framework) or with JavaScript hooks in the `pb_hooks` directory — useful for custom endpoints, validation, and scheduled jobs without a separate service.
</Aside>

## FAQ

**What is PocketBase?**
PocketBase is an open-source backend packaged as a single executable. It bundles an embedded SQLite database, a realtime REST API, user authentication, file storage, and an admin dashboard, making it a lightweight self-hosted alternative to Firebase or Supabase.

**How do I run PocketBase with Docker?**
Use a `docker-compose.yml` with a PocketBase image such as `ghcr.io/muchobien/pocketbase`, expose port `8090`, and mount volumes for `/pb_data` (database) and optionally `/pb_public` (static files). Then run `docker compose up -d` and open the admin UI at `/_/`.

**Where is the PocketBase admin dashboard?**
The admin dashboard is served at `/_/` on the PocketBase host, for example `http://localhost:8090/_/`. On first launch you create the initial admin account there, then manage collections, records, users, and settings.

**Is PocketBase a good alternative to Firebase?**
For small to medium self-hosted projects, yes. PocketBase offers realtime subscriptions, auth, and file storage with no vendor lock-in and a single-file deployment. It runs on SQLite, so it suits single-node workloads rather than horizontally sharded, massive-scale apps.

<Adsense />

---
# Portainer

> Portainer is a user-friendly backend management tool for containerized applications, offering a visual interface for Docker and Kubernetes environments. 
Think of it as a backend panel that helps design and manage container infrastructure within Docker and Kubernetes.
It simplifies the deployment, monitoring, and scaling of containers, making it easier to manage complex infrastructure.
Thus, with Portainer, teams can streamline their workflows and gain full control over their containerized ecosystem.
This guide covers deploying Portainer on Docker, Docker Swarm, and Kubernetes, plus Edge agents and upgrades.

Source: https://kbve.com/application/portainer/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';


<Aside>

Portainer is a web-based container management software that helps maintain [Docker](/application/docker/) and [Kubernetes](/application/kubernetes/) clusters within the eco-system.

</Aside>

## Information

This expert document covers the advanced configuration and deployment of Portainer across Docker, Docker Swarm, and Kubernetes environments.
Portainer’s intuitive interface provides granular control over containerized infrastructure, making it a vital tool for DevOps professionals and system administrators.
We'll start by detailing the setup process for Docker, including best practices for connecting to remote Docker hosts and securing the Portainer instance.
For Docker Swarm, we'll explore strategies for managing multi-node clusters, handling service updates, and integrating external storage solutions.
In the Kubernetes section, we'll dive into deploying Portainer within a k8s cluster using Helm charts and managing complex workloads with namespaces and RBAC policies.
We'll also cover advanced monitoring configurations using Portainer’s agent and extensions to gain insights into resource usage and performance.
Throughout this guide, you’ll find recommendations for optimizing container orchestration and maintaining high availability.
Whether you're managing a small development environment or a large-scale production system, this guide will provide the expertise needed to master Portainer’s capabilities.

---

<Adsense />

## Docker

Portainer needs two things on Docker: a persistent volume for its own data, and access to the Docker socket so it can manage the engine. You can deploy it with Compose or the raw CLI.

### Compose

The declarative option — save as `docker-compose.yml` and run `docker compose up -d`:

```yaml
services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: always
    ports:
      - "8000:8000"
      - "9443:9443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data

volumes:
  portainer_data:
```

Port `9443` serves the HTTPS UI; `8000` is the tunnel port used by Edge agents. The Docker socket mount is what lets Portainer see and control containers on the host.

<Aside type="caution">
Mounting `/var/run/docker.sock` grants Portainer root-equivalent control of the host. Restrict who can reach port `9443`, and set a strong admin password on first login — the setup screen locks after a few minutes for security.
</Aside>

-   For Docker [Compose](/application/portainer#compose)

-   Docker CLI

    -   Step by Step Docker Command Line

        -   1. Portainer will need a volume, `portainer_data`, to operate from.

            ```shell
            docker volume create portainer_data
            ```

        -   2. Option A - Community Edition

            -   We will have docker pull and run the CE portainer.

                ```shell
                docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest
                ```

        -   3. Option B - Business Edition

            -   BE is the premium commercial licensed version that unlocks all components within the enterprise suite.

                ```shell
                docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ee:latest
                ```

            -   If you wish to run the BE/EE version of portainer, setup the CE first, register for the BE key / license and then upgrade.
            -   Note: Portainer Business Edition requires a license key ahead of time. They may have a freemium option for up to 5 nodes.

### Swarm

For Swarm upgrades, we recommend that you snapshot / backup the container, as well as, make sure everything is stable and up-to-date.

It is recommended that you check the current instances of `portainer_portainer` and `portainer_agent`.

For Community Edition, the documentation recommends these following commands:

```shell
docker pull portainer/portainer-ce:latest
docker service update --image portainer/portainer-ce:latest --publish-add 9443:9443 --force portainer_portainer
```

After that was successfully upgraded, then move towards upgrading the portainer agent to the latest version with these commands below:

```shell
docker pull portainer/agent:latest
docker service update --image portainer/agent:latest --force portainer_agent
```

Now that the control center has the updated portainer and portainer agent, go ahead and use portainer to update the agent across the swarms.
To do this, you can manually update it via the shell

## Kubernetes

-   Step-by-Step Kubernetes Breakdown

    -   1. Create the namespace `portainer` using `kubectl`. Below is the example command.

        ```shell
            kubectl create namespace portainer
        ```

    -   2. Inside of the namespace,`$portainer`, use `kubectl` apply with the official manifest.

        ```shell
            kubectl apply -n portainer -f https://raw.githubusercontent.com/portainer/k8s/master/deploy/manifests/portainer/portainer.yaml
        ```

    -   3. The default location will be returned from the manifest, located at port 30777.

---

### Kubernetes Agent Upgrade

The current method for upgrade Portainer Agent through AWX would be to execute these following commands:

```shell
sudo kubectl delete namespace portainer
sudo kubectl apply -n portainer -f https://downloads.portainer.io/ce2-16/portainer-agent-k8s-lb.yaml
```

This will delete the existing portainer agent (which would be under the namespace of `portainer`) and then re-deploy the newer `ce2-16`.

However these notes are for Portainer Agent 2.16.1 / 11/18/2022. We will update these once there is another major release.

---

## Edge

-   Setup
    -   From Portainer, you must obtain the EDGE_ID and EDGE_KEY , both will be used to help organize the `{$EDGE_DEVICE}` within the hybrid cloud.
    -   For network automation within the `{$EDGE_DEVICE}` we recommend that you use `Consul` application from Hashicorp.
    -   For service automation within the `{$EDGE_DEVICE}` we recommend that you use `Terraform` application from Hashicorp.
    -   Finally, after establishing the automation, we use `Ansible` to execute commands to `Terraform`,`Consul` and `Portainer`.
-   Scale
    -   15000 `{$EDGE_DEVICE}` with a polling frequency of 5 seconds will generate about 7 mbps of network traffic and require 4 CPUs to handle the encryption / tunnel load, according to Portainer.

---

## Upgrades

Upgrading Portainer ensures access to the latest features, security patches, and performance improvements.
Before upgrading, always back up your Portainer data to prevent any potential loss.
Depending on your environment (Docker, Swarm, or Kubernetes), different upgrade strategies may apply, such as using Docker Compose or Helm charts. It’s recommended to test upgrades in a staging environment before applying them to production. For detailed steps and best practices, refer to the [Official Docs](https://docs.portainer.io/start/upgrade/) on upgrading Portainer.

---

## FAQ

**What is Portainer used for?**
Portainer is a web-based management UI for containers. It gives a visual dashboard to deploy, monitor, and manage [Docker](/application/docker/), Docker Swarm, and [Kubernetes](/application/kubernetes/) environments without memorizing CLI commands, with role-based access control for teams.

**What is the difference between Portainer CE and Business Edition?**
Community Edition (CE) is free and open-source with core container management. Business Edition (BE/EE) is the commercial version that adds RBAC, registry management, and support. BE requires a license key, though a free tier covers up to a small number of nodes.

**How do I install Portainer on Docker?**
Create a `portainer_data` volume, then run the `portainer/portainer-ce` image with the Docker socket mounted at `/var/run/docker.sock` and ports `8000` and `9443` published. Portainer's UI is then reachable over HTTPS on port `9443`.

**What is a Portainer Edge agent?**
The Edge agent connects remote or air-gapped Docker/Kubernetes hosts back to a central Portainer instance using an `EDGE_ID` and `EDGE_KEY` over an outbound tunnel. It lets one Portainer manage many distributed environments without exposing each host's API.

<Adsense />

---
# Proxmox

> Proxmox VE is an open-source virtualization platform built on Debian that runs KVM virtual machines and LXC
containers with a web UI, CLI, and REST API. This guide covers the qm and pct command cheatsheet, container
networking with netplan, Windows VM setup with VirtIO drivers, and theming.

Source: https://kbve.com/application/proxmox/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';


## Information

Proxmox is an exquisite open-source server platform that empowers you to orchestrate and administer virtual machines, containers, storage, networking, and backup.
It is based on Linux (Debian operating system) and uses KVM (qEMU) and LXC as virtualization technologies.
Proxmox offers a web interface for easy administration, as well as command-line interface/tools and a RESTful API.
The objective of this software is provide a base-line to build your own paradigm style hybrid cloud through HA (High Avalibity), CEPH and load balancing built-in.

> Hint: Utilize the PAM/PVE settings within Proxmox to secure and abstract the system authentication.

This page is a working reference: the [command cheatsheet](#cheatsheet) for `qm` (VMs) and `pct` (containers), [container networking](#network) with netplan, [Windows VM setup](#windows) including VirtIO drivers, and [theming](#style).

<Adsense />

## Cheatsheet

Proxmox Cheatsheet for quick commands and below are the basic CLI (command-line interface)

### QEMU

-   qEMU
    -   `man qm`
    -   `qm list` - List qEMUs on the server.
    -   `qm start $v_id` - Start the specific virtual machine (qEMU).
    -   `qm shutdown $v_id` - Shutdown the specific vm (qEMU).
    -   `qm reboot $v_id` - Reboot the specific vm (qEMU).
    -   `qm resume $v_id` - Resume the specific vm (qEMU).
    -   `qm reset $v_id` - Reset the specific vm (qEMU).
    -   `qm stop $v_id` - Stop the specific vm (qEMU).
    -   `qm config $v_id` - Configure the specific vm (qEMU).
    -   `qm set -onboot 1 $v_id`

### LXC

-   Proxmox Container
    -   `man pct`
    -   `pct list` - List all containers on the server. (LXC)
    -   `pct listsnapshot` - List all snapshots
    -   `pct start $v_id` - Start container by the specific $v-ID.
    -   `pct shutdown $v_id` - Shutdown container by specific $v-ID.
    -   `pct reboot $v_id` - Reboot container by specific $v-ID.
    -   `pct config $v_id` - Configure container by specific $v-ID.
    -   `pct set -memory $v_ram $v_id` - Set the memory for container.
        -   Example: `pct set -memory 1024 420`
        -   `$v_ram` is in megabytes by default.
    -   `pct enter $v_id` - Enter the terminal of the container (LXC).

---

## Network

-   Proxmox has several types of networking options and integrations. We will go over the basics here and slowly expand to different concepts afterwards.
-   The default ports for proxmox are `8006` for the web panel, which you can log in via PAM/Proxmox PVE and `85` for the PvEDaemon. To double check the ports, run `nmap 127.0.0.1 -p-` to see the two open ports and then run `netstat -nlp | grep -E ":85|:8006"` to get more information.

### Network Config (OVH)

-   Initial IPv4 Configuration during Install

-   ```yaml
    Subnet: XXX.XXX.XXX.XXX/32
    Address: XXX.XXX.XXX.XXX
    Gateway: DDD.DDD.DDD.DDD
    Name Servers: 208.67.222.222, 208.67.220.220
    Search Servers: fqdn.com
    #XXX.XXX.XXX.XXX is the IP of the container.
    #DDD.DDD.DDD.DDD is the IP of the dedicated server.
    ```

-   **NOTE:** As it turns out, this doesn't work, and we're not sure if it will ever work.

-   Ubuntu 22.04 LTS netplan config for container

    -   ```yaml
            network:
                version: 2
                ethernets:
                    ens18:
                        dhcp4: false
                        addresses: [XXX.XXX.XXX.XXX/32] # The IP of the container
                        routes:
                            - to: 0.0.0.0/0
                                via: XXX.XXX.XXX.254 # The first three octets of the host
                                on-link: true
                        nameservers:
                            addresses: [1.1.1.1, 1.0.0.1] # Default Nameservers (Shouldn't matter)
                            #addresses: [208.67.222.222, 208.67.220.220] # OVH Nameservers
        ```

-   **NOTE:** If you've set up the ubuntu box using the minimized version (which lacks vim, nano, etc), move or delete the existing `00-installer-config.yaml` and run `cat <<EOF >>00-installer-config.yaml` followed by the configuration above.
-   After updating the yaml, go ahead and run:

-   ```shell
      sudo netplan apply
    ```

-   Test the command by pinging a domain (google.com) and an IPv4 (8.8.8.8), making sure that it works!

## Windows

This is a generic guide to installing and setting up windows.

### Windows Audio

When booting up the Windows KVM, there has to be an audio configuration that has to be setup for the qemu server.

Grab the qEMU server id from the proxmox list, then go to `/etc/pve/qemu-server/$VMID.conf`, replacing the `$VMID` with the ID.

Then add this to the `args`:

```ini

args: -device intel-hda,id=sound5,bus=pci.0,addr=0x18 -device hda-micro,id=sound5-codec0,bus=sound5.0,cad=0 -device hda-duplex,id=sound5-codec1,bus=sound5.0,cad=1

```

If this is a fresh install, then you can add the args configuration at the bottom of the file.

### Windows Error

Quick and short solutions to common window errors that we faced when deploying.

### VirtIO Drivers

There are two drivers that you can use, the `stable` and `latest` iso.
To add them into your Proxmox instance, go to the iso folder, located below and then download the right driver ISO.

```shell
cd /var/lib/vz/template/iso
```

-   Stable

```shell
wget https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso
```

-   Latest (in the case if Stable does not work.)

```shell
wget https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/latest-virtio/virtio-win.iso
```

After downloading the right ISO, attach it to your KVM/QEMU instance and then reboot the machine. After the reboot, go to `My Computer` and run the iso to install the proper drivers.

---

## Notes

-   eXtremeSHOCK Optimization / Post Install Scripts located below
    -   [Repo](https://github.com/extremeshok/xshok-proxmox)

## Style

-   Dark Mode Theme for Proxmox
    -   Installation Script located here: [Github PVEDiscordDark](https://github.com/Weilbyte/PVEDiscordDark)
    -   The script alters the css / js , so that the panel has a "Dark" / Discord theme base.
    -   `bash <(curl -s https://raw.githubusercontent.com/Weilbyte/PVEDiscordDark/master/PVEDiscordDark.sh ) install`

## Podcast

General jokes/memes about the proxmox and general weird methods.
We were trying to find a cute and creative way to introduce the vast realm of virtual machines.

---

## Jokes

Dock Swarm

```yaml
# Setting up Docker Swarm on multiple Proxmox VE containers
#> Ziggy9263 (@jzanecook), h0lybyte (@KBVE)

## 1. Introduction

### 1.a. Crack your head against a wall

#> The important thing to remember is that any all things that go horribly wrong can and will do so.
#> Ziggy9263, from the docker container he has found himself trapped in

#In order to begin working on a Docker Swarm, first you need to brush up on the general concepts behind the entire premise of this system. There are no winners, and there are no losers, there are only those who have discovered the wonders of setting up Docker Swarm, and those who have wandered a little too close to the wonders and have developed a pus filled growth on their abdomen.

#If you have begun emitting a yellowish bioluminescence from your fingertips or have developed a large green and cyan vein stretching from your lower cheek to your posterior, then this article is not for you, and it's too late.

#Otherwise, if you've simply peered over the edge of this foreign landscape, not yet realizing that the brush you're walking through is toxic in nature due to the radiation left from previous swarms, then this article may come in handy in your short lived traversal from bomb stricken wasteland to the maw of the amorphous creature you accidentally brought to your doorstep while typing `docker stack deploy`.

#In the following sections, we'll go over the process of:
#-> Setting up Proxmox VE (7.2.1)
#-> Installing Proxmox Darkmode for Comfort
#-> Setting up `vmbr1` for Internalized Networking
#-> Setting up Traefik
#-> Minimizing DUIs
#-> Initializing a Docker Swarm
#-> Creating Nodes and Keeping Order via Quorum
#-> Creating Replicants and how to keep Rick Deckard off your ass
#-> Creating Reverse Proxies for your Nodes

### 1.b. Invest in your retirement fund

#If you haven't already, it's important that you do before it's too late. This article, however, will not help you with that.

## 2. Proxmox
### 2.a. Setting up Proxmox VE (7.2.1)
### 2.b. Installing Proxmox Darkmode for Comfort
### 2.c. Setting up `vmbr1` for Internalized Networking

## 3. Traefik
### 3.a. Setting up Traefik (Version Number Here h0ly don't forget version number here version number don't forget)
### 3.b. Minimizing DUIs

## 4. Docker Swarm
### 4.a. Initializing a Docker Swarm
### 4.b. Creating Nodes and Keeping Order via Quorum
### 4.c. Creating Replicants and how to keep Rick Deckard off your ass
#In case you aren't in the know like cool guy Jones, Rick Deckard is from Bladerunner and he hunts stray replicants, the premise here don't let replicants go stray.
### 4.d. Creating Reverse Proxies for your Nodes
```

---

## FAQ

**What is Proxmox VE?**
Proxmox Virtual Environment is an open-source server virtualization platform based on Debian Linux. It runs KVM/QEMU virtual machines and LXC containers under one web interface, with clustering, high availability, Ceph storage, and backups built in.

**What is the difference between `qm` and `pct` in Proxmox?**
`qm` manages KVM/QEMU virtual machines (full hardware virtualization), while `pct` manages LXC containers (lightweight OS-level virtualization). For example `qm start <id>` boots a VM and `pct start <id>` starts a container.

**What port is the Proxmox web interface on?**
The Proxmox web panel listens on port `8006` over HTTPS, and the PVEDaemon uses port `85`. You log in with PAM or Proxmox PVE authentication. Confirm the open ports with `nmap 127.0.0.1 -p-` or `netstat`.

**How do I install VirtIO drivers on a Windows VM in Proxmox?**
Download the VirtIO ISO into `/var/lib/vz/template/iso` with `wget`, attach it to the Windows KVM as a second CD drive, reboot, and run the installer from the ISO so Windows recognizes the paravirtualized disk and network devices.

<Adsense />

---
# Python

> Python is a general-purpose, high-level programming language known for its readability and versatility.
This guide covers installing Python on Windows, macOS, and Linux, managing virtual environments and pip,
and building typed web APIs with FastAPI, Pydantic, and Haystack.

Source: https://kbve.com/application/python/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

Python is a high-level, interpreted language prized for readable syntax and a vast ecosystem, spanning web development, data science, machine learning, and automation. Its interpreter runs on every major platform, and its package manager (`pip`) plus virtual environments make per-project dependency isolation straightforward.

This guide moves from setup to real APIs: [install Python](#setup) on Windows, macOS, and Linux, isolate dependencies with [virtual environments](#virtual-environments) and [pip](#pip), then build typed web services with [FastAPI](#fastapi), [Pydantic](#pydantic), and [Haystack](#haystack).

## Information

Python is a high-level, interpreted [programming](https://kbve.com/theory/programming/) language known for its clear syntax and readability, making it excellent for beginners and experienced developers alike.
It supports multiple programming paradigms, including procedural, object-oriented, and functional programming.
Python's vast ecosystem of libraries and frameworks—such as Django for web development, Pandas for data analysis, and TensorFlow for machine learning—makes it incredibly versatile for a wide range of applications.

Python is widely used in scientific computing, data mining, and [artificial intelligence](/application/ml/), thanks to its simplicity and the powerful libraries that extend its capabilities. It's also a favorite for automation, scripting, and rapid application development across diverse fields.
The language's design and module architecture encourage code reusability and maintainability.

<Adsense />

## Setup

These are various tutorials for setting up python on different operating systems!

### Windows

<Steps>

1. **Download Python Installer:**

    - Go to the [official Python website](https://www.python.org/).
    - Click on the "Downloads" section and select the latest version for Windows.

2. **Run the Installer:**

    - Double-click the downloaded file to run the installer.
    - Check the box that says "Add Python to PATH."
    - Click on "Customize installation" if you want to choose specific features, otherwise, click on "Install Now."

3. **Verify the Installation:**
    - Open Command Prompt (Win + R, type `cmd`, and press Enter).
    - Type `python --version` and press Enter. You should see the Python version you installed.
    - Also, check `pip` (Python package installer) by typing `pip --version`.

</Steps>

### macOS

<Steps>

1. **Download Python Installer:**

    - Go to the [official Python website](https://www.python.org/).
    - Click on the "Downloads" section and select the latest version for macOS.

2. **Run the Installer:**

    - Open the downloaded `.pkg` file and follow the installation instructions.
    - The installer will automatically add Python to your PATH.

3. **Verify the Installation:**
    - Open Terminal (Cmd + Space, type `Terminal`, and press Enter).
    - Type `python3 --version` and press Enter. You should see the Python version you installed.
    - Also, check `pip3` by typing `pip3 --version`.

</Steps>

### Linux (Ubuntu)

<Steps>

1. **Update and Upgrade System:**

    - Open Terminal (Ctrl + Alt + T).
    - Run the following commands:
        ```bash
        sudo apt update
        sudo apt upgrade
        ```

2. **Install Python:**

    - Run the command to install Python (replace `3.x` with the version you want, e.g., `3.10`):
        ```bash
        sudo apt install python3.x
        ```
    - Install `pip`:
        ```bash
        sudo apt install python3-pip
        ```

3. **Verify the Installation:**
    - Type `python3 --version` and press Enter. You should see the Python version you installed.
    - Also, check `pip3` by typing `pip3 --version`.

</Steps>

---

## Virtual Environments

<Steps>

1.  **Install `virtualenv`:**

    ```bash
    pip3 install virtualenv
    ```

2.  Create a virtual environment:

    ```bash
    virtualenv myenv
    ```

3.  Activate the virtual environment:

    -   Windows: `myenv\Scripts\activate`
    -   macOS/Linux: `source myenv/bin/activate`
    -   Deactivate the virtual environment by typing `deactivate`.

</Steps>

---

## pip

-   `pip` is the package manager for Python. It is used to install and manage software packages written in Python.

`pip` is included with most Python distributions, and it can be installed separately for other distributions.

To use `pip`, you need to know the name of the package you want to install.
You can find the name of the package by searching the Python Package Index (PyPI).

Once you know the name of the package, you can install it with the following command:

```shell
pip install <$package_name>
```

Replacing the syntax of `<$package_name>` with the package you would like to install from the PyPI libraries.

In this example, we will look into the install of the `requests` package via `pip`.

```shell
pip install requests
```

<Steps>

1. **Install Packages Using `pip`:**

    - To install a package:
        ```bash
        pip install package_name
        ```
    - To list installed packages:
        ```bash
        pip list
        ```

2. **Upgrade `pip`:**
    - Run the command:
        ```bash
        python -m pip install --upgrade pip
        ```

</Steps>

---

## FastAPI

FastAPI is a modern and fast web framework designed for building APIs with Python 3.7+ using standard Python type hints.
Offering high performance, FastAPI leverages asynchronous programming to achieve speeds comparable to those of Node.js and Go, making it ideal for developing scalable and efficient web applications.
The framework is built on top of Starlette for handling web components and Pydantic for data validation and serialization, ensuring smooth data management.
FastAPI stands out for its automatic interactive API documentation, featuring Swagger UI and ReDoc, which simplifies the process of exploring and testing API endpoints.
The framework also supports OAuth2 authentication with JWT tokens, making it a robust choice for secure API development.
Additionally, FastAPI's design focuses on developer productivity, reducing code duplication and enhancing maintainability.
By providing built-in support for data validation, serialization, and interactive documentation, FastAPI accelerates the development process, making it a popular choice for both small projects and large-scale enterprise applications.

### Tutorial on Setting Up FastAPI

<Steps>

0.  **Prepare Dev Environment**:

    Ensure that Python 3.7 or later is installed on your system.
    You can download the latest version from the [official Python website](https://www.python.org/).
    Follow the installation instructions for your operating system.
    Verify the installation by opening a terminal or command prompt and running:

    ```sh
    python --version
    ```

    This should display the installed Python version.

    Creating a virtual environment is a good practice to manage project dependencies.
    In your terminal or command prompt, navigate to your project directory and run:

    ```sh
    python -m venv env
    ```

    This command creates a virtual environment named `env`. Activate the virtual environment by running:

        - On Windows:

        ```sh
        .\env\Scripts\activate
        ```

        - On macOS/Linux:
        ```sh
        source env/bin/activate
        ```

1.  **Install FastAPI and Uvicorn**:

    FastAPI requires an ASGI server to run. Uvicorn is a recommended ASGI server for FastAPI. Install FastAPI and Uvicorn within your virtual environment by running:

    ```sh
    pip install fastapi uvicorn
    ```

    This command installs both FastAPI and Uvicorn, enabling you to build and serve your API.

2.  **Create a Basic FastAPI Application**:

    Organize your project directory with a simple file tree structure to keep everything neat and manageable.

    <FileTree>

    -   my_fastapi_project/
        -   main.py
        -   requirements.txt
    -   .gitignore

    </FileTree>

    -   **main.py:** The main application file where the FastAPI app is defined.
    -   **requirements.txt:** A file to list project dependencies, including `fastapi` and `uvicorn`.
    -   **.gitignore:** A file to specify which files and directories to ignore in version control (optional, but recommended).

    Create a new Python file in your project directory, for example, `main.py`.
    Open this file in a text editor and add the following code:

    ```python
    from fastapi import FastAPI

    app = FastAPI()

    @app.get("/")
    async def read_root():
        return {"Hello": "World"}

    @app.get("/items/{item_id}")
    async def read_item(item_id: int, q: str = None):
        return {"item_id": item_id, "q": q}
    ```

    This code defines a basic FastAPI application with two endpoints: a root endpoint (`/`) that returns a simple greeting and an endpoint (`/items/{item_id}`) that returns an item ID and an optional query parameter.

3.  **Run the FastAPI Application**:

    Use Uvicorn to run your FastAPI application. In your terminal or command prompt, navigate to your project directory and run:

    ```shell
    uvicorn main:app --reload
    ```

    The `--reload` option enables automatic reloads when code changes are detected, which is useful for development.
    Open a web browser and navigate to `http://127.0.0.1:8000` to see the greeting message.
    Visit `http://127.0.0.1:8000/items/1?q=test` to see the item endpoint in action.

4.  **Explore Automatic Interactive API Documentation**:

    FastAPI provides interactive API documentation automatically.
    With your application running, navigate to `http://127.0.0.1:8000/docs` to see the Swagger UI.
    This interface allows you to interact with your API endpoints directly from the browser.
    Another documentation interface is available at `http://127.0.0.1:8000/redoc`.

5.  **Add More Functionality**:

    Expand your FastAPI application by adding more routes, handling different HTTP methods, and integrating data validation.
    FastAPI’s documentation provides detailed guidance on various features, including path parameters, query parameters, request bodies, and response models.

    Let us begin by installing `Pydantic`, here is a quick command to do so:

    ```shell
    pip install pydantic
    ```

    Next, to add a POST endpoint for creating items, modify `main.py`:

    ```python
    from fastapi import FastAPI, HTTPException
    from pydantic import BaseModel

    app = FastAPI()

    class Item(BaseModel):
        name: str
        price: float
        is_offer: bool = None

    @app.post("/items/")
    async def create_item(item: Item):
        return item
    ```

    This code defines an `Item` model using Pydantic and a POST endpoint that accepts an `Item` and returns it.

    By following these steps, you will have a fully functional FastAPI application ready for further development and customization.

</Steps>

---

## Pydantic

Pydantic is a powerful data validation and settings management library for Python, leveraging Python type annotations to ensure robust and reliable data handling.
By defining data models through type hints, Pydantic automates the validation and parsing process, converting input data into the appropriate types and structures.
This functionality is particularly beneficial in scenarios requiring strict data integrity, such as API development and configuration management.
Pydantic supports various standard library types, custom data types, and even complex nested data structures.

Built with performance in mind, Pydantic's core validation logic is implemented in Rust, making it one of the fastest data validation libraries available.
The library also includes features like JSON Schema generation, custom validators, and the ability to run in strict or lax modes, allowing for flexible data coercion and validation.
With broad adoption, including use by major companies and integration with popular frameworks like FastAPI, Pydantic has become a cornerstone in the Python ecosystem for data validation.


### Pydantic Tutorial

<Steps>

0.  **Setting up your project**:

    First, create a new directory for your project.

    ```bash
    mkdir pydantic_project
    cd pydantic_project
    ```

    **Set Up a Virtual Environment**:
    
    Create and activate a virtual environment.

    ```bash
    python3 -m venv venv
    source venv/bin/activate  # On Windows use `venv\Scripts\activate`
    ```

    **Install Pydantic**
    Install Pydantic via pip.

    ```bash
    pip install pydantic
    ```

1.  **Project Structure**:

    Create the following project structure:

    <FileTree>

    - pydantic_project/
        - venv/
        - main.py
        - models/
            - user.py
        - utils/
            - helpers.py
    - .gitignore
    - README.md
    </FileTree>

2.  **Create Pydantic Models**:
        
    Create a Pydantic model in `models/user.py`.

    ```python
    # models/user.py
    from pydantic import BaseModel, EmailStr, Field
    from typing import List, Optional
    from datetime import date

    class Address(BaseModel):
        street: str
        city: str
        state: str
        zip_code: str

    class User(BaseModel):
        id: int
        name: str = Field(..., max_length=100)
        email: EmailStr
        is_active: bool = True
        addresses: List[Address] = []
        date_of_birth: Optional[date] = None

        class Config:
            schema_extra = {
                "example": {
                    "id": 1,
                    "name": "John Doe",
                    "email": "john.doe@example.com",
                    "is_active": True,
                    "addresses": [
                        {
                            "street": "123 Main St",
                            "city": "Anytown",
                            "state": "CA",
                            "zip_code": "12345"
                        }
                    ],
                    "date_of_birth": "1990-01-01"
                }
            }
    ```

3.  **Create Helper Functions**:

    Create helper functions in `utils/helpers.py`.

    ```python
    # utils/helpers.py
    from models.user import User, Address
    from typing import List

    def create_user(data: dict) -> User:
        return User(**data)

    def filter_active_users(users: List[User]) -> List[User]:
        return [user for user in users if user.is_active]

    def add_address_to_user(user: User, address_data: dict) -> User:
        address = Address(**address_data)
        user.addresses.append(address)
        return user
    ```

4.  **Main Application Logic**:

    Create the main application logic in `main.py`.
        
    ```python
    # main.py
    from models.user import User
    from utils.helpers import create_user, filter_active_users, add_address_to_user

    # Sample user data
    user_data = {
        "id": 1,
        "name": "John Doe",
        "email": "john.doe@example.com",
        "is_active": True,
        "addresses": [
            {
                "street": "123 Main St",
                "city": "Anytown",
                "state": "CA",
                "zip_code": "12345"
            }
        ],
        "date_of_birth": "1990-01-01"
    }

    # Create a user
    user = create_user(user_data)
    print(user)

    # Add a new address to the user
    new_address = {
        "street": "456 Elm St",
        "city": "Othertown",
        "state": "NY",
        "zip_code": "67890"
    }
    user = add_address_to_user(user, new_address)
    print(user)

    # Filter active users
    users = [user, create_user({**user_data, "id": 2, "is_active": False})]
    active_users = filter_active_users(users)
    print(active_users)
    ```

5.  **Run Your Application**:

    Run your application using the following command:

    ```bash
    python main.py
    ```

6.  **Extending Valdiation**:

    Pydantic automatically validates data. For instance, if you try to create a user with an invalid email, it will raise a `ValidationError`.

    **Custom Validators**
    You can add custom validation methods within your model.

    ```python
    from pydantic import validator

    class User(BaseModel):
        # ... (other fields)

        @validator('name')
        def name_must_be_capitalized(cls, v):
            if not v.istitle():
                raise ValueError('Name must be capitalized')
            return v
    ```

    **Serialization and Deserialization**
    Pydantic models can easily be serialized to and deserialized from JSON.

    ```python
    user_json = user.json()
    new_user = User.parse_raw(user_json)
    ```

    **Schema Generation**
    Pydantic can generate JSON Schemas for your models.

    ```python
    print(User.schema_json(indent=2))
    ```

</Steps>

You now have a detailed setup for a Pydantic project with models, helper functions, and application logic.
Do not forget, you can extend this project further by adding more models, complex validation, and integrating with other parts of your application.

---

## Haystack

Haystack is an advanced Python library designed to simplify the creation of search systems and question-answering applications.
It leverages natural language processing (NLP) to allow developers to build powerful search interfaces that can understand and process user queries in a human-like manner.
With Haystack, users can integrate various NLP models, connect to document stores, and implement sophisticated retrieval mechanisms.
It supports multiple backends, including Elasticsearch and FAISS, enabling flexible and scalable search solutions.
Additionally, Haystack offers features like end-to-end pipelines, real-time updates, and integration with external data sources, making it a versatile tool for modern information retrieval tasks.

---

## FAQ

**How do I create a Python virtual environment?**
Run `python -m venv .venv` to create an isolated environment in a `.venv` folder, then activate it with `source .venv/bin/activate` on macOS/Linux or `.venv\Scripts\activate` on Windows. Packages you install with pip then stay scoped to that project.

**What is the difference between pip and a virtual environment?**
`pip` is Python's package installer; a virtual environment is an isolated directory of Python and its packages. You use pip inside a virtual environment so each project has its own dependency versions without polluting the global system Python.

**What is FastAPI used for?**
FastAPI is a modern Python web framework for building APIs. It uses standard type hints and Pydantic models for automatic request validation and generates interactive OpenAPI documentation, while running on ASGI for high async performance.

**What is Pydantic?**
Pydantic is a data-validation library that uses Python type hints to parse and validate data at runtime. It powers FastAPI's request and response models, coercing and checking incoming JSON against your declared types and raising clear errors on mismatch.

**Which Python version should I use?**
Use the latest stable Python 3 release for new projects to get current syntax, performance, and security fixes. Pin the version per project with a virtual environment or a tool like `pyenv` so upgrades never break existing work.

<Adsense />

---
# Redis

> Redis is an open-source, in-memory data structure store used as a database, cache, and message broker.
This guide covers running Redis with Docker Compose, deploying it on Kubernetes as a StatefulSet, and
connecting with the redis-cli. Redis supports strings, hashes, lists, sets, sorted sets, bitmaps,
hyperloglogs, geospatial indexes, and streams.

Source: https://kbve.com/application/redis/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

Redis is an in-memory data structure store used as a cache, database, and message broker. It keeps data in RAM for microsecond reads and writes, with optional disk persistence (RDB snapshots and AOF logs) so data survives restarts. This guide runs Redis three ways — with Docker Compose for local development, on Kubernetes as a StatefulSet for production, and directly through the `redis-cli` for testing and debugging.

## Information

Redis, traditionally recognized as a high-performance in-memory data structure store, has evolved to serve as a versatile meta-engine for data object storage.
Leveraging its lightning-fast data retrieval capabilities, Redis can manage metadata about larger data objects stored elsewhere, acting as a dynamic indexing layer.
This allows applications to swiftly locate and access objects based on attributes or tags stored in Redis, bridging the gap between high-speed data access and bulk storage.
When used in this capacity, Redis enhances storage architectures by providing rapid, real-time insights into vast data landscapes without compromising on efficiency or performance.

<Adsense />

## Core Data Structures

Redis is more than a key-value cache — each value can be one of several native data structures, each with commands optimized for a specific access pattern.

| Structure | Description | Common Use |
| --------- | ----------- | ---------- |
| **String** | Binary-safe value up to 512 MB | Cache, counters (`INCR`), flags |
| **Hash** | Field-value map under one key | Store an object (user profile) compactly |
| **List** | Ordered, linked list | Queues, activity feeds (`LPUSH`/`BRPOP`) |
| **Set** | Unordered unique members | Tags, unique visitors, membership tests |
| **Sorted Set** | Members ranked by score | Leaderboards, rate limiting, priority queues |
| **Stream** | Append-only log with consumer groups | Event sourcing, message queues |
| **Bitmap / HyperLogLog** | Space-efficient counting | Daily active users, cardinality estimates |

Choosing the right structure is the single biggest Redis performance decision — a sorted set leaderboard answers "top 10" in `O(log N)` where a naive list would be `O(N log N)`.

## Persistence: RDB vs AOF

By default Redis holds data in RAM, but it offers two persistence modes so data survives restarts. They can run together.

- **RDB (snapshots)** — Periodically forks and writes a compact point-in-time dump (`dump.rdb`). Fast restarts and small files, but you can lose everything since the last snapshot on a crash.
- **AOF (append-only file)** — Logs every write command and replays it on restart. Far more durable (`appendfsync everysec` loses at most one second), at the cost of larger files and slightly slower writes.

<Aside type="tip">
For a cache, RDB alone is fine — losing a few seconds of cache is harmless. For Redis as a primary datastore, enable AOF (`--appendonly yes`) for durability, optionally alongside RDB for fast restarts.
</Aside>

## Redis Docker Integration

### Using Docker Compose

Integrating Redis with Docker Compose empowers developers to create consistent, reproducible, and scalable Redis environments. 
Known for its exceptional speed and flexibility, Redis becomes even more effective when combined with Docker Compose.
This pairing significantly boosts the operational resilience of applications and integrates smoothly into the broader application ecosystem.

The real transformation comes in how this integration redefines development workflows.
With Docker Compose, developers can simulate production-like conditions on their local machines, eliminating the common discrepancies between development and production environments.
This approach not only improves efficiency and precision during the development phase but also significantly boosts developers' confidence.
By testing and iterating in an environment that closely mirrors the final production setting, developers can ensure higher quality and reliability in their deployments.

A minimal `docker-compose.yml` runs a password-protected Redis with a persistent volume:

```yaml
services:
  redis:
    image: redis:7-alpine
    container_name: kilobase-redis
    command: ["redis-server", "--requirepass", "redispassword", "--appendonly", "yes"]
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    restart: unless-stopped

volumes:
  redis-data:
```

Bring it up with `docker compose up -d`. The `--appendonly yes` flag enables AOF persistence so data survives container restarts, and the named `redis-data` volume keeps it across `docker compose down`.

## Redis on Kubernetes

Deploying Redis on Kubernetes offers scalable and resilient solutions for managing in-memory data. 
[Kubernetes](/application/kubernetes/), a powerful orchestration platform for containerized applications, enhances Redis's capabilities, making it well-suited for high-demand environments that require rapid scalability and high availability.

### Benefits of Redis on Kubernetes

- **Scalability**: Kubernetes can automatically scale Redis instances based on traffic demands, ensuring that your application maintains high performance under varying load conditions.
- **High Availability**: By running Redis on Kubernetes, you can take advantage of Kubernetes’ self-healing features such as automatic restarts of failed Redis pods to minimize downtime.
- **Simplified Management**: Kubernetes simplifies the deployment and management of Redis clusters. Using Kubernetes’ services and deployments, you can easily manage complex Redis configurations and persistent storage.

### Typical Configuration

1. **StatefulSet**: Redis is typically deployed as a StatefulSet in Kubernetes. This ensures that each Redis instance retains a stable pod identity and storage across pod rescheduling and restarts.
2. **Persistent Volumes**: To ensure data persistence, Redis pods are configured with persistent volumes that are managed by Kubernetes. This setup protects data even if Redis pods are restarted.
3. **ConfigMaps and Secrets**: Redis configuration files and sensitive information such as passwords are managed using Kubernetes ConfigMaps and Secrets, ensuring secure and flexible configuration.
4. **Load Balancing**: Kubernetes Services are used to load balance requests across Redis pods, improving the distribution of client traffic and enhancing overall performance.

Deploying Redis with Kubernetes not only improves operational efficiency but also leverages cutting-edge technology to support dynamic, large-scale applications.

A minimal StatefulSet with a headless Service and a per-pod persistent volume:

```yaml
apiVersion: v1
kind: Service
metadata:
  name: redis
spec:
  clusterIP: None
  selector:
    app: redis
  ports:
    - port: 6379
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis
spec:
  serviceName: redis
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
        - name: redis
          image: redis:7-alpine
          args: ["--appendonly", "yes"]
          ports:
            - containerPort: 6379
          volumeMounts:
            - name: data
              mountPath: /data
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 1Gi
```

The `clusterIP: None` headless Service gives each pod a stable DNS name (`redis-0.redis`), and `volumeClaimTemplates` provisions a dedicated PVC per replica so data survives rescheduling.

* * *

### Redis CLI

You can interact directly with your Redis instance using the `redis-cli` command-line tool — perfect for quick testing, debugging, or peeking under the hood.

Thus, to connect to a redis instance via the cli:

```shell

redis-cli -h <host> -p <port> -a <password>

```

Example would be like this:

```shell
redis-cli -h redis -p 6379 -a redispassword
```

<Aside type="tip">

To access the kilobase redis or any docker instance: 

`docker exec -it kilobase-redis redis-cli -a redispassword`

</Aside>

### Essential Commands

Once connected, these cover most day-to-day operations:

```shell
SET user:1 "alice"        # store a string
GET user:1                # read it back
EXPIRE user:1 3600        # auto-delete after 1 hour
TTL user:1                # seconds remaining

HSET user:2 name bob age 30   # store a hash
HGETALL user:2                # read the whole hash

INCR page:views           # atomic counter
ZADD board 100 alice      # sorted set for leaderboards
ZREVRANGE board 0 9 WITHSCORES  # top 10

KEYS *                    # list keys (avoid in production)
SCAN 0 MATCH user:*       # cursor-based, production-safe
INFO memory               # memory + stats
```

<Aside type="caution">
Never run `KEYS *` on a busy production instance — it blocks the single-threaded server while it scans every key. Use `SCAN`, which iterates in small cursor-based batches.
</Aside>

## FAQ

**Is Redis a database or a cache?**
Both. Redis is an in-memory data structure store that can act as a primary database, a cache in front of a slower store, or a message broker. Persistence options (RDB snapshots and AOF logs) let it survive restarts when used as a database.

**How do I run Redis with Docker Compose?**
Define a `redis` service using the official `redis` image, expose port `6379`, pass a password with `--requirepass`, and mount a named volume at `/data` for persistence. Then run `docker compose up -d`.

**Why deploy Redis as a StatefulSet on Kubernetes?**
A StatefulSet gives each Redis pod a stable network identity and persistent volume that survive rescheduling. This is required for data durability and for replication, where replicas must reliably find the primary.

**How do I connect to a Redis instance from the command line?**
Use `redis-cli -h <host> -p <port> -a <password>`. Inside Docker, exec into the container first, for example `docker exec -it kilobase-redis redis-cli -a redispassword`.

<Adsense />

---
# React Native

> React Native is Meta's open-source framework for building native mobile apps for iOS and Android from a
single React + JavaScript/TypeScript codebase. This guide covers core concepts, the @kbve/rn shared
component package, running the app, and rendering the same components on the web via react-native-web.

Source: https://kbve.com/application/rn/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

import RnWebDemo from '@/components/rnweb/AstroRnWebDemo.astro';

## Overview

**React Native** is Meta's open-source framework for building **native** iOS and Android apps from a single **React** codebase in JavaScript or TypeScript. Instead of rendering to the DOM, React Native maps components like `View` and `Text` to real platform widgets — so the result is a genuinely native app, not a web view.

The same component model then stretches to the **web** through [react-native-web](#web), letting one codebase target mobile and browser.

This guide covers [core concepts](#concepts), the [@kbve/rn package](#kbve-rn), [running the app](#running), and the [web island demo](#web).

<Adsense />

## Concepts

React Native keeps React's component model, hooks, and JSX, but swaps DOM elements for native primitives:

| Primitive | Web equivalent | Purpose |
| --------- | -------------- | ------- |
| `View` | `<div>` | Layout container |
| `Text` | `<span>` / `<p>` | All text must live in a `Text` |
| `Image` | `<img>` | Images |
| `Pressable` / `TouchableOpacity` | `<button>` | Touch handling |
| `ScrollView` / `FlatList` | scroll container | Scrolling / virtualized lists |
| `StyleSheet` | CSS | Styling via JS objects |

<Aside type="note">
Layout is **flexbox only** and `flexDirection` defaults to `column` (not `row` like the web). There is no cascade — styles are explicit per component via `StyleSheet.create`.
</Aside>

## @kbve/rn

`@kbve/rn` is KBVE's **shared component package**. Its primitives are built on `View` / `Text` / `Pressable` / `StyleSheet` and are consumed by both the native app and — via react-native-web — these docs. Write and style a UI component once, reuse it across mobile and web, and keep the app and its documentation from drifting apart.

```tsx
import { View, Text, Pressable, StyleSheet } from 'react-native';

export function Greeting({ name }: { name: string }) {
  return (
    <View style={styles.card}>
      <Text style={styles.title}>Hello, {name}!</Text>
      <Pressable style={styles.button}>
        <Text style={styles.buttonText}>Tap me</Text>
      </Pressable>
    </View>
  );
}

const styles = StyleSheet.create({
  card: { padding: 16, gap: 8 },
  title: { fontSize: 18, fontWeight: '600' },
  button: { paddingVertical: 8, paddingHorizontal: 12, borderRadius: 8 },
  buttonText: { fontWeight: '500' },
});
```

## Running

The fastest path is **Expo**, which wraps React Native with a managed toolchain, device APIs, and a web target:

<Steps>

1. **Create an app**

   ```bash
   npx create-expo-app@latest my-app
   cd my-app
   ```

2. **Start the dev server**

   ```bash
   npx expo start
   ```

3. **Open it**
   Scan the QR code with the **Expo Go** app on a physical device, or press `i` / `a` to launch the iOS Simulator / Android emulator. Edit a file and save to see **Fast Refresh** update the running app instantly.

</Steps>

<Aside type="tip">
Expo gives you over-the-air updates, a large library of native device APIs, and a `react-native-web` build target — so the same project runs on iOS, Android, and the browser.
</Aside>

## Web

React Native components run in the browser through **react-native-web**, which maps the native primitives to DOM elements. The block below is a **proof of concept**: the exact same `@kbve/rn` component the native app renders, displayed here on the web.

It uses `View` / `Text` / `Pressable` / `StyleSheet` primitives aliased to
`react-native-web` and hydrated as a `client:only` Astro island. Its colors are wired
to Starlight's theme tokens, so it tracks light/dark with the rest of the docs.

<RnWebDemo />

## FAQ

**What is React Native?**
React Native is Meta's open-source framework for building native mobile apps for iOS and Android from a single React and JavaScript/TypeScript codebase. It maps components like `View` and `Text` to real native platform widgets, so the UI is genuinely native rather than a web view.

**What is the difference between React and React Native?**
React renders to the DOM for the web using HTML elements. React Native uses the same component model and hooks but renders to native platform views on iOS and Android. Logic and patterns transfer; the primitives and styling (`StyleSheet`, flexbox-only layout) differ.

**What is react-native-web?**
react-native-web maps React Native primitives — `View`, `Text`, `Pressable`, `StyleSheet` — to their DOM equivalents so the same component code also renders in a browser. It lets a single codebase target iOS, Android, and the web, and underpins Expo's web support.

**What is Expo?**
Expo is a framework and toolchain on top of React Native that streamlines building, running, and shipping apps — a managed workflow, device APIs, over-the-air updates, and a web target via react-native-web — so you can run on a device in seconds without native build setup.

**What is the `@kbve/rn` package?**
`@kbve/rn` is KBVE's shared React Native component package. Its primitives render in the native app and, via react-native-web, inside these docs as an Astro island — so a UI component is written and styled once and reused across mobile and web.

<Adsense />

---
# Rust

> Rust is a modern programming language known for its focus on safety, particularly memory safety, and performance.
It is designed to provide developers with the tools to create reliable and efficient software, often used in systems programming, web assembly, and embedded applications.

Source: https://kbve.com/application/rust/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import {  Adsense } from '@/components/astropad';

## Information

Rust is a modern systems programming language that aims to provide memory safety, concurrency, and high performance without sacrificing control over system resources.
Developed by Mozilla and now maintained by the Rust Foundation, it is designed to address common issues found in other languages like C and C++, such as null pointer dereferencing and buffer overflows, through its powerful ownership model and strict compile-time checks.
Rust's expressive type system, robust package manager (Cargo), and thriving ecosystem make it a popular choice for building reliable and efficient software, from operating systems and game engines to web servers and command-line tools.

---

<Adsense />

## Install

<Aside>

This tutorial is intended for users on Linux, MacOS, and WSL (Windows Subsystem for Linux). 
Windows users should follow the instructions for setting up WSL to use this guide effectively.

</Aside>

Installing Rust on Linux, MacOS, or WSL involves using the `rustup` tool, which manages the Rust installation and its associated tools.
You can install `rustup` by running a simple `curl` command in the terminal and following the prompts to complete the setup.
After configuring your shell and verifying the installation, you'll have a fully functional Rust development environment ready for use.

<Steps>

1.  **Install Rust using `rustup`**:

    Open a terminal and run the following command to download and install the `rustup` tool, which will manage your Rust installation.

    ```shell
    curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh
    ```

    Follow the prompts during the installation process to proceed with the default installation options. If the installation is successful, you will see a message indicating that Rust has been installed.

2.  **Configure Your Shell**:

    After the installation is complete, you need to configure your current shell session to use Rust by running the following command:

    ```shell
    source $HOME/.cargo/env
    ```

    This command ensures that Rust and its associated tools are available in your shell environment.

3.  **Verify the Installation**:

    To confirm that Rust has been installed correctly, check the version of the Rust compiler with the following command:

    ```shell
    rustc --version
    ```

    This command should display the installed version of Rust, indicating that the installation was successful.

4.  **Install Required Dependencies**:

    Rust requires a linker to combine its compiled outputs into one file. You may need to install additional tools if you encounter linker errors.

    **On Ubuntu/Debian**:

    ```shell
    sudo apt update
    sudo apt install build-essential
    ```

    **On Fedora**:

    ```shell
    sudo dnf groupinstall 'Development Tools'
    ```

    **On Arch Linux**:

    ```shell
    sudo pacman -S base-devel
    ```

    **On MacOS**:

    Install Xcode command line tools, which include a C compiler and linker.

    ```shell
    xcode-select --install
    ```

5.  **Update Rust**:

    Keep your Rust installation up-to-date with the following command:

    ```shell
    rustup update
    ```

6.  **Configure Your Development Environment**:

    To make the most of Rust, you should set up a development environment.

    **Install Visual Studio Code** (optional):

    VS Code is a popular code editor with excellent support for Rust.

    **On Linux**:

    ```shell
    sudo snap install --classic code
    ```

    **On MacOS**:

    Download and install from [the official website](https://code.visualstudio.com/).

    **Install the Rust extension for VS Code**:

    Open VS Code and install the "rust-analyzer" extension for Rust language support.

    **Set up your first Rust project**:

    ```shell
    cargo new hello_world
    cd hello_world
    cargo run
    ```

    This will create a new Rust project named `hello_world`, navigate into the project directory, and run the sample application.

7.  **Explore Rust Documentation**:

    Rust has extensive documentation and a friendly community. Here are some resources to get you started:

    - [The Rust Programming Language Book](https://doc.rust-lang.org/stable/book/)
    - [Rust By Example](https://doc.rust-lang.org/stable/rust-by-example/)
    - [Official Rust Documentation](https://doc.rust-lang.org/)


</Steps>


---

## Update

Updating Rust is simple and straightforward using the `rustup` tool.
By running the `rustup update` command in your terminal, you can ensure that your Rust installation and all associated components are kept up-to-date with the latest stable versions.

<Steps>

1. **Open a Terminal**:

    Ensure that you have access to a terminal on your Linux, MacOS, or WSL system.

2. **Run the `rustup` Update Command**:

    Use the following command to update Rust and all installed components to the latest version:

    ```shell
    rustup update
    ```

    This command will download and install the latest stable version of Rust and update all installed toolchains.

3. **Verify the Update**:

    After the update process is complete, verify that Rust has been updated successfully by checking the version:

    ```shell
    rustc --version
    ```

    This command should display the latest version of Rust, confirming that the update was successful.

4. **Clean Up Old Versions** (optional):

    To free up disk space, you can remove older versions of Rust that are no longer needed by running:

    ```shell
    rustup self uninstall
    ```

    This command will prompt you to confirm the removal of old toolchains and components.

</Steps>

---

## Cargo

<Aside>
> TLDR; Cargo is a package manager for Rust that handles the dependencies, compiling and distribution.

> Cargo can publish your package to **crates.io** so that it can be used with other applications within Rust.
</Aside>

Cargo is the Rust package manager and build system, designed to streamline the process of managing dependencies, compiling code, and building projects.
It simplifies tasks like creating new projects, running tests, and generating documentation with easy-to-use commands.
Cargo ensures that Rust developers can efficiently manage their projects' libraries and tools, maintaining consistency and reliability throughout the development lifecycle.

<Steps>

1. **Install Rust and Cargo**:

    Cargo comes bundled with Rust, so installing Rust also installs Cargo. If you haven't installed Rust yet, follow the installation steps below:

    Open a terminal and run the following command:

    ```shell
    curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh
    ```

    Follow the prompts to complete the installation. Once Rust is installed, Cargo will be installed automatically.

2. **Verify Cargo Installation**:

    To ensure Cargo is installed correctly, check its version by running:

    ```shell
    cargo --version
    ```

    This command should display the installed version of Cargo, confirming the installation was successful.

3. **Create a New Rust Project**:

    Use Cargo to create a new Rust project by running:

    ```shell
    cargo new my_project
    cd my_project
    ```

    This command creates a new directory named `my_project` with the necessary files and structure for a Rust project.

4. **Build the Project**:

    To compile your Rust project, navigate to your project directory and run:

    ```shell
    cargo build
    ```

    This command compiles your project and produces an executable in the `target/debug` directory.

5. **Run the Project**:

    After building your project, you can run it with:

    ```shell
    cargo run
    ```

    This command compiles (if necessary) and runs your project, displaying any output in the terminal.

6. **Add Dependencies**:

    To add external libraries (dependencies) to your project, edit the `Cargo.toml` file in your project directory and add the desired dependencies under the `[dependencies]` section. For example:

    ```toml
    [dependencies]
    serde = "1.0"
    ```

    After adding dependencies, run:

    ```shell
    cargo build
    ```

    Cargo will download and compile the specified dependencies for your project.

7. **Run Tests**:

    To run tests defined in your project, use:

    ```shell
    cargo test
    ```

    This command compiles and runs any tests found in the `tests` directory or within your source files.

8. **Generate Documentation**:

    Cargo can generate documentation for your project and its dependencies. To generate and view the documentation, run:

    ```shell
    cargo doc --open
    ```

    This command generates HTML documentation and opens it in your default web browser.

9. **(Optional) Install Cargo Watch**:

    Cargo Watch automatically runs Cargo commands when file changes are detected, useful for continuous development.

    **Install Cargo Watch**:

    ```shell
    cargo install cargo-watch
    ```

    **Use Cargo Watch**:

    To automatically recompile your project when you make changes, run:

    ```shell
    cargo watch -x build
    ```

    For automatic testing on file changes, use:

    ```shell
    cargo watch -x test
    ```

</Steps>

---

## Guides

-   [The Rust Programming Language Book](https://doc.rust-lang.org/stable/book/title-page.html)

    > (From the Official Rust Lang Website)
    > This book assumes that you’ve written code in another programming language but doesn’t
    > make any assumptions about which one. We’ve tried to make the material broadly accessible
    > to those from a wide variety of programming backgrounds. We don’t spend a lot of time talking
    > about what programming is or how to think about it. If you’re entirely new to programming, you
    > would be better served by reading a book that specifically provides an introduction to programming.

-   [A Gentle Introduction to Rust](https://stevedonovan.github.io/rust-gentle-intro/)

    > The aim of this tutorial is to take you to a place where you can read and write enough Rust to
    > fully appreciate the excellent learning resources available online, in particular
    > [The Book.](https://doc.rust-lang.org/stable/book/title-page.html)
    > It's an opportunity to try before you buy, and get enough feeling for the power of the language to want to go deeper.

-   [Rust 🦀 and WebAssembly 🕸](https://rustwasm.github.io/book/)

    > This small book describes how to use Rust and WebAssembly together.

-   [Cookin' with Rust](https://rust-lang-nursery.github.io/rust-cookbook/intro.html)

    > This Rust Cookbook is a collection of simple examples that demonstrate good practices to accomplish common
    > programming tasks, using the crates of the Rust ecosystem.

---

## Examples

-   These are some examples of repos, demos, and source code written in rust!

### MicroService

This is a quick repo / guide on a Rust MySQL Microservice!
Official [Repo](https://github.com/second-state/microservice-rust-mysql)


---

## Youki

Youki is a low-level OCI-compliant container runtime written in Rust, broadly comparable to `runc` and `crun`. 
Youki focuses on memory safety, good performance, and low resource usage, making it suitable as an alternative runtime under Docker, containerd, Podman, Kubernetes, and similar systems.
Official [Youki Repo](https://github.com/containers/youki)

### What Youki Actually Is

Youki is a low-level container runtime — the same layer that Docker, containerd, and Kubernetes ultimately call down into when they spin up a container. 
It implements the OCI runtime specification, which means it is responsible for:

-   Spawning the container process
-   Applying Linux namespaces and cgroups
-   Setting up the container environment (mounts, capabilities, seccomp, etc.)
-   Handing the running process back to the higher-level runtime

In practice, this makes Youki a drop-in replacement for `runc` or `crun`. It still relies on the host Linux kernel like any normal container runtime; it does not virtualize the kernel.

### Youki Key Facts

-   **Type:** OCI container runtime (low-level)
-   **Language:** Rust
-   **Spec support:** Implements the OCI runtime-spec
-   **Role:** Drop-in alternative to `runc` / `crun` in container stacks
-   **Initial release:** v0.0.1 announced December 2021

### Purpose and Design

Youki's goal is to implement the Open Container Initiative Runtime Specification in a modern, memory-safe language. Rust lets Youki interact directly with Linux syscalls — namespaces, cgroups, mounts, and so on — without the multi-threading constraints of Go or the memory-unsafe semantics of C. This design aims to reduce entire classes of vulnerabilities, such as buffer overflows and use-after-free bugs, while still achieving very low-level control over container creation.

### Performance and Resource Usage

Benchmarks published by the project show Youki's container create–start–delete cycle being faster and using less memory than `runc`, and competitive with `crun`. Measured runs on Linux report roughly 2× lower latency than `runc` in certain scenarios, which makes it attractive in resource-constrained environments and high-container-density workloads. Actual gains depend on the workload and environment, so treat these numbers as a directional signal rather than a guarantee.

### Integration and Ecosystem

Youki can act as a drop-in runtime for Docker by registering it in `daemon.json`, and for containerd, Podman, and CRI-O via their runtime configuration hooks.
It is also used as a base for more specialized runtimes - secure wrappers, alternate exec models, and WebAssembly-focused setups such as the WasmEdge integration where Youki is built with WASM support.

There are some quirks around device handling under `cgroups v2` that are worth noting if you are running Youki on newer distributions; check the project's issue tracker before relying on it for production workloads. Since Youki is a low-level runtime, the typical pattern is to pair it with a high-level runtime such as Docker, Podman, or containerd rather than driving it directly.

### Use Cases

Typical use cases include:

-   Running Linux containers in clusters where startup latency and memory headroom matter
-   Experimenting with Rust-based container tooling
-   Building derivative OCI runtimes that leverage Youki's core implementation while layering on extras like sandboxing, alternate exec models, or WASM support

---

## Axum

    -   Axum is an ergonomic and modular Rust web application framework.
    -   [Github Repo](https://github.com/tokio-rs/axum)
    -   Axum can be extended through Tower, which is an ecosystem of middleware, services and utilities

---

## eGUI

This crate is a user-friendly, easy-to-integrate, immediate-mode GUI library designed for rapid development of interactive applications in Rust.

### egui Dependency

        -   There are some dependencies that you might require when working with `egui`:

            ```shell
            sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev
            ```
                - Note: These dependencies are for Ubuntu / WSL.

        -   Making sure the `rustup` has the `wasm` components.

            ```shell
            rustup target add wasm32-unknown-unknow
            ```
        
        -   Installing `Trunk`

            ```shell
            cargo install --locked trunk
            ```

---

## Bevy

Bevy is a data-driven game engine built in Rust, using an Entity Component System (ECS) architecture.
The KBVE isometric game (`apps/kbve/isometric`) runs on Bevy 0.18 with WGPU as its rendering backend, targeting both native desktop (via Tauri) and WebAssembly (WebGPU).

### WGPU Rendering Pipeline

The isometric game initializes WGPU directly for desktop builds, bypassing Bevy's default windowing to render inside a Tauri webview surface.

#### Device Configuration

```rust
// renderer.rs — WGPU initialization
let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
    backends: wgpu::Backends::all(),     // Vulkan, Metal, DX12, GL
    ..Default::default()
});

let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions {
    power_preference: wgpu::PowerPreference::HighPerformance,
    compatible_surface: Some(&surface),
    force_fallback_adapter: false,
}).await;

let (device, queue) = adapter.request_device(&wgpu::DeviceDescriptor {
    required_features: wgpu::Features::empty(),
    required_limits: wgpu::Limits::default(),
    ..Default::default()
}).await;
```

| Setting | Value | Notes |
|---|---|---|
| Backends | `all()` | Auto-selects Vulkan/Metal/DX12 per platform |
| Power preference | `HighPerformance` | Ensures discrete GPU on switchable laptops |
| Features | `empty()` | No optional WGPU features requested |
| Limits | `default()` | Standard limits (2048 textures, 8 bind groups) |

#### Render Architecture

```mermaid
graph TD
    A[Tauri WebviewWindow] -->|raw_window_handle| B[wgpu::Surface]
    B --> C[wgpu::Adapter]
    C --> D[wgpu::Device + Queue]
    D -->|RenderCreation::Manual| E[Bevy RenderPlugin]
    E --> F[Forward Renderer]
    F --> G[PBR Pipeline]
    F --> H[Sprite Pipeline]
    F --> I[Custom Materials]
    I --> I1[WaterMaterial]
    I --> I2[PixelateMaterial]
    I --> I3[OrbMaterial]
    I --> I4[SmokeMaterial]
```

On WASM, Bevy's default WebGPU backend is used instead of the manual surface creation.

### Mesh and Texture Pipeline

The game uses two fundamentally different mesh strategies: **static chunk meshes** built once at load time, and **animated sprite meshes** updated per frame via UV shifting.

#### Static Chunk Meshes (Tilemap)

Terrain is divided into 16x16 tile chunks. Each chunk produces up to 4 meshes (body, cap, grass, water), built once and never updated:

```rust
// tilemap.rs — chunk mesh built via builder pattern (immutable after creation)
Mesh::new(PrimitiveTopology::TriangleList, RenderAssetUsages::default())
    .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
    .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)
    .with_inserted_attribute(Mesh::ATTRIBUTE_COLOR, colors)   // vertex colors for terrain bands
    .with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, uvs)       // tileset UVs
    .with_inserted_indices(Indices::U32(indices))
```

Chunk meshes use **vertex colors** as the primary shading mechanism (grass shades, dirt/stone/snow height bands), reducing material count. Only grass cap surfaces use UV-mapped textures from a tileset atlas.

#### UV-Shift Sprite Animation (Creatures)

Sprite creatures (frogs, wraiths) use per-frame mesh UV updates to animate through sprite sheet frames:

```rust
// Per-frame UV computation from atlas grid position
fn frame_uvs(anim: &Anim, frame: u32, flip: bool) -> [[f32; 2]; 4] {
    let col = anim.start_col + (frame % anim.frame_count);
    let row = anim.row;
    let u0 = col as f32 * FRAME_W;
    let u1 = u0 + FRAME_W;
    let v0 = row as f32 * FRAME_H;
    let v1 = v0 + FRAME_H;
    if flip {
        [[u1, v0], [u0, v0], [u0, v1], [u1, v1]]  // horizontal flip
    } else {
        [[u0, v0], [u1, v0], [u1, v1], [u0, v1]]
    }
}

// Applied every frame — triggers GPU buffer re-upload
mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, vec![uvs[0], uvs[1], uvs[2], uvs[3]]);
```

Each `insert_attribute` call replaces the mesh's UV buffer and triggers a GPU upload via Bevy's render asset system.

### Per-Frame GPU Upload Budget

```mermaid
graph LR
    subgraph "Per-Frame Mesh Uploads (Worst Case)"
        F[Frogs x8] -->|8 UV uploads| GPU
        W[Wraiths x6] -->|6 UV uploads| GPU
    end
    subgraph "Zero Per-Frame Uploads"
        FF[Fireflies x80] -.->|transform only| GPU
        BF[Butterflies x14] -.->|transform only| GPU
        TM[Tilemap chunks] -.->|built once| GPU
    end
```

| System | Entities | Per-Frame Uploads | Upload Type |
|---|---|---|---|
| Frogs | 8 pool | 8 | `ATTRIBUTE_UV_0` (4 vec2s) |
| Wraiths | 6 pool | 6 | `ATTRIBUTE_UV_0` (4 vec2s) |
| Fireflies | 80 pool | 0 | Transform + emissive only |
| Butterflies | 14 pool | 0 | Transform + vertex morph |
| Tilemap | ~50 chunks | 0 | Built once at chunk load |
| **Total** | | **14** | |

At 14 uploads of 32 bytes each (4 vertices x 2 floats x 4 bytes), the total per-frame mesh data is **448 bytes** — negligible on any GPU. The overhead is not the data size but the **draw call overhead** of Bevy's render asset change detection and GPU buffer staging.

### Custom Shader Materials

All custom shaders use Bevy's `Material` trait with `AsBindGroup` for automatic uniform binding:

```rust
// water.rs — custom material with uniform block
#[derive(Asset, TypePath, AsBindGroup, Clone)]
pub struct WaterMaterial {
    #[uniform(0)]
    pub uniforms: WaterUniforms,
}

#[derive(ShaderType, Clone, Copy)]
pub struct WaterUniforms {
    pub base_color: Vec4,       // surface color
    pub deep_color: Vec4,       // depth color
    pub ripple_speed: f32,      // wave animation speed
    pub ripple_scale: f32,      // wave pattern density
    pub highlight_strength: f32, // specular intensity
    pub foam_intensity: f32,    // edge foam
}
```

Bevy's `MaterialPlugin<T>` handles bind group creation, buffer allocation, and shader pipeline setup. Time is accessed in shaders via Bevy's built-in `globals.time` uniform.

| Shader | File | Purpose | Technique |
|---|---|---|---|
| `water.wgsl` | Animated water surfaces | Procedural noise + pixelated UV + foam | Value noise, overlay blend |
| `pixelate.wgsl` | Post-processing | Toon/cel-shading + edge detection | Screen-space quantization |
| `orb.wgsl` | HUD health/mana orbs | Fake spherical lighting + liquid sim | Meniscus + wobble |
| `smoke.wgsl` | Particle effects | Multi-lobe silhouette + FBM noise | Stepped pixel drift |

### Optimization Opportunities

<Aside type="tip">

The current UV-shift approach works correctly and performs well at the current entity count (14 sprite creatures).
These optimizations become relevant when scaling to 50+ sprite creatures or targeting low-end WebGPU devices.

</Aside>

**Uniform-driven UV offset (eliminates per-frame mesh uploads):**

Instead of rewriting the mesh UV buffer each frame, pass the current frame column and row as a shader uniform and compute UVs in the vertex shader:

```wgsl
// Proposed: sprite_sheet.wgsl
struct SpriteUniforms {
    frame_col: f32,
    frame_row: f32,
    sheet_cols: f32,
    sheet_rows: f32,
    flip: f32,
};

@group(3) @binding(0) var<uniform> sprite: SpriteUniforms;

@vertex
fn vertex(in: VertexInput) -> VertexOutput {
    var out: VertexOutput;
    let frame_w = 1.0 / sprite.sheet_cols;
    let frame_h = 1.0 / sprite.sheet_rows;
    var u = in.uv.x * frame_w + sprite.frame_col * frame_w;
    let v = in.uv.y * frame_h + sprite.frame_row * frame_h;
    if (sprite.flip > 0.5) {
        u = (sprite.frame_col + 1.0) * frame_w - (u - sprite.frame_col * frame_w);
    }
    out.uv = vec2(u, v);
    out.position = mesh_position_local_to_clip(in.position);
    return out;
}
```

This approach:
- Eliminates all `insert_attribute` calls (zero mesh uploads per frame)
- Moves UV computation to the GPU (where it belongs)
- Enables **instanced rendering** — all creatures of the same type can share one mesh
- Reduces CPU-GPU sync points from 14/frame to 0/frame

```mermaid
graph LR
    subgraph "Current: CPU UV Rewrite"
        CPU1[Compute UVs] --> BUF1[Write to mesh buffer] --> UP1[GPU upload]
    end
    subgraph "Proposed: Uniform UV Offset"
        CPU2[Set frame_col uniform] --> UNI[Uniform buffer update]
    end
    style UP1 fill:#f66,stroke:#333
    style UNI fill:#6f6,stroke:#333
```

**Texture compression:**

Sprite atlases are stored as uncompressed RGBA8 PNG. GPU-compressed formats reduce VRAM usage by ~4x:

| Format | Platform | Compression | Atlas VRAM |
|---|---|---|---|
| RGBA8 (current) | All | None | ~4.8 MB |
| BC7 | Desktop (Vulkan/DX12/Metal) | 4:1 | ~1.2 MB |
| ASTC 4x4 | Mobile/WebGPU | 4:1 | ~1.2 MB |

Bevy supports `.ktx2` with basis universal transcoding for cross-platform compressed textures.

**Instanced rendering:**

All sprite creatures of the same type share identical geometry (a quad). With the uniform-driven UV approach, these could use **GPU instancing** — one draw call for all frogs, one for all wraiths — reducing draw calls from 14 to 2.

---

## Q

Q is a powerful Godot Helper Crate designed for Rust developers using the GDExtension API.
It provides a robust set of tools to streamline game development, including a versatile Game Manager for handling core game logic, a Music Manager for seamless audio integration, and a Bevy ECS implementation for efficient entity-component-system architecture.
Additionally, Q leverages Tokio for high-performance multi-threading, enabling smooth and scalable concurrency in your Godot projects.
Whether you're building complex systems or optimizing performance, Q is your go-to crate for enhancing Rust-based Godot development.

### Q Mac

To build the crate on the mac, we have three options, the first is through the Nx monorepo command: `./kbve.sh -nx q:build-mac`!
The other option would be to run a [docker](/application/docker/) image to do the build process and the final option would be a [git workflow](/application/git/), more on those two later on.

---

## Askama

Askama is a compile-time type-safe templating engine for Rust, inspired by Jinja2.
It compiles templates into Rust code at build time, catching errors before runtime and producing zero-allocation rendering.
In the KBVE monorepo, we use Askama with Axum to serve dynamic pages where Astro generates the HTML shell and Askama fills in the data.

### Askama with Astro — The Template Pipeline

The core pattern: **Astro builds the template, Axum fills in the variables at runtime.**

This gives us the best of both worlds:
- Astro's full static site shell (nav, CSS bundles, layout, Starlight integration)
- Axum's dynamic data injection (meme content, user profiles, OG meta tags)

#### How It Works

```
1. Astro build  →  outputs HTML with {{ askama_vars }} as literal text
2. Copy step    →  moves Astro's output into Rust's templates/ directory
3. Cargo build  →  askama compiles those HTML files into Rust code
4. Runtime      →  Axum resolves data, askama substitutes {{ vars }}, serves HTML
```

The key insight is that Astro treats `{{ variable }}` as plain text — it does not interpret double curly braces.
When Astro builds, the output HTML literally contains `{{ meme_id }}`, `{{ title }}`, etc.
Askama then picks up that HTML file as a template and compiles it into type-checked Rust code.

#### Build Order (Critical)

Askama templates are compiled at **Rust build time**, not runtime.
This means the Astro build output **must exist** before `cargo build` runs.

**Local development:**
```shell
# 1. Build Astro first
npx nx run astro-memes:build

# 2. Copy the askama page output into Rust's template directory
cp dist/apps/astro-memes/askama/meme/index.html \
   apps/memes/axum-memes/templates/askama/meme.html

# 3. Build Rust (askama compiles the template)
cargo build --manifest-path apps/memes/axum-memes/Cargo.toml
```

**Dockerfile (multi-stage):**
```dockerfile
# Stage 1: Build Astro
FROM node:22-alpine AS astro-build
WORKDIR /app
COPY . .
RUN pnpm install && npx nx run astro-memes:build

# Stage 2: Build Rust (askama needs Astro output)
FROM rust:1.87 AS rust-build
WORKDIR /app
COPY . .
COPY --from=astro-build /app/dist/apps/astro-memes /app/apps/memes/axum-memes/templates/dist
RUN cargo build --release --manifest-path apps/memes/axum-memes/Cargo.toml

# Stage 3: Runtime
FROM debian:bookworm-slim
COPY --from=rust-build /app/target/release/axum-memes /usr/local/bin/
COPY --from=astro-build /app/dist/apps/astro-memes /app/templates/dist
CMD ["axum-memes"]
```

The Rust build stage receives the Astro output via `COPY --from=astro-build`, ensuring askama can find and compile the templates.

#### Creating an Askama-Powered Astro Page

<Steps>

1. **Create the Astro MDX page** with askama variables in the frontmatter.

    Place it under `src/content/docs/askama/` so it builds to a known path.
    Use askama template syntax (`{{ var }}`, `{% if %}`, `{% for %}`) directly in the frontmatter and component props — Astro outputs them as literal text.

    ```mdx
    ---
    title: "{{ title }} | Meme.sh"
    head:
        - tag: meta
          attrs:
            property: "og:title"
            content: "{{ title }}"
        - tag: meta
          attrs:
            property: "og:image"
            content: "{{ og_image }}"
        - tag: meta
          attrs:
            property: "og:url"
            content: "{{ canonical_url }}"
    description: "{{ description }}"
    template: splash
    sidebar:
        hidden: true
    ---

    import AskamaMyProvider from '@/components/providers/AskamaMyProvider.astro';

    <AskamaMyProvider />
    ```

2. **Create the Astro provider component** that renders the page body with askama variables.

    The provider defines askama template variables as JavaScript string literals.
    These are injected into the HTML via `set:html` — Astro outputs them verbatim.

    ```astro
    ---
    // AskamaMyProvider.astro
    // Askama variables: {{ title }}, {{ body_content }}, {{ author }}

    const askamaTitle = `{{ title }}`;
    const authorBlock = `{% if !author.is_empty() %}
    <p class="author">by {{ author }}</p>
    {% endif %}`;
    ---

    <article data-id={`{{ item_id }}`}>
        <h1 set:html={askamaTitle} />
        <Fragment set:html={authorBlock} />
        <!-- React island hydration target -->
        <div id="interactive-island" data-id={`{{ item_id }}`}></div>
    </article>

    <style>
        .author { color: #a1a1aa; font-size: 0.875rem; }
    </style>
    ```

    Key patterns:
    - Use backtick strings for askama variables: `` const x = `{{ var }}`; ``
    - Use `set:html` to inject askama blocks containing conditionals/loops
    - Use `<Fragment set:html={block} />` for multi-line askama blocks
    - Include a `<div id="...">` for React island hydration if needed

3. **Define the Rust askama struct** that maps to the template variables.

    The struct fields must match the `{{ var }}` names in the template exactly.

    ```rust
    use askama::Template;

    #[derive(Template)]
    #[template(path = "askama/my_page.html")]
    pub struct MyPageTemplate {
        pub item_id: String,
        pub title: String,
        pub description: String,
        pub canonical_url: String,
        pub og_image: String,
        pub author: String,
        pub body_content: String,
    }
    ```

    The `path` is relative to the `templates/` directory configured in `Cargo.toml`:
    ```toml
    [package.metadata.askama]
    dirs = ["templates"]
    ```

4. **Create the Axum route handler** that fetches data and renders the template.

    ```rust
    async fn page_handler(
        State(state): State<AppState>,
        Path(id): Path<String>,
    ) -> Response {
        match resolve_item(&state, &id).await {
            Ok(Some(item)) => {
                let template = MyPageTemplate {
                    item_id: item.id.clone(),
                    title: item.title.clone(),
                    description: item.description(),
                    canonical_url: item.canonical_url(),
                    og_image: item.thumbnail_url(),
                    author: item.author_name.unwrap_or_default(),
                    body_content: item.rendered_html(),
                };
                TemplateResponse(template).into_response()
            }
            Ok(None) => StatusCode::NOT_FOUND.into_response(),
            Err(e) => {
                warn!(error = %e, "failed to render page");
                StatusCode::INTERNAL_SERVER_ERROR.into_response()
            }
        }
    }
    ```

5. **Wire the build pipeline** — ensure Astro builds before Rust.

    In the Nx project config, add a dependency:
    ```json
    {
        "targets": {
            "build": {
                "dependsOn": ["astro-memes:build"],
                "executor": "nx:run-commands",
                "options": {
                    "command": "cargo build --release"
                }
            }
        }
    }
    ```

    Or in the Dockerfile, use multi-stage builds (see above).

</Steps>

### Askama Template Syntax Reference

Askama uses Jinja2-style syntax. Here are the most common patterns used in Astro-generated templates:

**Variable substitution:**
```html
<h1>{{ title }}</h1>
<meta property="og:image" content="{{ og_image }}" />
```

**Conditionals:**
```html
{% if !author.is_empty() %}
<p>by {{ author }}</p>
{% endif %}

{% if format_label == "video" %}
<video src="{{ asset_url }}" controls></video>
{% else %}
<img src="{{ asset_url }}" alt="{{ title }}" />
{% endif %}
```

**Option types (Rust `Option<T>`):**
```html
{% if let Some(avatar) = avatar_url %}
<img src="{{ avatar }}" alt="avatar" />
{% else %}
<div class="placeholder">No avatar</div>
{% endif %}
```

**Loops (Rust `Vec<T>`):**
```html
{% for tag in tags %}
<span class="tag">{{ tag }}</span>
{% endfor %}
```

**Filters:**
```html
{{ title|escape }}
{{ content|safe }}
{{ count|fmt("{:.1}") }}
```

**Integer comparisons:**
```html
{% if width > 0 %}width="{{ width }}"{% endif %}
```

### Common Pitfalls

<Aside type="caution">

**Build order matters.** If `cargo build` runs before `astro build`, askama will either use stale templates or fail to find them. Always build Astro first.

**Astro does NOT escape `{{ }}`** — this is what makes the pattern work. Astro treats double curly braces as plain text in MDX frontmatter, `set:html` attributes, and backtick strings. Do NOT use them in Astro expressions (`{}`) — those are Astro's own interpolation syntax.

**Template path must be correct.** The `#[template(path = "...")]` attribute is relative to the `templates/` directory. After the copy step, verify the file exists at the expected path before running `cargo build`.

**Askama is strict about types.** If your template uses `{{ width }}` and the struct field is `Option<i32>`, askama will error. Use `{% if let Some(w) = width %}{{ w }}{% endif %}` for optional fields, or provide defaults in the handler (`.unwrap_or(0)`).

**CSS in Astro components works normally.** Scoped `<style>` blocks in `.astro` files generate hashed class names that survive the askama pipeline — they are just static CSS in the final HTML.

</Aside>

### Existing Askama Pages in the Monorepo

| App | Route | Template | Provider |
|-----|-------|----------|----------|
| kbve | `/@{username}` | `askama/profile.mdx` | `AskamaProfileProvider.astro` |
| kbve | `/@{username}` (not found) | — | `AskamaProfileNotFoundProvider.astro` |
| memes | `/meme/{id}` | `askama/meme.mdx` | `AskamaMemeProvider.astro` |

---

## KBVE

---

## JEDI

---

## ERUST

---

## HOLY

---

--

## CI

For continuous integration, we recommend checking out our [git](/application/git/) section for more information.


### MSVC Target

There will come a time where the rust application that you are building will require Windows SDK and ABI!
When that situation comes, there are three options that are available, but not limited to.

**Windows Native Build**

A simple approach would be to setup the Rust cargo and application on a Windows 11 operating system and compile it from there.

**Github Actions**

Github Actions can provide you with a cloud windows VM that will pull the source code and cargo build the target release, with pre-installed visual studio code.

**Docker**

Nix-ready or custom docker image that has a multi-stage build process, including a cargo chef and layer caching, provides a fast and local way to build across multiple operating systems.

---
# SQL

> SQL is the standard language for managing data in relational databases like MySQL, MariaDB, and PostgreSQL.
This guide covers the MySQL/MariaDB cheatsheet, PostgreSQL with PSQL and extensions, CloudNativePG (CNPG)
and Barman on Kubernetes, plus Supabase schemas and backups.

Source: https://kbve.com/application/sql/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

SQL (Structured Query Language) is the standard programming language used for managing relational databases and performing various operations on the data they contain.
The SQL ecosystem includes a wide array of database systems such as MySQL and PostgreSQL, which are known for their robustness, scalability, and support for complex queries.
These systems are integral to many applications, providing transactional support, ACID compliance, and advanced data management capabilities to ensure data integrity and performance across numerous industries.

This page collects working references across engines: the [MySQL/MariaDB cheatsheet](#cheatsheet), [PostgreSQL](#postgresql) with PSQL and extensions, [CloudNativePG](#cnpg) and [Barman](#barman) for Postgres on Kubernetes, and [Supabase schemas](#supabase-schemas) and [backups](#backup).

---

<Adsense />

## Cheatsheet

### MySQL/MariaDB Cheatsheet

-   Admin Commands

    -   Drop Database (Be extremely careful when running this)

        -   ```sql
            DROP DATABASE {$db_name};
            ```
            -   Replace `{$db_Name}` with the database that you wish to DROP.
            -   _Remember that all the data will be removed and can not be recovered._

    -   List All Users

        -   ```sql
            SELECT user, host FROM mysql.user;
            ```
            -   This will display all the users within the database instance.

    -   Create User

        -   ```sql
            CREATE USER {$user[@'host']} IDENTIFIED BY 'plain-text-password';
            ```
            -   `{$user[@'host']}` can be replaced by an example like this `'root'@'localhost'` or `'root'@'10.%.%.%'`
                -   `10.%.%.%` - The `%` is a wildcard for the IP Address subnet.

    -   Drop User

        -   ```sql
            DROP USER {$user[@'host']}
            ```
            -   This will only remove the user from the mysql instance.

    -   Create Database

        -   ```sql
            CREATE DATABASE {$database_name}
            ```
            -   `{$database_name}` can be replaced as `database_name_example` , thus creating a statement like `CREATE DATABASE database_name_example`.

    -   Grant permissions / privilegages.
        -   ```sql
            GRANT ALL ON ${database_name}.* TO {$user[@'host']}
            ```
            -   There are a couple situations that this statement creates, first it gives `ALL` permissions to the database, `${database_name}` with the `.*` being a wildcard for all the tables inside of the database. Finally the `{$user[@'host']}` represents the user connecting via the IP Address.

---

## MySQL

---

## MariaDB

---

## PostgreSQL

PostgreSQL is an advanced open-source relational database system known for its robustness, performance, and extensibility.
It adheres to SQL standards and supports a wide range of data types, making it suitable for handling structured, semi-structured, and unstructured data.
Developers and database administrators alike benefit from its rich feature set, including support for JSON, full-text search, and spatial data through extensions like `PostGIS`.
For those looking to leverage machine learning capabilities, `pgvector` offers native support for storing and querying vector embeddings, ideal for AI-based applications.
PostgreSQL also provides powerful tools like `pg_barman` for seamless backups and disaster recovery, ensuring data safety and availability.
With built-in support for logical replication and partitioning, PostgreSQL can scale horizontally and handle complex workloads efficiently.
Additionally, advanced users can create custom functions and procedures using various languages such as PL/pgSQL, Python, and even JavaScript, enhancing its capabilities further.
But wait, there is more, because of its thriving community and vast ecosystem, PostgreSQL is a versatile solution for developers and enterprises looking to build high-performance, scalable, and secure data-driven applications.

### PSQL

`psql` is a powerful command-line interface and interactive terminal for PostgreSQL, offering a convenient way to interact with databases through SQL commands.
This tool can be used to connect to databases, execute queries, and manage database objects such as tables, schemas, and extensions.
For beginners, psql provides a straightforward method to learn SQL and interact with PostgreSQL, featuring built-in help and command-line flags to assist in query execution.
Advanced users and database administrators can leverage its full scripting capabilities, including support for automated backups, customized reports, and database tuning.
Furthermore, the tool also provides powerful meta-commands (such as \dt, \du, and \l) to display database information and manipulate objects quickly.
Additionally, psql can be used to execute SQL scripts, manage PostgreSQL configurations, and run commands for extensions like `pg_stat_statements` or `pgvector`.
It is a versatile tool that is essential for PostgreSQL users of all skill levels, serving as both a learning environment and a robust management utility.

<Aside title='Note: Using psql'>

This guide provides an overview of using the `psql` command-line interface with PostgreSQL 15, 16, and 17.

It is intended for users who want to manage their PostgreSQL databases efficiently. 
Some advanced features, such as certain meta-commands and flags, may behave differently or be unavailable in older versions of `psql`.
Be sure to check the compatibility of specific commands if using an older PostgreSQL version.

</Aside>


---


### Extensions

Postgres extensions provide powerful enhancements to the core database, enabling advanced features such as full-text search, geospatial queries, and custom data types.
With the flexibility of extensions, developers can easily tailor Postgres to suit specific use cases and application needs.
Setting up extensions like pg_stat_statements or pg_cron helps monitor performance and schedule maintenance tasks within the database itself.
Building custom extensions allows organizations to embed domain-specific logic directly into the database, making it a robust platform for complex data operations.
It's essential to verify extension compatibility with your Postgres version to avoid conflicts.
This guide will walk through the setup, configuration, and best practices for both built-in and third-party extensions, ensuring a seamless experience for database administrators.

---

### CNPG

CloudNativePG, aka CNPG, is an open-source Kubernetes operator designed to manage PostgreSQL clusters natively within Kubernetes environments.
It supports the entire lifecycle of a PostgreSQL cluster, from initial deployment to ongoing maintenance, with built-in features like automated failover, scaling of read replicas, and rolling updates.
CloudNativePG leverages native PostgreSQL streaming replication to provide high availability and disaster recovery options.
It integrates directly with the Kubernetes API server, eliminating the need for external failover management tools.
Additionally, it supports common PostgreSQL extensions and offers monitoring capabilities through Prometheus integration.
This operator is tailored to modern cloud-native architecture and is ideal for PostgreSQL deployments that require seamless management within Kubernetes.

#### CNPG Image Requirements

The CloudNativePG operator for Kubernetes requires that certain PostgreSQL executables and tools be present within the container image during the image build process.
These requirements are essential for the operator to automate the management of PostgreSQL clusters, including initialization, backups, and restoration.
Without these components, the operator will not be able to perform tasks such as setting up the database, handling replication, or managing cloud-based backup solutions like Barman.
Additionally, if audit logging is required, the pgaudit extension should be installed as part of the container image build.

1. PostgreSQL Executables in Path:

- `initdb`
- `postgres`
- `pg_ctl`
- `pg_controldata`
- `pg_basebackup`

2. Barman Cloud Executables in Path (for integration with cloud storage):

- `barman-cloud-backup`
- `barman-cloud-backup-delete`
- `barman-cloud-backup-list`
- `barman-cloud-check-wal-archive`
- `barman-cloud-restore`
- `barman-cloud-wal-archive`
- `barman-cloud-wal-restore`

3. Optional PostgreSQL Extensions:

- `PGAudit` - The pgaudit extension should be pre-installed in the image if audit logging is required within the deployed PostgreSQL clusters.

4. Locale Settings:

- Ensure that appropriate locale settings are configured to support the desired language and encoding for the PostgreSQL database.


These requirements ensure compatibility and proper functionality of CloudNativePG with various PostgreSQL features, including cloud-based backup and restoration via Barman Cloud, as well as extended audit capabilities through PGAudit.

---

#### CNPG Deployment Example

Here is a quick base example of the bootstrap initdb that we are using to start our cluster.

```yaml

bootstrap:
    initdb:
        database: app
        owner: app
        dataChecksums: true
        encoding: 'UTF8'
        postInitApplicationSQLRefs:
            configMapRefs:
                -   name: {{ include "supabase.db.fullname" . }}-init
                    key: configmap.sql
                -   name: {{ include "supabase.db.fullname" . }}-sql
                    key: alt.sql
        postInitApplicationSQL:
            - "ALTER DATABASE postgres SET \"app.settings.jwt_secret\" TO '{{ .Values.secret.jwt.secretRefKey.secret }}';"
            - "ALTER DATABASE postgres SET \"app.settings.jwt_exp\" TO '3600';"


```

#### CNPG Recovery Example

Here is our CNPG recovery example using AWS for our self hosted supabase instance.
It should be noted that the new cluster should not share some the same variables like `name` because it might cause some errors with the new cluster's WAL.

```yaml

bootstrap:
    recovery:
        source: supabase

externalClusters:
    - name: supabase
      barmanObjectStore:
        serverName: supabase
        destinationPath: s3://kilobase/barman/restore/
        s3Credentials:
          accessKeyId:
            name: {{ .Values.secret.s3.secretRef }}
            key: {{ .Values.secret.s3.secretRefKey.keyId | quote }}
          secretAccessKey:
            name: {{ .Values.secret.s3.secretRef }}
            key: {{ .Values.secret.s3.secretRefKey.accessKey | quote }}
        wal:
          compression: gzip

```

---

#### CNPG Backup Example

There are two types of backups that we can utilize, the `Kind: Backup` and `Kind: ScheduledBackup`, both will store the postgres data into the barman object store in these examples.
Below is the `cnpg-cluster-backup.yaml` that we added for our self hosted supabase cluster.
The current `schedule: "0 0 0 * * 0"` is set for weekly backups but that can be easily adjusted for daily.

```yaml 

apiVersion: postgresql.cnpg.io/v1
kind: Backup
metadata:
  name: {{ include "supabase.db.fullname" . }}-backup
spec:
  method: barmanObjectStore
  cluster:
    name: {{ include "supabase.db.fullname" . }}

---
apiVersion: postgresql.cnpg.io/v1
kind: ScheduledBackup
metadata:
  name: {{ include "supabase.db.fullname" . }}-bk-job
spec:
  schedule: "0 0 0 * * 0"
  backupOwnerReference: self
  cluster:
    name: {{ include "supabase.db.fullname" . }}

```

<Aside>

Remember to test case the recovery of the backups using a secondary cluster deployment and becareful of the WAL locations, to avoid an overwrite.

</Aside>

---


### Barman


Barman (Backup and Recovery Manager) is an advanced backup and recovery solution designed specifically for PostgreSQL databases.
It allows database administrators to automate backup processes, perform disaster recovery, and maintain business continuity by ensuring that data is always recoverable.
Barman can be installed using Python’s package manager (pip) or through PostgreSQL’s official PPA (Personal Package Archive), making it easy to set up and integrate into existing infrastructures.
Once installed, Barman provides a command-line interface (barman-cli) that supports managing backups, restoring databases, monitoring replication, and verifying the integrity of stored data.
One of its key features is Point-in-Time Recovery (PITR), which enables the restoration of a database to a specific moment, even down to the second, providing a flexible approach for handling data inconsistencies or unintentional deletions.
Barman also supports parallel streaming and synchronous WAL (Write-Ahead Log) archiving, ensuring that backups remain up-to-date with minimal performance impact on the source database.
Additionally, Barman offers monitoring capabilities with built-in commands for checking the status of backups, space utilization, and replication delays, enabling proactive maintenance and alerts.
For cloud deployments, Barman Cloud CLI extends its capabilities by offering integration with cloud storage providers such as AWS S3, Azure Blob Storage, and Google Cloud Storage, making it a versatile solution for hybrid and cloud-native environments.
With the Barman Cloud CLI, you can seamlessly configure cloud storage, perform backups, restore operations, and leverage cloud-based encryption for an added layer of data security.
Overall, Barman and its cloud extension provide a comprehensive toolkit for database administrators to manage the complexities of PostgreSQL backups, ensuring data is securely stored, quickly recoverable, and effectively managed both on-premises and in the cloud.

<Aside>

💡 Reminder: Always test your Barman backup and recovery setup in a non-production environment before a real disaster occurs.
Running recovery simulations ensures that your backups are correctly configured and that the recovery process works as expected, giving you confidence that your data is safe and recoverable.
Regular testing is crucial to avoid unexpected failures during critical moments.

</Aside>

We want the barman to be installed directly into our postgres image and thus we will add a stage called `Barman`.
Here is a brief example of us setting up the barman cloud cli inside of our `kilobase` image that is based upon the supabase image.

```dockerfile

# Install necessary utilities like wget and gnupg before adding the PostgreSQL PPA
RUN apt-get update && apt-get install -y --no-install-recommends \
    gnupg \
    wget \
    ca-certificates && \
    rm -rf /var/lib/apt/lists/*

# Add the PostgreSQL PPA and import the key
RUN sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ focal-pgdg main" > /etc/apt/sources.list.d/pgdg.list' && \
    wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -

# Update and install barman-cli-cloud from the PostgreSQL PPA
RUN apt-get update && apt-get install -y --no-install-recommends \
    barman-cli-cloud

# Clean up unnecessary files to reduce image size
RUN apt-get clean && \
    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

```

<Aside title="Recap">

    The Postgres  is a powerful, open-source relational database system known for its advanced features, reliability, and strong standards compliance.
    It supports complex queries, data integrity, and extensibility through a variety of plugins, making it ideal for both small and large-scale applications.
    With support for ACID transactions, JSON, and custom extensions, Postgres is a popular choice for developers and enterprises alike.

</Aside>

---

## PlanetScale

---

## Supabase


Supabase is an open-source backend-as-a-service that provides a suite of tools to simplify building applications.
It offers a powerful, hosted PostgreSQL database with a built-in authentication system, storage services, and real-time functionality.
Supabase is built to scale with your application and supports various PostgreSQL extensions like pgvector for vector similarity searches and pgTAP for testing.
The platform includes a SQL Editor, allowing users to manage their data, run queries, and save frequently used SQL commands.
Supabase also integrates with tools like Barman for database backups and supports advanced features like row-level security to ensure data privacy and security.

Supabase is ideal for both beginners and experts due to its flexibility and comprehensive feature set.
It can be used for rapid prototyping, building full-stack applications, or extending existing apps with complex data relationships.
Additionally, Supabase is highly extensible, allowing developers to add Postgres extensions with just a few clicks from the dashboard, making it easy to expand database capabilities as needed!

### Supabase Schemas


https://supabase-schema.vercel.app


---

## Backup

If you need a quick way to backup the `mysql` database, then use this command below:

```shell
sudo docker exec [$mysql_container_name] /usr/bin/mysqldump -u [$mysql_username] --password=[$mysql_password] [$database_name] > [$destination_path]
```

You could save the execution command as a shell file and/or reference it inside of your AWX stack.

More information on [AWX](/application/ansible/#awx) and [Docker](/application/docker/)

---

## Notes

---

## Videos

---

## References

### Q&A

-   #### What to do if you just installed `mysql-server` on Ubuntu on WSL and it never even prompted you for a password?

    -   [Well here's a cool link](https://stackoverflow.com/questions/42421585/default-password-of-mysql-in-ubuntu-server-16-04) that tells you exactly what to do.
    -   Long story short it's like `ALTER USER 'root'@'localhost' IDENTIFIED BY 'password'` once you actually get in

-   #### What to do if you've never used this foreign and vaguely antiquated technology before and you wish you had a time machine that would let you go back in time so you could sit with the pioneers of this dying technology and learn from them what drugs they were smoking when they decided on the syntax?

    -   [Well here's a cool link](https://devhints.io/mysql) that will help in your journey to understand the aforementioned topics.

---

## FAQ

**What is the difference between SQL and MySQL?**
SQL is the standard query language for relational databases. MySQL is a specific database system that implements SQL. PostgreSQL, MariaDB, and SQLite are other systems that also speak SQL with their own extensions.

**What is the difference between MySQL and PostgreSQL?**
Both are open-source relational databases. MySQL is known for simplicity and read-heavy speed, while PostgreSQL offers richer SQL compliance, advanced types (JSONB, arrays), and extensions. PostgreSQL is often preferred for complex, write-heavy, or analytical workloads.

**What is CloudNativePG (CNPG)?**
CloudNativePG is a Kubernetes operator that runs PostgreSQL clusters as native resources. It handles provisioning, failover, rolling updates, and backups (often via Barman), managing high-availability Postgres declaratively inside a cluster.

**How do I reset a MySQL root password?**
Log into the MySQL shell and run `ALTER USER 'root'@'localhost' IDENTIFIED BY 'newpassword'`. On a fresh Ubuntu install that never prompted for a password, you may first need to authenticate through the `auth_socket` plugin.

<Adsense />

---
# Supabase

> A deep dive into Supabase, an open-source Firebase alternative powered by PostgreSQL.

Source: https://kbve.com/application/supabase/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## User

### User Vault - Secrets

This is a quick section for setting up a quick proof of concept and for the demo, we will be doing a character ai inspired meme.
Full disclosure, this is just for fun and is not meant to be taken serious.

```sql

create table private.user_secrets (
  id uuid primary key default gen_random_uuid(),
  user_id uuid not null references auth.users(id) on delete cascade,
  key text not null, -- user-facing label like "osrs_email" or "github_token"
  vault_key text not null, -- actual vault path, like "user/{user_id}/osrs/email"
  created_at timestamptz default now(),
  updated_at timestamptz default now(),

  constraint unique_user_key unique (user_id, key)
);

alter table private.user_secrets enable row level security;
create policy "No access by default" on private.user_secrets
  for all using (false); 
revoke all on private.user_secrets from anon, authenticated, public;
grant all on private.user_secrets to service_role;

```

After setting up the `user_secrets`, we can move forward with the next step and that would be the `osrs` table.

```sql

create table private.user_osrs_accounts (
  id uuid primary key default gen_random_uuid(),
  user_id uuid not null references auth.users(id) on delete cascade,
  account_name text not null, -- user-facing label (not email or login)
  vault_email_key text not null,
  vault_password_key text not null,
  state text default 'offline' check (state in ('offline', 'active', 'banned', 'error')),
  world integer,
  p2p boolean default false,
  created_at timestamptz default now(),
  updated_at timestamptz default now(),

  constraint unique_user_account_name unique (user_id, account_name)
);

alter table private.user_osrs_accounts enable row level security;

create policy "No access by default" on private.user_osrs_accounts
  for all using (false);

revoke all on private.user_osrs_accounts from anon, authenticated, public;
grant all on private.user_osrs_accounts to service_role;

alter table private.user_osrs_accounts
add constraint unique_email_key_per_account unique (vault_email_key);

```

Now we need to setup the function to handle our user secret and making sure that it gets saved into the vault.
The internal RPC call is just for the service role and we will create a public facing proxy rpc function that will handle more of the core.
Since we wont be touching the value, we can leave that the way it is, but the key should be sanitized to be just az09 and underscore.
Furthermore, we should also do a quick check to make sure that the uuid for the `p_user_id` is valid since we will delete these based upon that.

```sql

create or replace function private.set_user_secret_internal(
  p_user_id uuid,
  p_key text,
  p_value text
)
returns void
language plpgsql
security definer
set search_path = private, vault, public
as $$
declare
  v_vault_key text;
  v_secret_id uuid;
begin
  -- Validate user
  if not exists (select 1 from auth.users where id = p_user_id) then
    raise exception 'Invalid user_id';
  end if;

  -- Validate key format
  if p_key !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid key format';
  end if;

  -- Build vault key path
  v_vault_key := format('user/%s/%s', p_user_id, p_key);

  -- Attempt to create the secret (will fail if name not unique)
  begin
    select vault.create_secret(p_value, v_vault_key, format('Secret for %s', p_key))
      into v_secret_id;
  exception when unique_violation then
    -- If the name already exists, update the secret
    update vault.secrets set secret = p_value, updated_at = now()
    where name = v_vault_key;
  end;

  -- Link it in user_secrets
  insert into private.user_secrets (user_id, key, vault_key)
  values (p_user_id, p_key, v_vault_key)
  on conflict (user_id, key) do update
    set vault_key = excluded.vault_key,
        updated_at = now();
end;
$$;

revoke all on function private.set_user_secret_internal(uuid, text, text)
  from public, anon, authenticated;

grant execute on function private.set_user_secret_internal(uuid, text, text)
  to service_role;


```

Now we want to make sure that the public facing authenticated user is calling this internal function through our proxy function.
Here is the public facing proxied function.

```sql

create or replace function public.set_user_secret(
  p_key text,
  p_value text
)
returns void
language plpgsql
security definer
set search_path = public, private
as $function$
declare
  v_user_id uuid := auth.uid();
begin
  if v_user_id is null then
    raise exception 'Not authenticated';
  end if;

  if p_key !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid key format. Only lowercase a-z, 0-9, and underscores (3–64 characters) are allowed.';
  end if;


  -- Call internal secure vault setter
  perform private.set_user_secret_internal(v_user_id, p_key, p_value);
end;
$function$;

-- Revoke all access to the function from default/public roles
revoke all on function public.set_user_secret(text, text)
from public, anon;

-- Grant only to authenticated users
grant execute on function public.set_user_secret(text, text)
to authenticated;

```

Now that we got the secrets set with a public facing proxy rpc, we can focus on getting the said secrets from the vault.
We will follow the same logic and create two new functions, one for internal usage and another for public schema.

```sql

create or replace function private.get_user_secret_internal(
  p_user_id uuid,
  p_key text
)
returns text
language plpgsql
security definer
set search_path = private, vault, public
as $$
declare
  v_vault_key text;
  v_secret text;
begin
  -- Validate key format
  if p_key !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid key format. Must match /^[a-z0-9_]{3,64}$/';
  end if;

  -- Get vault key path
  select vault_key into v_vault_key
  from private.user_secrets
  where user_id = p_user_id and key = p_key;

  if not found then
    raise exception 'Secret key not found for user';
  end if;

  -- Get decrypted secret
  select decrypted_secret into v_secret
  from vault.decrypted_secrets
  where name = v_vault_key;

  if v_secret is null then
    raise exception 'Secret not found in Vault';
  end if;

  return v_secret;
end;
$$;

revoke all on function private.get_user_secret_internal(uuid, text)
from public, anon, authenticated;

grant execute on function private.get_user_secret_internal(uuid, text)
to service_role;




create or replace function public.get_user_secret(
  p_key text
)
returns text
language plpgsql
security definer
set search_path = public, private
as $function$
declare
  v_user_id uuid := auth.uid();
  v_secret text;
begin
  if v_user_id is null then
    raise exception 'Not authenticated';
  end if;

  -- Validate key format again at proxy level
  if p_key !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid key format. Only lowercase a-z, 0-9, and underscores (3–64 characters) are allowed.';
  end if;

  -- Call the internal function
  v_secret := private.get_user_secret_internal(v_user_id, p_key);
  return v_secret;
end;
$function$;

-- Revoke all by default
revoke all on function public.get_user_secret(text)
from public, anon;

-- Allow only authenticated users
grant execute on function public.get_user_secret(text)
to authenticated;

```

Now we got those two functions out of the way, lets loop back around to getting them inserted into the database without any major issues.
Internal function to create osrs account,

```sql
create or replace function private.create_osrs_account_internal(
  p_user_id uuid,
  p_account_name text,
  p_email_key text,
  p_password_key text,
  p_world integer default null,
  p_p2p boolean default false
)
returns void
language plpgsql
security definer
set search_path = private, vault, public
as $function$
declare
  v_email text;
  v_password text;
  v_email_key text := format('user/%s/%s', p_user_id, p_email_key);
  v_password_key text := format('user/%s/%s', p_user_id, p_password_key);
begin
  -- Validate user exists
  if not exists (select 1 from auth.users where id = p_user_id) then
    raise exception 'Invalid user ID';
  end if;

  -- Validate account name
  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format';
  end if;

  -- Validate key formats
  if p_email_key !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid email key format';
  end if;

  if p_password_key !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid password key format';
  end if;

  -- Confirm the secrets exist in Vault
  v_email := private.get_user_secret_internal(p_user_id, p_email_key);
  v_password := private.get_user_secret_internal(p_user_id, p_password_key);

  -- Insert or update OSRS account metadata
  insert into private.user_osrs_accounts (
    user_id,
    account_name,
    vault_email_key,
    vault_password_key,
    world,
    p2p
  )
  values (
    p_user_id,
    p_account_name,
    v_email_key,
    v_password_key,
    p_world,
    p_p2p
  )
  on conflict (user_id, account_name) do update
  set
    vault_email_key = excluded.vault_email_key,
    vault_password_key = excluded.vault_password_key,
    world = excluded.world,
    p2p = excluded.p2p,
    updated_at = now();
end;
$function$;

revoke all on function private.create_osrs_account_internal(
  uuid, text, text, text, integer, boolean
) from public, anon, authenticated;

grant execute on function private.create_osrs_account_internal(
  uuid, text, text, text, integer, boolean
) to service_role;


```

The public function that we will be using this function

```sql

create or replace function public.create_osrs_account(
  p_account_name text,
  p_email text,
  p_password text,
  p_world integer default null,
  p_p2p boolean default false
)
returns void
language plpgsql
security definer
set search_path = public, private
as $function$
declare
  v_user_id uuid := auth.uid();
begin
  -- Ensure the user is logged in
  if v_user_id is null then
    raise exception 'Not authenticated';
  end if;

  -- Validate account_name to prevent abuse
  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name. Only lowercase letters, numbers, and underscores (3–64 characters) are allowed.';
  end if;

  -- Call the internal secure creator
  perform private.create_osrs_account_internal(
    v_user_id,
    p_account_name,
    p_email,
    p_password,
    p_world,
    p_p2p
  );
end;
$function$;

-- Revoke default access
revoke all on function public.create_osrs_account(
  text, text, text, integer, boolean
) from public, anon;

-- Grant access only to authenticated users
grant execute on function public.create_osrs_account(
  text, text, text, integer, boolean
) to authenticated;

```

Okay, after getting the ability to create accounts and updating them, there will be two more functions that we will need, one for deleting and one for listing.

```sql

create or replace function public.list_osrs_accounts()
returns table (
  account_name text,
  state text,
  world integer,
  p2p boolean,
  created_at timestamptz,
  updated_at timestamptz
)
language sql
security definer
set search_path = public, private
as $function$
  select
    account_name,
    state,
    world,
    p2p,
    created_at,
    updated_at
  from private.user_osrs_accounts
  where user_id = auth.uid();
$function$;

revoke all on function public.list_osrs_accounts() from public, anon;
grant execute on function public.list_osrs_accounts() to authenticated;


```

For deleting the user account, we will have to invoke a the private public schema setup again with an internal function.

```sql
create or replace function private.delete_osrs_account_internal(
  p_user_id uuid,
  p_account_name text
)
returns void
language plpgsql
security definer
set search_path = private, vault, public
as $$
declare
  v_email_key text;
  v_password_key text;
begin
  -- Validate user
  if not exists (select 1 from auth.users where id = p_user_id) then
    raise exception 'Invalid user ID';
  end if;

  -- Validate account name
  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format';
  end if;

  -- Fetch vault keys
  select vault_email_key, vault_password_key
    into v_email_key, v_password_key
  from private.user_osrs_accounts
  where user_id = p_user_id and account_name = p_account_name;

  if not found then
    raise exception 'Account not found';
  end if;

  -- Delete secrets by name
  delete from vault.secrets where name = v_email_key;
  delete from vault.secrets where name = v_password_key;

  -- Remove account row
  delete from private.user_osrs_accounts
  where user_id = p_user_id and account_name = p_account_name;
end;
$$;

revoke all on function private.delete_osrs_account_internal(uuid, text)
from public, anon, authenticated;

grant execute on function private.delete_osrs_account_internal(uuid, text)
to service_role;

```

The next part of the document will be focused on the public schema that we want to utilize.

```sql

create or replace function public.delete_osrs_account(
  p_account_name text
)
returns void
language plpgsql
security definer
set search_path = public, private
as $function$
declare
  v_user_id uuid := auth.uid();
begin
  if v_user_id is null then
    raise exception 'Not authenticated';
  end if;

  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format. Only lowercase letters, numbers, and underscores (3–64 characters) are allowed.';
  end if;

  perform private.delete_osrs_account_internal(v_user_id, p_account_name);
end;
$function$;

revoke all on function public.delete_osrs_account(text)
from public, anon;

grant execute on function public.delete_osrs_account(text)
to authenticated;

```

To help with the stats and making sure that we give the user some basic information to work with, lets go ahead and build a private facing schema.

```sql

create table private.osrs_account_information (
  account_id uuid primary key references private.user_osrs_accounts(id) on delete cascade,

  -- Optional public display name for UI
  username text check (
    username ~ '^[a-zA-Z0-9 _\\-]{3,32}$'
  ),

  -- RuneScape stat values
  combat_level integer check (combat_level >= 3 and combat_level <= 126),
  total_level integer check (total_level >= 0 and total_level <= 2277),
  quest_points integer check (quest_points >= 0 and quest_points <= 300),

  -- Optional user-facing notes
  notes text check (char_length(notes) <= 500),

  last_synced_at timestamptz default now(),
  updated_at timestamptz default now()
);


alter table private.osrs_account_information enable row level security;

create policy "No access by default" on private.osrs_account_information
  for all using (false);

revoke all on private.osrs_account_information from anon, authenticated, public;
grant all on private.osrs_account_information to service_role;

```

Now we will use an internal function to create the core RPC call, then we can loop back around and create the public facing one.
This should prepare us for the next stage, once we get these executed.

```sql
create or replace function private.upsert_osrs_account_info_internal(
  p_user_id uuid,
  p_account_name text,
  p_username text default null,
  p_notes text default null,
  p_combat_level integer default null,
  p_total_level integer default null,
  p_quest_points integer default null,
  p_wealth_gp bigint default null
)
returns void
language plpgsql
security definer
set search_path = private, vault, public
as $function$
declare
  v_account_id uuid;
  v_clean_username text;
  v_clean_notes text;
begin
  -- Validate user
  if not exists (select 1 from auth.users where id = p_user_id) then
    raise exception 'Invalid user ID';
  end if;

  -- Validate account name
  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format.';
  end if;

  -- Lookup account
  select id into v_account_id
  from private.user_osrs_accounts
  where user_id = p_user_id and account_name = p_account_name;

  if not found then
    raise exception 'OSRS account not found or not owned by user.';
  end if;

  -- Clean username
  if p_username is not null then
    if p_username !~ '^[a-zA-Z0-9 _\\-]{3,32}$' then
      raise exception 'Invalid username format.';
    end if;
    v_clean_username := trim(p_username);
  end if;

  -- Clean notes (light sanitization only)
  if p_notes is not null then
    v_clean_notes := trim(p_notes);
    if char_length(v_clean_notes) > 500 then
      v_clean_notes := left(v_clean_notes, 500);
    end if;
  end if;

  -- Upsert
  insert into private.osrs_account_information (
    account_id,
    username,
    notes,
    combat_level,
    total_level,
    quest_points,
    wealth_gp
  )
  values (
    v_account_id,
    v_clean_username,
    v_clean_notes,
    p_combat_level,
    p_total_level,
    p_quest_points,
    p_wealth_gp
  )
  on conflict (account_id) do update
  set
    username       = coalesce(excluded.username, private.osrs_account_information.username),
    notes          = coalesce(excluded.notes, private.osrs_account_information.notes),
    combat_level   = coalesce(excluded.combat_level, private.osrs_account_information.combat_level),
    total_level    = coalesce(excluded.total_level, private.osrs_account_information.total_level),
    quest_points   = coalesce(excluded.quest_points, private.osrs_account_information.quest_points),
    wealth_gp      = coalesce(excluded.wealth_gp, private.osrs_account_information.wealth_gp),
    updated_at     = now();
end;
$function$;

revoke all on function private.upsert_osrs_account_info_internal(
  uuid, text, text, text, integer, integer, integer, bigint
)
from public, anon, authenticated;

grant execute on function private.upsert_osrs_account_info_internal(
  uuid, text, text, text, integer, integer, integer, bigint
)
to service_role;


```

Then we need to link this function back around to the public facing schema function, which the authenticated user will call.

```sql
create or replace function public.update_osrs_account_info(
  p_account_name text,
  p_username text default null,
  p_notes text default null,
  p_combat_level integer default null,
  p_total_level integer default null,
  p_quest_points integer default null,
  p_wealth_gp bigint default null
)
returns void
language plpgsql
security definer
set search_path = public, private
as $function$
declare
  v_user_id uuid := auth.uid();
begin
  if v_user_id is null then
    raise exception 'Not authenticated';
  end if;

  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format. Only a-z, 0-9, and underscores (3–64 characters) are allowed.';
  end if;

  -- Proxy to internal function
  perform private.upsert_osrs_account_info_internal(
    v_user_id,
    p_account_name,
    p_username,
    p_notes,
    p_combat_level,
    p_total_level,
    p_quest_points,
    p_wealth_gp
  );
end;
$function$;

-- Secure permissions
revoke all on function public.update_osrs_account_info(
  text, text, text, integer, integer, integer, bigint
) from public, anon;

grant execute on function public.update_osrs_account_info(
  text, text, text, integer, integer, integer, bigint
) to authenticated;

```

To pull this information, we will create another function to help us.

```sql

create or replace function public.get_osrs_account_info(
  p_account_name text
)
returns table (
  username text,
  combat_level integer,
  total_level integer,
  quest_points integer,
  wealth_gp bigint,
  notes text,
  last_synced_at timestamptz,
  updated_at timestamptz
)
language sql
security definer
set search_path = public, private
as $function$
  select
    i.username,
    i.combat_level,
    i.total_level,
    i.quest_points,
    i.wealth_gp,
    i.notes,
    i.last_synced_at,
    i.updated_at
  from private.user_osrs_accounts a
  join private.osrs_account_information i
    on a.id = i.account_id
  where a.user_id = auth.uid()
    and a.account_name = p_account_name;
$function$;

-- Lock down access
revoke all on function public.get_osrs_account_info(text) from public, anon;
grant execute on function public.get_osrs_account_info(text) to authenticated;

```

Finally, we will run this query below to make sure that everything was included without any issues:

```sql
-- Check existence of tables and functions
WITH expected_tables(schema, name) AS (
  VALUES
    ('private', 'user_secrets'),
    ('private', 'user_osrs_accounts'),
    ('private', 'osrs_account_information')
),
expected_functions(schema, name, arg_types) AS (
  VALUES
    ('private', 'set_user_secret_internal',    ARRAY['uuid', 'text', 'text']),
    ('public',  'set_user_secret',             ARRAY['text', 'text']),
    ('private', 'get_user_secret_internal',    ARRAY['uuid', 'text']),
    ('public',  'get_user_secret',             ARRAY['text']),
    ('private', 'create_osrs_account_internal',ARRAY['uuid', 'text', 'text', 'text', 'integer', 'boolean']),
    ('public',  'create_osrs_account',         ARRAY['text', 'text', 'text', 'integer', 'boolean']),
    ('public',  'list_osrs_accounts',          ARRAY[]::text[]),
    ('private', 'delete_osrs_account_internal',ARRAY['uuid', 'text']),
    ('public',  'delete_osrs_account',         ARRAY['text']),
    ('private', 'upsert_osrs_account_info_internal', ARRAY['uuid', 'text', 'text', 'text']),
    ('public',  'update_osrs_account_info',    ARRAY['text', 'text', 'text']),
    ('public',  'get_osrs_account_info',       ARRAY['text'])
),
normalized_functions AS (
  SELECT
    n.nspname AS schema,
    p.proname AS name,
    p.oid,
    (
      SELECT array_agg(format_type(t.oid, NULL)::text ORDER BY a.ordinality)
      FROM unnest(p.proargtypes) WITH ORDINALITY AS a(oid, ordinality)
      JOIN pg_type t ON t.oid = a.oid
    ) AS normalized_args
  FROM pg_proc p
  JOIN pg_namespace n ON n.oid = p.pronamespace
)

-- Final result: tables and functions
SELECT
  'table' AS type,
  et.schema || '.' || et.name AS identifier,
  CASE WHEN pt.tablename IS NOT NULL THEN '✅ exists' ELSE '❌ missing' END AS status
FROM expected_tables et
LEFT JOIN pg_tables pt
  ON pt.schemaname = et.schema AND pt.tablename = et.name

UNION ALL

SELECT
  'function' AS type,
  ef.schema || '.' || ef.name || '(' || array_to_string(ef.arg_types, ', ') || ')' AS identifier,
  CASE WHEN nf.oid IS NOT NULL THEN '✅ exists' ELSE '❌ missing' END AS status
FROM expected_functions ef
LEFT JOIN normalized_functions nf
  ON ef.schema = nf.schema
  AND ef.name = nf.name
  AND coalesce(nf.normalized_args, ARRAY[]::text[]) = ef.arg_types

ORDER BY type, identifier;

```

After verifying the tables and functions, we can loop back all the way to the top and look at the front end.
We know that these two are the public facing RPCs

```

public.set_user_secret(p_key text, p_value text) → void
public.get_user_secret(p_key text) → text

```

Then we have the core functions to help with create and listing.

```
public.create_osrs_account(
  p_account_name text,
  p_email text,
  p_password text,
  p_world integer default null,
  p_p2p boolean default false
) → void

public.list_osrs_accounts() → table (
  account_name text,
  state text,
  world integer,
  p2p boolean,
  created_at timestamptz,
  updated_at timestamptz
)

public.delete_osrs_account(p_account_name text) → void

public.update_osrs_account_state(
  p_account_name text,
  p_state text
) → void

public.update_osrs_account_info(
  p_account_name text,
  p_username text default null,
  p_notes text default null,
  p_combat_level integer default null,
  p_total_level integer default null,
  p_quest_points integer default null,
  p_wealth_gp bigint default null
) → void

public.get_osrs_account_info(p_account_name text) → table (
  username text,
  combat_level integer,
  total_level integer,
  quest_points integer,
  wealth_gp bigint,
  notes text,
  last_synced_at timestamptz,
  updated_at timestamptz
)

```

For the type safety, we can utilize zod and this would be the schema:

```ts

import { z } from 'zod';

export const UserSecretSchema = z.object({
  user_id: z.string().uuid(),
  key: z.string().regex(/^[a-z0-9_]{3,64}$/),
  vault_key: z.string(),
  created_at: z.string().datetime(),
  updated_at: z.string().datetime(),
});

export const OsrsAccountSchema = z.object({
  id: z.string().uuid(),
  user_id: z.string().uuid(),
  account_name: z.string().regex(/^[a-z0-9_]{3,64}$/),
  vault_email_key: z.string(),
  vault_password_key: z.string(),
  state: z.enum(['offline', 'active', 'banned', 'error']),
  world: z.number().int().nullable(),
  p2p: z.boolean(),
  created_at: z.string().datetime(),
  updated_at: z.string().datetime(),
});

export const OsrsAccountListEntrySchema = OsrsAccountSchema.pick({
  account_name: true,
  state: true,
  world: true,
  p2p: true,
  created_at: true,
  updated_at: true,
});

export const OsrsAccountInfoSchema = z.object({
  username: z.string().min(3).max(32).optional(),
  combat_level: z.number().int().min(3).max(126),
  total_level: z.number().int().min(0).max(2277),
  quest_points: z.number().int().min(0).max(300),
  notes: z.string().max(500).optional(),
  last_synced_at: z.string().datetime(),
  updated_at: z.string().datetime(),
});

```

And finally to call these functions, we can use this proof of concept:

```ts

const supabase = createClient(...);

// Example: Create account
await supabase.rpc('create_osrs_account', {
  p_account_name: 'iron_chip',
  p_email: 'osrs_email',
  p_password: 'osrs_pw',
  p_world: 301,
  p_p2p: true,
});

// Example: Get account metadata
const { data } = await supabase.rpc('get_osrs_account_info', {
  p_account_name: 'iron_chip',
});

// Example: Update account info (parameters in correct order)
await supabase.rpc('update_osrs_account_info', {
  p_account_name: 'iron_chip',
  p_username: 'Chip the Slayer',
  p_notes: 'Main account. Slayer training.',
  p_combat_level: 92,
  p_total_level: 1780,
  p_quest_points: 213,
  p_wealth_gp: 50000000
});

// Example: Update account state (login/logout)
await supabase.rpc('update_osrs_account_state', {
  p_account_name: 'iron_chip',
  p_state: 'active'  // 'offline', 'active', 'banned', 'error'
});

```

Lets go ahead and update the table for the user and track their wealth in gp too.

```sql

alter table private.osrs_account_information
add column wealth_gp bigint check (wealth_gp >= 0) default 0;

```

Next we want to keep track of the actual state of the account, so that we can keep track of it.

```sql

create or replace function private.update_osrs_account_state_internal(
  p_user_id uuid,
  p_account_name text,
  p_state text
)
returns void
language plpgsql
security definer
set search_path = private
as $function$
begin
  -- Validate
  if not exists (select 1 from auth.users where id = p_user_id) then
    raise exception 'Invalid user ID';
  end if;

  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format.';
  end if;

  if p_state not in ('offline', 'active', 'banned', 'error') then
    raise exception 'Invalid state value.';
  end if;

  -- Update the state
  update private.user_osrs_accounts
  set state = p_state,
      updated_at = now()
  where user_id = p_user_id and account_name = p_account_name;

  if not found then
    raise exception 'OSRS account not found for user.';
  end if;
end;
$function$;

revoke all on function private.update_osrs_account_state_internal(uuid, text, text)
  from public, anon, authenticated;

grant execute on function private.update_osrs_account_state_internal(uuid, text, text)
  to service_role;

```

That will be the private internal schema and now we can prepare for the public schema for the user to call.
This will be the public 

```sql

create or replace function public.update_osrs_account_state(
  p_account_name text,
  p_state text
)
returns void
language plpgsql
security definer
set search_path = public, private
as $function$
declare
  v_user_id uuid := auth.uid();
begin
  if v_user_id is null then
    raise exception 'Not authenticated';
  end if;

  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format.';
  end if;

  if p_state not in ('offline', 'active', 'banned', 'error') then
    raise exception 'Invalid state value.';
  end if;

  perform private.update_osrs_account_state_internal(v_user_id, p_account_name, p_state);
end;
$function$;

revoke all on function public.update_osrs_account_state(text, text)
  from public, anon;

grant execute on function public.update_osrs_account_state(text, text)
  to authenticated;

```

For the login, we want to make one call to grab all the information we need for the login.
So we need our dual function go grab that information.

```sql

create or replace function private.get_osrs_login_credentials_internal(
  p_user_id uuid,
  p_account_name text
)
returns table (
  email text,
  password text
)
language plpgsql
security definer
set search_path = private, vault, public
as $function$
declare
  v_email_key text;
  v_password_key text;
begin
  -- Validate
  if not exists (select 1 from auth.users where id = p_user_id) then
    raise exception 'Invalid user';
  end if;

  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format';
  end if;

  -- Fetch key names
  select vault_email_key, vault_password_key
  into v_email_key, v_password_key
  from private.user_osrs_accounts
  where user_id = p_user_id and account_name = p_account_name;

  if not found then
    raise exception 'OSRS account not found';
  end if;

  -- Fetch decrypted secrets
  return query
  select
    (select decrypted_secret from vault.decrypted_secrets where name = v_email_key),
    (select decrypted_secret from vault.decrypted_secrets where name = v_password_key);
end;
$function$;

revoke all on function private.get_osrs_login_credentials_internal(uuid, text)
from public, anon, authenticated;
grant execute on function private.get_osrs_login_credentials_internal(uuid, text)
to service_role;


```

After executing the private function, we will add out public facing one next.

```sql

create or replace function public.get_osrs_login_credentials(
  p_account_name text
)
returns table (
  email text,
  password text
)
language plpgsql
security definer
set search_path = public, private
as $function$
declare
  v_user_id uuid := auth.uid();
begin
  if v_user_id is null then
    raise exception 'Not authenticated';
  end if;

  if p_account_name !~ '^[a-z0-9_]{3,64}$' then
    raise exception 'Invalid account name format';
  end if;

  return query
    select * from private.get_osrs_login_credentials_internal(v_user_id, p_account_name);
end;
$function$;

revoke all on function public.get_osrs_login_credentials(text)
from public, anon;

grant execute on function public.get_osrs_login_credentials(text)
to authenticated;

```

Next we want to have a live view of the inventory, character health and location for the account that is logged in.
I am thinking that the data would be stored as `osrs_account_viewport` and can be used later on for realtime data.
Here is the base table that we can create to help us handle that:

```sql

create table private.osrs_account_viewport (
  account_id uuid primary key references private.user_osrs_accounts(id) on delete cascade,

  -- Core stats
  current_health integer check (current_health >= 0),
  max_health integer check (max_health > 0),

  current_prayer integer check (current_prayer >= 0),
  max_prayer integer check (max_prayer >= 0),

  run_energy integer check (run_energy >= 0 and run_energy <= 100),

  -- Location
  region text,
  x_coord integer,
  y_coord integer,

  -- Inventory (simplified to array of item names or structured JSON)
  inventory jsonb default '[]',

  -- Recent chat log (last few messages)
  recent_chat jsonb default '[]',

  last_updated_at timestamptz default now()
);

alter table private.osrs_account_viewport enable row level security;

create policy "No access by default" on private.osrs_account_viewport
  for all using (false);

revoke all on private.osrs_account_viewport from anon, authenticated, public;
grant all on private.osrs_account_viewport to service_role;

```




### User Function - Register

This is our register function as a proof of concept, includes some additional things like CORS and refreshing the material view.

```ts

// deno-lint-ignore-file no-explicit-any
import { createClient } from "npm:@supabase/supabase-js@2";
import { z } from "npm:zod@3.22.4";
import "jsr:@supabase/functions-js/edge-runtime.d.ts";
const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "POST, OPTIONS",
  "Access-Control-Allow-Headers": "apikey, X-Client-Info, Content-Type, Authorization, Accept, Accept-Language, X-Authorization",
  "Access-Control-Expose-Headers": "Content-Length, X-JSON"
};
Deno.serve(async (req)=>{
  if (req.method === "OPTIONS") {
    return new Response(null, {
      status: 204,
      headers: corsHeaders
    });
  }
  const supabaseAuth = createClient(Deno.env.get("SUPABASE_URL"), Deno.env.get("SUPABASE_ANON_KEY"), {
    global: {
      headers: {
        Authorization: req.headers.get("Authorization") ?? ""
      }
    }
  });
  const supabaseAdmin = createClient(Deno.env.get("SUPABASE_URL"), Deno.env.get("SUPABASE_SERVICE_ROLE_KEY"));
  const inputSchema = z.object({
    username: z.string().regex(/^[a-zA-Z0-9_-]{3,30}$/)
  });
  try {
    const body = await req.json();
    const parsed = inputSchema.parse(body);
    const { data: { user }, error: userError } = await supabaseAuth.auth.getUser();
    if (userError || !user) {
      return new Response(JSON.stringify({
        error: "Unauthorized"
      }), {
        status: 401,
        headers: {
          ...corsHeaders,
          "Content-Type": "application/json"
        }
      });
    }
    const { id: user_id } = user;
    const { error: rpcError } = await supabaseAdmin.rpc("create_user_context_proxy", {
      user_id,
      username: parsed.username,
      bio: "",
      avatar_ulid: null,
      role: null,
      level: 1,
      credits: 0,
      khash: 0
    });
    if (rpcError) {
      console.error("[create_user_context] RPC Error", rpcError);
      return new Response(JSON.stringify({
        error: rpcError.message
      }), {
        status: 500,
        headers: {
          ...corsHeaders,
          "Content-Type": "application/json"
        }
      });
    }
    const { error: metaError } = await supabaseAdmin.auth.admin.updateUserById(user_id, {
      user_metadata: {
        username: parsed.username
      }
    });
    if (metaError) {
      console.error("[user_metadata] Failed to update:", metaError);
      return new Response(JSON.stringify({
        error: metaError.message
      }), {
        status: 500,
        headers: {
          ...corsHeaders,
          "Content-Type": "application/json"
        }
      });
    }
    supabaseAdmin.rpc("refresh_view", {
      p_view_name: "user_balances_view"
    }).then(({ error })=>{
      if (error) {
        console.error("[refresh_view] Failed to refresh view:", error.message);
      }
    });
    return new Response(JSON.stringify({
      success: true
    }), {
      status: 200,
      headers: {
        ...corsHeaders,
        "Content-Type": "application/json"
      }
    });
  } catch (err) {
    console.error("[create_user_context] Parse/Error", err);
    return new Response(JSON.stringify({
      error: err?.message ?? "Unknown error"
    }), {
      status: 400,
      headers: {
        ...corsHeaders,
        "Content-Type": "application/json"
      }
    });
  }
});

```

### User Schema - Inventory - Hybrid

<Aside type="note">
The hybrid inventory system combines two complementary approaches to handle different types of game items efficiently:

1. **Stackable Items** (`inventory_stackable`): For items that can be grouped together (consumables, materials, currency)
2. **Instance Items** (`inventory_instances`): For unique items with individual properties (weapons with different durability, enchanted gear)
</Aside>

#### Inventory Design Philosophy

The dual-table approach optimizes both storage and query performance:

- **Stackable items** reduce database bloat by storing quantities instead of individual rows
- **Instance items** preserve unique characteristics and modification history
- **Unified querying** through views and functions provides a seamless developer experience

#### Inventory Key Features

**Security & Performance:**
- All tables use Row Level Security (RLS) with restrictive policies, i.e deny all but `service_role`
- Only the `service_role` has direct access to prevent unauthorized modifications, which will be used by the RPC.
- Indexed on `user_id` for fast lookups.
- UUID primary keys with automatic generation.

**Data Integrity:**
- Foreign key constraints ensure referential integrity with `auth.users`
- Check constraints prevent negative quantities.
- Unique constraints prevent duplicate stackable entries per user/item.
- JSONB metadata fields for flexible item properties, extendable to instance items later on.

**Scalability Considerations:**
- Stackable items table remains lean even with millions of users.
- Instance items can store complex metadata without affecting stackable performance.
- Partitioning strategies can be applied based on `user_id` for large datasets.

We want to keep track of the user inventory but with a couple checks in place, this is for items that are at the spaceship level.
This system will use a dual tracking system, one for the stackable and another for the instance.

```sql
create table private.inventory_stackable (
  id uuid primary key default gen_random_uuid(),
  user_id uuid references auth.users(id)
    on delete cascade on update restrict,
  item_id text not null, -- ULID/SKU of item type
  quantity integer not null check (quantity >= 0),
  meta jsonb default '{}'::jsonb,
  created_at timestamptz default now(),
  updated_at timestamptz default now()
);

-- Unique constraint: 1 row per (user_id, item_id)
create unique index idx_unique_stackable_user_item on private.inventory_stackable(user_id, item_id);

-- Fast lookup
create index idx_stackable_user on private.inventory_stackable(user_id);

-- Enable and lock down RLS
alter table private.inventory_stackable enable row level security;

create policy "No access to stackable inventory" on private.inventory_stackable
  for all using (false);

create table private.inventory_instances (
  id uuid primary key default gen_random_uuid(),
  user_id uuid references auth.users(id)
    on delete cascade on update restrict,
  item_id text not null, -- ULID/SKU of item type
  meta jsonb default '{}'::jsonb, -- durability, modifiers, etc
  created_at timestamptz default now()
);

-- Fast lookup
create index idx_instances_user on private.inventory_instances(user_id);

-- Enable and lock down RLS
alter table private.inventory_instances enable row level security;

create policy "No access to inventory instances" on private.inventory_instances
  for all using (false);

-- Service Role Perms.

-- Grant all access to the service role
grant select, insert, update, delete on private.inventory_stackable to service_role;
grant select, insert, update, delete on private.inventory_instances to service_role;

-- If using sequences (not needed for UUIDs, but safe practice)
grant usage, select on all sequences in schema private to service_role;
```

## Admin

### Admin Schema

This is the schema that we will be using to install the admin panel.

```sql

-- Create the admin schema
create schema if not exists admin;

-- Revoke default PUBLIC access
revoke all on schema admin from public;

-- Revoke access to objects in the schema from anon/authenticated
revoke all on all tables in schema admin from anon, authenticated;
revoke all on all functions in schema admin from anon, authenticated;

-- Grant access to service_role
grant usage on schema admin to service_role;
grant select, insert, update, delete on all tables in schema admin to service_role;
grant execute on all functions in schema admin to service_role;

```

### Refresh Flags Table

The core table for refreshing the material views, allowing us to cache some of the future heavy reads.

```sql

-- Create the refresh_flags table in the admin schema
create table if not exists admin.refresh_flags (
  view_name text primary key,
  needs_refresh boolean default true,
  updated_at timestamptz default now()
);

-- Revoke all privileges on the table from public-facing roles
revoke all on table admin.refresh_flags from public;
revoke all on table admin.refresh_flags from anon;
revoke all on table admin.refresh_flags from authenticated;

-- Grant access only to the service role
grant select, insert, update, delete on table admin.refresh_flags to service_role;

-- Enable RLS explicitly
alter table admin.refresh_flags enable row level security;

-- (Optional) Create a RLS policy for service_role
create policy "Service can access all rows"
on admin.refresh_flags
for all
to service_role
using (true)
with check (true);
```

The next part will be to deploy the function to handle the flag shifts and refreshing the material views.

```sql

create or replace function admin.refresh_view(p_view_name text)
returns void
language plpgsql
security definer
set search_path = admin, public
as $$
begin
  -- Ensure the view exists in the public schema
  if not exists (
    select 1 from pg_matviews
    where schemaname = 'public' and matviewname = p_view_name
  ) then
    raise exception 'Invalid or unknown materialized view: %', p_view_name;
  end if;

  -- Only refresh if flagged
  if exists (
    select 1 from admin.refresh_flags
    where view_name = p_view_name and needs_refresh
  ) then

    -- Dynamically refresh the view safely
    execute format(
      'refresh materialized view concurrently public.%I',
      p_view_name
    );

    -- Reset the flag
    update admin.refresh_flags
    set needs_refresh = false,
        updated_at = now()
    where view_name = p_view_name;
  end if;
end;
$$;

-- Secure the function: prevent access from public/anon/authenticated
revoke execute on function admin.refresh_view(text) from public;
revoke execute on function admin.refresh_view(text) from anon;
revoke execute on function admin.refresh_view(text) from authenticated;

-- Allow only service role to call it
grant execute on function admin.refresh_view(text) to service_role;

```

Next, we want a proxy function so that it be easier to call from the edge workers.

```sql

create or replace function public.refresh_view(p_view_name text)
returns void
language plpgsql
security invoker
set search_path = public, admin
as $$
begin
  -- Step 1: Set the refresh flag
  insert into admin.refresh_flags (view_name, needs_refresh)
  values (p_view_name, true)
  on conflict (view_name)
  do update set needs_refresh = true, updated_at = now();

  -- Step 2: Call the internal secure function
  perform admin.refresh_view(p_view_name);
end;
$$;

-- Secure the function
revoke execute on function public.refresh_view(text) from public;
revoke execute on function public.refresh_view(text) from anon;
revoke execute on function public.refresh_view(text) from authenticated;
grant execute on function public.refresh_view(text) to service_role;

```

## Utility


### Generate ULID Functions

```sql

create or replace function gen_ulid()
returns text
language plpgsql
set search_path = public, extensions
as $$
declare
  time_part text := to_hex((extract(epoch from clock_timestamp()) * 1000)::bigint);
  rand_part text := encode(extensions.gen_random_bytes(10), 'hex');
begin
  return lpad(time_part, 12, '0') || rand_part;
end;
$$;

```

<Adsense />

### Function Discord Hook Notification


```ts

// deno-lint-ignore-file no-explicit-any
import { createClient } from "npm:@supabase/supabase-js@2";
import { z } from "npm:zod@3.22.4";
import "jsr:@supabase/functions-js/edge-runtime.d.ts";

const DISCORD_WEBHOOK = Deno.env.get("DISCORD_WEBHOOK_URL");
const DISCORD_THREAD_ID = Deno.env.get("DISCORD_THREAD_ID"); // <-- Set this in your env

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "POST, OPTIONS",
  "Access-Control-Allow-Headers": "apikey, X-Client-Info, Content-Type, Authorization",
  "Access-Control-Expose-Headers": "Content-Length"
};

Deno.serve(async (req) => {
  if (req.method === "OPTIONS") {
    return new Response(null, { status: 204, headers: corsHeaders });
  }

  const supabase = createClient(
    Deno.env.get("SUPABASE_URL"),
    Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")
  );

  const inputSchema = z.object({
    uuid: z.string().uuid(),
    message: z.string().min(1).max(2000)
  });

  try {
    const body = await req.json();
    const { uuid, message } = inputSchema.parse(body);

    const { data: user, error } = await supabase
      .from("auth.users")
      .select("raw_user_meta_data")
      .eq("id", uuid)
      .single();

    if (error || !user) {
      return new Response(JSON.stringify({ error: "User not found" }), {
        status: 404,
        headers: corsHeaders
      });
    }

    const discordId = user.raw_user_meta_data?.provider_id;

    if (!discordId) {
      return new Response(JSON.stringify({ error: "Discord not linked" }), {
        status: 400,
        headers: corsHeaders
      });
    }

    const webhookUrl = `${DISCORD_WEBHOOK}?thread_id=${DISCORD_THREAD_ID}`;

    const discordPayload = {
      content: `<@${discordId}> ${message}`
    };

    const discordRes = await fetch(webhookUrl, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(discordPayload)
    });

    if (!discordRes.ok) {
      const errText = await discordRes.text();
      return new Response(JSON.stringify({ error: `Discord error: ${errText}` }), {
        status: 502,
        headers: corsHeaders
      });
    }

    return new Response(JSON.stringify({ success: true }), {
      status: 200,
      headers: corsHeaders
    });
  } catch (err: any) {
    return new Response(JSON.stringify({ error: err?.message ?? "Unknown error" }), {
      status: 400,
      headers: corsHeaders
    });
  }
});

```

---
# Terraform

> Terraform is HashiCorp's open-source infrastructure as code (IaC) tool that provisions and manages cloud
resources across AWS, Azure, GCP, and hundreds of providers from declarative HCL configuration files.
This guide covers the core workflow, HCL basics, state management, and reusable modules.

Source: https://kbve.com/application/terraform/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

**Terraform** is HashiCorp's open-source **infrastructure as code (IaC)** tool. Instead of clicking through cloud consoles, you declare the resources you want — servers, networks, DNS records, databases — in `.tf` configuration files, and Terraform provisions them to match. The same config reproduces an environment identically every time, and version control gives you a full history of infrastructure changes.

Terraform is **provider-agnostic**: one workflow drives AWS, Azure, GCP, Kubernetes, Cloudflare, and hundreds more via a plugin ecosystem.

This guide covers the [core workflow](#workflow), [HCL basics](#configuration), [state management](#state), and [reusable modules](#modules).

<Adsense />

## Workflow

Terraform's day-to-day loop is four commands:

<Steps>

1. **`terraform init`**
   Downloads the providers and modules your config references and prepares the working directory. Run it once per project and again whenever providers or backends change.

   ```bash
   terraform init
   ```

2. **`terraform plan`**
   A dry run. Terraform reads current state, compares it to your config, and prints exactly what it would add, change, or destroy — without touching anything.

   ```bash
   terraform plan -out=tfplan
   ```

3. **`terraform apply`**
   Executes the plan against real providers. With a saved plan file it applies without re-prompting; otherwise it shows the diff and waits for `yes`.

   ```bash
   terraform apply tfplan
   ```

4. **`terraform destroy`**
   Tears down everything the configuration manages. Useful for ephemeral environments and test stacks.

   ```bash
   terraform destroy
   ```

</Steps>

<Aside type="tip">
Always review `terraform plan` output before applying — the "destroy" and "replace (`-/+`)" lines are where accidental data loss hides.
</Aside>

## Configuration

Terraform files are written in **HCL (HashiCorp Configuration Language)**. A minimal AWS example:

```hcl
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.region
}

variable "region" {
  type    = string
  default = "us-east-1"
}

resource "aws_instance" "web" {
  ami           = "ami-0abcdef1234567890"
  instance_type = "t3.micro"

  tags = {
    Name = "kbve-web"
  }
}

output "public_ip" {
  value = aws_instance.web.public_ip
}
```

| Block | Purpose |
| ----- | ------- |
| `terraform` | Provider requirements and backend config |
| `provider` | Configure a target platform (region, credentials) |
| `resource` | A managed piece of infrastructure |
| `variable` | Parameterize a configuration |
| `output` | Export values after apply |
| `data` | Read existing resources you don't manage |

## State

Terraform records what it manages in a **state file** (`terraform.tfstate`). State maps your config to real resource IDs so Terraform can detect drift and compute minimal changes.

For teams, **never** commit local state to git — store it **remotely** with locking so two applies can't race:

```hcl
terraform {
  backend "s3" {
    bucket         = "kbve-tfstate"
    key            = "prod/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "tf-locks"
    encrypt        = true
  }
}
```

<Aside type="caution">
State can contain secrets (passwords, keys) in plaintext. Use a remote backend with encryption at rest and restrict access — treat the state file as sensitive.
</Aside>

## Modules

A **module** is a reusable bundle of Terraform config. Package infrastructure once, call it many times with different inputs:

```hcl
module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "5.0.0"

  name = "kbve-prod"
  cidr = "10.0.0.0/16"
}
```

The [Terraform Registry](https://registry.terraform.io/) hosts thousands of community and verified modules. Wrap your own patterns into local modules under a `modules/` directory to keep environments DRY.

## Wrappers

-   [PreTF](https://github.com/raymondbutcher/pretf)
-   [TerraformJS](https://github.com/mdawar/terraformjs)

## References

-   [Terraform The Hard Way](https://github.com/AdminTurnedDevOps/Terraform-The-Hard-Way)
-   [Terraform Sentry Provider](https://github.com/jianyuan/terraform-provider-sentry)
-   [Awesome Terraform](https://github.com/shuaibiyy/awesome-terraform)
-   [Terraform Scalable Self-Hosted GitHub Runners](https://github.com/philips-labs/terraform-aws-github-runner)

## FAQ

**What is Terraform used for?**
Terraform is an infrastructure as code tool that provisions and manages cloud and on-prem resources through declarative configuration files. You describe the desired end state in HCL, and Terraform figures out the create, update, and destroy actions needed to reach it across providers like AWS, Azure, and GCP.

**What is the difference between `terraform plan` and `terraform apply`?**
`terraform plan` is a dry run that shows what changes Terraform would make without touching any infrastructure. `terraform apply` executes those changes against real providers after an optional confirmation prompt.

**What is Terraform state and why does it matter?**
State is a JSON file that maps your configuration to the real resources Terraform manages. It lets Terraform detect drift and plan minimal changes. In teams, store it remotely (e.g. an S3 bucket with locking) so no two people apply at once against a shared, stale state.

**What is a Terraform module?**
A module is a reusable, parameterized package of Terraform configuration. Modules let you package a VPC, cluster, or service once and reuse it across environments with different variables.

**Is Terraform free?**
The Terraform CLI is open source and free. HashiCorp also offers HCP Terraform with paid tiers for remote state and run pipelines. OpenTofu is a community-driven, MPL-licensed fork maintained under the Linux Foundation.

<Adsense />

---
# Traefik

> Traefik is a cloud-native reverse proxy and load balancer with automatic service discovery and Let's Encrypt TLS.
This guide covers running Traefik with Docker Compose, patching and installing it on a Kubernetes (k3s) cluster,
wiring BasicAuth middleware, and automating Cloudflare DNS challenges for ACME certificates.

Source: https://kbve.com/application/traefik/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Overview

Traefik is a cloud-native reverse proxy and load balancer that makes deploying, configuring, and integrating infrastructure components easy and automatic. Unlike a static proxy, Traefik discovers services dynamically from providers — Docker labels, Kubernetes CRDs, or file config — and reconfigures its routes as containers start and stop. It also provisions Let's Encrypt TLS certificates automatically.

This guide moves from local to production: run Traefik with Docker Compose, patch and install it on a k3s Kubernetes cluster, attach BasicAuth middleware, and automate Cloudflare DNS challenges for ACME certificates.

<Steps>

1. **Docker** — Stand up Traefik locally with Compose and an `acme.json` for certificates.

2. **Kubernetes** — Install the CRDs and RBAC, then patch the service and add Helm.

3. **Middleware** — Isolate concerns like auth into `Middleware` resources referenced by Ingress.

4. **Cloudflare** — Wire scoped API tokens so Traefik solves the ACME DNS-01 challenge automatically.

</Steps>

---

<Adsense />

## Docker

Docker Compose - There should be an acme.json file that you create and pass through the docker with the permission of chmod 600. - Furthermore, there are two more files that you will have to configure and pass through before launching the traefik container. We provided them in the #config section below.

A complete `docker-compose.yml` that runs Traefik, mounts the Docker socket for auto-discovery, and routes to a `whoami` test service:

```yaml
services:
  traefik:
    image: traefik:v3.1
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedByDefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--api.dashboard=true"
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "./acme.json:/acme.json"
    restart: unless-stopped

  whoami:
    image: traefik/whoami
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.whoami.rule=Host(`whoami.localhost`)"
      - "traefik.http.routers.whoami.entrypoints=web"
```

Traefik reads the `traefik.*` labels on each container and builds routers automatically — no separate config file needed for basic routing. Mounting the Docker socket read-only (`:ro`) lets Traefik watch for containers starting and stopping.

<Aside type="caution">
Mounting `/var/run/docker.sock` gives Traefik root-equivalent access to the host. Keep it read-only and never expose the Traefik API/dashboard publicly without authentication.
</Aside>

## Kubernetes

-   Patching Traefik on k3s cluster

    -   We want to find the instance of where traefik is running. Running `sudo kubectl get all -o wide --all-namespaces` should display all your containers, look for traefik.
    -   Patch

        -   ```shell
            sudo kubectl patch svc traefik -n kube-system -p '{"spec":{"externalTrafficPolicy":"Cluster"}}'
            ```

    -   std output should be `service/traefik patched`

-   Helm Charts

    -   ```shell
        helm repo add traefik https://helm.traefik.io/traefik
        ```

        -   **Sucess**: std output should be

            -   ```shell
                "traefik" has been added to your repositories
                ```

    -   ```shell
        helm repo update
        ```

-   Traefik Middleware for Kubernetes

    -   Middleware kind should be isolated for performance and security reasons.

        -   Auth - Kind: Middleware

            -   Example:

                -   ```yaml
                    apiVersion: traefik.containo.us/v1alpha1
                    kind: Middleware
                    metadata:
                        name: longhorn-auth
                        namespace: longhorn-system
                    spec:
                        basicAuth:
                            secret: authsecret
                    ```

                    -   The middleware should be saved as a yaml / yml file and applied using kubectl.

        -   Auth - Kind: Ingress

            -   Calling the `longhorn-auth` in the `Ingress` via `annotations`:

                -   Example:

                    -   ```yaml
                        apiVersion: networking.k8s.io/v1
                        kind: Ingress
                        metadata:
                            name: longhorn-ing-traefik
                            namespace: longhorn-system
                            annotations:
                                externalTrafficPolicy: Local
                                kubernetes.io/ingress.class: traefik
                                traefik.ingress.kubernetes.io/router.middlewares: longhorn-system-longhorn-auth@kubernetescrd
                                ingress.kubernetes.io/whitelist-x-forwarded-for: 'true'

                        spec:
                            rules:
                                - host: 'x.kbve.com'
                                  http:
                                      paths:
                                          - path: /
                                            pathType: Prefix
                                            backend:
                                                service:
                                                    name: longhorn-service-provider
                                                    port:
                                                        number: 8000
                        ```

                    -   In our PoC above, we see that the middleware is referenced as:

                        ```yaml
                        traefik.ingress.kubernetes.io/router.middlewares: longhorn-system-longhorn-auth@kubernetescrd
                        ```

                        Its important to note the namespace of the middleware, `longhorn-system` , before calling the middleware's name. This is to let the crd know where the middleware is located.

---

## Config

Traefik reads two kinds of configuration: **static** (`traefik.yml`, entrypoints and providers, loaded once at startup) and **dynamic** (routers, services, middleware, hot-reloaded at runtime). For Docker deployments, create the ACME store first so Traefik can persist issued certificates:

```shell
touch acme.json
chmod 600 acme.json
```

<Aside type="caution">
`acme.json` must be `chmod 600`. Traefik refuses to start if the permissions are too open, since the file holds private keys.
</Aside>

A minimal static `traefik.yml` enabling the Docker provider and a Let's Encrypt resolver:

```yaml
entryPoints:
  websecure:
    address: ":443"

providers:
  docker:
    exposedByDefault: false

certificatesResolvers:
  letsencrypt:
    acme:
      email: admin@kbve.com
      storage: acme.json
      dnsChallenge:
        provider: cloudflare
```

Mount `acme.json` and `traefik.yml` into the container and pass the Cloudflare token (see [Cloudflare](#cloudflare) below) so the `dnsChallenge` resolver can complete.

---


## Notes

[According to the notes on Traefik & Kubernetes](https://doc.traefik.io/traefik/providers/kubernetes-crd/)
we first need to install the Resource Definitions and RBAC into `kubectl` by running the following commands:

```shell
# Install Traefik Resource Definitions:
kubectl apply -f https://raw.githubusercontent.com/traefik/traefik/v2.8/docs/content/reference/dynamic-configuration/kubernetes-crd-definition-v1.yml

# Install RBAC for Traefik:
kubectl apply -f https://raw.githubusercontent.com/traefik/traefik/v2.8/docs/content/reference/dynamic-configuration/kubernetes-crd-rbac.yml

```

After this installation, we'll have a set of [Custom Resource Definitions](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)
which should have the following benefits:

-   The usage of `name` and `namespace` to refer to another Kubernetes resource.
-   The usage of [secret](https://kubernetes.io/docs/concepts/configuration/secret/) for sensitive data (TLS certificates and credentials).
-   The structure of the configuration.
-   The requirement to declare all the [definitions](https://doc.traefik.io/traefik/reference/dynamic-configuration/kubernetes-crd/#definitions).

See the list of CRDs in the dedicated [routing section](https://doc.traefik.io/traefik/routing/providers/kubernetes-crd/).

The biggest thing we need from this is the ability to add the [BasicAuth](https://doc.traefik.io/traefik/middlewares/http/basicauth/) plugin.
This plugin (which is what we tried to reference before with the `auth@file` line) uses an htpasswd password to block incoming traffic to the pod.

This will require setting up an IngressRoute (which is a specific Kubernetes resource added by the Traefik Resource Definitions) with settings to specify
what the middlewares are. [Find more info on the Traefik Middlewares Here](https://doc.traefik.io/traefik/middlewares/overview/)

### IngressRoute Example

`IngressRoute` is Traefik's native alternative to the standard Kubernetes `Ingress`. It exposes Traefik-specific features — middleware chains, TLS resolvers, and match rules — directly, without annotation soup. This route attaches the `longhorn-auth` middleware from the previous example:

```yaml
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: longhorn-route
  namespace: longhorn-system
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`x.kbve.com`)
      kind: Rule
      middlewares:
        - name: longhorn-auth
      services:
        - name: longhorn-service-provider
          port: 8000
  tls:
    certResolver: letsencrypt
```

The `match` rule uses Traefik's expression syntax — combine with `&&`, `||`, and `PathPrefix(...)` for fine-grained routing. `certResolver: letsencrypt` triggers automatic ACME certificate issuance for the host.

## Dashboard

Traefik ships a web dashboard that visualizes every router, service, and middleware it has discovered — invaluable for debugging why a route isn't matching. Enable it with `--api.dashboard=true` (see the Compose example above), then secure it behind BasicAuth:

```yaml
labels:
  - "traefik.enable=true"
  - "traefik.http.routers.dashboard.rule=Host(`traefik.kbve.com`)"
  - "traefik.http.routers.dashboard.service=api@internal"
  - "traefik.http.routers.dashboard.middlewares=dashboard-auth"
  - "traefik.http.middlewares.dashboard-auth.basicauth.users=admin:$$apr1$$..."
```

<Aside type="caution">
In Docker Compose, `$` must be escaped as `$$` inside label values, or Compose interprets it as variable substitution and your htpasswd hash breaks.
</Aside>

---


## Cloudflare

These are notes on integrating `Cloudflare` with `Traefik`, including automating some of the actions so that you may not have to repeat them.

### Acme Docs

[Official Docs](https://go-acme.github.io/lego/dns/cloudflare/#api-tokens)

Access the API Tokens directly from [Cloudflare Profile](https://dash.cloudflare.com/profile/api-tokens)

Common environmental variable names and their purpose:

-   `CF_API_EMAIL` - The Cloudflare account holder's email.
-   `CF_API_KEY` - The Cloudflare API key.
-   `CF_DNS_API_TOKEN` - The API token with `DNS:Edit` permission.
-   `CF_ZONE_API_TOKEN` - The API token with `Zone:Read` permission.

<Aside type="tip">
Prefer the scoped `CF_DNS_API_TOKEN` + `CF_ZONE_API_TOKEN` pair over the legacy global `CF_API_KEY`. A scoped token limits blast radius if leaked, and Cloudflare recommends it for ACME DNS challenges.
</Aside>

---

## FAQ

**What is Traefik?**
Traefik is a cloud-native reverse proxy and load balancer that automatically discovers services from providers like Docker and Kubernetes, and provisions Let's Encrypt TLS certificates without manual configuration.

**How is Traefik different from Nginx?**
Traefik discovers routes dynamically from labels and CRDs, so it reconfigures itself as containers start and stop. [Nginx](/application/nginx/) uses static config files that require a reload. Traefik also ships automatic ACME TLS, whereas Nginx needs an external tool like certbot.

**What is a Traefik middleware?**
Middleware modifies requests or responses as they pass through a router — for example BasicAuth, rate limiting, or header rewrites. On Kubernetes it is a `Middleware` CRD referenced from an Ingress or IngressRoute by namespace-qualified name.

**How does Traefik get TLS certificates from Cloudflare?**
Traefik uses the ACME DNS-01 challenge with Cloudflare's API. You supply a scoped API token (`DNS:Edit` and `Zone:Read`) via environment variables, and Traefik creates the required DNS TXT record automatically to prove domain ownership.

<Adsense />

---
# Unity

> Unity is a powerful 3D and 2D game engine that enables the creation of cross-platform games, interactive experiences, and real-time 3D applications.
The Unity Engine offers tools for animation, physics, rendering, and artificial intelligence, supporting both beginners and professional developers.
With extensive support for VR, AR, and mobile platforms, Unity serves as a comprehensive development environment for building engaging content across a variety of industries.

Source: https://kbve.com/application/unity/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

-   Unity is a versatile cross-platform engine used for creating games, applications, and interactive animations across desktop, mobile, console, and virtual/augmented reality platforms.
    Unity's engine provides a highly adaptable environment that supports both 2D and 3D development, making it ideal for a wide range of projects, from simple indie games to complex, enterprise-level applications.
    Furthermore, the engine’s compatibility spans across major operating systems and gaming consoles, including Windows, macOS, Linux, iOS, Android, PlayStation, Xbox, and Nintendo Switch.
    With built-in features like real-time rendering, physics simulation, and animation tools, Unity serves as an all-in-one solution for developers.
    Additionally, its support for AR and VR development empowers creators to produce immersive experiences with robust performance and seamless integration.
    Finally, our goal with this document is to provide as much information as we can for the Unity engine, its plugins, concepts and more!

-   The engine primarily utilizes C# for scripting and offers extensive support for custom development through a variety of libraries, plugins, and asset packages.
    With C# at its core, Unity provides a robust framework for implementing gameplay logic, managing data structures, and interacting with the engine's extensive API.
    Developers can enhance and extend Unity’s capabilities using third-party libraries, Unity Asset Store packages, and custom plugins written in C#.
    Furthermore, Unity supports scripting in the form of MonoBehaviour scripts, which provide easy-to-use methods for handling core events like Start(), Update(), and more.
    This flexibility enables the development of complex systems, such as AI behaviors, procedural content generation, and real-time multiplayer features.

<Adsense />

---

## Services

There are several products that Unity offers ontop of their game engine, including DevOps, Advertising and Hosting services.

<Aside>
Many Unity services require a separate subscription. Review the official pricing page before committing to them.
</Aside>

---

## Header

-   Right click and create empty
-   Name it below : (Replace HeaderName with the name you would want)

```shell
---> HeaderName
```

---

## Scene

Every project starts with a scene and are a fundamental concept in Unity game / application development.
They are self-contained units that contain all of the game objects, components, and data for a particular game level.
Scenes can be loaded and unloaded at runtime, which allows developers to create games with multiple levels or to create games that can be customized by the player.

When you create a new Unity project, you are given a default scene that contains a camera and a directional light.
You can add additional game objects to this scene by dragging them from the Assets window into the Scene view.
Furthermore, you can also create new game objects by using the Create menu in the Hierarchy window.

Once you have created your game objects, you can add components to them.
Components are scripts that add functionality to game objects.
For example, you can add a Rigidbody component to a game object to make it move around in the world.
You can also add a Collider component to a game object to make it collide with other game objects.

When you are finished creating your game objects and adding components to them, you can save your scene by clicking the Save button in the top-left corner of the Unity Editor.
You can also save your scene by pressing `Ctrl+S`.

### Async Scene

When switching between the scenes or loading multiple scenes, we recommend utilizing the asynchronous scene loader through a custom management script.
This will allow you to load complex levels while not impacting performance too greatly.

<Aside>
Use async loading to keep your frame rate stable when streaming large scenes. Test on target hardware to avoid performance spikes.
</Aside>

---

## WebGL

A breakdown of WebGL for the Unity game engine!

### WebGL Information

When converting a project over to WebGL, there are a couple extremely important steps that you might have to take to prepare for an automated pipeline and distribution.
The most important step is to make sure that you have the HTML5/WebGL module for the specific Unity version installed and ready.
After that check the resolution, an example would be 800 x 600 but you can set it to your project's desired scope.
Next you want to make sure to check the box, `Run in background`, and save it. This should change the `runInBackground` inside of `ProjectSettings\ProjectSettings.asset` from 0 (false) to 1 (true).
Finally double check that you have the right compression methods enabled or in some cases, like Github Pages, disabled completely.

---

## Pipeline

Unity has three core concepts for their render / build pipeline, which takes all your source code within your project and builds a finished product for various operating systems.

### CICD

For continous integration and continous development within the Unity Pipeline, we recommend going to our [git](/application/git/#unity) for information.

The notes for Github Actions / Circle CI within Unity and the general scope of the project have been migrated to the Git documentation.

---

## API

Part of building out the game and the multiplayer is to have a reference point for each player, we decided the best way to do that would be through JWTs / web tokens.

### Multiplayer

These are our notes and information regarding multiplayer

-   Colyseus.io seems like the first engine of choice that we might use.

    -   Github [Repo](https://github.com/colyseus/colyseus)
    -   Colyseus.io [Docs](https://docs.colyseus.io/colyseus/)

-   Reference Links
    -   Chowdera [1](https://chowdera.com/2021/05/20210512110823582J.html)
    -   S1H [2](https://blog.s1h.org/colyseus-multiplayer-game/)

---

## Strapi

Here is a custom function to help you integrate `Strapi` into your application.

> Hint: Since the function is an IEnumerator, we suggest wrapping it inside of a coroutine.

```c#

private IEnumerator LoginEnumProcess() //  [VOID]  -> {LoginEnumProcess()}
    {
        var user = new UserLoginData(); user.identifier = _text_Username.text;  user.password = _text_Password.text;

        //* {Request Header}
            string jsonData = JsonUtility.ToJson(user);
            var request = new UnityWebRequest(LoginURL, "POST");
            byte[] jsonToSend = new System.Text.UTF8Encoding().GetBytes(jsonData);
            request.uploadHandler = (UploadHandler)new UploadHandlerRaw(jsonToSend);
            request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
            request.method = "POST";
            request.SetRequestHeader("Content-Type", "application/json");
            request.SetRequestHeader("Accept", "application/json");

            yield return request.SendWebRequest();

            //? {y} -> Error
            if(request.result != UnityWebRequest.Result.Success)    { Debug.Log(request.error);  yield break; }
            else {
            //! {y} -> Success  -> #NEXT    -> #WIP

                JSONNode userData = JSON.Parse(request.downloadHandler.text);
                Debug.Log(userData);

                GlobalValue.PlayerJWT = userData["jwt"];
                GlobalValue.PlayerEmail = userData["user"]["email"];
                GlobalValue.PlayerUsername = userData["user"]["username"];

                    // PlayerPrefs.SetString("jwt", userData["jwt"]);
                    // PlayerPrefs.SetString("username", userData["user"]["username"]);
                    // PlayerPrefs.SetString("email", userData["user"]["email"]);
                    // PlayerPrefs.Save();
            //? {y} -> Migrate load to Global Values?
                Debug.Log(PlayerPrefs.GetString("username"));


                SceneManager.LoadScene("Base", LoadSceneMode.Single);
                yield break;
                }

    }

```

---

## AppWrite

Another `API` that you can use inside of Unity is AppWrite but there is only an unofficial plugin for the integration.
Thus we suggest being careful if using it in a production environment.

The unofficial plugin repo is hosted on [Github](https://github.com/AlexMeesters/unity-appwrite-plugin)

The prerequisites for the plugin are [UniTask](/application/unity/#unitask) and JSON.NET, information on both can be found further down in this guide.

---

## Firebase

Firebase integration with Unity makes it easy for developers to add these features to their games without sacrificing security.
For example, developers can use Firebase Authentication to allow users to sign in to their games with their Google, Facebook, or Apple accounts.
They can also use Firebase Realtime Database to store data in real time, such as the player's score or the current state of the game.
There are a couple other cool features included in the Firebase integration, such as using Firebase Cloud Messaging to send push notifications to players, such as notifications about new levels or in-game events.

The three core benefits with using Firebase are the `Ease of use`, `Scalability` and `Security`:

-   Ease of use: Firebase is designed to be easy to use, even for developers who are new to cloud services.
-   Scalability: Firebase can scale to support even the most demanding games.
-   Security: Firebase is a secure platform that uses industry-standard security measures to protect your data.

The repository for the Firebase Unity SDK is located [here](https://github.com/firebase/firebase-unity-sdk)

Further documentation and information can be found at the [Google Firebase Docs for Unity](https://firebase.google.com/docs/unity/setup)

### Firebase Setup

The setup has a couple `prerequisites` that you will need to ensure before going deeper into the integration.

-   Unity prerequisities for Firebase.
-   -   KBVE recommends 2021.3 LTS or higher.
-   -   Make sure that your unity project is Unity 2021.1 LTS or higher, while it does support 2019.1 LTS, in 2024, it will become deprecated.

-   Apple -> Unity prerequisites for Firebase.
-   -   KBVE recommends xCode 14.x or higher.
-   -   xCode 13.3.1 or higher.
-   -   CocoaPods 1.10.x or higher.
-   -   iOS target of v11 or higher.
-   -   tvOS target of v12 or higher.

-   Android
-   -   Android API level 19 or higher.
-   -   KBVE Recommends 23 or higher, if you are using cryptography.

<Aside>
Ensure each platform-specific requirement is installed before running the Firebase setup; missing tools can cause build failures later.
</Aside>

---

## Steam

These notes are still a work in progress, but I will try my best to continue to improve them as I am building out the Steam API for the Unity/React Project.
Official [Repo](https://steamworks.github.io/installation/#unity-instructions)

### Steam Setup

It seems that before you start to integrate SteamWorks / Steam API / SteamWorksNET , you need an active SteamWorks developer account. You can create the account [here](https://partner.steamgames.com/newpartner/?)

`Legal Name`

Steam Defines it as

> This is really, really important to enter correctly. Carefully read all instructions below. You will be unable to release your product via Steam until this name matches all records.
> The name you enter below must be the legal entity that owns or has rights to publish the game, software or video ("content") and is the legal entity that will be signing the Steam Distribution Agreement. The legal name you enter here must match the name as written on official documents with your bank and on United States IRS tax documents or foreign tax documents if applicable. You will need to enter this name again as your bank account holder and the legal name associated with a tax payer identification number in the following steps.
> If you don't have a company name and you are the sole owner of your content, please fill in your full name as the Legal Name and your own address as Street Address. If you co-own the content with other individuals, you must form a legal entity to own and receive payments for your content.
> The Legal Name here is for internal use. If you have a DBA or 'friendly name' that you wish to show to customers on your store page, you will be able to enter that separately when creating your store page.

This is an extremely important step, we advise that you consult with your legal parties if there are any major issues.

We recommend that, if you are a US Citizen, have all our personal information (Tax, Bank, KYC, ect...) ready before completing the application. Furthermore, there is a $100 fee for the application.

### Steam Launch

Well we applied as of 11/23/2022 , so we will wait until everything is confirmed and then move forward with this.

Okay so we been approved, now you should have 1 application credit in your Steamworks profile! This is where you then create your application, using that application credit that you paid $100 for!

Place your application name and then go through the form, it will then spit out some interesting variables:

> Requesting AppID For: KBVE.com RogueJester
> Created package "KBVE.com RogueJester Developer Comp" with ID 802XXX
> Created package "KBVE.com RogueJester for Beta Testing" with ID 802XXX
> Created package "KBVE.com RogueJester" with ID 802XXX
> Added auto-grant to publisher \*XXX
> Created store item '518XXX'
> Created store package for store item '518XXX'

You should keep this information safe and as a reference step.

---

## Plugins

Collection of plugins for Unity game engine.
We want to include as many reference points and notes for the plugins that we are currently using.

---

## KBVE

For the quick commands to link the KBVE Packages

```shell
cd /path/to/your/unity-project/Packages

ln -s /Users/kbve/kbve/packages/unity/mmextensions com.kbve.mmextensions
ln -s /Users/kbve/kbve/packages/unity/ssdb com.kbve.ssdb
```

If its relative:

```shell
ln -s ~/Documents/GitHub/kbve/packages/unity/mmextensions com.kbve.mmextensions
ln -s ~/Documents/GitHub/kbve/packages/unity/ssdb com.kbve.ssdb
ln -s ~/Documents/GitHub/NSprites com.tonymax.nsprites

```


---

## Vuplex

This is a 3rd party plugin provider for Unity, that extends out the webview components for cross-platform compatibility through their own object-based library.

These are reference points for common errors within the Vuplex libraries / eco-system.

Vuplex Resources

Loading multiple webview components within a single scene can cause a spike within the client's CPU/RAM, thus it is recommended to de-sync / destroy or de-activate any un-used Canvas. Furthermore, only activate the GameObject when the player is within a set proximity to the object through the Unity's Collider system via event triggers.
Vuplex does run an instance of a chromium browser and that can lead to memeory and cpu leaks.

An example of this would be to declare the GameObject, add collision and then hook it a simple trigger script, like this:

```c#

    public GameObject webviewObject;
    [SerializeField] private bool EnablePlayerWebview;

    private void OnTriggerEnter(Collider other)
    {
        if(other.CompareTag("Player") && EnablePlayerWebview) { webviewObject.SetActive(true);   }

    }

    private void OnTriggerExit(Collider other)
    {
        Debug.Log("Exiting");
        webviewObject.SetActive(false);
    }

```

Here is our current work in progress Vuplex helper.

```c#

using System;
using System.Threading.Tasks;
using UnityEngine;
using Vuplex.WebView;

namespace Utils
{
    public class VuplexHelper : MonoBehaviour
    {
        public string CanvasObjectName = "Canvas";
        public string CanvasWebViewPrefabName = "CanvasWebViewPrefab";
        public string CanvasWebViewPrefabViewName = "CanvasWebViewPrefabView";

        private CanvasWebViewPrefab _canvasWebViewPrefab; // Updated to use CanvasWebViewPrefab

        private async void Start()
        {
            try
            {
                await InitializeWebView();
            }
            catch (Exception ex)
            {
                Debug.LogError($"Vuplex CanvasWebView initialization failed: {ex.Message}");
            }
        }

        /// <summary>
        /// Initializes the CanvasWebViewPrefab and sets up communication.
        /// </summary>
        private async Task InitializeWebView()
        {
            // Step 1: Find the Canvas GameObject
            GameObject canvasObject = GameObject.Find(CanvasObjectName);
            if (canvasObject == null)
            {
                Debug.LogError($"No GameObject found with the name {CanvasObjectName}");
                return;
            }
            Debug.Log($"Found Canvas GameObject: {GetFullPath(canvasObject)}");

            // Step 2: Find the CanvasWebViewPrefab under the Canvas GameObject
            Transform canvasWebViewPrefabTransform = canvasObject.transform.Find(CanvasWebViewPrefabName);
            if (canvasWebViewPrefabTransform == null)
            {
                Debug.LogError($"No GameObject found with the name {CanvasWebViewPrefabName} under {CanvasObjectName}.");
                return;
            }
            Debug.Log($"Found CanvasWebViewPrefab GameObject: {GetFullPath(canvasWebViewPrefabTransform.gameObject)}");

            // Step 3: Find the CanvasWebViewPrefabView under the CanvasWebViewPrefab GameObject
            Transform canvasWebViewPrefabViewTransform = canvasWebViewPrefabTransform.Find(CanvasWebViewPrefabViewName);
            if (canvasWebViewPrefabViewTransform == null)
            {
                Debug.LogError($"No GameObject found with the name {CanvasWebViewPrefabViewName} under {CanvasWebViewPrefabName}.");
                return;
            }
            Debug.Log($"Found CanvasWebViewPrefabView GameObject: {GetFullPath(canvasWebViewPrefabViewTransform.gameObject)}");

            // Step 4: Try to get the CanvasWebViewPrefab component from CanvasWebViewPrefabView
            _canvasWebViewPrefab = canvasWebViewPrefabViewTransform.GetComponent<CanvasWebViewPrefab>();
            if (_canvasWebViewPrefab == null)
            {
                // Step 5: Fallback to get CanvasWebViewPrefab from CanvasWebViewPrefab itself
                Debug.LogWarning($"CanvasWebViewPrefab component not found on {CanvasWebViewPrefabViewName}. Trying to find CanvasWebViewPrefab on {CanvasWebViewPrefabName}.");
                _canvasWebViewPrefab = canvasWebViewPrefabTransform.GetComponent<CanvasWebViewPrefab>();

                if (_canvasWebViewPrefab == null)
                {
                    Debug.LogError("Failed to locate the CanvasWebViewPrefab component after multiple attempts.");
                    return;
                }
            }

            // Step 6: Wait for the CanvasWebViewPrefab to initialize
            await _canvasWebViewPrefab.WaitUntilInitialized();

            // Step 7: Subscribe to the MessageEmitted event
            _canvasWebViewPrefab.WebView.MessageEmitted += OnMessageReceived;
            Debug.Log("Vuplex CanvasWebView successfully initialized and ready to receive messages.");
        }

        /// <summary>
        /// Handles messages received from the WebView.
        /// </summary>
        private void OnMessageReceived(object sender, EventArgs<string> eventArgs)
        {
            Debug.Log("JSON received: " + eventArgs.Value);
            // Further processing of the received message can be done here.
        }

        /// <summary>
        /// Unsubscribes from the event and performs cleanup if needed.
        /// </summary>
        private void OnDestroy()
        {
            if (_canvasWebViewPrefab != null && _canvasWebViewPrefab.WebView != null)
            {
                _canvasWebViewPrefab.WebView.MessageEmitted -= OnMessageReceived;
            }
        }

        /// <summary>
        /// Helper method to get the full path of a GameObject in the hierarchy.
        /// </summary>
        private string GetFullPath(GameObject gameObject)
        {
            string path = gameObject.name;
            while (gameObject.transform.parent != null)
            {
                gameObject = gameObject.transform.parent.gameObject;
                path = gameObject.name + "/" + path;
            }
            return path;
        }
    }
}

```

Vuplex Errors

-   Click and scroll not working : Case 1

There could be multiple reasons why click/scroll might not be functional, depending on the operating system, AR/VR tool kits and the Unity's input system.
When defusing the situation, we recommend build multiple test cases with all components mapped out and then using `Debug.Log` to check through all the variables at play.
We been in situations where a foot of a humanoid object was not tagged as a `Player`, thus causing the whole collision engine to be off and not registering the functionality within a scene.

---

## UCC

Ultimate Character Controller was the plugin of choice when doing RSDD aka rapid self-destructive development.
Official Documentation [Link](https://opsive.com/support/documentation/ultimate-character-controller/). It is over 300 pages and covers the controller and its interaction within the unity environment.
According to Opsive, their UCC is a professional and kinematic character controller that is designed for flexibility, modularity and performance; we consider it an "AIO" or "All-In-One" library.

### UCC URP

Grab the invoice number from the plugin purchase and head over to [OPSive Downloads](https://opsive.com/downloads/) with it.
After placing the invoice number into the system, it will give you download integrations for external plugins.

### UCC Asset Store

Official [Asset Store](https://assetstore.unity.com/packages/tools/game-toolkits/ultimate-character-controller-233710).
Last Release Date: 3.0.3 - Nov 24, 2022

### UCC Reference

[Opsive Video Collection](https://opsive.com/videos/?pid=923)
[First Person Character Creation](https://www.youtube.com/watch?v=EAuS_0OxyrA)

### UCC Character

The core of the UCC, Ultimate Character Controller, would be the Character model and its interactivity within the `Scene`, thus these notes are for referencing through the plugin and movement, collision, motion, gravity, abilities and more for the `Humanoid` / `Character`.

### UCC Inventory

The `UCC Inventory` can be broken into modules, that we will refer to as:

-   Inventory
-   Item
    -   Action (Item)
    -   Object (Item)
-   Attributes
-   Currency
-   Crafting
-   Input

There are more modules within the system but v3 was released in late November 2022 and we still have to read through the notes/documentation && create test cases for each of the additional modules.

### UCCIS Attributes

The `Attributes` can be referenced throughout the `engine` and are designed to `override, inherit or modify` the value of another attribute; `Attributes` can be utilized to create variants (`Override`, `Inherit` or `Modify`) of Item Definitions.

The `Attributes` can be broken down into three variant types: (As referenced in the documentation)

-   Override: Overrides the `parent` attribute value of the given object.
-   Inherit: Inherits the `parent` attribute value of the given object.
-   Modify: Uses an expression to compute a value that is dependent on the “parent” attribute or any other attribute in the same collection.

### UCCIS References

[Asset Store](https://assetstore.unity.com/packages/tools/game-toolkits/ultimate-inventory-system-166053)
[Inventory Docs](https://opsive.com/support/documentation/ultimate-inventory-system/)

Video Tutorials

[Video Part 1](https://www.youtube.com/watch?v=-AqJ3-BXS70)
[Video Part 2](https://www.youtube.com/watch?v=m0Z-wPFkM9w)

The two part video tutorial goes through a UCC / Inventory integration.

---

## Modular AI

Modular AI helps design the behavior of GameObjects within Unity.
The official [Modular AI repo](https://github.com/Kitbashery/Modular-AI)

---

## Hey Area Object Spawner

A simple tool that helps procedural generation of objects within an area.
The plugin's official [repo for Hey Area Object Spawner](https://github.com/JahnStar/Hey-Area-Object-Spawner)

## Hierarchy 2

-   Hierarchy 2 helps organize the Unity UI.
-   Official Asset [Store](https://assetstore.unity.com/packages/tools/utilities/hierarchy-2-166483)

---

## Javascript

### OneJS

-   Interpol between Javascript and Unity through JINT
-   This plugin is not open source but rather a private engine.

<Aside>

Remember to follow the guide for the specific version of OneJS that you are planning to use!
We do not have the up-to-date and extact install guide, because of the difference between v1 and v2.
Furthermore, there are a couple different engines that you might be using.

</Aside>

There are three core tasks that we will need for the `OneJS` and they handle the typescript, bundling and tailwindcss generation.
Below are the `tasks.json` for `.vscode` folder:

```json

{
	"version": "2.0.0",
	"tasks": [
	  {
		"label": "tsc: watch - App/tsconfig.json",
		"type": "shell",
		"command": "npx",
		"args": [
		  "tsc",
		  "-p",
		  "tsconfig.json",
		  "--watch"
		],
		"group": "build",
		"problemMatcher": [
		  "$tsc-watch"
		],
		"isBackground": true,
		"options": {
		  "cwd": "${workspaceFolder}/App"
		}
	  },
	  {
		"label": "esbuild: watch",
		"type": "shell",
		"command": "node",
		"args": [
		  "esbuild.mjs",
		  "--watch"
		],
		"group": "build",
		"problemMatcher": [],
		"isBackground": true,
		"options": {
		  "cwd": "${workspaceFolder}/App"
		}
	  },
	  {
		"label": "postcss: watch",
		"type": "shell",
		"command": "npx",
		"args": [
		  "postcss",
		  "input.css",
		  "-o",
		  "../Assets/tailwind.uss",
		  "--watch"
		],
		"group": "build",
		"problemMatcher": [],
		"isBackground": true,
		"options": {
		  "cwd": "${workspaceFolder}/App"
		}
	  },
	  {
		"label": "build: all",
		"dependsOn": [
		  "tsc: watch - App/tsconfig.json",
		  "esbuild: watch",
		  "postcss: watch"
		],
		"problemMatcher": [],
		"group": {
		  "kind": "build",
		  "isDefault": true
		}
	  }
	]
  }
  
```

If the project is stored in a monorepo, then adjust the `cwd` under `options` to fix the pathing for the commands.

Under some situations, you might have to add an anti-strip pattern to your `link.xml`.
We can update these docs a bit more after the release of Unity 6.

### React

-   For React and Unity integration, we recommend going to our [React](/application/javascript/#react) application page.

---

## Python

The official notes and changelogs for the python integration inside of unity can be found on their [website](https://docs.unity3d.com/Packages/com.unity.scripting.python@7.0/changelog/CHANGELOG.html).

---

## JSON

There are a couple options for JSON plugins, the two main ones that we recommend are the JSON.NET library from Nuget and the SimpleJSON.### SimpleJSON

### JSON.NET

Here is a simple [guide](https://github.com/jilleJr/Newtonsoft.Json-for-Unity/wiki/Install-official-via-UPM) on how to install the official JSON.NET plugin from NewtonSoft.

### SimpleJSON

SimpleJSON is a plugin for JSON parsing in C#.

-   Official [Repo](https://github.com/Bunny83/SimpleJSON)

---

## Webview

Unity plugins that focus on webview by providing abstract layers that extend to controllers.

### UniWebView

-   Adding Webview for iOS/Android can be easier through UniWebView, which is an open source web view component for mobile platforms.
-   Official [Repo](https://docs.uniwebview.com/api/)

### Vuplex Plugin

A commercial plugin that extends WebView components across all platforms, with major focus on AR/VR development kits for Oculus, Hololens and more.
Notes on the [Vuplex](/application/unity/#vuplex)

---

## Corgi

These are KBVE notes and references for the `Corgi Engine` that was developed by More Mountains. Please note that the core of the Corgi Engine is a private / premium plugin for the Unity Engine, thus parts of our codebase / references will not work `out of the box`, as you will have to install the latest engine from the Unity Asset store.
We are currently test casing the corgi engine as the base for our 2D engine and then going to integrate it with our 2DUnity. As of early December 2022, we are test casing the pipeline with the engine as an underlay and restructuring our `2DUnity` as a gateway layer, a similar setup to our `3DUnity` and `UCC`.

### Corki Namespace

The `Corki` namespace is a KBVE extension of the `Corgi` namespace, adding custom gateway layers that make it easier to infer and interpolate among different APIs.

---

## TopDown Engine

The rareicon is games core logic and operations are from the TopDown Engine by MoreMountains.

---

## Unity Canvas

The Canvas is a GameObject within Unity that extends the UI elements and utilizes the EventSystem / Scene View.

## Unity Assets

-   Unity Assets are a collection of media files.

## 2D Assets

This is a collection of 2D assets that can be a great resource / reference for anyone looking to make a 2D game. We could migrate the 2D assets into their own reference later down the line.

### PixelFrog

Official [Itch](https://pixelfrog-assets.itch.io/)

Treasure Hunters [Download](https://pixelfrog-assets.itch.io/treasure-hunters)
Kings and Pings [Download](https://pixelfrog-assets.itch.io/kings-and-pigs)
Pixel Adventure [Download](https://pixelfrog-assets.itch.io/pixel-adventure-1)
Pirate Bomb [Download](https://pixelfrog-assets.itch.io/pirate-bomb)

## 2D

These are the notes for Unity's 2D engine and/or projects related to the 2D development cycle.

## 2D Examples

The list below are open source projects that use Unity as their base for 2D/Retro style games.

### Newbark

Official [Repo](https://github.com/itsjavi/newbark-unity)

Itsjavi created an amazing open source proof-of-concept version of classic Pokemon (Red/Blue/Gold) that has been updated to Unity 2021 and has URP. It should be noted that there assets that might be infringing on intellectual property of Nintendo/Game Freak.
On a positive note, upon looking through his repo, I did stumble across a github bot known as [ImgBot](/application/git/#imgbot), which provides image optimization via Git pulls.

The project uses: 2021.1.6f1 as the Unity Version and there seems to not include any pipeline/workflow, which might be because of the copyright issues.
The project also has [URP / Universal Render Pipeline](/application/unity/#urp)

I suppose it be interesting to take a look at their combat system, since the biggest issue that I see would be the usage of copyrighted material, but if you were to swap them out, then there might be a case to continue and `enhance` the repo? If anyone might be down to do this, please reach out to h0lybyte.

### Kailius

Official [Repo](https://github.com/Walkator/kailius)

This was another open source 2D repo that sparked my interest because it was built for the phone! It is a great reference point for a game written for Android by going through `input design` from dual perspective of UX/UI and internal scripting.

### Minor 2Ds

[SpaceWalk Official Repo](https://github.com/Angel1841/Space-Walk)
[FinalProject UnityW2022](https://github.com/DuncanBH/FinalPlatformerProject)

---

## Notes

-   Unity follows a duel release structure for their engine, a `latest` engine build and a `LTS` engine.
-   We recommend using the `LTS` as it has `Long Term Support`, which the company states for about 2 years, whereas the `latest` does not have any extended support.

---

## Errors

-   Common errors that users might face when working with Unity. This error log is meant to help keep track and may save some future developers a lot of time.

### Error WebGL-000001FEA50EC410

-   ```shell
      [.WebGL-000001FEA50EC410] GL_INVALID_FRAMEBUFFER_OPERATION: Draw framebuffer is incomplete
    ```

    -   Solution: Turn on post processing on the Main Camera.

### Error libil2cpp ERROR: Could not open Il2CppData/

Currently: There might be an issue when directly loading the Git LFS, so we will reference it via Github's media server.
Git Notes can be found [here](/application/git)

### Error Dirty Branch

This will be a common error that you will see throughout `CI/CD` and comes from various issues, it can be from the wrong `guid` / `Seralization` or broken `ProjectSettings.asset`

You can ignore the dirty branch errors by using `allowDirtyBuild: true` within the `game-ci`, however this may cause problems down the line when the build gets more complex and additional platforms i.e `WebGl`, `Xbox`, ect...

---
# Unreal Engine

> Unreal Engine is a powerful real-time 3D creation platform developed by Epic Games, widely used for building high-fidelity games, simulations, and interactive experiences.
The engine offers advanced rendering capabilities, including Nanite virtualized geometry and Lumen global illumination, alongside robust tools for animation, physics, and AI.
With support for C++ and Blueprints visual scripting, Unreal Engine provides flexibility for both programmers and designers across industries including gaming, film, architecture, and automotive.

Source: https://kbve.com/application/unreal/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Information

Unreal Engine is a leading real-time 3D creation platform developed by Epic Games, powering some of the most visually stunning games and interactive experiences in the industry.
Originally launched in 1998, the engine has evolved through multiple generations, with Unreal Engine 5 introducing groundbreaking features like Nanite virtualized geometry for film-quality assets and Lumen for fully dynamic global illumination and reflections.
The engine supports development across PC, consoles, mobile, VR, and AR platforms, making it a versatile choice for a wide range of projects.

Unreal Engine uses C++ as its primary programming language, offering direct access to the engine's source code for deep customization.
For rapid prototyping and designer-friendly workflows, the Blueprints visual scripting system allows logic creation without writing code.
The engine also includes a comprehensive suite of tools for animation (Sequencer, Control Rig), audio (MetaSounds), world building (World Partition, PCG), and multiplayer networking.

<Adsense />

---

## Getting Started

To begin developing with Unreal Engine, download the Epic Games Launcher and install the desired engine version.
Projects can be created from templates covering common game genres and application types.
The editor provides a viewport for scene composition, a content browser for asset management, and a details panel for property editing.

<Aside>
Unreal Engine is free to use with a 5% royalty on gross revenue after the first $1 million USD per product. Review the EULA for full licensing terms.
</Aside>

---

## Blueprints

Blueprints is Unreal Engine's visual scripting system that allows designers and developers to create gameplay logic, UI interactions, and procedural content without writing C++ code.
Blueprint graphs use nodes connected by wires to define execution flow and data relationships.
Blueprints can be used standalone or in conjunction with C++ classes for hybrid workflows.

### Blueprint Types

- **Level Blueprint** - A specialized Blueprint scoped to a single level, useful for level-specific scripting such as triggers, cutscenes, and door mechanics.
- **Blueprint Class** - A reusable asset that defines a new class with components, variables, and logic. Most gameplay actors are Blueprint Classes.
- **Blueprint Interface** - Defines a contract of functions that multiple Blueprint Classes can implement without inheritance coupling.
- **Blueprint Macro Library** - A collection of reusable macro graphs that can be shared across multiple Blueprints.
- **Blueprint Function Library** - A static function container accessible from any Blueprint, useful for utility operations.

### Blueprint Communication

Blueprints communicate through several patterns depending on the relationship between actors:

- **Direct References** - Dragging actor references into the graph for tightly coupled communication.
- **Event Dispatchers** - A publish/subscribe pattern where one Blueprint broadcasts an event and others bind to it.
- **Interfaces** - Sending messages to actors without knowing their concrete type, enabling loose coupling.
- **Casting** - Converting a reference to a specific type to access its unique variables and functions.

---

## C++ Development

Unreal Engine's C++ framework uses a custom build system (Unreal Build Tool) and a reflection system powered by macros like `UCLASS`, `UPROPERTY`, and `UFUNCTION`.
These macros expose C++ types to the editor, Blueprints, and the garbage collector.
The Gameplay Framework provides base classes such as `AActor`, `APawn`, `ACharacter`, and `AGameModeBase` for structuring game logic.

### Gameplay Framework

The Gameplay Framework establishes the class hierarchy that most Unreal projects build upon:

- **UObject** - Base class for all engine objects, providing reflection, serialization, and garbage collection.
- **AActor** - Any object that can be placed or spawned in a level. Has a transform, components, and lifecycle events.
- **APawn** - An Actor that can be possessed by a Controller, representing an entity in the world.
- **ACharacter** - A Pawn with a CharacterMovementComponent for walking, jumping, swimming, and flying.
- **APlayerController** - Handles player input and possesses a Pawn. One per human player.
- **AGameModeBase** - Defines the rules of the game, spawn logic, and match state. Exists only on the server in multiplayer.
- **AGameStateBase** - Replicated state visible to all clients, such as scores and match timers.

### Modules and Build System

Unreal projects are organized into modules, each with a `.Build.cs` file that declares dependencies, include paths, and compilation settings.
The Unreal Build Tool (UBT) processes these files to generate platform-specific project files and compile the engine and game code.
The Unreal Header Tool (UHT) runs before compilation to parse reflection macros and generate boilerplate code for serialization, replication, and Blueprint exposure.

### Common Macros

- `UCLASS()` - Marks a class for the reflection system. Supports specifiers like `Blueprintable`, `Abstract`, and `Config`.
- `UPROPERTY()` - Exposes a member variable to the editor, Blueprints, serialization, or replication.
- `UFUNCTION()` - Exposes a function to Blueprints, the editor, or the networking system (RPCs).
- `USTRUCT()` - Marks a struct for reflection, enabling serialization and Blueprint access.
- `UENUM()` - Marks an enum for reflection, making it usable in Blueprints and the editor.

---

## Rendering

Unreal Engine 5 introduced Nanite and Lumen as core rendering technologies.
Nanite enables the use of film-quality source art with millions of polygons directly in scenes, automatically handling LOD and streaming.
Lumen provides real-time global illumination and reflections without baking, adapting dynamically to scene changes.

### Nanite

Nanite is a virtualized geometry system that intelligently streams and processes only the triangles visible on screen.
It eliminates the need for manual LOD authoring, polygon budgets, and draw call optimization for static meshes.
Nanite meshes can contain billions of source triangles, with the system automatically managing detail reduction based on screen coverage.

<Aside>
Nanite does not currently support skeletal meshes, translucent materials, or world-position-offset deformation. Plan your asset pipeline accordingly.
</Aside>

### Lumen

Lumen is a fully dynamic global illumination and reflections system that works at multiple scales.
It uses a combination of screen-space tracing, mesh distance fields, and surface caching to produce realistic indirect lighting in real time.
Lumen eliminates the need for baked lightmaps in most scenarios, allowing artists to iterate on lighting without waiting for build times.

### Virtual Shadow Maps

Virtual Shadow Maps (VSM) provide high-resolution, per-pixel shadow mapping that scales with Nanite geometry.
VSMs are cached and updated incrementally, reducing the performance cost of complex shadow-casting scenes.

### Render Pipeline Options

- **Deferred Rendering** - The default pipeline, optimized for complex scenes with many dynamic lights.
- **Forward Rendering** - Optional pipeline with MSAA support, useful for VR and mobile targets where anti-aliasing quality is critical.
- **Path Tracer** - A reference ray tracer for offline-quality rendering, useful for architectural visualization and film production.

---

## World Building

Unreal Engine provides several systems for creating and managing large game worlds.

### World Partition

World Partition is a distance-based streaming system that replaces the older World Composition and level streaming approaches.
It divides the world into a grid of cells that load and unload automatically based on player proximity.
This enables seamless open worlds without manual sub-level management.

### Procedural Content Generation (PCG)

The PCG framework allows designers to create rule-based systems for populating worlds with foliage, props, roads, and other environmental details.
PCG graphs define operations like point sampling, filtering, mesh spawning, and attribute-based randomization.
Results can be generated at edit time or at runtime for dynamic environments.

### Landscape

The Landscape system handles large-scale outdoor terrain with heightmap-based geometry, multi-layer material painting, and foliage placement.
Landscapes support LOD streaming and can span kilometers while maintaining reasonable memory and draw call budgets.

---

## Animation

Unreal Engine's animation system supports skeletal meshes, blend spaces, state machines, and procedural animation through several tools.

### Animation Blueprints

Animation Blueprints (AnimBP) drive skeletal mesh animation using an AnimGraph that blends poses, evaluates state machines, and applies modifiers each frame.
The Event Graph handles logic such as reading movement speed from the owning Pawn to drive blend parameters.

### Sequencer

Sequencer is the cinematic editor for creating in-game cutscenes, trailers, and scripted sequences.
It supports keyframing transforms, material parameters, camera cuts, audio tracks, and Blueprint events on a multi-track timeline.

### Control Rig

Control Rig provides a node-based rigging system for creating custom animation controllers directly in the engine.
It is used for procedural adjustments like IK solvers, look-at constraints, and physics-driven secondary motion.

### MetaHuman

MetaHuman is a framework for creating photorealistic digital humans with high-fidelity facial animation, hair simulation, and body rigs.
MetaHumans are created via the MetaHuman Creator web tool and imported into Unreal projects as ready-to-animate assets.

---

## Audio

### MetaSounds

MetaSounds is a node-based audio system that replaces the legacy Sound Cue editor.
It provides a programmable DSP graph for designing procedural audio, interactive music systems, and real-time sound effects with full control over signal routing and parameter modulation.

### Sound Classes and Mixes

Sound Classes group audio sources by category (dialogue, music, SFX) for volume control and ducking.
Sound Mixes define cross-class blending rules, such as lowering music volume when dialogue plays.

---

## Physics

Unreal Engine uses Chaos Physics as its default physics engine, providing rigid body simulation, cloth, destruction, and vehicle dynamics.

### Chaos Destruction

The Chaos Destruction system enables real-time fracturing of geometry collections.
Meshes are pre-fractured in the editor using Voronoi patterns or custom fracture planes, then simulated at runtime with strain-based breaking thresholds.

### Chaos Vehicles

Chaos Vehicles provide a physics-driven vehicle simulation with suspension, tire friction curves, engine torque, and transmission modeling.

---

## AI

Unreal Engine includes several systems for building artificial intelligence in games.

### Behavior Trees

Behavior Trees define AI decision-making through a tree of tasks, decorators, and services evaluated by an AI Controller.
Tasks perform actions, decorators gate execution based on conditions, and services run periodically to update the Blackboard.

### Blackboard

The Blackboard is a key-value data store used by Behavior Trees to share state such as target locations, health values, and alert levels.

### Environment Query System (EQS)

EQS generates and scores spatial queries to help AI select optimal positions for actions like cover, flanking, or patrolling.
Queries define a set of test points, apply scoring functions (distance, line of sight, dot product), and return the best-scoring result.

### Navigation

The NavMesh system generates walkable surfaces for AI pathfinding.
Nav Mesh Bounds Volumes define the area to generate navigation, and Nav Modifiers can adjust costs, exclude regions, or create custom area types.

---

## Multiplayer

Unreal Engine includes a built-in networking framework with server-authoritative replication, RPCs (Remote Procedure Calls), and relevancy management.
The engine supports dedicated servers, listen servers, and peer-to-peer topologies.
For large-scale multiplayer, Epic provides tools and integrations for session management and matchmaking.

### Replication

Replication is the process of synchronizing actor state from the server to connected clients.
Properties marked with `UPROPERTY(Replicated)` or `UPROPERTY(ReplicatedUsing=OnRep_Function)` are automatically sent to relevant clients.
Replication conditions (`COND_OwnerOnly`, `COND_SkipOwner`, `COND_InitialOnly`) control when and to whom properties replicate.

### RPCs

Remote Procedure Calls allow functions to execute across the network boundary:

- **Server RPCs** - Called on a client, executed on the server. Used for input validation and authoritative game actions.
- **Client RPCs** - Called on the server, executed on the owning client. Used for cosmetic feedback and UI updates.
- **Multicast RPCs** - Called on the server, executed on all connected clients. Used for effects visible to everyone.

### Dedicated Servers

Unreal supports headless dedicated server builds that run the authoritative game simulation without rendering.
Server builds exclude client-only content and rendering code, reducing binary size and resource usage.

---

## Platform

Unreal Engine supports deployment to a wide range of platforms from a single project.

### Supported Platforms

- **Desktop** - Windows, macOS, Linux
- **Console** - PlayStation 5, Xbox Series X|S, Nintendo Switch
- **Mobile** - iOS, Android
- **XR** - Meta Quest, Apple Vision Pro, SteamVR, PlayStation VR2

### Packaging and Distribution

Projects are packaged through the editor or command line using `UnrealBuildTool` and `RunUAT`.
Packaging produces a standalone build with cooked content optimized for the target platform.

---

## CICD

For continuous integration with Unreal Engine, builds are typically automated using `RunUAT` (Unreal Automation Tool) scripts.
Common CI tasks include compiling the project, cooking content, running automated tests, and packaging for distribution.

<Aside>
Unreal builds require significant disk space and memory. Plan CI runner specs accordingly — expect 50+ GB disk and 16+ GB RAM for non-trivial projects.
</Aside>

### KBVE Unreal CI/CD Pipeline

The KBVE monorepo runs two Unreal Engine workflows:

- **`.github/workflows/ci-unreal.yml`** — Dispatch router (receives workflow_dispatch calls)
- **`.github/workflows/ci-unreal-build.yml`** — Worker (game, server, win-setup, mac-setup modes)

#### Server Build Flow

Server builds produce dedicated server binaries for deployment to Agones fleets.

<Steps>

1. **Extract version** from `version.toml` and `manifest_version` input
2. **Clone external repo** (if `external_repo_url` set) or use monorepo path
3. **Build server target** via UBT (`-Server -TargetType=Server -Configuration=Shipping`)
4. **Package to `/tmp/ue5-build-output/LinuxServer/`**
5. **Deploy to PVC** at `/mnt/longhorn/ows-server/${TARGET}/${VERSION}/`
6. **Symlink latest** (`ln -sfn ${VERSION} /mnt/longhorn/ows-server/${TARGET}/latest`)
7. **Prune old versions** — keep 3 newest by semver, protect `latest` target

</Steps>

**Prune Strategy:**

The prune step uses `sort -V -r` (semver descending) to keep the 3 newest versions for rollback.
It protects the `latest` symlink target and skips versions with `.nfs*` files (active servers).

```bash
# Example: versions 0.3.24, 0.3.25, 0.3.26, 0.3.27, 0.3.28
# Keep: 0.3.28, 0.3.27, 0.3.26
# Prune: 0.3.25, 0.3.24 (unless in use)
```

**Fleet Integration:**

Agones gameserver pods mount the PVC at `/server` with `subPath: ${TARGET}` (e.g., `chuckServer`).
The pod looks for `/server/latest/LinuxServer/${TARGET}.sh` to start the server.

#### Game Build Flow

Game builds produce packaged client binaries for Windows, macOS, Linux, and mobile platforms.

<Steps>

1. **Extract version** from `version.toml`
2. **Clone external repo** or use monorepo path
3. **Build client target** for each platform in `build_targets` (Win64, Linux, Mac)
4. **Cook content** for each target configuration
5. **Package to artifacts** (zip per platform)
6. **Upload to itch.io** (if `deploy_to_itch` enabled)
7. **Create GitHub release** with platform zips

</Steps>

**Version Sync:**

Client and server versions are kept in sync via `ci-dispatch-manifest.json`.
Each Unreal game entry has a single `version` field used for both client and server builds.

```json
{
  "key": "unreal_chuck_beta",
  "version": "0.3.28",
  "engine": {
    "server_target": "chuckServer",
    "server_config": "Shipping",
    "client_config": "Shipping"
  }
}
```

**LFS Routing:**

Projects using external repos (e.g., `chuck` at `github.com/kbve/chuck`) store LFS blobs on Forgejo (`git.kbve.com/KBVE/chuck.git`).
The `kbve.sh -lfs` router injects `-c lfs.url=...` to override `.lfsconfig` per project.

```bash
./kbve.sh -lfs chuck pull
./kbve.sh -lfs chuck push origin dev
```

---

## Plugins

Unreal Engine supports a plugin architecture for extending editor and runtime functionality.
Plugins can be written in C++ or Blueprints and distributed via the Unreal Marketplace or as source.

### Plugin Structure

A typical plugin contains:

- **`.uplugin` file** - JSON descriptor with plugin metadata, module definitions, and dependencies.
- **Source module(s)** - C++ modules with `.Build.cs` files, each producing a DLL or static library.
- **Content** - Optional assets (meshes, materials, Blueprints) bundled with the plugin.
- **Shaders** - Optional custom shader files (`.usf`, `.ush`) for rendering extensions.

### Creating a Plugin

Plugins can be scaffolded from the editor via Edit > Plugins > Add, or created manually by setting up the directory structure and `.uplugin` descriptor.
The engine supports several module types: `Runtime`, `Editor`, `DeveloperTool`, and `Program`, each loaded at different stages of the engine lifecycle.

---

## KBVE Plugins

KBVE maintains a collection of open-source Unreal Engine plugins at `packages/unreal/` in the monorepo.
All plugins follow a consistent structure: `.uplugin` descriptor, `version.toml` for versioning, `Source/` with `Public/` and `Private/` directories, and `ThirdParty/` for vendored libraries with their licenses.

### KBVETinyBVH

A runtime plugin wrapping [jbikker/tinybvh](https://github.com/jbikker/tinybvh) v1.6.7, a single-header BVH (Bounding Volume Hierarchy) construction and traversal library for ray tracing.
TinyBVH provides data structures for rapidly finding ray-triangle intersections in virtual scenes.

**Features:**
- CPU BVH construction and traversal via `tiny_bvh.h`
- OpenCL GPU traversal kernels for hardware-accelerated ray tracing
- Vulkan compute shader support
- Scene loading utilities via `tiny_scene.h`
- Auto-detects SSE4.2, AVX, AVX2, and NEON SIMD

**Included files:**
- `tiny_bvh.h` — Core library (CPU)
- `tiny_ocl.h` — OpenCL helper for GPU traversal
- `tiny_scene.h` — Scene/GLTF loading utilities
- OpenCL kernels: `traverse.cl`, `traverse_bvh2.cl`, `traverse_bvh4.cl`, `traverse_cwbvh.cl`, `traverse_tlas.cl`, `tools.cl`, `wavefront.cl`, `wavefront2.cl`, `raytracer.cl`
- Vulkan compute: `traverse.comp`

**Usage:**

```cpp
#include "KBVETinyBVH.h"

// Build a BVH from triangle data
tinybvh::BVH bvh;
bvh.Build((tinybvh::bvhvec4*)MyTriData, TriangleCount);

// Cast a ray
tinybvh::Ray ray(
    tinybvh::bvhvec3(0, 0, 0),
    tinybvh::bvhvec3(0, 0, 1),
    1e30f
);
bvh.Intersect(ray);
// Intersection info is in ray.hit
```

**License:** MIT (included at `ThirdParty/tinybvh/LICENSE`)

### KBVEUnrealMCP

An editor-only plugin that exposes a WebSocket JSON command server for AI-assisted Unreal Engine development.
Any external MCP (Model Context Protocol) bridge — Python, TypeScript, or Node.js — can connect to the plugin and control the editor programmatically.
Targets UE 5.7+.

**Architecture:**

```
[AI Client] --MCP--> [External Bridge] --TCP (JSON\n)--> [KBVEUnrealMCP Plugin]
                                                              |
                                                  TMap<FString, Handler> dispatch
                                                              |
                                                  GameThread UE API execution
```

The plugin runs a TCP server on port `9777` (configurable in Project Settings under KBVE Unreal MCP).
Clients connect via TCP and send newline-delimited JSON (`\n` terminated).
All handler methods are dispatched via a `TMap`-based registry for O(1) lookup.
Every UE API call is marshaled to the GameThread via `AsyncTask` for thread safety.
Verified compiling on UE 5.7.4 (Mac, universal binary).

**JSON Protocol:**

```json
// Request
{ "id": "uuid", "method": "actor.spawn", "params": { "class_path": "/Script/Engine.PointLight", "location": [0, 0, 200] } }

// Response
{ "id": "uuid", "success": true, "result": { "actor_name": "PointLight_0", "actor_label": "PointLight_0" } }

// Error
{ "id": "uuid", "success": false, "error": { "code": "NOT_FOUND", "message": "Actor not found" } }
```

**Implemented Handler Domains (28 domains, 170+ methods):**

| Domain | Methods | Status |
|--------|---------|--------|
| `actor.*` | spawn, delete, find, list, get/set_transform, get/set_property, duplicate, batch_transform, attach, detach, add_component | Complete |
| `blueprint.*` | create, add/remove_component, list_components, set_component_property, add/remove_variable, add_function_node, add_event_node, connect_nodes, disconnect_pin, set_pin_default, delete_node, set_default, reparent, validate, compile, get_graph, snapshot_graph, diff_graph, restore_graph | Complete |
| `asset.*` | search, get_info, get_references, get_dependents, list, validate | Complete |
| `level.*` | get_info, list_levels, open, save, get_world_outliner | Complete |
| `console.*` | execute (with safety validation), get_log | Complete |
| `viewport.*` | get/set_camera, take_screenshot, focus_actor | Complete |
| `python.*` | execute, evaluate | Complete |
| `material.*` | create, modify, apply, get_info, set_parameter, create_instance | Complete |
| `lighting.*` | spawn_light, set_properties, build_lighting, get_info | Complete |
| `navigation.*` | rebuild_navmesh, test_path, get_info | Complete |
| `physics.*` | set_properties, enable_simulation, get_info, add_constraint | Complete |
| `performance.*` | get_stats, profile_gpu, get_memory_info | Complete |
| `audio.*` | spawn_source, set_properties, play, stop, get_info | Complete |
| `input.*` | create_action, create_mapping, bind_action, get_info | Complete |
| `spline.*` | create, add_point, set_properties, get_info | Complete |
| `codeanalysis.*` | analyze_class, find_references, search_code, get_hierarchy, list_classes, list_functions, list_properties | Complete |
| `network.*` | set_replication, get_info | Complete |
| `geometry.*` | create_procedural_mesh (basic shapes), get_info | Complete |
| `ai.*` | create_behavior_tree, set_blackboard, get_info | Complete |
| `animation.*` | create_anim_bp, set_sequence, add_notify, get_tracks | Complete |
| `niagara.*` | create_system, activate, deactivate, set_parameter, get_info | Complete |
| `gameplay.*` | create_interaction, get_info (tags, GAS, trigger volumes) | Complete |
| `editor.*` | undo, redo, select, get_selection, rename_asset, delete_asset, find_in_radius, raycast, set_label, set_folder, add/remove_tag, find_by_tag | Complete |
| `foliage.*` | paint (radial scatter with ground snap), remove (area clear), get_info (type/instance counts) | Complete |
| `placement.*` | grid (rows x cols), circle (radial with face_center), scatter (random with ground snap + scale), along_spline (evenly distributed) | Complete |
| `streaming.*` | list_levels (persistent + streaming), load_level, unload_level, set_visibility | Complete |
| `landscape.*` | sculpt, flatten, smooth, get_info | Partial |
| `widget.*` | create, set_property, get_info | Partial |
| `mcp.*` | ping, list_methods, server_info | Complete |

**Safety features:**
- Console command denylist (blocks `exit`, `quit`, `RestartEditor`, `crash` by default)
- Python execution toggle
- Path validation to prevent writes outside the project directory
- Configurable rate limiting

**Implementation Roadmap:**

The following methods are registered but return `NOT_IMPLEMENTED`. Each is tracked for future PRs:

| Domain | Stubbed Methods | Reason |
|--------|----------------|--------|
| `landscape.*` | paint_layer | Weight map painting requires layer info setup |
| `widget.*` | add_element, bind_event, add_to_viewport, remove | UMG widget tree manipulation + PIE-only viewport ops |
| `animation.*` | add_state, add_transition | AnimGraph state machine node manipulation is version-sensitive |
| `gameplay.*` | add_ability, add_attribute | GAS is an optional plugin; needs conditional loading |
| `network.*` | create_session | Depends on project-specific online subsystem config |
| `geometry.*` | set_vertices | Requires ProceduralMeshComponent plugin |
| `ai.*` | add_task | BT graph node editing requires specialized graph API |

**License:** Part of the KBVE monorepo (MIT)

### Custom Editor Extensions

Third-party plugins extending the Unreal Editor with specialized workflows:

#### SelShader

**[envieous/UnrealEngine-SelShader](https://github.com/envieous/UnrealEngine-SelShader)** — Editor shader selection and inspection toolkit.

Provides advanced shader debugging and visualization tools for material artists and rendering engineers.
Allows selecting shaders directly in the viewport, inspecting compiled shader bytecode, and visualizing pipeline state objects (PSOs).

**Features:**
- Viewport shader picker (click to select active shader stage)
- PSO inspector with draw call metadata
- HLSL bytecode viewer and disassembler integration
- Material instance parameter override visualization
- Shader complexity heatmaps per pass

**Use Case:** Debugging performance hotspots, validating shader permutations, and profiling material complexity in large scenes.

**License:** Check repository for licensing terms.

#### Angelscript

**[Hazelight/UnrealEngine-Angelscript](https://github.com/Hazelight/UnrealEngine-Angelscript)** — AngelScript scripting language integration for Unreal Engine.

Alternative to Blueprints and C++ with text-based scripting, hot reload, and editor integration.
Used in production by Hazelight Studios (*It Takes Two*, *A Way Out*) for rapid gameplay iteration without full C++ recompilation.

**Features:**
- Text-based scripting with syntax similar to C++/C#
- Instant hot reload of script changes in PIE (Play In Editor)
- Full access to UE reflection system (UCLASS, UPROPERTY, UFUNCTION)
- Editor integration with syntax highlighting and autocomplete
- Debugging support with breakpoints and watches
- Lower compile times than C++ for iteration-heavy workflows

**Use Case:** Gameplay scripting for teams needing faster iteration than C++ without Blueprint's visual overhead. Ideal for narrative-heavy or systems-driven games where designers write code.

**Supported Versions:** UE5.1+ (check repo for latest compatibility)

**License:** MIT

### Other KBVE Plugins

| Plugin | Description | Third-Party License |
|--------|-------------|-------------------|
| **KBVEXXHash** | xxHash 0.8.3 — extremely fast non-cryptographic hash | BSD 2-Clause |
| **KBVEZstd** | Zstandard 1.5.7 — fast lossless compression | BSD 3-Clause |
| **KBVESQLite** | SQLite — embedded SQL database | Public Domain |
| **KBVEYYJson** | yyjson — fast JSON parser | MIT |
| **KBVELibGit** | libgit2 — Git repository management from the editor | GPL-2.0 with linking exception |
| **KBVEWASM** | WebAssembly runtime integration | Various |
| **UEDevOps** | DevOps toolkit: telemetry, error reporting, GitHub integration | KBVE (MIT) |

---

## Windows VM Tooling (KubeVirt)

<Aside type="caution" title="KubeVirt VMs">
    These instructions are for headless Windows Server VMs running inside KubeVirt
    on the KBVE cluster. For local development, use the standard installers.
</Aside>

### Visual Studio Build Tools (Offline Install)

UE5 requires Visual Studio Build Tools for C++ compilation. On a headless Windows VM
without internet reliability (Cilium masquerade NAT drops long connections), use the
offline layout approach:

<Steps>

1. **Download the bootstrapper** on a machine with stable internet:

   | Edition | Download |
   |---------|----------|
   | Build Tools | `vs_buildtools.exe` |
   | Professional | `vs_professional.exe` |
   | Community | `vs_community.exe` |

   All available from Microsoft's Visual Studio downloads page (version 17 release channel).

2. **Create an offline layout** with the UE5 workload:

   ```powershell
   # Download all required components for UE5 C++ development
   vs_buildtools.exe --layout C:\VSLayout --lang en-US `
     --add Microsoft.VisualStudio.Workload.VCTools `
     --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 `
     --add Microsoft.VisualStudio.Component.Windows11SDK.22621 `
     --includeRecommended
   ```

3. **Transfer the layout** to the VM via the sidecar HTTP proxy or PVC mount.

4. **Install from the layout** inside the VM:

   ```powershell
   # Run from the layout directory (no internet required)
   C:\VSLayout\vs_buildtools.exe --noweb --passive --norestart `
     --add Microsoft.VisualStudio.Workload.VCTools `
     --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 `
     --add Microsoft.VisualStudio.Component.Windows11SDK.22621
   ```

</Steps>

### Git Bash Integration

To use Git Bash inside Visual Studio's terminal:

1. Open `View > Terminal`
2. Click the gear icon in the terminal's upper right
3. Navigate to `Environment > Terminal` in Options
4. Add a new profile:
   - **Name**: Git Bash
   - **Shell Location**: `C:\Program Files\Git\bin\bash.exe`
   - **Arguments**: `--login -i`
5. Set as default (optional), click OK

### VS Code CLI (Headless Server)

For remote development on headless Windows VMs via VS Code tunnels:

```powershell
# Download VS Code CLI (no GUI needed)
Invoke-WebRequest -Uri "https://code.visualstudio.com/sha/download?build=stable&os=cli-win32-x64" `
  -OutFile "$env:TEMP\vscode-cli.zip"
Expand-Archive "$env:TEMP\vscode-cli.zip" -DestinationPath "C:\vscode-cli"

# Start a tunnel (connects to your local VS Code via tunnel)
C:\vscode-cli\code.exe tunnel --accept-server-license-terms
```

This creates a remote tunnel that your local VS Code can connect to via the
Remote - Tunnels extension, allowing full IDE access to the Windows VM without
VNC or RDP.

### winget (Windows Package Manager)

For VMs with internet access (or via sidecar proxy):

```powershell
# Install Git
winget install --id Git.Git -e --source winget

# Install VS Code (full GUI — only if VM has display)
winget install --id Microsoft.VisualStudioCode -e --source winget

# Install VS Build Tools
winget install --id Microsoft.VisualStudio.2022.BuildTools -e --source winget
```

<Aside type="tip" title="Issue #9328">
    Downloads on KubeVirt VMs drop due to Cilium VXLAN masquerade NAT.
    Use the sidecar HTTP proxy with aria2c for reliable large downloads.
    See [issue #9328](https://github.com/KBVE/kbve/issues/9328).
</Aside>

---

## macOS VM Tooling (KubeVirt)

<Aside type="caution" title="Apple EULA">
    macOS VMs must run on genuine Apple hardware (Mac Pro, Mac Mini, etc.)
    per Apple's EULA. Only deploy on Apple-branded physical hosts.
</Aside>

### Status: Not Yet Provisioned

The macOS KubeVirt VM (`macos-builder`) manifest exists but hasn't been set up yet.
Uses the [OSX-KVM](https://github.com/kholia/OSX-KVM) approach for KVM-based macOS.

### Provisioning Checklist

- [ ] Apple hardware node added to cluster (Mac Mini / Mac Pro with Talos)
- [ ] Upload macOS install image via virtctl (`BaseSystem.img`)
- [ ] Install macOS via VNC (`virtctl vnc macos-builder -n angelscript`)
- [ ] Install Xcode + Command Line Tools
- [ ] Install GitHub Actions runner (label: `UE5-Mac`)
- [ ] Configure download-proxy access for large downloads
- [ ] Test UE5 source build (`GenerateProjectFiles.sh` + `xcodebuild`)

### Required Tools (inside macOS VM)

| Tool | Purpose | Size |
|------|---------|------|
| Xcode | Metal shader compiler, iOS/macOS SDK | ~13GB |
| Command Line Tools | `clang`, `make`, `git` without full Xcode | ~3GB |
| Homebrew | Package manager for cmake, ninja, etc. | ~500MB |
| GitHub Actions Runner | Self-hosted runner for CI jobs | ~200MB |

### Xcode Installation (Offline via download-proxy)

```bash
# Stage Xcode .xip on the download proxy (from a machine with Apple ID auth)
# Then inside the macOS VM:
curl http://download-proxy.angelscript.svc:8080/Xcode_16.2.xip -o /tmp/Xcode.xip
xip -x /tmp/Xcode.xip -C /Applications/
sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
xcodebuild -license accept
```

### CI Workflow

The `ci-unreal.yml` workflow (`task: mac-setup`, routes to `ci-unreal-build.yml` mode `mac-setup`) follows the same two-job pattern as Windows:
1. **Linux runner**: stages downloads via download-proxy (aria2c)
2. **macOS VM runner**: installs from staged files on the shared PVC

### Challenges

- Xcode download requires Apple Developer account authentication
- Metal shader compilation needs GPU passthrough (not available on non-Apple hosts)
- Same masquerade NAT issue as Windows — use download-proxy
- OSX-KVM requires specific CPU feature flags (`invtsc`, `vmx`, `avx2` — already configured)

<Giscus />

---
# v01d

> Virtualized Object Intelligence Daemon, or VOID, is an operator application that manages servers, nested machines and clustered instances within an eco-system.

Source: https://kbve.com/application/v01d/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Adsense } from '@/components/astropad';

## Overview

**v01d** (VOID — *Virtualized Object Intelligence Daemon*) is an internal operator that manages servers, nested machines, and clustered instances across the KBVE ecosystem. It leans on **soft-scripting automation** with fine-grained RBAC, orchestrating virtual environments and containers without heavy configuration.

Its behavior is organized into **environs** — regulating entities such as [tr33](#tr33) (timers), [s33d](#s33d) (data seeding), [bl0ck](#bl0ck) (micro storage), and [r00t](#r00t) (OS-level embed).

## Information

Virtualization soft scripting for automation.

v01d is a powerful virtualization software designed to streamline automation through soft scripting.
It enables developers, agents and IT administrators to easily create, manage, and orchestrate virtual environments without the need for complex configurations.
With support for various hypervisors and cloud platforms, v01d simplifies the deployment and scaling of virtual machines and containers.
The software's scripting capabilities offer fine grained control (RBAC) over automation workflows, making it ideal for both small scale testing and large scale production setups.
By leveraging **v01d**, teams can reduce overhead and enhance operational efficiency across their virtualized infrastructure.


<Adsense />

## VOID

-   Virtualized Object Intelligence Daemon, or VOID, is an operator application that manages servers, nested machines and clustered instances within an eco-system.

    -   Linux

        -   `void_install_ubuntu.sh` - (chmod 777) - Installation for Ubuntu 24+ , after the install script runs, it will delete itself.
        -   `void_install_debian.sh` - (chmod 777) - Installation for Debian 11+ , after the install script runs, it will delete itself.

    -   Windows

        -   `void_install_win11.exe` - (admin privilege) - Install for Windows 11

    -   Mac
        -   Mac M1 / M2\* has an ARM based system, so it might have to be isolated from the intel macs.
        -   Expanding upon brew might be a better course for Macs\*

-   Environs are entities that help balance and regulate the digital environmental.

## TR33

-   `tr33` - (environ) - a collection of timers that handle micro tasks on the host machine.
    -   `tr33._04` - v4 is stable for Ubuntu 22 LTS, Debian 9, Windows 10/11.
        -   `tr33._04.nginx.1_22` - Nginx
        -   `tr33._04.apache.1` - Disabled.
    -   `tr33._05YAML_.` - v5 is unstable but utilizes YAML, slated for deprecation by Q3 of 2024.
    -   `tr33._06JSON_.` - v6 is unstable but utilizes a JSON-based API for commands, slated for deprecation by Q4 of 2025.0
    -   `tr33._01` - Deprecated - A rootkit that was designed and based upon various viruses.
    -   `tr33._02` - Deprecated.
    -   `tr33._03` - Deprecated.

## S33D

-   `s33d` - (environ) - an application or library that expands upon torrent data seeding.
    -   `s33d._dna.` - commands that the host computer must run to enable specific future applications.
        -   `s33d._dna.WebRTC.1_3` - Enables WebRTC.
    -   `s33d._nfc.` - Compressed information that can be stored inside NFC. The format will take about 64 bytes.
        -   `68 74 74 70 73 3a 2f 2f 6e 2e 6b 62 76 65 2e 63 6f 6d 2f 64 6e 61 2f` - 23 bytes for the generic/default location of the seed, with 40 bytes left over for additional information regarding the application(s).

## BL0CK

-   `bl0ck` - micro storage for host.
    -   `bl0ck.B64AES.` - Based 64 - AES compressed data block.
    -   `bl0ck.chain._` - Micro blockchain for the void system(s).

## R00T

-   `r00t` - (environ) - an embed that sits on-top of the operating system.
    -   `r00t` - Disabled as of `tr33._02` because the design induced significant flaws and exploits; uncle ben does not approve of such power for any man.

## FAQ

**What is v01d?**
v01d (VOID — Virtualized Object Intelligence Daemon) is an operator application that manages servers, nested machines, and clustered instances across the KBVE ecosystem. It focuses on soft-scripting automation with fine-grained RBAC over virtual environments and containers, from small-scale testing to production.

**What is an environ in v01d?**
An environ is an entity that helps balance and regulate the digital environment managed by VOID. Examples include `tr33` (timers for micro tasks), `s33d` (data seeding), `bl0ck` (micro storage), and `r00t` (an OS-level embed, currently disabled).

**What is `tr33` in v01d?**
`tr33` is an environ — a collection of timers that handle micro tasks on the host machine. The stable branch, `tr33._04`, targets Ubuntu 22 LTS, Debian 9, and Windows 10/11, while the YAML- and JSON-based v5 and v6 lines are unstable and slated for deprecation.

**Which platforms does v01d install on?**
VOID ships install scripts for Linux (Ubuntu 24+ and Debian 11+, which self-delete after running) and a Windows 11 installer that needs admin privileges. On Apple Silicon Macs (M1/M2), the ARM architecture may require isolation from Intel Macs, with Homebrew as a likely path.

<Adsense />

---
# WireGuard

> WireGuard is a fast, modern, open-source VPN protocol that builds encrypted point-to-point tunnels with
state-of-the-art cryptography and a tiny codebase. This guide covers the core concepts, a basic peer-to-peer
setup, a full Kubernetes DaemonSet deployment, Docker, and Netmaker automation.

Source: https://kbve.com/application/wireguard/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';


## Information

WireGuard is a modern, high-performance VPN application designed to be simple, fast, and secure.
It utilizes state-of-the-art cryptography to establish encrypted connections between devices, ensuring privacy and security over the internet.
Unlike traditional VPN solutions, WireGuard is lightweight, with a minimal codebase that reduces the potential for vulnerabilities and improves performance.
It is cross-platform, supporting major operating systems like Linux, Windows, macOS, iOS, and Android, and is known for its ease of configuration and seamless integration into existing network infrastructures.
WireGuard's efficiency and robust security make it an ideal choice for both personal and enterprise use.

## How WireGuard Works

WireGuard connects **peers**, not clients and servers — the model is symmetric. Each peer has a **key pair**: a private key it keeps secret and a public key it shares. A peer accepts an encrypted packet only if it is signed by a known public key listed in its config, so the public keys themselves form the access control list.

Three fields do most of the work in every config:

| Field | Meaning |
| ----- | ------- |
| `PrivateKey` | This peer's secret key (from `wg genkey`) |
| `PublicKey` | The remote peer's public key, under `[Peer]` |
| `AllowedIPs` | Which IPs are accepted from and routed to that peer |
| `Endpoint` | The remote peer's reachable `IP:port` |
| `PersistentKeepalive` | Seconds between keepalives to hold a NAT mapping open |

## Basic Peer-to-Peer Tunnel

Before the Kubernetes deployment, here is the smallest useful setup — two machines linked over a single UDP port. Generate a key pair on **each** peer:

```bash
umask 077
wg genkey | tee privatekey | wg pubkey > publickey
```

Server (`/etc/wireguard/wg0.conf`):

```ini
[Interface]
PrivateKey = <Server_Private_Key>
Address = 10.0.0.1/24
ListenPort = 51820

[Peer]
PublicKey = <Client_Public_Key>
AllowedIPs = 10.0.0.2/32
```

Client (`/etc/wireguard/wg0.conf`):

```ini
[Interface]
PrivateKey = <Client_Private_Key>
Address = 10.0.0.2/24

[Peer]
PublicKey = <Server_Public_Key>
Endpoint = server.example.com:51820
AllowedIPs = 10.0.0.0/24
PersistentKeepalive = 25
```

Bring the tunnel up on both ends with `wg-quick up wg0` (and down with `wg-quick down wg0`). Check live status and handshake times with `sudo wg`. Setting the client's `AllowedIPs` to `0.0.0.0/0` instead would route **all** its traffic through the server — a full VPN.

<Steps>

0.  **Tutorial**:

    This is a step-by-step tutorial on setting up WireGuard for a Kubernetes cluster to enable access to containers from different networks via WireGuard!

1.  **Prepare Kubernetes Cluster**:

    Ensure that you have a running Kubernetes cluster.
    You can use a managed service like GKE, EKS, or AKS, or set up your cluster using tools like Minikube, kubeadm, or k3s.

2.  **Install WireGuard on Nodes**:

    Install WireGuard on all Kubernetes nodes.
    The following instructions are for Ubuntu, but they can be adapted for other distributions.

    ```bash
    sudo apt update
    sudo apt install -y wireguard
    ```

3.  **Configure WireGuard Keys**:

    Generate WireGuard keys on each node. 
    
    This example below shows how to generate keys on a single node:

    ```bash
    umask 077
    wg genkey | tee privatekey | wg pubkey > publickey
    ```

    Repeat this step for each node in the cluster and keep a record of each node's private and public keys.

4.  **Create WireGuard Configuration**:

    Create a WireGuard configuration file for each node.
    Below is an example configuration (`wg0.conf`) for a node:

    ```ini
    [Interface]
    PrivateKey = <Node_Private_Key>
    Address = 10.0.0.1/24
    ListenPort = 51820

    [Peer]
    PublicKey = <Peer_Node_Public_Key>
    Endpoint = <Peer_Node_IP>:51820
    AllowedIPs = 10.0.0.2/32
    PersistentKeepalive = 25
    ```

    - Replace `<Node_Private_Key>` with the node's private key.
    - Replace `<Peer_Node_Public_Key>` with the peer node's public key.
    - Replace `<Peer_Node_IP>` with the peer node's IP address.
    - Adjust the `Address` and `AllowedIPs` fields as needed.

5.  **Deploy WireGuard DaemonSet**:

    Create a Kubernetes DaemonSet to deploy WireGuard on all nodes.

    Save the following YAML to a file named `wireguard-daemonset.yaml`:

    ```yaml
    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
    name: wireguard
    namespace: kube-system
    spec:
    selector:
        matchLabels:
        name: wireguard
    template:
        metadata:
        labels:
            name: wireguard
        spec:
        hostNetwork: true
        containers:
        - name: wireguard
            image: k8s.gcr.io/pause:3.1  # Use a pause container
            securityContext:
            privileged: true
            volumeMounts:
            - name: wireguard-config
            mountPath: /etc/wireguard
            - name: lib-modules
            mountPath: /lib/modules
        volumes:
        - name: wireguard-config
            hostPath:
            path: /etc/wireguard
        - name: lib-modules
            hostPath:
            path: /lib/modules
    ```

    Deploy the DaemonSet:

    ```bash
    kubectl apply -f wireguard-daemonset.yaml
    ```


6.  **Create WireGuard ConfigMap**:

    Create a ConfigMap to store the WireGuard configuration files.
    Save the following YAML to a file named `wireguard-configmap.yaml`, and include the configuration for each node:

    ```yaml
    apiVersion: v1
    kind: ConfigMap
    metadata:
    name: wireguard-config
    namespace: kube-system
    data:
    wg0.conf: |
        [Interface]
        PrivateKey = <Node1_Private_Key>
        Address = 10.0.0.1/24
        ListenPort = 51820

        [Peer]
        PublicKey = <Node2_Public_Key>
        Endpoint = <Node2_IP>:51820
        AllowedIPs = 10.0.0.2/32
        PersistentKeepalive = 25

        [Peer]
        PublicKey = <Node3_Public_Key>
        Endpoint = <Node3_IP>:51820
        AllowedIPs = 10.0.0.3/32
        PersistentKeepalive = 25
    ```

    Replace the placeholders with actual keys and IPs.
    
    Apply the ConfigMap:

    ```bash
    kubectl apply -f wireguard-configmap.yaml
    ```

7.  **Create WireGuard Init Container**:

    Modify the DaemonSet to include an init container that sets up WireGuard. 
    
    Update `wireguard-daemonset.yaml`:

    ```yaml
    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
    name: wireguard
    namespace: kube-system
    spec:
    selector:
        matchLabels:
        name: wireguard
    template:
        metadata:
        labels:
            name: wireguard
        spec:
        hostNetwork: true
        initContainers:
        - name: setup-wireguard
            image: busybox
            command: ["sh", "-c", "cp /etc/wireguard-config/wg0.conf /etc/wireguard/wg0.conf && wg-quick up wg0"]
            volumeMounts:
            - name: wireguard-config
            mountPath: /etc/wireguard-config
            - name: wireguard
            mountPath: /etc/wireguard
        containers:
        - name: wireguard
            image: k8s.gcr.io/pause:3.1
            securityContext:
            privileged: true
            volumeMounts:
            - name: wireguard
            mountPath: /etc/wireguard
            - name: lib-modules
            mountPath: /lib/modules
        volumes:
        - name: wireguard-config
            configMap:
            name: wireguard-config
        - name: wireguard
            hostPath:
            path: /etc/wireguard
        - name: lib-modules
            hostPath:
            path: /lib/modules
    ```

    Update the DaemonSet:

    ```bash
    kubectl apply -f wireguard-daemonset.yaml
    ```

8.  **Verify WireGuard Setup**:

    Check the status of WireGuard on each node:

    ```bash
    sudo wg
    ```

    You should see the WireGuard interface `wg0` and its peers.

9.  **Access Containers Across Networks**:

    Now, your nodes are connected via WireGuard.
    You can access containers across different networks by using the WireGuard IP addresses.
    
    For example, if you have a pod on Node 1 with a WireGuard IP of `10.0.0.1`, you can access it from Node 2 using that IP.

10. **Conclusion**:

    You have successfully set up WireGuard on a Kubernetes cluster, enabling secure communication between containers across different networks.
    This setup can be expanded and customized to fit more complex networking requirements.

</Steps>

<Adsense />

## Docker

Installing WireGuard on Docker!

-   Docker Compose

    -   Github
        	src="data/wireguard/docker-compose.yml"
        	description="This is a docker compose for wireguard."
        - Embed is disabled as of right now.

-   Ubuntu Installation Guide
    -   Core Pre-Installation
        -   Make sure your docker install is setup! If you need more information, please visit our Docker application page.
        -   Check your firewall, are you using `ufw` , `iptables` or `nftables`
    -   Firewall
        -   Wireguard will be operating on the `UDP` port of `51820`.
        -   For: `ufw`
            -   To enable the port through `ufw` run `sudo allow 51821/udp`


---


## Netmaker

-   Netmaker is a Wireguard automation application that handles self-hosted homelabs to small business / enterprise networking.
-   [Official Github Repo](https://github.com/gravitl/netmaker)

### Netmaker Install

-   Advance install for netmaker allows the setup of a highly available installation within Kubernetes through helm.
-   The _default_ settings may not install `wireguard` at the kernel level (for security reasons) and default to Postgres for storage.
    -   Not having kernel level wireguard may cause performance drops and they recommend that you install wireguard before beginning.
-   Helm Install Commands:

    -   ```shell
        helm repo add netmaker https://gravitl.github.io/netmaker-helm/
        helm repo update
        ```

    -   If you do not have `helm` or `kubernetes` setup, we recommend you visit our [kubernetes setup](/application/kubernetes).

-   The storage of the certificates will be an issue for this netmaker cluster, they recommend two types of storage classes:
    -   `RWO` - `Read Write Once` - Storage instance where only a single node is allowed to access the storage volume at a time for read and write access.
    -   `RWX` - `Read Write Many` - Storage instance where many nodes can concurrently read and write to the storage volume.

---

## FAQ

**What is WireGuard?**
WireGuard is an open-source VPN protocol that creates fast, encrypted point-to-point tunnels. It uses modern cryptography, runs in the Linux kernel for high performance, and has a very small codebase — a few thousand lines — which reduces its attack surface.

**How does WireGuard differ from OpenVPN?**
WireGuard is far smaller and faster. It runs in the kernel with modern fixed cryptography and connects almost instantly, whereas OpenVPN runs in userspace with configurable ciphers and higher overhead. WireGuard configs are also much simpler.

**What are `AllowedIPs` in a WireGuard config?**
`AllowedIPs` serves two roles — it defines which source IPs are accepted from a peer (a cryptographic access control list) and which destination IPs are routed through that peer. Setting `0.0.0.0/0` routes all traffic through the tunnel.

**What is `PersistentKeepalive` in WireGuard?**
It sends a small packet every N seconds to keep a NAT or firewall mapping open. It is needed when a peer sits behind NAT and must stay reachable; a value of `25` seconds is the common default.

**What port does WireGuard use?**
WireGuard uses a single UDP port, `51820` by default, set with `ListenPort`. Because it is UDP-only, you must allow that port through firewalls like `ufw`, `iptables`, or `nftables` on the server side.

<Adsense />

---
# ARPG

> Diablo-style multiplayer isometric action RPG built on Phaser 4 and @kbve/laser

Source: https://kbve.com/arcade/arpg/

import AstroIsoArpg from '@/arcade/AstroIsoArpg.astro';

<AstroIsoArpg />

---
# Blackjack

> Classic blackjack table built with Phaser.

Source: https://kbve.com/arcade/blackjack/

import AstroBlackjack from '@/arcade/blackjack/AstroBlackjack.astro';
import DeferredAdsense from '@/components/kbve/DeferredAdsense.astro';

<div class="kbve-dashboard-page relative min-h-screen w-full bg-transparent">

<AstroBlackjack />

<DeferredAdsense />

</div>

---
# Isometric

> Play the KBVE isometric game — a WebGPU-powered world built with Bevy and Rust.

Source: https://kbve.com/arcade/isometric/

import AstroIsometric from '@/arcade/isometric/AstroIsometric.astro';

<AstroIsometric />

---
# RareIcon

> Play the WebGL Demo of RareIcon

Source: https://kbve.com/arcade/rareicon/

---
# Runner

> Play our endless runner

Source: https://kbve.com/arcade/runner/

import AstroRunner from '@/arcade/runner/AstroRunner.astro';

<AstroRunner />

---
# Solitaire

> Klondike solitaire — single-player card game built with Phaser.

Source: https://kbve.com/arcade/solitaire/

import AstroSolitaire from '@/arcade/solitaire/AstroSolitaire.astro';
import DeferredAdsense from '@/components/kbve/DeferredAdsense.astro';

<div class="kbve-dashboard-page relative min-h-screen w-full bg-transparent">

<AstroSolitaire />

<DeferredAdsense />

</div>

---
# Frontline Grid

> Play a compact turn-based tactics prototype with grid movement, terrain,
range control, and enemy counter turns.

Source: https://kbve.com/arcade/tactics/

import AstroTactics from '@/arcade/tactics/AstroTactics.astro';

<AstroTactics />

---
# Tower Defense

> Place towers, defend the path, survive the waves.

Source: https://kbve.com/arcade/towerdefense/

import AstroTowerDefense from '@/arcade/towerdefense/AstroTowerDefense.astro';
import DeferredAdsense from '@/components/kbve/DeferredAdsense.astro';

<div class="kbve-dashboard-page relative min-h-screen w-full bg-transparent">


<AstroTowerDefense />

<DeferredAdsense />
</div>

---
# Bitcoin

> Bitcoin analysis, history, and data compilation.

Source: https://kbve.com/crypto/bitcoin/

import { Aside } from '@astrojs/starlight/components';
import BentoGrid from '@/components/bento/BentoGrid.astro';

export const contentModules = import.meta.glob('./_content/*.mdx', { eager: true });

export const bentoItems = Object.entries(contentModules).map(([path, mod]) => {
    const frontmatter = mod.frontmatter || {};
    return {
        bentoId: frontmatter.bentoId || path.split('/').pop().replace('.mdx', ''),
        title: frontmatter.title || path.split('/').pop().replace('.mdx', ''),
        description: frontmatter.description || '',
        bentoSize: frontmatter.bentoSize || 'medium',
        bentoOrder: frontmatter.bentoOrder ?? 99,
        bentoColor: frontmatter.bentoColor || 'from-zinc-700/30 to-zinc-900/60',
        icon: frontmatter.icon || 'file-text',
        Content: mod.Content,
    };
});

<Aside title="Not Financial Advice" type="danger">
This is not financial advice. The data compiled here is for reference purposes only.
</Aside>

<BentoGrid items={bentoItems} pageKey="bitcoin" />

---
# Audio and Sound Design

> Game audio fundamentals — the audio pipeline, adaptive/interactive music, spatialization, and the mix budget that keeps a soundscape readable.
Own-words reference cross-linked to KBVE projects.

Source: https://kbve.com/gdd/audio/

import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
import { Giscus, Adsense } from '@/components/astropad';

## Introduction

Game audio is interactive: sound responds to player action and game state in real time, unlike linear film audio. It splits into three jobs — sound effects (feedback), music (emotion/pacing), and dialogue/VO (narrative) — all balanced by a runtime mix. This page covers the pipeline, adaptive music, spatialization, and the budget.

<Aside type="tip" title="Source material">
For depth see the [FMOD docs](https://www.fmod.com/docs/), [Wwise docs](https://www.audiokinetic.com/library/), and the [Game Audio Learning](https://gameaudiolearning.com/) resources. This page summarizes the concepts.
</Aside>

<Adsense />

---

## The audio pipeline

From source asset to the player's speakers:

1. **Assets** — recorded or synthesized samples, usually compressed (Vorbis/Opus) for size, kept uncompressed (PCM) for short latency-critical SFX.
2. **Events / cues** — gameplay triggers an abstract event ("footstep", "explosion") rather than a specific file; the audio system picks the actual sample(s).
3. **Voices / channels** — each playing sound occupies a voice; a finite voice budget is enforced by priority and culling.
4. **Buses / submixes** — voices route through a mix graph (SFX bus, music bus, VO bus) for grouped volume, effects, and ducking.
5. **Master out** — final limiter, output to the device at the platform's sample rate.

<Aside>
Trigger **events**, not files. Indirection lets sound designers swap samples, add randomization, and tune behavior without touching gameplay code — the audio analogue of the [Type Object pattern](/gdd/patterns/).
</Aside>

---

## SFX design principles

- **Variation** — randomize pitch/volume and round-robin samples so repeated sounds (footsteps, gunfire) don't fatigue the ear.
- **Layering** — build one impactful sound from layers (a punch = whoosh + impact + low thud).
- **Feedback** — every meaningful player action needs an audible confirmation; silence reads as a bug.
- **Readability** — gameplay-critical sounds (enemy behind you, low health) must cut through the mix; cosmetic sounds yield.

---

## Adaptive and interactive music

Music that responds to the game instead of looping flatly:

<CardGrid>
  <Card title="Horizontal re-sequencing" icon="seti:clock">
    Arrange the track as segments and reorder/transition between them based on state (explore → tension → combat), respecting musical bar boundaries.
  </Card>
  <Card title="Vertical layering" icon="seti:db">
    Author stacked stems (drums, strings, lead) and fade layers in/out with intensity — same loop, rising energy.
  </Card>
  <Card title="Transitions & stingers" icon="seti:plan">
    Quantize transitions to the beat; fire short stingers on events (victory, discovery) over the running bed.
  </Card>
  <Card title="State-driven" icon="random">
    Game state (combat, menu, cutscene) drives the music system as inputs, not hardcoded track swaps.
  </Card>
</CardGrid>

---

## Spatialization

Placing sound in 3D so the player can locate it:

- **Panning & attenuation** — position in the stereo/surround field and roll off volume with distance.
- **3D audio / HRTF** — head-related transfer functions simulate how ears localize sound, for headphone immersion.
- **Occlusion & obstruction** — muffle and low-pass sounds behind walls so geometry shapes what you hear.
- **Reverb zones** — environment-driven reverb (cave vs hall vs open field) grounds sound in space.
- **Doppler** — pitch shift on fast-moving sources (vehicles, projectiles).

---

## The mix and budget

- **Voice budget** — a hard cap on simultaneous sounds; priority and distance culling decide who plays when the cap is hit.
- **Ducking / sidechain** — automatically dip music/SFX when dialogue plays so speech stays intelligible.
- **Dynamic range** — leave headroom; a wall of max-volume sound is exhausting and hides important cues.
- **Memory & streaming** — stream long music from disk, keep short latency-critical SFX resident in memory.

<Aside type="caution">
The mix is a zero-sum space. Adding loudness to one thing buries another. Design the hierarchy — what must always be heard — before tuning levels.
</Aside>

---

## How KBVE applies these

- **Event Queue for audio** — KBVE drains cross-system messages on a fixed cadence rather than firing direct calls; audio events fit that same [Event Queue](/gdd/patterns/) model — decouple *when triggered* from *when played*.
- **State-driven music** — the GDD's [core-loop and game-state](/gdd/) sections drive which audio state is active (exploration, combat, menus, cutscenes), matching the music-direction guidance in the core template.

---

## Further reading

- [FMOD documentation](https://www.fmod.com/docs/) — events, parameters, mixing.
- [Wwise documentation](https://www.audiokinetic.com/library/) — interactive music and spatial audio.
- [Game Audio Learning](https://gameaudiolearning.com/) — curated audio implementation resources.
- [Architecture Patterns](/gdd/patterns/) — Event Queue and Object Pool recur in audio engines.

<Giscus />

---
# Entity Component System

> The ECS architecture — entities, components, and systems — and why data-oriented design wins for high-entity-count games.
Own-words reference cross-linked to KBVE's Unity DOTS and Bevy projects.

Source: https://kbve.com/gdd/ecs/

import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
import { Giscus, Adsense } from '@/components/astropad';

## Introduction

Entity Component System (ECS) is an architecture that separates **identity** (entity), **data** (components), and **behavior** (systems). It is the data-oriented answer to the object-oriented entity hierarchies that buckle under thousands of objects. KBVE leans on it hard — Unity DOTS for rareicon, Bevy for the isometric/server crates.

<Aside type="tip" title="Source material">
For the foundations see the [Unity DOTS / Entities docs](https://docs.unity3d.com/Packages/com.unity.entities@latest), the [Bevy ECS guide](https://bevy.org/learn/), and Mike Acton's "Data-Oriented Design and C++" talk. This page summarizes the concepts and maps them to KBVE work.
</Aside>

<Adsense />

---

## The three parts

- **Entity** — an identity, usually just an integer ID. It owns no data and no behavior; it is a key that groups components.
- **Component** — plain data, no logic. `Position`, `Velocity`, `Health`. An entity *is* the set of components attached to it.
- **System** — behavior, no persistent data. A system queries for all entities that have a given set of components and processes them in a batch each frame.

<Aside>
The shift from OOP: instead of "a `Monster` object with `update()`", you have a `Monster` *entity* tagged with `Position`, `Health`, `AITag` components, processed by a `MovementSystem`, `CombatSystem`, and `AISystem` that each sweep every matching entity.
</Aside>

---

## Why ECS — data-oriented design

The real payoff is memory layout. OOP scatters each object across the heap; chasing pointers thrashes the CPU cache. ECS stores components of the same type **contiguously** (struct-of-arrays). A system iterating `Position` + `Velocity` walks two tight arrays in order — the cache stays hot, the prefetcher wins.

- **Cache locality** — process like data together; this is the [Data Locality pattern](/gdd/patterns/) made structural.
- **Parallelism** — systems with non-overlapping component access run on different threads with no locks.
- **Composition over inheritance** — add a capability by adding a component, not by editing a class tree.

---

## Storage models

- **Archetype-based** (Unity DOTS, Bevy default) — entities with the same set of component types are grouped into "archetypes" / tables; iteration is a linear scan of matching tables. Fast iteration; adding/removing a component moves the entity between tables (structural change).
- **Sparse-set** (Bevy opt-in, EnTT) — each component type owns a packed array plus an index map; cheap add/remove, slightly slower iteration.

Choose archetype for read-heavy hot loops, sparse-set for components that churn (frequently added/removed).

---

## Queries and change detection

- **Query** — "give me every entity with `A` and `B`, without `C`." The system's window into the world.
- **Change detection / change gate** — skip entities whose data did not change since last run; avoid redundant work.
- **Structural changes** — adding/removing components or creating/destroying entities. These often can't happen mid-iteration; defer them via command buffers / entity command queues to a sync point.

<Aside type="caution" title="Burst / job gotchas">
In Unity DOTS Burst code, KBVE has hit several sharp edges: build the query with `EntityQueryBuilder` (not the array overload) inside `[BurstCompile] ISystem`; `SystemAPI.Query` can't live in static methods; don't `[BurstCompile]` static helpers taking vector types; and main-thread reads of singleton `NativeContainer`s need `CompleteDependency()` / `.Complete()`, not just `CombineDependencies`. See the rareicon project notes.
</Aside>

---

## Trade-offs

<CardGrid>
  <Card title="Wins" icon="approve-check">
    Massive entity counts, cache-friendly, trivially parallel, data-driven composition, clean system boundaries.
  </Card>
  <Card title="Costs" icon="warning">
    Steeper mental model, harder debugging (no single "object"), structural-change rules, more ceremony for simple games.
  </Card>
</CardGrid>

ECS is overkill for a small game with few entities. It earns its complexity when you have thousands-to-millions of similar things to simulate every frame.

---

## How KBVE applies these

- **rareicon (Unity DOTS)** — the deepest ECS adoption: Burst `ISystem` jobs, packed components, parallel event pipelines with `NativeList.ParallelWriter`, `PipelineHandle`/`DrainHandle` coordination, a multi-role job system where every unit carries every `JobPriorities` byte, and a micro-optimization checklist baked into every new system.
- **NetCode world split** — under Unity NetCode the world is split; gameplay is client-only, so services scan `World.All` for `KingTag` rather than the default injection world.
- **Bevy crates** — the isometric game and server-side crates (`bevy_npc`, `bevy_skills`, `bevy_statemachine`) use Bevy's ECS for simulation and behavior.

---

## Further reading

- [Unity Entities (DOTS) docs](https://docs.unity3d.com/Packages/com.unity.entities@latest)
- [Bevy ECS guide](https://bevy.org/learn/)
- Mike Acton — "Data-Oriented Design and C++" (CppCon).
- [Architecture Patterns](/gdd/patterns/) — Component, Data Locality, and Update Method underpin ECS.

<Giscus />

---
# Netcode and Multiplayer

> Networking models, replication, and latency-hiding for multiplayer games — authority, prediction, and the trade-offs between client-server and peer-to-peer.
Own-words reference cross-linked to KBVE's transport and server projects.

Source: https://kbve.com/gdd/netcode/

import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
import { Giscus, Adsense } from '@/components/astropad';

## Introduction

Netcode is the layer that keeps multiple players in sync over an unreliable, latent network while the game still feels responsive. The hard part is physics: light takes time, packets drop, and you must hide that from the player. This page covers topologies, replication, latency hiding, and the security stance — mapped to KBVE's transport stack.

<Aside type="tip" title="Source material">
The canonical reads are Gabriel Gambetta's [Fast-Paced Multiplayer](https://www.gabrielgambetta.com/client-server-game-architecture.html) series, Valve's [Source Multiplayer Networking](https://developer.valvesoftware.com/wiki/Source_Multiplayer_Networking), and the [Gaffer On Games](https://gafferongames.com/) networking articles. This page summarizes and maps them to KBVE.
</Aside>

<Adsense />

---

## Topologies

- **Client-server (authoritative)** — the server owns the truth; clients send input, receive state. The standard for competitive and persistent games because it's the only practical way to resist cheating.
- **Peer-to-peer** — peers talk directly; lower infrastructure cost but trust and NAT problems, and "who is authoritative?" gets messy.
- **Lockstep (deterministic)** — peers exchange only inputs and run identical simulations in step. Tiny bandwidth, scales to huge unit counts (RTS), but demands bitwise determinism and stalls on the slowest peer.

<Aside>
Authoritative client-server is the default unless you have a specific reason (RTS unit counts → lockstep; tiny co-op → maybe P2P).
</Aside>

---

## Replication

Replication is keeping client state in sync with server state efficiently:

- **State replication** — server sends snapshots of relevant game state; clients render it. Robust to packet loss (next snapshot supersedes the lost one).
- **Delta compression** — send only what changed since the client's last acknowledged snapshot.
- **Relevancy / interest management** — only replicate what a client can perceive (area of interest, distance, visibility). Bandwidth is the budget; don't send the whole world.
- **Reliability tiers** — UDP by default; layer your own reliability only where needed (RPCs, events) and leave fast-changing state unreliable.

---

## Latency hiding

The techniques that make a laggy network feel instant:

<CardGrid>
  <Card title="Client-side prediction" icon="rocket">
    The client applies the player's input immediately instead of waiting for the server round-trip, so movement feels instant.
  </Card>
  <Card title="Server reconciliation" icon="seti:default">
    When the authoritative state arrives, the client rewinds and re-applies any inputs the server hadn't processed yet, correcting drift.
  </Card>
  <Card title="Entity interpolation" icon="seti:clock">
    Render *other* players slightly in the past, smoothly interpolating between received snapshots to hide the gaps.
  </Card>
  <Card title="Lag compensation" icon="seti:crystal">
    The server rewinds the world to the shooter's view-time when validating a hit, so well-aimed shots register despite latency.
  </Card>
</CardGrid>

<Aside type="caution">
Prediction can mispredict — the correction must be smoothed (not snapped) or it looks like rubber-banding. Interpolation adds intentional latency to *other* entities; that's the price of smoothness.
</Aside>

---

## Tick rate and timing

- **Tick rate** — how often the server simulates and snapshots (e.g. 30/60 Hz). Higher = more responsive, more bandwidth/CPU.
- **Fixed timestep** — the simulation must advance in fixed steps for determinism and fair prediction; decouple it from render framerate (see the [Game Loop pattern](/gdd/patterns/)).
- **Clock sync** — clients estimate server time + RTT to schedule input and interpolation correctly.

---

## Security

The first rule: **never trust the client.**

- Validate every input server-side; the client sends *intent*, the server decides *outcome*.
- Movement, hits, economy, and item grants are server-authoritative.
- Rate-limit and sanity-check inputs; clamp to physically possible actions.
- Keep authority and transport concerns separated and never mix transports in shared structs.

<Aside>
KBVE's services treat auth as server-side truth: OWS gates world access on a Supabase JWT/UUID, enforces character-ownership with a 403, and resolves identity from the `sub` claim rather than client-supplied names.
</Aside>

---

## How KBVE applies these

- **Transport isolation** — WS and WT transports are kept strictly isolated; never mixed in shared structs, following the lightyear examples. This is a recorded engineering rule.
- **rareicon (Unity NetCode)** — NetCode splits the world; gameplay is client-only and UI/services must scan `World.All` for `KingTag` rather than the default injection world.
- **Authoritative auth** — OWS/ROWS resolve `userguid = sub` from the Supabase JWT, gate world-IP on bearer-or-session, and 403 on character-ownership mismatch.
- **Known issue** — the isometric game's WASM WebSocket handshake reports `linked = true` but the netcode never completes the handshake; native works fine.

---

## Further reading

- Gabriel Gambetta — [Fast-Paced Multiplayer](https://www.gabrielgambetta.com/client-server-game-architecture.html).
- [Gaffer On Games](https://gafferongames.com/) — networked physics, reliability over UDP, snapshot interpolation.
- Valve — [Source Multiplayer Networking](https://developer.valvesoftware.com/wiki/Source_Multiplayer_Networking).
- [Architecture Patterns](/gdd/patterns/) — Event Queue and Double Buffer recur in netcode.

<Giscus />

---
# Game Programming Patterns

> Architecture patterns for game code — decoupling, sequencing, behavioral, and optimization patterns that keep a growing codebase maintainable.
Original summaries with intent, when-to-use, and trade-offs, cross-referenced to the KBVE game projects that apply them.

Source: https://kbve.com/gdd/patterns/

import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
import { Giscus, Adsense } from '@/components/astropad';

## Introduction

A Game Design Document describes *what* the game is. This page describes *how* the code is shaped to support it. The patterns below are the common architectural building blocks of game engines and gameplay code: ways to decouple systems, sequence frame work, model behavior, and squeeze out performance.

These are own-words summaries focused on **intent**, **when to reach for it**, and **the trade-off you accept**. They are not a substitute for the source material.

<Aside type="tip" title="Primary source">
The canonical reference is Robert Nystrom's *Game Programming Patterns*, free to read online at [gameprogrammingpatterns.com](https://gameprogrammingpatterns.com/). Read it there for full worked examples and code. This page summarizes and maps the patterns onto KBVE's projects.
</Aside>

<Adsense />

---

## Design Patterns Revisited

Classic Gang-of-Four patterns, reconsidered through a game-shaped lens — where they help and where they hurt.

### Command

Wrap an action in an object so it can be stored, queued, undone, or replayed. The caller fires a command without knowing what it does; the command knows how to do and undo it.

- **Use when:** input remapping, undo/redo, AI issuing the same actions as a player, recording/replaying input, networked input streams.
- **Trade-off:** one object per action adds indirection and allocation; pool or flyweight commands if they are hot.

### Flyweight

Share the data that is identical across many instances; keep only the per-instance data local. A thousand trees reference one shared mesh/texture and carry only their own transform.

- **Use when:** huge counts of near-identical entities (foliage, tiles, particles, mobs).
- **Trade-off:** the shared state must be immutable; mutation leaks across every user of the flyweight.

### Observer

Let objects announce events without knowing who listens. Subjects publish; observers subscribe. Decouples the thing that changes from the things that react.

- **Use when:** achievements, UI reacting to gameplay, analytics, loosely coupled cross-system notifications.
- **Trade-off:** implicit control flow is hard to trace; dangling observers leak. Prefer an explicit event queue for high-volume or ordered events.

### Prototype

Create new objects by cloning an existing instance rather than instantiating a class. Spawners hold a template and stamp out copies.

- **Use when:** data-driven spawning, editor-defined entity templates, varied enemy definitions without a class explosion.
- **Trade-off:** deep vs shallow clone bugs; in practice a data/Type Object approach is often clearer than literal cloning.

### Singleton

A single globally-accessible instance. The most over-used pattern in game code.

- **Use when:** rarely — and even then prefer dependency injection or a Service Locator.
- **Trade-off:** hidden coupling, ordering hazards at startup/shutdown, and a wall for testability and multithreading. Treat as a smell, not a default.

---

## Sequencing Patterns

Patterns that govern time — how the game advances frame to frame.

### Double Buffer

Render or compute into a back buffer, then swap it with the front buffer atomically. Readers always see a complete, consistent frame; writers never tear.

- **Use when:** rendering, any state where a half-updated read is visible/wrong (e.g. cellular automata, simultaneous-turn resolution).
- **Trade-off:** double the memory for the buffered state; the swap must be cheap and atomic.

### Game Loop

The heartbeat: process input, update the world, render — forever, decoupled from the wall clock so the game runs the same on fast and slow hardware.

- **Use when:** always; it is the spine of real-time games. Choose fixed-timestep update with interpolated rendering for deterministic simulation.
- **Trade-off:** a variable timestep is simpler but makes physics/sim non-deterministic and order-sensitive.

### Update Method

Each live entity gets an `update()` called once per frame to advance its own behavior by one tick. The loop walks a collection and ticks each.

- **Use when:** many objects with independent per-frame behavior.
- **Trade-off:** scattered cache access and per-object virtual calls hurt at scale — see **Data Locality** and ECS designs as the answer.

<Aside>
KBVE's ECS-heavy projects (rareicon on Unity DOTS) effectively replace per-object Update Method with batched system passes — the same sequencing intent, restructured for **Data Locality**.
</Aside>

---

## Behavioral Patterns

Patterns for defining what entities *do*.

### Bytecode

Encode behavior as data — instructions for a tiny virtual machine — instead of hardcoding it in the engine language. Designers/modders author behavior without recompiling.

- **Use when:** spell/skill scripting, modding surfaces, sandboxed user content, data-driven content at volume.
- **Trade-off:** you are building (and debugging) a VM and toolchain; heavy upfront cost. AngelScript/Lua often fill this role off-the-shelf.

### Subclass Sandbox

A base class exposes a set of safe primitive operations; subclasses define behavior by combining those primitives, never touching the engine directly.

- **Use when:** many variations of one concept (power-ups, abilities) authored by gameplay programmers.
- **Trade-off:** the base class becomes a god-object of primitives; favor composition (**Component**) when variation explodes.

### Type Object

Move what would be subclasses into data instances of a single "type" class. A `Monster` holds a reference to a `MonsterType` ("Dragon", "Goblin") that carries shared stats/behavior.

- **Use when:** content defined by designers in data; new "kinds" should not require new code.
- **Trade-off:** less compile-time type safety; behavior differences beyond data still need code.

### State

Model an entity as a finite state machine — explicit states with explicit transitions — instead of a tangle of boolean flags.

- **Use when:** characters with modes (idle/walk/jump/attack), UI flows, AI. Use hierarchical/pushdown FSMs when states share sub-behavior.
- **Trade-off:** state explosion for complex behavior; consider behavior trees or **StateTree** for richer AI.

<Aside>
See KBVE's `behavior_statetree` work for a typed-command FSM boundary in production.
</Aside>

---

## Decoupling Patterns

Patterns that let one part of the program change without breaking others.

### Component

Build an entity by composing independent components (position, render, physics, health) instead of one deep inheritance tree. The entity is a bag of parts.

- **Use when:** entities that mix and match capabilities; the foundation of ECS.
- **Trade-off:** cross-component communication needs a discipline (messages, shared data, or systems) or it becomes spaghetti.

### Event Queue

Decouple *when* an event is sent from *when* it is processed. Producers enqueue; a consumer drains the queue on its own schedule.

- **Use when:** audio, async systems, smoothing bursty input, ordering and rate-limiting cross-system messages.
- **Trade-off:** added latency; queued state can go stale; debugging is harder than a direct call. Watch for feedback loops.

### Service Locator

Provide global access to a service through an indirection layer, so callers find it without hardcoding the concrete implementation.

- **Use when:** swappable subsystems (audio, logging, platform layer), null/mock implementations for tests.
- **Trade-off:** still a global; hides dependencies. Prefer explicit injection where practical.

---

## Optimization Patterns

Patterns that trade complexity for speed — apply only after profiling.

### Data Locality

Lay out data so the CPU cache stays hot: contiguous arrays of the data a loop actually touches, processed in order. The single biggest real-world game perf lever.

- **Use when:** hot loops over many entities; the core motivation behind ECS / struct-of-arrays.
- **Trade-off:** less flexible, less object-oriented layout; harder to mutate structure at runtime.

### Dirty Flag

Defer expensive recomputation until the result is actually needed, and skip it entirely when nothing changed. Mark dirty on write; recompute lazily on read.

- **Use when:** derived data that is costly to compute and changes less often than it is read (world transforms, baked lighting, derived stats).
- **Trade-off:** correctness hinges on every mutation setting the flag; a missed set is a silent stale-data bug.

### Object Pool

Reuse a fixed set of pre-allocated objects instead of allocating/freeing constantly. Take from the pool, return when done.

- **Use when:** high-churn short-lived objects (bullets, particles, effects, network packets).
- **Trade-off:** must reset object state on reuse; pool sizing and leaks; objects outlive their logical lifetime.

### Spatial Partition

Organize objects by their position (grid, quadtree, BVH, BSP) so spatial queries touch only nearby candidates instead of every object.

- **Use when:** collision, range queries, neighbor finding, culling at scale.
- **Trade-off:** the structure must be maintained as objects move; choose grid vs tree by density and movement patterns.
- **Go deeper:** [Spatial & Pathfinding](/gdd/spatial/) covers concrete structures (grid, quadtree, BVH, R-tree, k-d, BSP) and pathfinding (A*, flow fields, nav meshes).

---

## How KBVE applies these

<CardGrid>
  <Card title="ECS = Data Locality + Component" icon="seti:rust">
    rareicon (Unity DOTS) batches systems over packed component arrays — Component + Data Locality + Update Method, fused.
  </Card>
  <Card title="State / StateTree" icon="random">
    `behavior_statetree` models AI/units as typed-command state machines with a bounded queue boundary.
  </Card>
  <Card title="Object Pool" icon="seti:default">
    Combat events, bullets, and network packets reuse pooled buffers rather than per-frame allocation.
  </Card>
  <Card title="Event Queue" icon="comment">
    Cross-system messaging (chat relay, combat pipeline) drains queues on a fixed cadence rather than direct calls.
  </Card>
</CardGrid>

<Aside type="caution" title="Optimize last">
The Optimization patterns buy speed by spending flexibility and adding bug surface. Reach for them only with a profiler result in hand. Design with the Decoupling and Behavioral patterns first; optimize the hot 5% second.
</Aside>

---

## Further reading

- *Game Programming Patterns* — Robert Nystrom, free online: [gameprogrammingpatterns.com](https://gameprogrammingpatterns.com/)
- *Design Patterns: Elements of Reusable Object-Oriented Software* — the Gang of Four (origin of Command, Flyweight, Observer, Prototype, Singleton, State).
- Unity DOTS / ECS docs — Data Locality and Component patterns in a production engine.

<Giscus />

---
# Shaders and Rendering

> Real-time rendering and shader fundamentals for game projects — the GPU pipeline, shader stages, common techniques, and the performance budget that governs them.
Own-words reference cross-linked to the KBVE projects that ship custom rendering.

Source: https://kbve.com/gdd/shaders/

import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
import { Giscus, Adsense } from '@/components/astropad';

## Introduction

A shader is a small program that runs on the GPU, in parallel, for every vertex or every pixel. Rendering is the process of turning scene data into the frame the player sees. This page covers the pipeline, the shader stages, the techniques worth knowing, and the budget that keeps it all real-time.

<Aside type="tip" title="Source material">
For deep dives, see [The Book of Shaders](https://thebookofshaders.com/) (fragment shaders, GLSL), [LearnOpenGL](https://learnopengl.com/) (full pipeline), and the engine-specific docs for [Unity Shader Graph](https://docs.unity3d.com/Manual/shader-graph.html) and [Unreal Material Editor](https://docs.unrealengine.com/). This page summarizes concepts and maps them to KBVE rendering work.
</Aside>

<Adsense />

---

## The GPU pipeline

Geometry flows through fixed and programmable stages to become pixels:

1. **Vertex shader** — runs per vertex; transforms model-space positions into clip space, passes data (UVs, normals) downstream. Programmable.
2. **Rasterization** — fixed-function; turns triangles into fragments (candidate pixels) and interpolates the vertex outputs across each triangle.
3. **Fragment / pixel shader** — runs per fragment; computes the final color, sampling textures and evaluating lighting. Programmable. Usually the hot stage.
4. **Output merger** — fixed-function; depth/stencil test, blending, and write to the framebuffer.

<Aside>
The vertex shader runs once per vertex; the fragment shader runs once per covered pixel — often **orders of magnitude more invocations**. Push work up to the vertex stage when you can.
</Aside>

---

## Shader stages beyond vertex/fragment

- **Geometry shader** — emits new primitives from input primitives (rarely used; slow on many GPUs).
- **Tessellation (hull + domain)** — subdivides patches on the GPU for adaptive detail (terrain, displacement).
- **Compute shader** — general-purpose GPU work outside the raster pipeline: particle simulation, culling, post-processing, image processing. Reads/writes buffers and textures directly.

---

## Shader languages

Shaders are written in a GPU language, then compiled to the driver's native format. Which language you use is mostly dictated by your graphics API and engine.

| Language | API / ecosystem | Notes |
| --- | --- | --- |
| **GLSL** | OpenGL, Vulkan, WebGL | The long-time cross-platform standard; C-like. Vulkan compiles GLSL to SPIR-V. |
| **HLSL** | Direct3D, also Vulkan | Microsoft's language; the de-facto AAA standard, usable on Vulkan via SPIR-V. |
| **WGSL** | WebGPU (wgpu) | The WebGPU Shading Language — the modern web/portable target; what you write against [wgpu](https://wgpu.rs/) (the Rust WebGPU implementation). |
| **MSL** | Metal (Apple) | Metal Shading Language; C++-based, Apple platforms only. |
| **SPIR-V** | Vulkan, WebGPU | Not hand-written — a binary *intermediate representation* that GLSL/HLSL/WGSL compile **to**; the driver consumes it. |

<Aside>
**SPIR-V is the hub.** Modern toolchains author in GLSL/HLSL/WGSL, compile to SPIR-V, then translate to the platform's native format (DXIL, MSL, SPIR-V). Tools like [naga](https://github.com/gfx-rs/wgpu/tree/trunk/naga) (used by wgpu) and SPIRV-Cross translate between these languages.
</Aside>

### wgpu / WGSL

[wgpu](https://wgpu.rs/) is the Rust implementation of the WebGPU standard — one API that targets Vulkan, Metal, D3D12, and WebGPU-in-the-browser. You write shaders in **WGSL**; wgpu (via naga) compiles them to each backend. For Rust game/graphics work that must run native *and* on the web, this is the portable path.

### Engine-specific shader languages

Most engines wrap a standard language in their own material/shader layer with engine-provided inputs and node graphs:

- **Godot** — [GDShader](/application/godot/#shaders) (`.gdshader`), a GLSL-derived language with Godot's render pipeline built in. Covered in the [Godot application doc](/application/godot/#shaders).
- **Unity** — ShaderLab wrapping HLSL, plus the node-based Shader Graph.
- **Unreal** — the node-based Material Editor compiling to HLSL under the hood.

<Aside type="tip">
This page stays language-agnostic on engine specifics. Application-specific shader languages (GDShader, ShaderLab, Unreal materials) are documented on their engine pages and linked from here, not inlined.
</Aside>

---

## Spaces and transforms

Vertices move through a chain of coordinate spaces:

- **Model → World** — place the mesh in the scene (the model matrix).
- **World → View** — relative to the camera (the view matrix).
- **View → Clip** — apply perspective/orthographic projection (the projection matrix).
- **Clip → NDC → Screen** — perspective divide and viewport mapping (fixed-function).

The combined **MVP matrix** (model-view-projection) is the workhorse of the vertex shader.

---

## Lighting models

- **Lambert (diffuse)** — brightness ∝ `dot(normal, lightDir)`; matte surfaces.
- **Blinn-Phong** — diffuse + a specular highlight from the half-vector; cheap, classic.
- **PBR (physically based)** — energy-conserving model driven by albedo, metallic, roughness, normal maps; the modern default for realistic look, consistent across lighting conditions.
- **Toon / cel** — quantize lighting into bands for a stylized, illustrated look.

---

## Common techniques

<CardGrid>
  <Card title="Texturing & UVs" icon="seti:image">
    Sample color/normal/roughness maps using per-vertex UV coordinates interpolated across the surface.
  </Card>
  <Card title="Normal mapping" icon="seti:default">
    Fake surface detail by perturbing normals from a texture instead of adding geometry.
  </Card>
  <Card title="Post-processing" icon="seti:video">
    Full-screen passes after the scene renders: bloom, tone mapping, color grading, depth of field, outlines.
  </Card>
  <Card title="Billboarding" icon="seti:plan">
    Orient quads toward the camera for sprites, foliage, and impostors — cheaper than 3D geometry.
  </Card>
  <Card title="Instancing" icon="seti:db">
    Draw thousands of copies of one mesh in a single draw call; per-instance data via buffers.
  </Card>
  <Card title="Stylized post (Kuwahara/ink)" icon="seti:pipeline">
    Painterly filters and edge ink for a non-photoreal art direction — see KBVEPostShader below.
  </Card>
</CardGrid>

---

## Performance budget

Real-time means the whole frame fits in your time slice — 16.6 ms at 60 fps, 8.3 ms at 120 fps. Rendering shares that budget with simulation.

- **Overdraw** — pixels shaded then overwritten; transparency and dense foliage are the usual culprits. Sort and cull.
- **Draw calls** — each one has CPU cost; batch and instance to cut them.
- **Bandwidth** — texture sampling and framebuffer traffic; compress textures, use mip-maps, shrink render targets.
- **Shader complexity** — instruction count in the fragment shader multiplied across millions of pixels; move math to the vertex stage or precompute into textures.

<Aside type="caution" title="GPU-bound vs CPU-bound">
Profile before optimizing. A frame can be limited by the CPU (draw-call submission, sim) or the GPU (shading, bandwidth). KBVE's chuck perf work found the game thread idle while the **GPU** was the wall — the fix was cutting RT/Lumen/VSM/post, not CPU work.
</Aside>

---

## How KBVE applies these

- **KBVEPostShader** — stylized post-process (BotW/Ghibli look) via a Kuwahara + cel + ink `FSceneViewExtension` in Unreal. Insertion point and SceneTextures binding are the two compile-verify gotchas.
- **chuck grass** — billboard + instanced foliage drained into a global HISM, nearest-camera-first, with WPO billboards and a 120 fps cvar stack tuned against a GPU-bound profile.
- **Isometric game** — UV-mapped grass-cap texture on the ground tileset; grass-blade billboards were disabled due to pixel swim (sub-pixel rendering instability).

---

## Further reading

- [The Book of Shaders](https://thebookofshaders.com/) — fragment shaders and GLSL, interactive.
- [LearnOpenGL](https://learnopengl.com/) — the full real-time pipeline from scratch.
- [Inigo Quilez articles](https://iquilezles.org/articles/) — SDFs, noise, raymarching, shader math.
- Unity Shader Graph and Unreal Material Editor docs for node-based authoring.

<Giscus />

---
# Spatial Partitioning and Pathfinding

> Spatial acceleration structures (grids, quadtrees, BVH, R-trees, k-d trees, BSP) and pathfinding (A*, flow fields, nav meshes) — how games answer "what is near me?" and "how do I get there?" without touching every object.
Own-words reference cross-linked to KBVE projects.

Source: https://kbve.com/gdd/spatial/

import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
import { Giscus, Adsense } from '@/components/astropad';

## Introduction

Two questions dominate game simulation at scale: *what is near me?* (spatial queries) and *how do I get there?* (pathfinding). Both become impossibly slow if answered naively — checking every object against every other is O(n²). This page covers the acceleration structures that make spatial queries cheap and the pathfinding algorithms that move agents through a world.

This expands on the [Spatial Partition pattern](/gdd/patterns/) with concrete structures and trade-offs.

<Aside type="tip" title="Source material">
For depth see [Real-Time Collision Detection](https://realtimecollisiondetection.net/) (Ericson) on acceleration structures, [Amit Patel's Red Blob Games](https://www.redblobgames.com/pathfinding/a-star/introduction.html) on pathfinding, and the [Game Programming Patterns Spatial Partition chapter](https://gameprogrammingpatterns.com/spatial-partition.html). This page summarizes and maps the concepts to KBVE.
</Aside>

<Adsense />

---

## Why spatial structures

A spatial query — "what's within radius r?", "what does this ray hit?", "which objects overlap?" — naively scans every object: O(n) per query, O(n²) for all-pairs. Acceleration structures organize objects by position so a query only visits nearby candidates, turning O(n) into roughly O(log n) or O(1) per query.

The universal trade-off: **build/update cost vs query speed**. Static geometry can afford an expensive structure built once; objects that move every frame need cheap updates or a structure rebuilt each frame.

---

## Acceleration structures

<CardGrid>
  <Card title="Uniform grid" icon="seti:grid">
    Divide space into fixed-size cells; each cell lists the objects in it.
  </Card>
  <Card title="Quadtree / Octree" icon="seti:plan">
    Recursively split space into 4 (2D) or 8 (3D) until each node holds few objects.
  </Card>
  <Card title="BVH" icon="seti:default">
    Tree of nested bounding volumes wrapping the objects themselves.
  </Card>
  <Card title="R-tree" icon="seti:db">
    Balanced tree of bounding rectangles; database-style, disk-friendly.
  </Card>
  <Card title="k-d tree" icon="seti:crystal">
    Binary tree splitting on one axis at a time; great for nearest-neighbor.
  </Card>
  <Card title="BSP tree" icon="seti:json">
    Recursive splits by arbitrary planes; exact front-to-back ordering.
  </Card>
</CardGrid>

### Uniform grid

Space is divided into equal cells; each object is bucketed into the cell(s) it overlaps. A range query visits only the cells the query touches.

- **Best for:** objects of similar size, evenly distributed, moving constantly (cheap to update — just move between buckets). The default for 2D particle/agent swarms.
- **Weak when:** density varies wildly (empty cells waste memory, hot cells degrade to linear scan) or object sizes vary a lot. Spatial hashing (hash cell coords instead of a dense array) fixes the "huge sparse world" memory problem.

### Quadtree / Octree

Start with one node covering the whole space; when a node holds too many objects, subdivide it into 4 (quadtree, 2D) or 8 (octree, 3D) children and redistribute. Recursion adapts depth to local density.

- **Best for:** non-uniform distributions, mixed object sizes, mostly-static or slow-moving worlds.
- **Weak when:** objects move fast (constant re-insertion) or straddle node boundaries (loose quadtrees relax boundaries to reduce churn).

### BVH (Bounding Volume Hierarchy)

A tree where each node is a bounding volume (usually an AABB) enclosing its children, and leaves wrap actual objects. Unlike quadtrees (which partition *space*), a BVH partitions *objects* — volumes may overlap, but each object lives in exactly one leaf.

- **Best for:** ray casting, collision broad-phase, and rendering — the standard for raytracing acceleration and physics engines. Refittable: when objects move a little, expand parent bounds instead of rebuilding.
- **Weak when:** objects move so far the tree quality degrades; periodic rebuild or rebalance needed.

### R-tree

A height-balanced tree of minimum bounding rectangles, related to the B-tree. Designed for databases and on-disk spatial indexes (GIS, PostGIS), it keeps the tree balanced under insertion/deletion.

- **Best for:** large, persistent spatial datasets, disk-backed indexes, query-heavy with moderate update rates.
- **Weak when:** high-churn real-time simulation — the balancing overhead outweighs an in-memory grid/BVH. Rare in the hot frame loop, common in tooling and servers.

### k-d tree

A binary tree that splits on one axis per level (x, then y, then z, cycling). Excellent for nearest-neighbor and k-nearest queries.

- **Best for:** static point clouds, nearest-neighbor search, photon mapping.
- **Weak when:** dynamic data — k-d trees are painful to rebalance, so they shine on static sets.

### BSP tree

Binary Space Partitioning recursively splits space by arbitrary planes (not axis-aligned). It yields an exact ordering of geometry from any viewpoint — the classic Doom/Quake visibility and sorting structure.

- **Best for:** static level geometry, exact visibility ordering, CSG.
- **Weak when:** dynamic scenes — BSP trees are expensive to build and assume static geometry.

<Aside>
Rule of thumb: **grid** for uniform moving swarms, **BVH** for rays/collision, **quadtree/octree** for non-uniform density, **k-d tree** for nearest-neighbor on static points, **R-tree** for persistent/disk indexes, **BSP** for static visibility ordering.
</Aside>

---

## Pathfinding

Once you can ask "what's near me?", agents still need "how do I get there?"

### A* and graph search

A* searches a graph (grid cells, waypoints, nav-mesh polygons) from start to goal, guided by a heuristic that estimates remaining distance. It's optimal and complete with an admissible heuristic, and the workhorse of single-agent pathfinding.

- **Variants:** Dijkstra (A* with a zero heuristic — uniform-cost), Greedy best-first (heuristic only — fast but non-optimal), JPS (Jump Point Search — A* optimized for uniform grids), Theta* (any-angle paths).
- **Cost:** per-agent search; expensive when thousands of agents path every frame to the same goal — that's where flow fields win.

### Flow fields (and flow gates)

Instead of pathing each agent individually, compute **one** field over the whole map that, at every cell, stores the direction toward the goal. Every agent just samples its cell and follows the arrow. The cost is amortized: one Dijkstra-style pass from the goal builds a cost (integration) field, then a flow field of directions — then N agents path for free.

- **Build:** a breadth-first / Dijkstra sweep outward from the goal produces an **integration field** (cost-to-goal per cell); the gradient of that field is the **flow field** (direction per cell).
- **Flow gates:** chokepoints — doors, bridges, narrow passes — that the integration field naturally routes flow through, and where you throttle or meter agent throughput to avoid clumping/deadlock. Gating flow at these cells keeps dense crowds moving instead of jamming the pinch point.
- **Best for:** RTS/swarm games — hundreds or thousands of units converging on shared goals. One field, any number of followers.
- **Weak when:** few agents with distinct goals (per-agent A* is cheaper than building a whole field per goal), or highly dynamic costs that force frequent field rebuilds.

<Aside type="caution" title="Crowds, not just paths">
A path is not movement. Dense crowds need local avoidance (RVO/ORCA, boids steering) layered on top of the field/path so agents don't overlap or oscillate at flow gates. Pathfinding picks the route; steering resolves the traffic.
</Aside>

### Navigation meshes

A nav mesh represents walkable space as convex polygons instead of a grid. Pathfinding runs over the polygon graph (fewer nodes than a fine grid), then a string-pulling/funnel pass smooths the polygon path into a direct route.

- **Best for:** 3D and continuous worlds, varied geometry, smoother paths than grid A*.
- **Weak when:** frequently changing geometry (mesh must be regenerated/patched).

### Hierarchical pathfinding

Partition the map into clusters, precompute paths between cluster portals, and search the coarse graph first, refining only within clusters along the route. Trades optimality for huge speedups on large maps (HPA*).

---

## How KBVE applies these

- **rareicon** — uniform-grid / spatial-hash style partitioning suits its DOTS swarms; the [task-offer dispatcher](/gdd/) and job system reason over nearby candidates rather than the full entity set, and HexDB drains feed spatial reads.
- **Flow-field candidates** — large-unit-count convergence (colony/swarm behavior) is the textbook flow-field + flow-gate case; per-agent A* is reserved for distinct-goal units.
- **Static vs dynamic split** — level/tilemap geometry favors a built-once structure (quadtree/BSP), while moving units favor a grid rebuilt or updated each frame — the build-vs-query trade-off in practice.

---

## Further reading

- [Red Blob Games — A* and pathfinding](https://www.redblobgames.com/pathfinding/a-star/introduction.html), interactive and definitive.
- [Red Blob Games — flow fields / vector fields](https://www.redblobgames.com/pathfinding/tower-defense/).
- *Real-Time Collision Detection* — Christer Ericson (grids, BVH, k-d, BSP).
- [Game Programming Patterns — Spatial Partition](https://gameprogrammingpatterns.com/spatial-partition.html).
- [ECS & Data-Oriented Design](/gdd/ecs/) — spatial structures pair with data-oriented layout for cache-friendly queries.

<Giscus />

---
# January: 01

> Daily Log for January 1st of each year!

Source: https://kbve.com/journal/01-01/

import { Adsense } from '@/components/astropad';

## Notes

---

## Quote

>  “Celebrate endings—for they precede new beginnings.” 
>  — <cite>Jonathan Lockwood Huie</cite>

---

## Tasks

- [X] - No Tasks!


## 2026

### OSRS Over Allocation Issue

-   04:45PM

    Updating the OSRS axum routes, mainly reducing the allocation from 4 strings down to a single one.
    However we can not go zero allocation because of the mpsc, which might be an issue in the future.
    There is a way we could avoid the cache actor and directly hook into the dashmap, but that might hurt our scaling.
    For reference, we are using the tokio's sync mpsc rather than the std mpsc channel. 

### Content Margin/Padding

-   07:29PM

    Finally figured out the issue with the starlight theme causing some weird element issues!
    Turns out that I need to add the `not-content` css tag to anything that might conflict with our starlight theme, allowing us to just not have any of their overrides.
    This should solve some of the button issues we had earlier as well.
    Going to implement this fix, hopefully it will resolve the other margin issues with the OSRS.

### Phaser Quick Game

-   08:36PM

    Maybe we could update parts of the Arcade to include some quick games to play via Phaser.
    It has been a while since we made a simple game, might be a simple runner!

## 2025

-   09:04AM

    **Morning**

    Next day! Almost refreshed and ready for this whole year!
    Its actually cool to be able to loop back finally, but this year is going to be wild and amazing.

-   10:00AM

    **Rimworld**

    As tradition, the first session of the year should be a rimworld playthrough, I been dying to try that rimworld clone wars mod!
    I am going to update the rimworld notes to quickly grab them.

-   02:42PM

    **Kilobase**

    Updated the kanban board from the postgres side and made sure the older kanban tables were removed.
    We will store all that date inside of the Amazon dynamodb but I need to figure out the best way to handle the timestamps for the tables, hmm.
    Looks like that TTL is an option in from the Amazon docs but I will have switch back and look through how to call it in Rust.


<Adsense />


## 2024

- 10:22am - It is 2024, this might be a bit out there but I think 2025 will come really fast.

- 11:54am - Going to clean up the SQL queries for generating the backend tables!
    There were a couple issues with the migration that I had to handle manually, so I decided to just restart the generation process.

- 12:13pm - After cleaning up the SQL generations, I am going to switch back to migrating some of the Obby vaults from `kbve.com`.

- 3:23pm - The one thing that is a bit annoying is that completing some of the documentations will take a while! Hmm...
    I guess its like having a library of books but a decent chunk of them are missing pages and/or chapters, but as of right now it seems to be the best way to handle it.

---
# January: 02

> Daily Log for January 2nd of each year!

Source: https://kbve.com/journal/01-02/

import { Adsense } from '@/components/astropad';


## Notes

## 2026

### Phaser Runner

-   04:45PM

    Building a generic phaser runner to get a better understanding of movement and combat.
    I will add it into the arcade once I am done.

## 2025

-   09:55AM

    **Market**
    The drop in $TSLA was just perfect for the start of the day.
    I still need offload a couple hundred shares of TSLA but thank god it was not during that $400 put spread.

-   11:05AM

    **MultiBranch**

    For this year, I am going to start working in the multi-branch part of the mono-repo, getting better at utilizing the split branches, without having to use cherrypick.
    Branch branch branch! Its like Oprah and her car giveaway.

-   03:04PM

    **Fudster**

    Not the library, but the laptop was shipped out and hopefully he gets it tomorrow.
    I believe its through air, which is a bit of a wild way to ship someone a laptop xD.

-   06:27PM

    **Hardcore**

    Finally getting the balls to play the hardcore mode, this time with the goal of hitting 60, at least once.
    I believe I will fail, so I will try to have a couple characters to help burden the blow and not have to start all over.
    Leveling them in bulk might take a bit more time but I feel like its a good move.

## 2024

-   12:32pm - Building the js-embeds for the Monorepo!
    The first step would be to plan the bundling software for the embedable widgets, which might be done through React or Svelte.
    I am going to double check if the vite plugin is up-to-date, by running:

    ```shell
        pnpm install -D @nx/vite
    ```

    then double check the plugin with:

    ```shell
        nx g @nx/vite:init
    ```

    There might be isssues that you run into, if so, run:

    ```shell
        pnpm nx reset
    ```

    Okay! As I am writing this, I decided to add reset into the kbve shell file, so that it would run the commands in a managed tmux session.

    ```shell
        ./kbve.sh -reset
    ```

    This would be the reset command that we can run everytime we update the NX monorepo.

-   1:04pm - Going to push through this minor update!
    I am still working out exactly how I would want to structure the js-embed applications, I could do them via folders within the `apps` but there might be a better way to handle this./
    Upon thinking it through, I believe we could start with a generic `js-embed-react` as an application and then add minor `sub-folders` within to help with the build.
    However that might end up being way too much abstraction for the given moment.`

-   5:40pm - Just wrapped up the first season of Patheon and it was an interesting story! I will not go too much into the review or spoliers, but I do recommend watching it.

-   5:44pm - Let me start the `js-embed-passport`, since we have installed the base requirements for it!
    To start the project, I am going to run an initializer within NX.

    ```shell
    nx g @nx/react:app js-embed-passport --bundler=vite
    ```

    The scope of this embedable passport would be to help handle some of the communication between our WASMs and javascript.
    Ah the command has been updated to include a flag for version Nx18, which we do not have but that means this commnand will become out dated later this year!
    So fair warning.

    To get the service of the development build, I had to run this command:

          ```shell
          nx run js-embed-passport:serve:development
          ```

    For the production build, the command will be like this:

          ```shell
          pnpm exec nx run js-embed-passport:build --configuration=production
          ```

    I decided to update the build configuration, by adding a quick rollupOptions to the build configuration.

    Inside of the `vite.config.ts`, I added these `rollupOptions` to the `build`:

    ```ts

        build: {
            outDir: '../../dist/apps/js-embed-passport',
            reportCompressedSize: true,
            commonjsOptions: {
                transformMixedEsModules: true,
            },
            rollupOptions: {
                output: {
                    // Change the output directory structure and naming
                    entryFileNames: `js-embed-passport.js`,
                    chunkFileNames: `[name].js`,
                    assetFileNames: `[name].[ext]`,
                },
            },
        },

    ```

    The `js-embed-passport.js` will be the final embedable javascript file that we will call for our purposes.

-   6:15pm - I pushed through the `dev` branch into the `main` branch, as I felt it would make sense to keep the js-embed-passport within the dev branch until it was ready.
    The next move would be to clean up the starter template and see what minor edits we can make!
    I should keep a future note to myself, after the branch builds the js-embed-passport, I want it to make a new pull request back to the repo with the final build.
    This is a bit weird at firet but the idea here would be that this would be the stepping stone towards having the monorepo build and repair itself.
    Starting small and working from there would make the most sense.

-   6:18pm - To avoid having major responsive issues, we could keep with the passport style and limit the size of the window that it generates but scale it up for larger screens.
    The core of the widget / library should still remain being tailwindcss, so that should help us with blending it amoungst other themes.
    I had to update the final production command with an additional flag, thus the new command will look like this:

          ```shell
              pnpm exec nx run js-embed-passport:build --configuration=production --emptyOutDir

          ```

    The additional command to empty out directory will make sure to clean up the /dist/ folder.

- 8:43pm - Removing the `koa` libraries from the packages and the the reverse proxy application.

- 10:07pm - I will postpone migrating the rust proxy because there are a couple errors in the local docker build.

<Adsense />

## Quote

>  “Null” 
>  — <cite>Null</cite>

---

## Tasks

- [X] - Remove

-   8:43pm - Removing the `koa` libraries from the packages.

---
# January: 03

> Daily Log for January 3rd of each year!

Source: https://kbve.com/journal/01-03/

import { Adsense } from '@/components/astropad';


## Notes

## 2026

### OSRS Item Page

-   11:15AM

    The item page is going through another revamp, I am currently trying to figure out the best way to handle the charts.
    Once we get the OSRS charts resolved and proper index + mapping for the items, we can expand this into the stocks.
    Having all the stock data, afterwards would be amazing but there is going to be some issues figuring it all out in the future.
    I believe we might have to lock down the API but for now we can keep it open.
    

## 2025

-   12:30PM

    **Hardcore**

    I did not get a chance to write the story of yesterday or well this mornings hardcore event, it was way too wild.
    Next round, I am going to keep it a bit more chill and slow, moving too fast is part of the problem.
    Treat it more like a RTS than a MMO, is the best way that I can describe the hardcore flow!

-   03:34PM

    **EoY**

    The End of the Year reports as well as Q4s are going to be rough if the trade deals move forward.
    Hmm, I can get furthere down into the notes for that on a different page, but once the tariffs kicks.
    
-   04:24PM

    **Python**

    Updating the python package for nx, to `20.3.1` via `pnpm add @nxlv/python@20.3.1`.
    This upgrade could break somethings, but just want to make sure it all works.

## 2024

- 6:05am - Getting ready for work and double checking my accounts for 2024!
    I need to adjust my morning gym routine, I might have to get up earlier.

- 12:45pm - Finished up with work and going to focus on KBVE monorepo.

- 2:20pm - Preparing a test case of the embed widget and see how it will work within our astro framework.
    Adding the `react-helmet-async` for calling some of the abstract scripts, like hcaptcha.
    Under the `main.tsx`, we will import the helmet provider and then wrap our `App` element inside of it.
        ```js

        import { HelmetProvider } from 'react-helmet-async';

            root.render(
            <StrictMode>
                <HelmetProvider>
                    <App />
                </HelmetProvider>
            </StrictMode>
        );
        ```
    Afterwards we would call `<Helmet>` for the abstract scripts that we would need within certain states.
    For the `register` state, we would use it like this:

        ```js
        <Helmet>        
        <script src="https://js.hcaptcha.com/1/api.js?" async defer></script>
        </Helmet>
        ```

- 7:56pm - Finished onboarding `SoksoaCode` and we were able to get the `twin.macro` library up and running within the `js-embed-passport` application!
    The issue was just forgetting some basic generic javascript/typescript settings, including making sure vite and babel can play together.

- 11:40pm - Ending the night of DnD with some league, tomorrow is another da

---

<Adsense />

## Quote

>  “Null” 
>  — <cite>Null</cite>

---

## Tasks

- [X] - Remove

---
# January: 04

> Daily Log for January 4th of each year!

Source: https://kbve.com/journal/01-04/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### OSRS MDX Files

-   10:56AM

    Adding the custom prebuild script to create all 10K MDX files for the OSRS items.
    The plan is to migrate all the dynamic paths into the static paths for the OSRS flow.
    Then we pull the live data from our new API endpoints and render the chart/data from there!
    Later on, we can use the db workers to keep the data safely stored in the user's browser storage.

## 2025

-   02:40PM

    **HardCore**

    Got to the barrens today but its been rough, I am alone in the wasteland!
    I hope that the fellow guildmates reach the course of the level.

-   06:10PM

    **Abilities**

    Healing! A core of the gameplay is what we need to build now!
    The issue ticket that we are currently handling is [3651](https://github.com/KBVE/kbve/issues/3651).
    
-   08:05PM

    **Twitch**

    While working through the AOE spells, I thought it be cool to work on the twitch stream!

## 2024

-   11:00am - Going to aim at getting out of work earlier than before but I have some issues to prepare for, including being assigned to AAPL at $190.
    I will have to prepare around $38K to offset the 200 shares of AAPL from the two puts.

-   11:54am - Out of lunch and going to start doing the `GlobalStyles.tsx` for the `js-embed-passport`.
    I am going to migrating out the `KB.tsx` into its own JS/TS library, so that I can call it from anywhere.
    We can call the library, `KhashVault` and have it serve as the cache for the nanostorage.

-   12:18pm - Now I am looking into the bundler for the custom library that I am going to be using.
    For the vite bundler, we could use the nx generator via this command:

          ```shell
              pnpm nx g @nx/js:lib khashvault  --directory packages/khashvault --bundler=vite
          ```
          Including the Nx 18 command for deriving the name / root.

    For the vite test casing, it seems that we would have to configure the `vite-plugin-dts`, this is a vite plugin that generates declaration files `*.d.ts`.

    To make sure that we have the plugin installed, we would run this command:

          ```shell
              pnpm i vite-plugin-dts -D
          ```

    After the plugin has been installed, it would be wise to reset the monorepo, with this command:

          ```shell
              ./kbve.sh -reset
          ```

    Okay to run the test casing for the library, we will use this command:

          ```shell
              pnpm exec nx run khashvault:test
          ```

          The `khashvault` is the name of the library that we just created.

    Going to migrate the `storage.ts` from the `Astro-ve` to the new `KhashVault` library that we are building.

-   7:31pm - The protobuf integration first requries having the right library installed.
    For the WSL/Ubuntu:
    `shell
          sudo apt-get install protobuf-compiler
      `
    After the compiler is added and installed, we will check the version, with this command:

          ```shell
                  protoc --version
          ```

          This should return something along this line:
              `libprotoc 3.12.4`

    This library will be used to help automate the protobuf types for javascript/typescript.

-   10:17pm - To automatically generate the protos, we are using the diesel_ext.
    The command that we are going to run is:
    `shell
          diesel_ext --proto > src/kbveproto.proto
      `
    However upon the generation, there were three TODO errors that appear in the proto.
    An example of it would be: - `TODO: unknown type Binary`

-   10:44pm - The current solution might be to just run sed after the generation to fix some of the generated files.
    It seems that I forgot to remove the `Identifiable` from the `derive` but need to account for the commas.
    So here the is the shell command that I will add into the kbve shell.

          ```shell
              sed -i -e 's/#[derive(.*,\s*)Identifiable,\s*(.*)]/#[derive(\1\2)]/g' -e 's/#[derive(.*),\s*Identifiable\s*]/#[derive(\1)]/g' your_file.rs
          ```
          This was giving some issues with the regex of the comma, so I decided to just remove the instance with `, Identifiable`.
          I will come back to this issue later on.

          ```rust

          use crate::apikey::dsl::apikey;
          use crate::appwrite::dsl::appwrite;
          use crate::auth::dsl::auth;
          use crate::globals::dsl::globals;
          use crate::n8n::dsl::n8n;
          use crate::profile::dsl::profile;
          use crate::settings::dsl::settings;
          use crate::users::dsl::users;

          ```
          We will skip this part of the code block as well for now.

          The next two phases of the protobuf generation would be the `into_proto` and the `from_proto`.
          Both of these can be generated using `-f` and `-i` flags, like this:

              ```shell
                  diesel_ext -i -c class_name > src/into_proto.rs
                  diesel_ext -f -c class_name > src/from_proto.rs

              ```
                  Replacing the `class_name`.

          There are a couple errors that the CLI is throwing, which were similar to the ones with Binary types.


## Quote

> “Celebrate endings—for they precede new beginnings.”
> — <cite>Jonathan Lockwood Huie</cite>

---

## Tasks

-   [x] -   No Tasks!

---
# January: 05

> Daily Log for January 5th of each year!

Source: https://kbve.com/journal/01-05/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2026

### KBVE User Profiles

-   11:00PM

    The KBVE profile system will need to be refactored, but its tough to do that without having all the data points.
    The three main features will be a custom upslash image, user bio and status!
    Afterwards we could do a friend list and youtube playlist.

## 2025

-   08:31PM

    **Tesla**

    About to grab some food and swing back around for the python application as v1.
    Then we do a rust application for v2.
    Ugh, taco bell adventures...

# 2024

- 11:31am - Had to drop my tesla off for some minor repairs before the winter gets worse.

- 12:05pm - After the kbveproto.proto is generated and patched, we have to prepare a javascript version.
    I am thinking to extend out the shell script so that after it finishes patching the init. proto file, it will then generate the js proto.
    We will have it create the js file in the `/packages/kbve/src/` folder and then move that file over `/packages/khashvault/src/lib/`
    The command to generate the protoc:
        ```shell
        protoc --js_out=import_style=commonjs,binary:. src/kbveproto.proto
        ```
    Hmm, before I run the generation, I am thinking that I might copy the proto over to the khashvault location.
    Okay so it seems that the protoc library does not support typescript out of the box, so I have two options:
        - `protoc-gen-ts` and `grpc-tools`.
        Of the two options, I will be using the `grpc-tools` with `grpc_tools_node_protoc_ts`, which can be installed using this command:
        ```shell
            pnpm i grpc-tools grpc_tools_node_protoc_ts -D
        ```
    After installing the two packages, I believe I might need another, `google-protobuf` but I have to double check the notes for the client-side requirements.

- 1:48pm - I am going to take a break from the Protobuf and begin building the `engine.ts` within the `khashvault`!
    Going to migrate the `kbve.ts` from the `Astro-ve` into the `khash-vault` package.
    
## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   No Tasks!

---
# January: 06

> Daily Log for January 6th of each year!

Source: https://kbve.com/journal/01-06/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2026

### Profile Operations

-   03:15PM

    Always have Fudster be our tom, key for the friend list, hmm.
    Banner for the background should be parallax and stored as the unsplash id.
    For the youtube player and general playlist, we will keep that saved on the supabase side for now. 
    Finally, we have the special effects that would be boolean, which can be snow or rain or leaves?
    Oh, then there is the guestbook and wall concept, but I am not too sure if that might be worth it.

### Clickhouse Edge Functions

-   08:44PM

    The clickhouse operations still need some adjustments, one of them would be to make sure the backups are done.
    I still need to check the recovery, since barman helps us on the postgres level, I will have to find something for the clickhouse.

## 2025

-   01:22AM

    **Stream**

    Finally got OBS to work among multiple machines, had to downgrade to v30.2 because v31 certs were not approved for League.

-   05:44AM

    **Dockerfile**

    OKay let me get the dockerfile rolling for the `pydiscordsh`.
    Well before we do the docker, we need to add `https://pypi.org/project/fastapi/`, so lets do that next.
    The command would be: 

```shell
        pnpm nx run pydiscordsh:add --name fastapi
```

-   05:21PM

    **Python**

    After adding the fastapi, we will need to also add the supabase and then figure out the best way to add the service key.
    I am not too sure if we just need the basic service key or if we need a whole new key, hmm but regardless, I was thinking that we could also integrate turso aka sqlite.
    Majority of the voting records, bumps and server information should be stored in the turso db, but the user information should be through the supabase.

```shell
        pnpm nx run pydiscordsh:add --name supabase
```

-   05:58PM

    **Atlas**

    Looks like the atlas build seem to fail, but it might be because the version was not bumped?
    We can loop back around and see why there were issues on that end.

## 2024

-   3:54pm - Working on the JS Embed Passport with Soksoa!
    We removed the dangerously set HTML component.

-   7:45pm - After spending some time in the shadow realm, err, I mean doing WASM research, I believe I am ready to move towards building my first component.
    The library that I have been experimenting with is `egui` and it has handled all my personal benchmarks and abstract test casing, including working flawless in my tesla.
    I was looking for a way to migrate out of javascript and into something that could be utilized in both web and mobile, but also embedable systems in the future.
    The logs for today are a bit out of scope, so I will have to come back to them another day and clean them up.

-   9:40pm - Playing some quick rounds of League, but this time on the PBE server! I am a bit surprised with the item shift too, while it feels great to get out of the forced mythic, there is still some mental lag.
    The best thing out of the update is the change to the support items, or well it is just now one item but with the flexibility to choose what it becomes later on!
    This makes it easier to formulate your build as the game goes on, giving room to go a bit more tanky or more damage.

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   No Tasks!

---
# January: 07

> Daily Log for January 7th of each year!

Source: https://kbve.com/journal/01-07/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

Lucky 7 of the first.

## 2026

### OSRS Item Updates

-   08:00PM

    Updating more of the OSRS items, but the issue might be that we will have to loop through them all again. 
    Our goal will be to prepare all of the mdx files, such that, they will be great for a RAG system.
    While building this out, I still have to prepare the edge functions as I am building out the item database.

## 2025

-   03:00PM

    **SPY**

    Damn I am still bag holding a bunch of spy, hopefully I can offload them before the end of this month.

    **Python**

    The best way to handle the supabase jwts, hmm.
    One idea would be to just pass the JWT secret over and use that to validate the information.
    
    We ended up going HAM!
    A huge chunk of the code has been updated and now we can almost see a production ready server live within the next week.
    There are a couple things that still need to be fixed but that should not be an issue, we just need to tackle it all slowly.


## 2024

-   12:38am - There are a couple library names that I wanted to use for the `egui` and `wasm` build, but I think I might go with `wasm-bosm`.
    I am also thinking maybe there might be a play on words that I could use?
    The library or crate that I am going to write would be based upon `egui` and `eframe`, so the traditional route would be to use that `e` type beat.
-   2:30pm - I will have to create a new ticket for tracking the CryptoThrone development:
    The ticket would be something like this:

        -   This will be a small WASM based game that we can develop on the side.

        -   The premise of the game is still under development but the goal would be to test cases some of the general WASM libraries while providing a flexible learning prod cycle.

        -   This issue ticket will be for keeping track of the development of CT.

        -   It seems that I was not able to get the direct `CNAME` setup for the `https://api.cryptothrone.com` and had to use an A record, but I believe there might be a way to handle this?
            I guess it might be because of the security structure that is in place, we could also setup a proxy and have that be the endpoint that we could use in the future.
            The error that it threw was `Error 1014: CNAME Cross-User Banned in Cloudflare` when using the CNAME.

    However I do not want to extend too far out right now and try to keep focus with getting the WASM library up and running.

-   Continued:

    -   My current research has taken me into the tauri, trunk and egui realm of the WASM.

    -   I am debating how I would want to build out the WASMs and have something that might be production ready, but I might just make a couple test case examples.

    -   The CORS needs to be fixed for the API, maybe instead of hard coding the CORS, I could just load them from the database?

    -   This would mean that I would have to create a new table, hmm.
        We could also just store the CORS as a global key, so that it would be something along the lines of `cors_$slot` , thus we could parse through the whole global table, looking for any instance of the `cors_$` and then parse the value it holds as the CORS domain?
        This would mean we would not have to add a whole new table just for the CORS? Most applications or API backends would not have more than a couple domains, so for us to over extend might not make the most sense.

-   MDX Migrations:

    -   Besides migrating over a bunch of the MDX documents, I believe I will drop `strapi` and `supabase` for the time being from the migration.
        I am just using this as a reference to keep track of the documents that I have skipped.


## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   MDX Migrations

---
# January: 08

> Daily Log for January 8th of each year!

Source: https://kbve.com/journal/01-08/

import { Adsense } from "@/components/astropad";

<Adsense />

## Notes

## 2026

### Handy TTS and LLM

-       12:02AM

        Adding basic support for the LLM and TTS for the handy fork!
        The goal would be so that it can listen to what I am saying, turn it into text.
        After it gets the text, we need to feed it to a LLM for parsing!
        We could have the LLM be part of the core application, trying to keep it all offline ready.
        Yet, there should be some functions that would allow us to call the cloud LLM providers?
        Finally after getting the response, we would need to do a text to speech.

### Riot API Integration

-       12:46AM

        We could also integrate the game client, i.e league and have a quick text model?
        Let us imagine playing league, then having comms that would allow us to ask questions related to the game.
        I could ask what items that I should buy, it would look at the stats and determine the best item?
        For example it could respond back if I am going tank, support, damage and then determine the best option for the player.

-       03:16PM

        The LCU seems to be straight forward and does not seem to require any major abstraction.
        So we play the game and have it listen to when we connect, then just go from there?

### Books of Tauri

-       5:54PM

        The core lore could be around three books and having their locks be important.
        Book one opens the second book, while the key of the 2nd book opens the third.
        This way have this chain among the books, allowing them to act like runes or scrolls?
        I am still working this out, such that it will make sense.

### Full Action Plan for Handy-Like Clone

-       08:28PM

        These are the core parts that the application will need:
        1. Adding Discord support.
        2. Adding VectorDB / or database with vector support.
        3. Adding League support. We can connect to the LCU and get information from a league match that is being played.
        4. Adding supabase login via OAuth, we can re-use the KBVE API that RentEarth is also utilizing.

## 2025

-       **Rancher**

        05:56PM

        Something went wrong with the rancher certs and I was able to figure it out by going through the issue tickets.
        I believe the issue was that when we updated rancher, it might have reset the certs but we were able to make sure that ACME / LetsEncrypt does its job.
        After going through some casual walk through with ChatGPT, we were able to solve the issue.

-       **Secrets**

        06:58PM

        We need to update the Sealed secrets once more and then enable the `discord` namespace to have access to the `service_role`.


```shell

        ./kbve.sh -nx kilobase:seal --namespace=supabase --keyName=supabase-secret-jwt --secrets=""

```

        Going to recreate the secrets here and then move forward, making sure that the `service_role` has the right key.
        After using the jwt decrypt, I think we put the wrong service key in the seal!
        Once we update the sealed secret, I will add another seal inside of the new `discordsh` namespace, which will then grab that information and use it.
        Our goal would then be to migrate some of the user-defined functions directly to the supabase, including the JWT/Auth.

-       07:32PM

        **DockerHub**

        Next on the agenda will be to add in the dockerhub image for DiscordSH!
        After it gets added, we can move forward with building out the helm chart and we should be good to go!
        That was a quick fix to the docker build, next we want to prepare the discord shell build.

## 2024

- 2:31pm - erust

  - Preparing for the crate creation of `erust` , which will hold the `egui` / `eframe` library.

  - The command that we will run to create the library will be like this:

        ```shell

        pnpm nx g @monodon/rust:library erust

        ```

  - After creating the base library known as erust, we will now create the application that will utilize the erust library.

        ```shell

        pnpm nx g @monodon/rust:binary rust_wasm_embed

        ```

  - Make sure we are up to date with rust, by running this in our shell:

        ```shell

        rustup update

        ```

  - Followed by adding our egui dependencies and migrating the generic `eframe_template` files over to the `apps/rust_wasm_embed`.

- 5:02pm - Bug Wars

  - We will first focus on getting the general build out of the way for the `apps/rust_wasm_embed` and focus on tackling any bugs that might appear.

  - I believe I would also have to setup the `Trunk` for the build and also need to add the rustup targets.
    These will be added into the `Rust` docs tomorrow.

## Quote

> “.”
> — <cite></cite>

---

## Tasks

- [x] - Setup `egui`

---
# January: 09

> Daily Log for January 9th of each year!

Source: https://kbve.com/journal/01-09/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Supabase Login for Handy Fork

-   11:15AM

    The Supabase login system will be similar to the oauth setup that we did with unity.
    I am thinking that it be wise to avoid the webview method, because it be better to just have it utilize single sign on.
    Later on, I could move all of that into a sidecar that will be a crate, then in future projects, I just load the sidecar.

### Vector Database for Handy Fork

-   01:59PM

    Currently looking at implementing a vector database for the handy application.
    Instead of it using our kubernetes vector setup, I want it to use a local embedded database.
    This should make it easier to manage and keep the costs of operations localized, rather than having to deal with the cloud.
    Moving as much of this into a local machine is the goal!


## 2025

-   **Helm**

    04:53PM

    Going to finish up the helm chart and then we can move forward.
    The `pydiscordsh-main.yaml` is almost done, we just need to fix the ingress.
    After finishing up the ingress and before the end of the night, I need to configure the sealed secrets.

```shell

        ./kbve.sh -nx kilobase:seal --namespace=discordsh --keyName=discord-turso --secrets=""

```

-   **WoW**

    07:10PM

    Some quick hardcore afk game play!
    I am thinking that it will be a bit rough to do on the side, while still programming.

-   **Car**

    09:00PM

    Car battery should be charged!
    Went out in the cold, got some greek yogurt and everything seems charged.

-   **Deployment**

    11:52PM
    
    The deployment of `PyDiscordSh` is below:
    
    Repo: `https://github.com/KBVE/kbve.git`
    Branch : `dev`
    Paths: `/migrations/kube/charts/discordsh`

    There were some 503 errors but we were able to get everything wired!


## 2024

    -   3:03pm - `erust` library
        After test casing the `apps/rust_wasm_embed` , I want to move some of the `egui` functions into the `erust` library / packages / crate, so that I can use them in multiple applictions.
        The first module inside of the `erust` library will be the `ironatom.rs`.
        I will migrate some of the generic boilerplate into this module and test case the build from that aspect.

    -   4:16pm - `debug`
        I was able to split the application and library, now I am going to add state management inside of the `erust` library.
        During the debug stage, I went ahead and split the codebase up, as planned and started to build out widgets for the `erust` application.
        One of the next objectives would be to integrate some images into the WASM, including the background.
        I would like it so that the user has some integration settings but that might have to be done later on.

        Two additional libraries that I wanted to add were:
        `reqwest`, at version 0.11 and `image`.
        

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   No Tasks!

---
# January: 10

> Daily Log for January 10th of each year!

Source: https://kbve.com/journal/01-10/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Supabase Integration for Handy Fork

-   01:05AM

    Adding supabase integration into tauri for the rust application.
    I might even go as far as testing out the webview within the handy app.

## 2025

-   **Supabase**

    01:15PM

        The supabase integration with fastapi can be done in two ways, indirectly through the JWT or directly though a local connection to the supabase.
        Before making the local connection to the supabase, I am going to do the remote connection first!
        We just want to make sure that the user can login from the supabase instance.
        Actually we also need to add the ingress to have a local connection but for now we can use a `https://supabase.kbve.com` during the testing phase.
        In the future we want to use a `supabase.local` to handle it for us.

    05:20PM

        We were missing the PyJWT, so I am going to go ahead and add that into the repo.
        To do this, we will use this nx command:

```shell
 pnpm nx run pydiscordsh:add --name pyjwt
```

        This will add the library to our `pydiscordsh`.
    
    11:00PM

        There was a solid amount of progress being made this Friday!
        However I am going to switch the notes over to the next day.

## 2024

-   11:04am - `WorkFlow`

        #### Workflow

            Preparing a new document for table optimization!
            I am going to move away from adding large text chunks and focus more on visualizations, as it makes the reading a bit easier.
            Sometimes I feel like I am just writing 30 pages of non-sense that feels almost useless because of GPT, thus I think focusing more on the visual elements would be better for everyone.
            Furthermore, I wonder if I should include RAG embeds into the mixture, I suppose that will be the future of MDX in 2024!

-   3:00pm - `SoD`

        #### SoD

            Got off of work and jumping straight into Season of Discovery!
            I am currently leveling up a Night Elf Druid called BearBeer and its been a throw back, playing classic WoW is always a childhood throwback.
            Since i have a decent background in Ascension, this SoD concept seems like it is a great concept for Blizzard to expand upon.
            However, I think the leveling should be a bit slower, with limits on the speed of progression.
            I should also note the amount of bots is a bit insane.

-   5:30pm - `Rune`

        #### Rune

            While I am enjoying the flow of the game, looking for the runes is also a bit more interesting, I like how they are doing it for this gamemode.
            There could be some further improvements with how to handle the runes but so far they have been balanced.

-   7:40pm - `ERust`

        #### ERust

            The library needs a couple changes, I believe the best course of action would be to modularize the crate into sub-folders.
            This means I should also do the same for the `kbve` crate too.
            I might have to remove a bunch of the `widgets` that I have in place and refactor them, maybe split it into three groups:

                - `widgets`
                - `utility`
                - `state`

                These are the first three modules within the `erust` that I will focus on.

---

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   No Tasks!

---
# January: 11

> Daily Log for January 11th of each year!

Source: https://kbve.com/journal/01-11/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Handy Tools

-   01:15AM

    An application that would one that we keep running as a personal discord bot that does work for me.
    Yet each time I try to build around it, there are still issues that I keep running into, like is it even worth the time.
    

## 2025

-   **Supabase**

    12:06AM
        The goal for the rest of the night is to configure the go true external auth for discord but also make sure that the callbacks work.
        Okay, so lets look through the different areas that we need to adjust for!
        First we need to update the `GOTRUE_JWT_ADMIN_ROLES` to include the `supabase_admin` as well.
        All of these edits will be in `migrations/kube/charts/kilobase/supabase/values.yaml` at the start and we can work from there.        

-   **JWT**

    12:25AM

        While working on the external supabase configuration, I also wanted to work on the JWT for the `pydiscordsh`.
        After looking through the examples, it seems we would setup different `APIRouters`, the three main ones will be:

            -   `/v1/discord/`
            -   `/v1/admin/`
            -   `/v1/users/`
    
        I am also thinking we could do some other routes, maybe `/v1/tags/` and `/v1/category/` ?
        We are not yet fully limited to these but they will make it easier for us to build around.

        It would look something like this:

        ```python

        admin_router = APIRouter(prefix="/v1/admin", tags=["Admin"])

        def verify_admin_jwt(credentials: HTTPAuthorizationCredentials = Depends(security)):
            """
            Dependency for protecting routes under admin access using Kilobase.
            """
            token = credentials.credentials
            try:
                kilobase.verify_admin_jwt(token)
            except ValueError as e:
                raise HTTPException(status_code=403, detail=str(e))

        # Admin Protected Routes
        @admin_router.get("/health-status", dependencies=[Depends(verify_admin_jwt)])
        def admin_health_status():
            """Check Supabase health status."""
            return kilobase.health_status()

        @admin_router.get("/users", dependencies=[Depends(verify_admin_jwt)])
        def get_admin_users():
            """Fetch all admin users."""
            # Example placeholder for fetching admin users
            return {"users": kilobase.get_user_by_id("some_user_id")}

        @admin_router.post("/add-category", dependencies=[Depends(verify_admin_jwt)])
        def admin_add_category(category: str):
            """Add a new category."""
            return {"message": f"Category '{category}' added successfully"}

        ```

        Then we can work around exactly how we want to handle some of the routes and concepts.

-   **Unity**

    04:01PM

        I believe we are finishing up the abilities from where we last left off.

## 2024

-   11:30am - `Paladin`

    ### Paladin

        I decided to make a Paladin within the Season of Discovery!
        I am thinking of making the character a bit like ThorSoul from my DnD campaign but maybe use it as a creative tool.
        Nothing is more classic than role playing as a Paladin in low level WoW.

-   1:20pm - `Sync`

    #### Sync

        The monorepo branches are a bit out of sync amoung all my computers, with my mac book being well over `200` commits in the `cherryhole`.
        I will have to slowly bring all the repos up to date and that will require me to really think about how I would manage the `apps` and `packages`.
        Should I place the `embeds` into their own eco-system, should I have a multi-cluster mono-repo?
        These are questions that I had not thought about but it would be interesting to see how this year will go with this monorepo.

-   2:30pm - `state`

    #### State

        Refactor the `applicationstate.rs` into the state module, this way I can have multiple states that I would like to use for future applications.
        The state module for the `erust` will be broken into these areas:

            -   `user`
                - The User State will keep all the generic user information for the WASM.

            -   `ui`
                - User Interface State will keep all the UI settings for the WASM.

            -   `network`
                - Network State will handle the state management for the networking, HTTP, WebSockets, gRPC and a couple other nifty features.

            -   `device`
                - Device State will handle the general device settings, this could be included inside of the `ui` but I feel like it could be isolated, in the instance of future IoT devices.

        I am thinking that it might make more sense to have the states get generated automatically using the Diesel extension.
        Okay the CLI would generate the erust dbmodels, now I would have to swap out the parts within the generated structs , to then match it with the way that I would call them in erust?!.
        
---

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   No Tasks!

---
# January: 12

> Daily Log for January 12th of each year!

Source: https://kbve.com/journal/01-12/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Godot Deadlock

-   03:13PM

    Decided to revist the godot application aka cityvote and try to resolve the deadlock for combat.
    The main issue is that we keep running into issues with combat data from the rust side and a desync from the godot side.
    I am going to try again in a couple weeks, maybe there might be a different path that I could take to help resolve it.

## 2025

-   **Python**

    04:30PM

        There are a couple issues with the connection between the namespace of `discordsh` and the `supabase`.
        The problem might not be a python issue but rather the time it takes to connect to the URL through the DNS jumps?
        Hmm, I think the solution might be to create a local bridge or connection between the two nameservers and have that be the `SUPABASE_URL`.
        We did something similar a while back with the redis connection, so I suppose I could pull that.

-   **WoW**

    08:06PM

        Time to level up my mage in wow, but I should do the macros first.
        Wand macro and then maybe some sort of instant cast spam macro, hmm.
        Arcane Missle into Wand is definitely the go to move, it works almost perfectly but I think the null on the wand macro is a bit off.
        

## 2024

    -   4:40pm  - `crates`

        #### Crates

            Going to release about three crates within this weekend!
            The target is establish bare-bone but functional crates and see if we can use them outside of the mono-repo.
            The main test case would be to establish a functional hybrid repo.

            To prepare for the `cargo publish --dry-run`, I ran into some errors that need to be fixed for the package.
            The main error stems from the older `utility.rs` , which have to be adjusted for the crate release.
            I am also thinking that before I begin the cargo release, I should also map out the pipeline, that includes automating the bump of the version within the package.
            To tackle this, I would have to update the `kbve.sh` shell file and include a function to help me do that.
            After adding the function into the shell, I believe I would utilize the github actions to run the minor version bumps.
            Hmm, this would be part of the pipeline? Let us find out, maybe I might be doing it wrong, but that is part of the discovery phase.

    -   5:58pm - `shell`

        #### Shell

            Okay we added the shell function to help bump the version, now I am thinking of making a custom github action that would call the shell file.
            In this case, we would have an additional workflow that we would call after the sucess of the cargo release.
            To go back and understand this, we would have the first workflow dry run the package and then publish the package if everything is fine!
            If the package was published, we would then run an additional workflow that would bump up the version of the `erust` gui? 

            However this could cause a loop, where everytime the code is ran, it would automatically update the package over and over.
            So we have to becareful on how we run the checks, maybe we could make the release be a specific workflow that we call isolated from the whole monorepo's action.
            This means that we would have to run the workflow manually to represent that the package is ready for a release, rather than have it do it automatically from the erust file?

            Actually to handle avoiding any endless loops, we would just check if the `/src/` was changed , rather than the root of the package.
            This will help prevent the loop of releases if we change the `Cargo.toml` or `README.md`, since they would be sitting in the root of the package, rather than inside of the `/src/` folder.

            I am still theorycrafting this out, so maybe I might run into other problems but this should be more than eneough for now.
            So the delta of changes for `erust` would be inside of the `/packages/erust/src` and not within the root aka `/packages/erust/`.
            Extremely important when not trying to create an endless loop of releases.

            Now let me start adding the changes to the pipeline.
            We will go into the first `jobs` at line 18 within the `ci-main.yml` and add a new line to track the changes for `erust`.

            So under the `outputs` of `alter` , we would add `erust` and change the delta outputs for it.
            
            ```yaml

                    jobs:
                        alter:
                            runs-on: ubuntu-latest
                            name: File Alterations
                            if: github.repository == 'kbve/kbve'
                            outputs:
                                herbmail:  ${{ steps.delta.outputs.herbmail_any_changed  }}
                                kbve: ${{ steps.delta.outputs.kbve_all_changed_files }}
                                rareicon: ${{ steps.delta.outputs.rareicon_all_changed_files }}
                                discordsh: ${{ steps.delta.outputs.discordsh_all_changed_files }}
                                atlas: ${{ steps.delta.outputs.atlas_any_changed  }}
                                api: ${{ steps.delta.outputs.api_any_changed  }}
                                proxy: ${{ steps.delta.outputs.proxy_any_changed  }}
                                saber: ${{ steps.delta.outputs.saber_any_changed  }}
                                rustprofile:  ${{ steps.delta.outputs.rustprofile_any_changed  }}   
                                erust:  ${{ steps.delta.outputs.erust_any_changed  }}

            ```

            Then under the `steps` for the `alter` job, we would add the folder that we check, and in this case, we put `packages/erust/src/**` , making sure to check directly the changes in the `src` file.
            This is to avoid the endless loop problem? Hopefully it will help.

            The amount of debugging that I am currently doing to fix the pipeline is a bit much!
            I had to take a bit of a break and focus on something else before I was ready to setp back into this pit.
            We were able to get the crate to release as erust with version `0.1.1`, but I also want it to create a patch to minor bump the package.
            Furthermore, I want to use that minor patch as a future way to send out notifications too.

            Ended up spending a decent amount of time at night to get the patching fixed.


## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   Building a crate.

---
# January: 13

> Daily Log for January 13th of each year!

Source: https://kbve.com/journal/01-13/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

-   **WoW**

    03:40PM

        Time to level up the mage!
        My plan is to get the mage quickly to level 16 or so and then switch over to the warlock.
        Maybe I could run some quick ragefire once docker desktop closes up.

-   **Supabase**

    05:37PM

        I finished up the discord tags earlier at night.

## 2024

    -   1:40pm - `readme`
            I am going to rewrite the readme for the monorepo, maybe make some minor changes to how I am presenting this monorepo?
            There are some styles that I wanted to incorporate into the `Readme` but I will try to do it slowly, without going too crazy.

    -   4:25pm - `erust`

            #### Erust

                Time to clean up the `erust` library and prepare it for the next version.
                So we need to replace the `applicationstate.rs` with a modular state system, however we might need to create a whole new crate.
                The new crate would be for proc-macros that we could utilize in the future for additional crates, like `kbve`. 
                Sometimes making libraries can become a pain, but I suppose that it will help my future self.

    -   8:04pm - `issues`

            #### issues
            
                I am going to spend some time going over the issue tickets and maybe creating a couple new ones to help me keep track of the changes.
                I do want to add a couple GHA / Github Actions that would help create, manage and even respond/answer the issue tickets later down the line.
                The idea would be to slow drip the mL integration into the monorepo, hopefully not causing too many issues down the line.

                - [502](https://github.com/KBVE/kbve/issues/502) - Issue 502 will be for the Script Migration.

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   Cleaning up read me.

---
# January: 14

> Daily Log for January 14th of each year!

Source: https://kbve.com/journal/01-14/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

-    **WoW**

    04:05PM

        Been making some unique macros and trying to get past some of the limitations that the WoW addons / API has but its just a bit pointless.
        I fear that if I push the boundries just a bit too much, I might get flagged for botting xD.

-   **Supabase**

    08:19PM

        Time to prepare the new `discord_server` table, I want to make sure that we can easily add the new tables but also remove them if we have any issues.
        While working through this, I realized that my `user_profile` table has to also get updated because its still one version behind the new one that I wanted.
        I made the foolish mistake of trying to place the socials all into just one json blob, only to find out that its just not worth it!
        Ughhh!

        Forgot to include the uninstall script from my other pc, going to sync that in and going to shift my entry over to the following day.


## 2024

    -   3:55pm - `Ansible`

        #### Ansible
        
            It seems that the ansible tower started to corrupt and break.
            I am thinking that I might have accidentally messed up the networking when working on the NFTable migration, RIP.
            The 



    -   4:00pm - `Graph`

        #### Graph
        
            Going to expand the `kbve.sh` shell file and include a tmux session for the nx graph.
            The command will be a simple one, like `./kbve.sh -graph` and that will create a `graph` tmux session.
            
            Shell Command:

                ```shell

                    -graph)
                        manage_tmux_session "graph" "pnpm nx graph"
                        ;;

                ```
            
            In the future we could add a custom action that would rebuild the `graph` and export it into the `report` system.
            The command can push out the graphs via JSON but there is no official graph image or md file that we could use.
            Thus we would have to take the json output and basically render it ourselves, hmm that might be an issue to look into.

    -   8:45pm - `Reports`

        #### Reports

            There are a couple data points / weekly reports that I am getting, like the database report from PlanetScale, Search report from Google, ect...
            I am thinking it would make sense to gather all these data points and place them into one final report?
            We could extend the public data folder out within the `kbve.com` and maybe create a new directory.
            This new directory will be called `outpost` and I am thinking of placing it under `/public/data/outpost`.
            Then we create a couple new folders for the outpost, then have the automation place the documents inside of those said folders.
            Granted this would be for public-only information and data processing, while private-only data would be done through the Planetscale database.
            Instead of mixing the two in the same database, we are basically splitting them from the start, this way we can avoid a couple different permission issues as well.

    -   2:35am - `Druid`
        
        #### Druid

            I spent majority of the night just playing on my Druid!
            Got my cat form and just running around killing mobs and questing, its really just a solid break from the programming.
            However I am very much tempted to write some custom macros and making it easier to play on my controller.
            The goal would then be to ride my bike and play some WoW.

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   Cleaning up read me.

---
# January: 15

> Daily Log for January 15th of each year!

Source: https://kbve.com/journal/01-15/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

-   **Supabase**

    01:00AM

        The next major update should be ready by tomorrow, we want to keep the turso integration but also slowly build out the migration to the postgres.
        While that is going on, I want to start the front end of the discordsh server.
        The question remains if we want to use NextJS or Astro, hmm, both are already included in the monorepo but I am thinking that astro with shadcn would be a better move than material design and nextjs.
    
    01:34AM

        We want to include the `Constraints` for the `discord_servers` table, even though we already have them in the python code.
        This is just a double check for the sake of data integrity!
        Starting with the `invite` column, this is what I am thinking we will include.
        
```sql
CONSTRAINT ck_valid_invite_code CHECK (invite ~ '^[A-Za-z0-9-]{2,100}$')
```

        Next column that we want to limit is the `name`.
        Actually, while looking at the `name` field, I believe it would make more sense to just drop the `TEXT` field and use a `varchar` field instead!
        We should limit it to about 100 characters, to be safe, we will do 101 characters.
        The `name` field will then be 101.

```sql

name VARCHAR(101) NOT NULL,

CONSTRAINT ck_name_combined CHECK (
        name ~ '^[\p{L}\p{N} _-]{2,100}$'
    ),

```

        Okay the name was replaced from TEXT field to the varchar field and we added a basic check against common attack vectors.
        Granted we will not be letting the server owner directly edit the table through the RPC or supabase's api client.
        The plan is still to use the python server as a medium of handling the `discord_server` data.

        Okay, that field is out of the way, the next field will be `summary` and we will follow the same logic.
        Dropping the `TEXT` and using a `VARCHAR` instead.

```sql

summary VARCHAR(200) NOT NULL,

CONSTRAINT ck_summary_combined CHECK (
    summary ~ '^[\p{L}\p{N} _\-,.!?]{2,200}$'
)

```
        That will handle the summary issue for our use case!
        Okay quickly added description and website as well.
        Both need an additional sanitization before they get added into the table but we will handle that from the python side.

-   **FastAPI**

    The next move would be to see if we can get the SQLModels to work with the Supabase API.


### 2024

    -   4:40pm  - `outpost`

        #### outpost

            These are just some small notes for the outpost.
            This issue ticket will keep track of it: [503](https://github.com/KBVE/kbve/issues/503)
            So under the Nx Outpost, I could add the automated report to that folder.
            In addition, I could also test case some PDF processing, converting it over to a MD/MDX using Ollama.
            During the folder creations for the outpost, I will throw in a `.gitkeep` to help keep track of the folders.
            Furthermore, I believe I should include a MD file that we could test case under the `egui`, I would want to pull that file and see if it can be rendered.
            
    -   5:26pm  -   `migration`

        #### migration

            Going to tackle the [502](https://github.com/KBVE/kbve/issues/502) issue right now because it would be related to the 503.
            I will create a new folder under `/data/` for scripts!

            Okay so for the outpost scripts, we will place them under `/tools/scripts/public` , which is a symbolic link to `/apps/kbve.com/public/data/scripts`.
            For organization, we will call this the `/outpost/nx/` and the script name will be `report.sh`.

            Actually I am thinking of just using the `./kbve.sh` shell file as the base for creating the report file.
            I believe I would need to also build out a base template for the markdown files.
            Thus, under the `/data/` folder, I will go ahead and create a `mdx` folder, where I will store the templates for the time being.

            As I am currently test casing the report script, here is the command to run it, as of right now.

                ```shell

                    ./kbve.sh -createmarkdown report ./apps/kbve.com/public/data/outpost/nx/report.mdx

                ```

            This command would create the `report.mdx` as a file in the outpost location.


## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   Cleaning up read me.

---
# January: 16

> Daily Log for January 16th of each year!

Source: https://kbve.com/journal/01-16/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

-   **Python**

    04:54PM

        I want to finalize the tag migration before moving forward with the unity build test.
        The tag migration does not seem to be a major problem so far but I think there might be a couple ways we could do it a bit better.
        Majority of the changes will be in the `tags.py`, I believe we can keep the routes the same as well.
        The goal here would not be to drop tursodb/sqlite but rather use it as a place holder for testing new futures.
        The next thing that I want to do is make a verification system that checks if the IP address had made a bump, then log that information as a hash within tursodb.
        This would make the most sense for now.

    08:04PM

        The deep-dive into the tag system is almost complete, I just need to go through the code a couple more times and start to remove the extra routes.
        The whole join/or route system can just be dropped and we can just pull the materialized view data directly instead!
        Now the best way to go about this is to look for edge cases where things might fail and comment up all the code to account for that.


## 2024

    -   2:39pm  -  `GHA`

        #### GHA

            It seems to be another github action day!
            This time around we are going to shift the `nx report` stage inside of the main workflow and have it produce a mdx file.
            Yesterday I was able to finish a couple SSH commands that would help with our goal of slowly building out the outpost.
            
            This is the current part of the action that generates the report:

                ```yaml

                    -   name: Generate NX Report
                        shell: bash
                        run: |
                            pnpm nx report

                ```

                As of right now, we just generate the report but do not save/store it anywhere, thus we now add the action to save it as a `report.mdx`

                During the `erust` version bumping, we created a custom GHA action that would run our shell script, so we will utilize that action to run our report mdx creation.

                ```yaml

                    -   name: KBVE Shell
                        uses: ./.github/actions/kbve-shell
                        with:
                            flag: '-cargobump erust'
                            create_pull_request: true
                            github_token: ${{ secrets.GITHUB_TOKEN }}
                            pull_request_title: 'erust-minor-version-bump'
                            pull_request_body: 'Bumping up the minor version of the erust package.'
                    
                ```

                That was the original `erust` bump, so now we will go ahead and move the commands around a bit to fit into our new GHA.

                ```yaml
                    
                    -   name: KBVE Shell - Generate Report
                        uses: ./.github/actions/kbve-shell
                        with:
                            flag: '-outpostgraph'
                            create_pull_request: true
                            github_token: ${{ secrets.GITHUB_TOKEN }}
                            pull_request_title: 'outpost-nx-report'
                            pull_request_body: 'Generating NX Report and saving it as a MDX Report'

                ```

                Now that should generate a pull request with the updated `nx report` into the repo.
                So lets go ahead and push this all through and test case it!

            Yay! The report was generated and then prepared to be placed back into the monorepo via [this pull request](https://github.com/KBVE/kbve/pull/509)
            This means we have a way to keep track of the type of environment that the GHA is running, building and preparing the monorepo in!
            There are some slight differences between the packages that Github is using verse the ones that I am currently using in WSL.
    
    -   5:53pm  -   `erust`

        ####    ERust

            Going to shift gears and see if we can build out the pipeline for the `erust` and the `rust-wasm-embed` library.
            There are a couple waysd we can handle the library, of which, I decided to make an issue ticket to help keep track of.
            Under [510](https://github.com/KBVE/kbve/issues/510), I will try to keep a decent track of progress during the staging, test casing and any major bugs.
            I might split the bugs up into multiple issue tickets but that might be for later on, when I burn out trying to solve them haha.
            
            The next stage would be to build another crate/library but this time for thne proc-marcos.
            We want to isolate the proc-macros away from the `erust`, so that it would be easier to manage and allows us to utilize them again in the future.
            To start the `holy` library, we will run this command:
                
                ```
                    pnpm nx g @monodon/rust:library holy

                ```
                This will create our new `holy` library for use to use.
                Proc Pally Library! I should play my paladin while I am making this library lmfao.

            Now we have to prepare the library for its purpose of being a proc macro.
            The `holy` crate will start with a basic Getter/Setter but I do want to expand upon it!
            I did notice that we would want to handle the visibility, so I suppose that should be next on the list.
            It looks like both of the Getters/Setters were fine! Now I will go ahead and publish those as a crate, under the name of `holy`.

            I should look into migrating some of the custom NX commands as well in the future!
            However for this situation, we will continue to use 
            

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   Cleaning up read me.

---
# January: 17

> Daily Log for January 17th of each year!

Source: https://kbve.com/journal/01-17/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

-   **Markets**

    12:45PM

        The rebound has been epic, I saw that next week SPY calls for $600 skyrocketed over 300%, great win for a ton of people.
        I am going to let my calls all expire and then next week, open up with a double S&P and nvidia, both should net me about $1K.
        I could also sneak in puts but with the market being way too green, those puts wouldnt be worth the risk.

-   **GameJam**

    02:15PM

        The clock has started and we are now at day 1.
        I am thinking that we will build out the ci-cd and gdd within the next 2-3 days, then shift towards producing a quick game by day 7.
        Then spend the day 8 and 9 to debug and by day 10, we should have at best, a playable first level.

    08:05PM

        Starting the build pipeline, first we need to make sure that the kbve token has access to the repo.
        Lets go ahead and start that process of updating and moving the branches up a bit.
        Hmm, this could be an issue that I need to keep track of, `runs-on: ubuntu-20.04`, but for now it should be fine.
        Perfect, we got the azure code and the pipeline is building without any major issues! Yes!
        Now that its moving forward, we can integrate the itch deployment and loop back around to fixing?
        Okay I am thinking about the game design right now and going with a nature feel might be the best for this game jam.

    11:01PM

        Okay made some more changes and going to push it up towards production!
        Later on, I think I might split the code up a bit and make the `dev` build go to `gh-pages`.
    

## 2024

    -   11:00am - `WORK`

            #### Work

                Getting ready for another interesting meeting where we will be looking over the encryption migrations.
                I want to push forward more PGP outside of the email scope and for communication within other applications.
                However this might be easier for me to show how to do it than explain why we should do it.

    -   3:20pm  -  `crates`

            #### Crates

                The build yesterday failed because I did not link the `holy` crate with a version.
                I am going to update that with this push and then switch over to the `kbve` crate.
                Added the `README.md` and updated the `Cargo.toml`, now I am going to add the action to publish and minor bump the KBVE crate.
                There were some minor errors that I had to overlook, the first was making sure that the report that gets generated includes an Unix timestamp.
                We want to always have a new pull request made when there is a push to the main, that pull request should be the nx report for the monorepo.
                As of now, we have three crates that we are currently producing from this monorepo.
                    `kbve` - This is the Axum / Diesel backend crate, that provides basic boilerplating and will be extended as the backend gets more features.
                    `erust` - This is a Rust egui / eframe helper, which will include a state management that we can utilize.
                    `holy` - This is a Rust proc marco crate that will help with automating some of the rust code.

                With these three out of the way, we can look at continue to build out the applications within this repo!
                Now I am thinking of expanding the branches out, I might go back to the older structure of the tree.
                Currently we have a `main` and `dev` setup but adding two more branches, `alpha` and `beta` might make sense as we build out the pipeline.
                The staging would then look like `dev` -> `alpha` -> `beta` -> `main`.
                With the two additional stages, I could migrate some of the pipeline features into those areas, without causing too many problems.
                I believe we could then move the `saber` build out of `dev` and look at shipping only an `alpha` build, speeding up the checks on the `dev` branch as well.
                As for the `beta` branch, this is where we could include the WASM / JS embed builds that would then go back into the `dev` branch to prepare for production.
                The cycle feels a bit weird to write out, but it does make sense in my head. 
                I just need to make sure everything adds up before splitting the branch up a bit more.

                

## Quote

> “.”
> — <cite></cite>

---

## Tasks

-   [x] -   Finish up `kbve` crate.

---
# January: 18

> Daily Log for January 18th of each year!

Source: https://kbve.com/journal/01-18/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Unreal

-   04:15PM

    The migration for unreal is going okayish.
    The goal will be to keep the unity as the way it is, then loop back around once I get pissed off.
    At this point, I have been using unreal, unity, phaser and godot, but still have not yet launched a game.
    These engines are fine, but my search for a proper ECS system that I would like to work with seems to be an unending one.


## 2025

-   **WebGL**

    12:10AM

        Fixing up the webgl build so that it has a bit better performance and making sure that it loads smoothly!
        Okay we were able to resolve a decent amount of the issues but the mac builds still have issues, ugh.

    04:39AM

        Nevermind, I seem have made loading worse, ugh.
        Maybe its because I have the progress manager being called twice, hmm?
        Okay, let me go ahead and do a quick rebuild.

    07:52AM

        Break from the normal flow of C# and do some quick rust!
        We will build the game server out following our same strat as rareicon.

```shell

pnpm nx g @monodon/rust:binary rust_p16_gameserver --directory=apps/rust_p16_gameserver

```

## 2024

-   **Movement**

    8:30AM

        Going through the saber unity engine and comparing it against the RougeJester source code, trying to find a middle ground on how I should handle the movement.
        Besides refactoring the Camera, Entity system, Combat, the movement seems to be a bit jittery.
        I am thinking of creating a whole new movement script based upon the previous ones that we had written and maybe integrate the event system around it.
        There are a couple more concepts that I want to test out inside of an empty unity project and see if I can make any major break-throughs on how I am handling it.
        Do not even get me started on the physics engine, ugh.

-   **Branches**

    5:30PM

        I made an issue ticket going over the branch split, going to start writing out the Github actions for the branch split now.
        We would update the `ci-dev.yml` under the workflows, so that it does not pull to main anymore and goes to Alpha.
        After copying over and creating the `ci-alpha.yml`, I had to go back and remove the Saber build that was there under the `ci-dev.yml`.

-   **Warcraft**

    9:05PM

        In between the programming and test casing, I am still leveling up my druid!
        I am close to hitting level 24, then just need to do a bit more to hit the level cap of 25.
        Super excited to venture into the battle grounds as a druid, hopefully I do not get ran through like earlier.
        The WSG is still in my blood, capture the flag for life, kill all the horde! Muahahaha.

---
# January: 19

> Daily Log for January 19th of each year!

Source: https://kbve.com/journal/01-19/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

-   **GoDot**

    06:06AM

        Okay, I am getting the full feel of the rust and godot integration, my focus is a bit split between both games.
        I am torn between wanting to finish the unity game and also learning more about godot.

-   **Snow**

    08:50PM

        I hate cleaning up snow but the night blanket that covers everything looks so peaceful and amazing!
        After recently watching the hateful8, I am really getting that winter vibes.

    09:59PM

        Just came back into the house after doing a quick pre-shovel and my hands feel so frozen.

## 2024

    - 8:00am - `BranchHell`

        #### BranchHell

            There seems to be a bit of a broken branch pipeline!
            This is already an issue and I need to resolve it before I run into more problems.
            I believe the first part of the issue was that I made the CI pipelines before I made the branches.
            The next issue was that I forgot to adjust the rules haha!
            This proves that doing multiple things at once is a bit of a pain, however I will get better at it with more time and skill.

            Now we want to test case the Trunk deployment of the WASM, during the `beta` phase of the build, I believe we should have the action publish the rust wasm embed.
            The process should be simple in that it would run `trunk build --release` within the `apps/rust_wasm_embed`

            After reviewing the nx commands, I think it would be time for me to slowly utilize that executor.
            The `executor` will be the `nx:run-commands` and then the target would be split amoung two different commands.
            The first command will be the `trunksetup` and the second command will be the `trunkdeploy`.
            After getting both of those configured, I will update the `kbve.sh` file to include a `-nx` flag with `rust_wasm_embed:trunksetup` and `rust_wasm_embed:trunkdeploy` to run the commands.
            This way we are still using the `kbve.sh` shell but instead of adding the functions directly into the shell script, we will move them over to nx commands.

    
    - 8:25pm - `Holy`

        #### Holy

            Expanding the crate so that we can the proc-macro_derive -> Observer with the attributes of `holy`.
            My current method of building out the Observer would be to use the `Arc<Mutex<>>` and the basic lock system that would be associated with it.
            I was thinking we could use a lockfree linked list or a BTreeMap, but after some test casing, I am going with a Crossbeam AtomicCell.
            This Atomic cell will help resolve our lock issue when it comes to multi-thread applications and allowing the variables to be accessed without having to unlock.

            So the first part of the Observer function would be similar to this:
                
                ```rust

                        #[proc_macro_derive(Observer, attributes(holy))]
                        pub fn observer_derive(input: TokenStream) -> TokenStream {
                            let ast = parse_macro_input!(input as DeriveInput);
                            generate_observer_impl(&ast)
                        }

                ```

                Then moving the impl into its own function!

    -   10:30pm - `Warcraf`

        #### Warcraft

            Ending the night with some Battlegrounds and maybe a quick raid.
            Just did the BFD with a random 10

---
# January: 20

> Daily Log for January 20th of each year!

Source: https://kbve.com/journal/01-20/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

-   **President**

    10:00AM

        The new president is taking office, well I guess not really new but it is what it is.
        I am wondering how the markets will react tomorrow, since they are closed today.

-   **GoDot**

    09:05PM

        Updating the rust ffi into the godot wasm build, going to try the first build and see where it goes from there.
        The reference issue that I was using is here [438](https://github.com/godot-rust/gdext/issues/438).
        The target will be using a `-z` flag , so we need to setup the nightly.

        ```shell

        rustup toolchain install nightly
        rustup component add rust-src --toolchain nightly
        rustup target add wasm32-unknown-emscripten --toolchain nightly

        ```

        Next we need to add the emscripten to our WSL instance!
        For this, I created a custom script that we can invoke with `./tools/scripts/public/emscripten/install_emsdk.sh`.
        We also want to make sure that the rustup has a wasm32 nightly added `rustup target add wasm32-unknown-emscripten --toolchain nightly` 



### 2024

    - 5:40pm - `Holy`

        #### Holy

            One of the issues with the observer crate would be if we needed to include a Vec around the field object before placing it inside of the AtomicCell.
            There needs to be a bit more test casing and I believe that it would make sense to wrap it around the Vec, but I need to go through some real world test cases before I write it out.
            Besides the observer macro needing an updated AtomicCell with a Vec, the setter's notification has to be modified a bit. 
            Both of these issues can be resolved in a test case of the `rust_wasm_embed`.

    - 11:00pm   - `PalWorld`

        #### PalWorld
            
            Playing a couple hours of palworld and it has been great!
            Ended up building a massive base on Zachs server, while I been debugging the Crossbeam crate for an AtomicCell object.
            The game is still in early access but it has been very fun so far, the whole pokemone with guns is absolutely correct.
            I want to see what the end game content will look like and then explore the whole map, ah, collecting different pal monsters, it really is a trip down memory lane.

    - 4:00am - `Sleep`

        #### Sleep

            There was not much major progress today, it felt more like a break from the normal research and coding sessions, thus I will keep this entry short and sweet.

---
# January: 21

> Daily Log for January 21st of each year!

Source: https://kbve.com/journal/01-21/

import { Adsense } from '@/components/astropad';

## Notes

<Adsense />

## 2026

### Impression Burst

-   12:26AM

    Looking at the search impressions data and we are seeing a burst!
    This could mean that we need to further improve and tweak our website, but results are there!
    I am thinking that if we expand to all OSRS items, it will make it easier to build around crypto and stocks.
    Finally, once its all organized, we can loop back around and work on the game asset area and marketplace.

## 2025

-   **Rust**

    12:23AM

        Preparing the rust integration with the godot project.
        To build the wasm, we would run this command:

```shell
     ./kbve.sh -nx rust_godot_towerdefense:build-wasm
```

    07:48PM

        Trying to adjust the windows build again but this time instead of the target being `x86_64-pc-windows-msvc`, we will make it `x86_64-pc-windows-gnu`.
        Granted the msvc would give us better performance but the errors are just a bit too much for me to deal with right now.
        Perfect, the dll works without any major issues and we can move forward with setting up the hex grid next.

-   **Markets**

    10:40AM

        Going to offload some more of my SPY and prepare to switch to selling puts.
        I think we might see SPY reach upwards of $625 or more mid year.

    

## 2024

    2:40pm -   `Food`

        #### Food

            Went on a sleepless adventure to restock my empty fridge, the lack of healthy food in my diet and the overall lack of sleep are both a dangerous combo.
            My heart is wondering why I am running on red bull, like a college frat boy, I can tell I am getting old lmfao.


    4:29pm -    `Nx`

        #### Nx
        
            I have to go back and update the Nx Run commands for the Rust WASM, the two commands were the `trunksetup` and the `trunkdeploy`.
            There is also another issue that we might have to tackle and that is the nx migration to version 17.3.0, which is currently in beta right now.

    6:01pm -    `TrunkSetup`

        #### TrunkSetup

            The first of the nx command would be the `trunksetup`,  here is the json for the nx command to help setup and run the command.

                ```json 

                    "trunksetup": {
                        "executor": "nx:run-commands",
                        "options": {
                            "commands": [
                            "rustup update",
                            "sudo apt-get install -y libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev libxkbcommon-dev libssl-dev",
                            "rustup target add wasm32-unknown-unknown",
                            "cargo install --locked trunk"
                            ],
                            "parallel": false
                        }

                    }
                ```

            The executor will be `nx:run-commands` and then followed by the commands, which would setup the environment for the trunk to build the wasm.
            Finally, we set the parallel to false, to keep the commands linear, which would take a bit more time but it would help dismiss errors.
            If we wanted to set the parallel to true, then we would have to further split the commands.

            Next I am going to split the `trunkdeploy` into two commands, one being the `trunkserve` and the other `trunkrelease`.
            This is just to avoid any confusion and making it easier to do developement and production cycles.
            
            The `trunkserve` would be an easy nx run command.

                ```json

                    "trunkserve": {
                        "executor": "nx:run-commands",
                        "options": {
                            "cwd": "apps/rust_wasm_embed",
                            "commands": [
                            "trunk serve"
                            ],
                            "parallel": false
                        }
                    }

                ```

            Just a quick note, we have to `cwd` to the root of the project.

            Finally, we would add the `trunkrelease`, which will build the wasm and prepare the WASM and hash files for us to use.
            Here we will just copy over the `trunkserve` and rename the serve with the release.
            
                ```json

                    "trunkrelease": {
                        "executor": "nx:run-commands",
                        "options": {
                            "cwd": "apps/rust_wasm_embed",
                            "commands": [
                            "trunk build --release"
                            ],
                            "parallel": false
                        }
                    }

                ```

            The next move would be to test case the nx run commands through the kbve shell file, like this:

                ```shell

                    ./kbve.sh -nx rust_wasm_embed:trunkrelease

                ```

            Which we will then add into our Github action for the trunk release and organize the pipeline!

            Before pushing through, I believe it would make sense to sync the branches up for a release and then add in this feature?
            We could also not do that and just try a rolling update and see how it would work?

    7:15pm -    `HerbWASM`

        #### HerbWASM

            We need to make sure that the WASM that gets released from the `rust_wasm_embed` has a clean folder to deploy to!
            This includes making sure the folder gets wiped clean and that only successful builds get copied over for a new `dev` branch.
            Okay, let me take a step back, the work flow would be like this:

                - [1] There are changes to the `rust_wasm_embed` application using `nx affected` or file changes inside of `/apps/rust_wasm_embed/src/`
                - [2] During the `alpha` branch, these changes should be lint and tested, using a combination of unit and integration testing. If any fails, then we do not move it out of alpha.
                - [3] Duriing the `beta` branch, we would run the trunk release and then create a new pull request with the distrubtion files, as a patch back into the same mono-repo.
                - [4] Finally during the new patch, with the files, we would setup more unit / integration testing but this time between the Astro website and the wasm embeds.

            This would be the current workflow / pipeline that I would want to build out tonight.

            The current route that I am taking would be to create a quick custom shell script to handle the `/dist/` folder migration.
            Under the nx run commands, we would just have it deploy the script for now, by making sure to `chmod +x` and then running it.
            The script name, hmm, I am thinking of calling it `herbwasm.sh` for now, but I can always come back and update it.

            Opps, the script would be called `pipelineherbwasm.sh`, and it will be placed under the `tools/scripts/public/wasm/` folder.

---
# January: 22

> Daily Log for January 22nd of each year!

Source: https://kbve.com/journal/01-22/

import { Adsense } from '@/components/astropad';

## Notes

## 2026

### Material Functions in Unreal

-   11:44PM

    Spent the day to get a better understanding of the material functions within the shader graph.
    I was not a major fan of it before, but I am starting to understand why it is being utilized.
    The whole custom params that get sent over to each instance makes sense because the GPU is what handles the rendering!
    If we were using the C++ directly, then we have a CPU cost for the rendering, so it would make sense that we pass that through.

### Unreal Fragments

-   11:47PM

    The fragment side of the cplusplus is also interesting, I been researching and getitng a better understanding of it.
    


## 2025

-   **GoDot**

    07:54AM

        After burning the midnight oil, I have gotten almost somewhere and yet no where at the same time?
        Ugh, okay here is the original toml, going to back up a bit and see what I can do to resolve some of these issues.

```toml

        [target.wasm32-unknown-emscripten]
        rustflags = [
            "-C", "link-args=-sSIDE_MODULE=2",
            "-C", "link-args=-pthread", # was -sUSE_PTHREADS=1 in earlier emscripten versions
            "-C", "target-feature=+atomics,+bulk-memory,+mutable-globals",
            "-Z", "link-native-libraries=no",
            "-C", "link-arg=-fwasm-exceptions",
            "-C", "link-args=-sSUPPORT_LONGJMP=wasm",
            "-C", "llvm-args=-enable-emscripten-cxx-exceptions=0",
            "-C", "llvm-args=-wasm-enable-sjlj",
            "-C", "link-args=-sDISABLE_EXCEPTION_CATCHING=1",
        ]

```

        That was the original toml, but I am going to back up and remove some of the flags that are there.
        Next going to replace this:
```
        "cargo +nightly build -Z build-std -Z unstable-options --target wasm32-unknown-emscripten --artifact-dir dist/wasm",
```
        With a bit of a better build?
        Okay wow, 151MB to 338KB.

-   **Music**

    10:58PM

        I decided it would make sense to move the music into its own component.
        Now we need to test the build and make sure that it works on itch.
        Okay the `DLL` for debug is around 283MB, but let us see what the size is for a normal release.
        Less than 1MB, we are good to go, yessir!

### 2024

    -   12:00pm - `WorkPlay`

        #### WorkPlay

            Tell me how I spent most of my time just AFK farming on Palworld while listening to random people talk in meetings.
            After a quick lunch break, I am going to take a quick nap and then focus on learning how to pipeline the Rust WASM.
            Now the question becomes, what should I have for lunch? 
            Honestly watching myself butcher a bunch of Palworld monsters... uhhh really did not make me want to eat anything meat related lmao.
            I will do quick greek yogurt smoothie and a spicy salad.

        
    -   4:00pm - `Apple`

        #### Apple

            It looks like I am going to be forced to sell a couple blocks of my Apple shares at around $190 each.
            At first, I felt that it might be a bit rough on my books to handle the sale, but majority of those shares were on margin.
            The net profit from the block sale should offset the interest that I was paying to hold those shares, but I really wish I had the script sell the shares for a bit more.
            I am currently looking at a way to do a combination of cover calls with poorman calls and a hail mary call.
                
                A poor man's cover call is basically a long dated call option, think 2025, that we then sell smaller dated call options against.
                A hail mary call is a really far dated call and strike, usually the goal would be to take advantage of stock price surges, which can easily net a couple points in the wallet.

            Granted these are just side notes for myself and makes it easier to organize the future hedgefund that is in my mind.
    
    -   11:00pm - `HerbWASM`

        #### HerbWASM

            I ended up missing my goal for the weekend, so I should focus on catching up on my own personal goals.
            I do not want to blame Palworld but having double digit hours does not help haha.
            Actually since the game came out, I am definitely past the 24 hour mark of playing the game, granted that does include some AFK farming.

            So there would be a couple scripts that we would would execute through the shell.
            The first would be the initial setup, so we would do:

            - [1] Trunk Setup -> `./kbve.sh -nx rust_wasm_embed:trunksetup`
            - [2] Trunk Release -> `./kbve.sh -nx rust_wasm_embed:trunkrelease`
            - [3] Herbmail Pipeline -> `./kbve.sh -nx rust_wasm_embed:pipe`

            After that we would need to pull the hash of the completed files, so that we can store them.

            So lets expand the pipeline to include the SRI hash of the files that get generated.
            We are getting the sha integrity from the produced files and the unique hash wasm variables.

---
# January: 23

> Daily Log for January 23rd of each year!

Source: https://kbve.com/journal/01-23/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### OSRS Items

-   12:15PM

    Looking through the whole OSRS item database and made some overrides.
    However there are still some issues with the data integrity, so I will be looking to resolving that next.

## 2025

-   **DLL**

    12:26AM

        I believe that we are getting close to making sure that our future games within godot can run on mac, windows and the browser.
        The only other operating system that I would target would be linux but I am not too worried about that for now.

-   **HexGrid**

    12:27AM

        After finishing up the music manager, we would want to figure out the best way to render the hexgrid aka the map itself.
        

-   **RustConfig**

    02:45AM

        Going back around, I am going to include the older flags for now!
        Granted that it would still create a bit of a larger wasm but I also want to make sure that the wasm will work on itch.
        We can test the configuration here below when I get a bit more time.

```toml

    "-C", "link-args=-sSIDE_MODULE=2",
    "-C", "link-args=-pthread", # was -sUSE_PTHREADS=1 in earlier emscripten versions
    "-C", "target-feature=+atomics,+bulk-memory,+mutable-globals",
    "-Zlink-native-libraries=no",
    "-Cllvm-args=-enable-emscripten-cxx-exceptions=0"

```

## 2024

    -   7:30am  - `PreWork`

        #### PreWork
        
            Decided to sleep a bit early and do some quick and dirty H as I get ready for work.
            
                    
    -   10:00pm - `Herb`

        #### Herb

            I am going to update the Astro for the HerbMail.com website to use the WASM md file that we created yesterday.
            Let me go ahead and rename the `pipelineherbwasm.sh` to `pipeline_herbmail_wasm_build.sh`
            This will make the script more specific, definitely helpful for debugging.  
            Okay now we need to enhance the script, such that it will take the MD file from the integrity and create a new MDX file for displaying the WASM.
            The folder that we will place the MDX inside of will be `/tools/`. 
            We would have to remove the existing file and then update it from that scope.

            There was an issue with Astro v2 and the MDX parsing, thus we will migrate the script to build using basic markdown for now.
            Finally the bigger issue was getting the WASM to render within Astro and its tailwind, somehow I hacked my way into making it work for just a general use.

---
# January: 24

> Daily Log for January 24th of each year!

Source: https://kbve.com/journal/01-24/

import { Adsense } from '@/components/astropad';

## Notes


<Adsense />

## 2025

-   **Email**

    01:03AM

        After migrating the n8n over to the kubes, I forgot to deploy my email system.
        Ugh, we have a backlog of around 1200 emails to go through, I cleaned up around 700 so far but it has been an issue.
        Granted the older n8n beta workflows from the coolify are still running, so half the email filter system is down.

    
-   **Bevy**

    01:15AM

        Next project for the gamejam will be to build out the gridmap, hmm I am thinking that we just use bevy_ecs for it.


## 2024

    -   8:24am  -   `Erust`

        #### Erust

            Going to add `egui_tiles` or `egui_dock` into the WASM component and see we can get a basic test case out of the way.
            We need to make sure that it can build to WASM without having any major issues.
            I should also note for myself that I need to do the worker box migration for the WASM!
            This would let us run the application in offline mode, which is important.
            Furthermore, we need to test case the nanostores integration during the unit and integration testing, making sure variables can move inbetween both the WASM and JS.
            Noted, we are using nanostores via `"nanostores": "^0.9.3"` , but persistence is under a different package.

            Okay the tiles seem to load fine, I just need to adjust the settings / styles for each of the tile within the grid system.

    -   11:50am -   `Unity`

        #### Unity

            Decided to play around with the Unity engine a bit more, here and there with the Cinemachine and the Combat Engine.
            I am still having a ton of issues with wrapping my brain around it, I think I just need more practice and test casing.
            The best option right now would be for me to just drop the pooling system and stick with a slower and intensive method of just tracking each object.
            This way the game can move forward and as I play around a bit more with it, I can look into a future update and revisit the gameobject pooling.
            There is also another option, which would be to just drop a browser build and just focus on a Windows version, but I feel like that would defeat the purpose of then even using Unity, since I want that WebGL build.
            I am craving a neopets style space game.

    -   5:30pm  -   `Remodel`

        #### Remodel

            We are looking to remodel the home a bit more, it seems that our guest bathroom is getting a bit too old and needs a revamp.
            I am using these notes as a way to keep track of the process, including adding a couple handicap / disability features to the bathroom.
            This would be an interesting test case for GPT, using it to help setup housing for people in need, such as older citizens or people with physical disabilities.
            I am going to ask it just some generic questions and how to help structure the property.

            Besides doing the remodeling, I do need to focus on placing the house into a trust as well, ugh, so many side quests that I get confused half the time.

            Now we would be changing out the basics, i.e repairing the bathtub and toliet, ideally making it so that it is easier to access.
            Also we need to replace the locks on the bathroom door that goes to the backyard, it needs better insulation and maybe an electric lock, just to make it easier to enter the home from the backside.

            I will keep light notes on this project, maybe even include some images of the project.


    -   7:20pm  -   `DnD`

        #### DnD

            Time to play some DnD with my friends!
            Andsam created two unique items for a `Drink Ability`:
                
                `Ectocoller Enthusiast`
                    > By drinking (via Drink Ability Action) Ectocooler consistently and with gusto, the line between life and death thins.
                    > The first time you would roll a death save, you roll with advantage. 
                    > Rolling a 19 is the same as a rolling a 20 as well (granting you 1 hp and bringing you back in the fight)

                `Hydro Homie`
                    > By drinking (via Drink Ability Action) pure water (and not that oily sewer stuff), you are tapped in to the fluid operations.
                    > Whenever you regain hp, you gain an additional 1 hp point.
                    > Further, the 1st time you regain hp, you gain 5 hp in addition.

            The session was in the DMZ, where we were basically establishing our own version of `snowfall`, basically turning the area into a West Korea - Camden Edition.


    -   11:00pm -   `Rust`

        #### Rust

            Just doing some casual Rust and maybe a H or two here and there.
            Taking the night to just relax, go over my written notes and do some general research into the WASM GUI Management.
            
            The pipeline under `ci-beta.yml` can now be extended, going to add the alter right now.

            Going to go ahead and make the `deploy` branch for the pipeline and see that will work as planned.

            After test casing the deployment via github actions of the beta branch, I believe we should also keep track of a timestamp inside of the `md` file that gets created.
            This will help keep track of the shifts made via the pull request and the timestamp can be called directly through the file, without having to use the Github API.
            To accomplish this, we would add this into the `pipeline_herbmail_wasm_build.sh` file

                ```shell

                    # Add Unix timestamp to the MDX file
                    TIMESTAMP=$(date +%s)
                    add_mdx_fields "timestamp" "$TIMESTAMP"

                ```

            This will make sure that we have a timestamp to keep track of the creation within the file itself.
            We can also expand this in the future to include the pull request number, as a reference for the build.

---
# January: 25

> Daily Log for January 25th of each year!

Source: https://kbve.com/journal/01-25/

import { Adsense } from '@/components/astropad';

## Notes


<Adsense />

## 2025

-   **Godot**

    08:45AM

        Finished up a quick godot meeting and now switching gears to focus on getting past that last hurdle.
        The goal of the extension is so that we can use it again in the future without having any major issues.

    04:53PM

        The next update will be for the load textures in 2D/3D, but before I spend too much time on that, I need to finish up the hex map generation.
        Currently the goal is to use the bevy ecs to help generate the world and fill in the hex tiles but the formula that I am using is not really working as I would have hoped.

-   **ShieldHero**

    09:05PM

        Watching season 2 of the shield hero while slowly drifting to sleep, I been slacking on the digital journal updates but I still keep a written log of all my journal entries.

## 2024

    -   6:30am  -   `Dreams`

        #### Dreams
        
            I was having some wild dreams of traveling the world as a crypto exchanger lmfao.
            Basically an international middle man that would over see the transfer of everything, from stolen goods to obtuse insurance problems.
            Like it could have been an epic series, hmm, that really gets me thinking!


    -   10:30AM -   `Rust`

        #### Rust

            Going to clean up the template again, maybe removing some of the additional behaviors from the side bar and probably sticking to just a grid view.
            After I clean all that up and get a base demo out of the way, I want to extend out the grid system using the erust state management.
    
    -   5:00pm  -   `SQL`

        #### SQL

            It might make sense to use both the bigint and ulid for the table management, thus I might have to go back and basically redo all the tables again.
            Thank god we do not have a large amount of data, so migrating this back would mean a bit of refactoring but the whole `kbve` package does need it regardless.
            I will update these notes again with how I plan to do that migration.

---
# January: 26

> Daily Log for January 26th of each year!

Source: https://kbve.com/journal/01-26/

import { Adsense } from '@/components/astropad';

## Notes

    #### keys

        Need to keep track of these keys:
            -   `portainer_stack`
            -   `jwt_secret`
            -   `portainer`
            -   `hcaptcha`
            -   `kbve`
            -   `shieldwall`
            

<Adsense />

## 2025

-   **Pasta**

    10:35AM

        The best way to start the day is to create a nice pot of pasta for the whole day!
        I am using a lentil-based pasta with my four cheese sauce, it hits perfect for lunch and the rest of the day.

-   **ECS**

    11:33PM

        The Bevy ECS will be for the tilemap and I got it to render the basic tiles, yet the placement of them is still a bit off.
        I am going to spend a bit too much time trying to resolve it but I think it will be worth it for the future.

-   **UI**

    12:55PM

        The UI/UX Godot extension will need a couple updates, one is a better menu system and the other will be a couple message canvas.
        One of the first ones that I want to add is a visual novel style canvas that will load a background image, an avatar and some kind of animation for the text to be displayed.

## 2024

    -   7:00am  -   `Bear`

        #### Bear

            Decided to start a TV series for my morning binge and since I enjoyed Shameless, I figured I would give FX's show a shot.
            Ended up watching almost all of the first season in one sitting, it was definitely on point and worth a watch.
            In between the the first couple episodes, I had to make a quick trip to Wawa and grab myself a steak and egg hoggie.


    -   10:30am -   `SQL`

        #### SQL
        
            The primary key will be shifted back to the BigInt via the Serial.
            `SERIAL is an alias for BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.`
            Given that the global table is still using the serial, I will just go back and basically replicate that.
            
            Next it would be preparing the different tables that the `kbve` package will need to include doing the refactor.

            The message table would look like this:

                ```javascript

                            export const message = mysqlTable('message', {
                                id: serial('id').primaryKey().notNull(),
                                sender_id: binary('sender_id', { length: 16 }).references(() => users.userid).notNull(),
                                receiver_id: binary('receiver_id', { length: 16 }).references(() => users.userid).notNull(),
                                content: text('content').notNull(),
                                sent_at: timestamp('sent_at', { mode: 'string' }).notNull().defaultNow(),
                            }, (table) => {
                                return {
                                    sender_id_idx: uniqueIndex("sender_id_idx").on(table.sender_id),
                                    receiver_id_idx: uniqueIndex("receiver_id_idx").on(table.receiver_id)
                                };
                            });

                ```

            However there should be some additional fields that we might want to add.

            Wait I forgot an additional change that I need to do for the schema, which is change the length of the fields from 256 to 255.

            Okay after deploying the new tables, I forgot to double check the global keys that we would need, so I might have to create a tool to keep track of those.

---
# January: 27

> Daily Log for January 27th of each year!

Source: https://kbve.com/journal/01-27/

import { Adsense } from '@/components/astropad';

## Notes

<Adsense />

## 2025

-   **Markets**

    08:03AM

        It is amazing to see how a single resource like deepseek was able to rip apart the markets.
        Looking at the cheap $NVDA stock is making me think about dumping into the 1k mark really quick?
        1000 shares would really be good a solid investment right about now.

-   **WoW**

    06:25PM

        Some quick hardcore runs on my new hunter and then going to switch over to the shaman after that.

-   **Godot**

    09:37PM

        The UI patch for the extension is a bit more annoying than what I would have thought.
        Ugh, I think I will have to get the computer back online asap because the speed and delay is getting to me!
        Having WSL open with wow is already killing my setup, ughhh.


## 2024

    -   11:30am -   `Schema`

        #### Schema

            Starting off the weekend with more schema changes!
            Finalize the message table and then expand out the host table, but before doing those two tables, I need to make sure the global keys are added.
            It seems that during the `dbmodels.rs` generation under the `erust` folder, the struct derives seem to fail, thus I need to see why it fails.
            The original shell uses sed to replace `(Queryable, Debug, Identifiable)` but since we shifted the primarykey back to serial / big int instead of binary, we no longer need the `Identfiable`!
            Thus going to remove that aspect of the schema generation.
            
            In addition, there would be the zod that we need to expand.

                ```javascript

                    export const registerUserSchema = z.object({
                        username: z.string(),
                        email: z.string(),
                        password: z.string(),
                        confirmPassword: z.string(),
                        });

                        export function registerUserSchemaValidation(schema: ZodRawShape) {
                        return registerUserSchema
                            .extend(schema)
                            .refine((data) => data.password === data.confirmPassword, {
                            message: "Passwords do not match",
                            path: ["confirmPassword"],
                            })
                            .refine((data) => /^[a-zA-Z0-9]+$/.test(data.username) && data.username.length >= 3 && data.username.length <= 20, {
                            message: "Username must be 3-20 characters long and only contain alphanumeric characters",
                            path: ["username"],
                            });
                    }

                ```
            
            This is an example of the zod expansion, which is through the `extend` and `refine` functions of the zod's `ZodRawShape` object.
            
    -   3:40pm -    `Refactor`

        #### Refactor

            The worst feeling about refactoring is knowning that you have to do it a couple times over and over.
            Even this current refactor that I am doing right now, sadly will be done again using SQLX instead of Diesel, which is a pain to think about down the line.
            The main reason we would be doing the refactor again, even if we are refactoring it right now is because of the C library that Diesel depends on for MySQL.


    -   11:40pm -   `Drizzle`

        #### Drizzle

            When updating Drizzle within the monorepo, we run three commands.
            The first command, aka `./kbve.sh -atomic drizzle kit upgrade`, would be to create a new branch for the upgrade, just to make sure that nothing breaks!
            The second command is `pnpm add drizzle-kit@latest -D` and finally the third command is `./kbve.sh -reset`.
            Finally, let us test case the studio by running `./kbve.sh -studio`.

            Inside of the studio, we want to add the seven global keys that we wiped earlier, which I placed under notes as keys.

---
# January: 28

> Daily Log for January 28th of each year!

Source: https://kbve.com/journal/01-28/

import { Adsense } from '@/components/astropad';

## Notes

    ### Unreal

        - Unreal Engine Tools, specifically for pipelines, https://src.redpoint.games/redpointgames/uet

<Adsense />

## 2026

### OSRS Items

-   04:11PM

    Making changes to the OSRS items and hopefuly we some really good graph design

## 2025

-   **Godot**

    11:07AM

        The UX/UI extension has been taking a bit too much of my time trying to figure out how to adjust the text display.
        One of the issues that I am having is trying to balance the text appearing and not getting in a way of the avatar.

    01:49PM
    
        A WSL command would make sense to add, where it then runs the build for windows, wasm and linux.
        Then we can add a m1 build that does mac, wasm and linux?! Hmm, going to keep notes on this for future reference.

        It would look something like this:

```json

  "build-wsl": {
    "executor": "nx:run-commands",
    "options": {
      "commands": [
        "pnpm nx run rust_godot_towerdefense:build-linux",
        "pnpm nx run rust_godot_towerdefense:build-windows",
        "pnpm nx run rust_godot_towerdefense:build-wasm"
      ],
      "parallel": false
    }
  },
```
        This would then run all three for us , making it a bit eaiser via this shell command:

```shell

./kbve.sh -nx rust_godot_towerdefense:build-wsl

```

-   **Menu**

    02:17PM

        The menu system will be expanded later today to include some custom shaders.
        

## 2024

    -   9:53am  -   `Refactor`

        #### Refactor

            The `kbve` package has a couple errors that needs to be addressed, which are mainly because the user table has `userid` now instead of `ulid` as a reference.
            
            Issue one would be under the `guild.rs` but now how should I refactor it? 

            For now I am just updating the references to the `ulid` table as `userid`, since we want to make sure the column names match for the inner/left joins.

            However during the `cargo test`, I noticed the holy crate was broken too, which means I need to go back and fix that as well xD!

            The issue with the holy crate would be the observers, which I have addressed.

            Going back to the `kbve` package and `rust_wasm_embed`, I reset the `hcaptcha` key within the database and we are running into some verification issues.

            To help resolve this, I am going to pull the dev server replication from `5` units to `1` and see what the problem is when it comes to the verification, which is most likely something stupid hehe.

            
            The goal right now would be to isolate the different functions of the package into their own files, then slowly extend out each one of them.
            I want to do this slowly but I will skip the integration testing and stack tracing until the base of the refactor is done.

        
        #### Captcha

            This was a pain to figure out because I could not tell if I was having errors from the HCaptcha service, itself, or if there was just something wrong with the docker network.
            In the end, I was able to register my test account, which is enough to move forward with the rest of the refactor.

            The current struct for HCaptcha looks like this:

                ```rust
                
                    #[derive(Deserialize)]
                    struct HCaptchaResponse {
                        success: bool,
                        challenge_ts: Option<String>, // Timestamp of the challenge
                        hostname: Option<String>, // Hostname of the site
                        credit: Option<bool>, // Deprecated field
                        #[serde(rename = "error-codes")]
                        error_codes: Option<Vec<String>>, // Error codes, if any
                    }

                ```

                The `error_codes` or `error-codes` should pass through the json but I can come back to that at a later time.

        #### Checks

            The `health_check` and `speed_test` utility functions will be migrated into one route that we will call system diagnostics.
            This route will contain all the information we would need to debug, examine and test the live instance.

            In the integration test case, I am calling them like this:

                ```rust
                                
                    .route("/health", get(kbve::routes::system_health_check))
                    .route("/speed", get(kbve::routes::system_database_speed_test))

                ```

            Both of the routes are working fine without any issues at the local point, I will save the progress at this route.

---
# January: 29

> Daily Log for January 29th of each year!

Source: https://kbve.com/journal/01-29/

import { Adsense } from '@/components/astropad';

## Notes

## 2026

### Unreal Engine Skeleton Animation

-   09:28AM

    The skeleton knights still have this weird animation bug that I been trying to resolve!
    It has been way too long of an issue, but I am making some better progress!
    I believe it might be the C++ code that I am using to track the animation state?

## 2025

-   **Hashmap**

    04:09PM

        One of the issues that we need to resolve before the end of the gamejam will be the lazy / macro / map.
        The hashmap that we are using right now from std collections will not be the best for multithreading.
        Thus we need to find a replacement for it, hmm.

    04:11PM

        The next couple builds have to focus on the part of the data structure and I also need to map out some of the caching.


-   **Issues**

    07:45PM

        First issue ticket that we will have to make is for upgrading the supabase core image that gets provided or built off of in kilobase.
        I believe the current supabase image is 15.1 and we need to upgrade to 15.6.

        Issue ticket 2 will be for finishing the discord.sh tags and making sure that migration happens amoung the tags without any problems.

        Issue ticket 3 is for the migration of server table, tags and their relationship inside of the postgres. This is important before we start the front
        end development. The option for front end can be nextjs or astro. The other option could be to use tamamgui for the front-end. This would make thigns a bit more interesting, yet the otherside of this would be, hmm wait, actually nevermind.
        We can not use tamagui and have to stick with either astro or nextjs, I will hold off on this until after the gamejam.

<Adsense />

## 2024

    -   7:30am  -   `Payment`

        #### Payment

            It is the end of the month, I need to double check all the auto payments for the end of the month and wanted to make sure that everything was working.
            I been trying to find ways to use AI to help manage the cashflow but honestly it seems to be a bit overkill because it does not do much to help.
            If anything it might be a waste of resources and time because autopayment and the timing around the credit (30 days) is already enough to handle most transactions.
            Instead of waiting until the end of the month, just a simple script to double check payments and pay within 14 days or post the date out to 27 days seems to handle the issue.

    -   8:50am  -   `Rust`

        #### Rust

            More rust through out the day!
            I went through a bit of a stump and was thinking of rotating out the Diesel and switching to SQLx and SeaORM but honestly that might not be worth the time investment.
            I decided to rename the `routes` module to `sys` because it felt like it would make more sense later down the line.
            Having the route / routes within the internal package is not worth it, as it can be kept to the application layer.

    -   10:30am -   `Entity`

        #### Entity

            Before doing the `Auth` module, I think it would make sense to build out the `entity` module.
            This will be extended in the future for multiplayer, users, economy and much more!
            The first one that I will add is the `generic_response.rs` under response, just to make sure that it works within the package.

            Next concept within the Entity will be the `header_response.rs` which will handle the basic headers and include a generic cookie for now.

            After pushing through the `header_response`, the next file within the response would be the `shield_response.rs`

            This will extend the header response with a `x-kbve-shield`, moving away from using the `spellbook` approach and rather using the `impl`.

    -   4:35pm  -   `Regex`

        #### Regex

            Taking a break from the entity creation and building out the sanitization!
            Starting with the regex, which I will place under the `sanitization_regex.rs` and then added extraction functions for each of them.
            
            I ended up renaming the module to `regex_extractor.rs` and now I am going to expand around it for the time being.
            One interesting test case was that I could migrate the ULID check into a regex, which should help with speed of verifying if its valid.
            Before we were using a function like this:

                ```rust

                    pub fn validate_input_ulid(ulid_str: &str) -> Result<&str, &'static str> {
    
                        // ULID is usually 26 chars.
                        if ulid_str.len() != 26 {
                            return Err("ulid_invalid");
                        }

                        // Crockford's base32 set
                        let base32_chars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";

                        // Validate each character
                        for c in ulid_str.chars() {
                            if !base32_chars.contains(c) {
                                return Err("Invalid character in ULID");
                            }
                        }

                        // ULID is valid
                        Ok(ulid_str)
                        }

                ```

            The sanitization module is now just two core files, the `regex_extractor.rs` which will isolate the regex and provide helper extraction functions.
            Then there is the `validator.rs`, which holds the new ValidationBuilder.

            The way we would use this is:

                ```rust

                        let mut validator = ValidatorBuilder::<&str>::new()
                            .password(); // Add password validation rule

                        let input = "YourPassword123!"; // The input password to validate
                        let result = validator.validate(&input); // Pass the input to the validate method

                        match result {
                            Ok(_) => println!("Password is valid."),
                            Err(err) => println!("Validation failed: {}", err),
                        }

                ```

            ^ That is the example for the password validation.

---
# January: 30

> Daily Log for January 30th of each year!

Source: https://kbve.com/journal/01-30/

import { Adsense } from '@/components/astropad';

## Notes

## 2026

### CityVote Combat Update

-   04:00AM

    I have decided that it would be best to just work on all the games and projects we have!
    Trying to resolve all the issues, one a time, switching from what could be the most pressing.
    This means that I will bring out the macbook air and get to grinding!

### Unreal Animations Bone Pains

-   12:30PM

    Trying to get the animation bones to change from walking to running or idle, yet there seems to be an issue with the flow.
    I am not too sure where the issue might be, it could be from the C++ side or it could be our material function itself.

### CityVote Website

-   01:10PM

    We should get the astro website up and maybe even sync the accounts from the supabase instance to the godot application.
    I am wondering if that it would then make sense to even build out the stema store too, because we could look at launching this game as a side project for KBVE.
    This is an interesting turn of events, maybe this will be an interesting year, having a bunch of games out for demo release would be great.

### BigMode 2026 GameJam

## 2025

-   **Godot**

    04:44PM

        The cache setup is giving me way too many issues and I will not have much for notes today.
        We are going really quick and trying to get the game ready for the end of the jam.

<Adsense />

## 2024

    -   6:05am  -   `Morning`

        #### Morning
        
            The morning routine of getting up early is starting to get to me.
            I am feeling a bit old when I get up xD

    -   9:17am  -   `Rust`

        #### Rust

            Going to do some more early morning Rust coding, just trying to figure out the best way for me to handle the validation.
            I been thinking about how I should handle the validator and maybe we might move it out of the `kbve` package and into its own package.

            Now I need to come up with a name that we would use for this validation builder, yet I believe it should be in its own enity.
            The idea of placing the validation builder into another package that we can call, hmm.

            Okay! The package name that I have decided upon is `jedi` and I believe that will be the place holder for the validation and sanitization that we will be using.
            This package will be shared between the `kbve` aka backend and the front end `erust`, so we have validation on both sides without having issues.
            The `erust` will extend the `jedi` package's ValidationBuilder for its internal structs.
    
            Now I need to fix the pipelines and begin the publishing for the package.


    -   8:35pm  -   `Jedi`

        #### Jedi

            The Jedi package is called `Juggernaut Electronic Data Interchange` and it will be the base for the validations and help maintain a source of truth for the rust structs.
            Besides integrating and utilizing the various EDI standards, like UNEDIFACT, ANSI ACS X12, VDA, ect... 

    -   9:40pm  -   `Movie`

        #### Movie

            A quick movie night with back to back bangers, the first is `Green Book` and then `Whiplash`, both were perfect musical masterpieces.
            I was on the fence with both of them but seeing them back to back is a flow!

---
# January: 31

> Daily Log for January 31th of each year!

Source: https://kbve.com/journal/01-31/

import { Adsense } from '@/components/astropad';

## Notes

    #### Tables

        The table for view management should be simple enough to help keep track of valid views that are performed on the instance of what is being queried.
        We could make it easier to help 

## 2025

-   **Gamejam**

    07:35AM

        Was suppose to pull an all nighter but I ended up passing out before I could get too far with the extension.
        Oh well, I did my best for a new godot project and maybe next round, I will get a better understanding of how the UI works for wasm builds.

-   **Godot**

    02:51PM

        Extension updates!
        I believe I will continue to work on the extension, maybe even go back around and integrate a couple of the things that I did not get a chance to do so with.
        The bevy ecs was really interesting and I am actually wondering how it would perform for a tilemap setup?

    04:21PM

        Starting to build out the different folders and seeing if I can start to use those to make things easier down the line.
        Since UI was a bit more tricky, I am thinking that it would make sense to master that out after this gamejam?
        There are a decent amount of things that we need to learn and understand before we can move forward with that eco-system.
        I suppose adding macros afterwards would make sense too but that will be on a later date.
        Okay I decided to extned out all of the UI, then wrapping it into simple chain calls, thus making it easier to shift through the code and build around it.

<Adsense />

## 2024

    -   7:30am -   `Epoxy`

        #### Epoxy

            We are remodeling the storage room and the bathroom, at the same time!
            For the storage room floor, we decided to layer it with an epoxy grey tone because the floor was getting old and dull.
            I never realized how easy it has become to DIY home improvements, and honestly, tackling them in small steps has made it so much easier.
            Cleaning out the storage room, I found my old airsoft collection, but it always feels good to organize your belongings, side note: I also found my nerf double barrel machine gun hehehe.
            
            The first layer was applied over night and now this morning, we are going to double check the corners and add a bit of a smaller layer in the corner / holes, just to get them even with the rest of the floor.


    -   10:45am -   `SVG`

        #### SVG

            Decided to float around with the idea of SVG generator for some random projects.
            As I am thinking it through, I could adjust the hierarchy for the objects within the JEDI library.

            Thus the question on my mind would be how would I setup the naming convention for the different objects.


    -   3:45pm  -   `Builder'

        #### Builder

            Inside of the Jedi crate, I added the hybrid validator with async support as an optional rule.
            This means we can move the validator that we have inside of the `kbve` package into the `jedi` package, thus making it easier to reference and maintain.
            
            We will also use the validator inside of the `erust` because that will help with the client-side sanitization, even though we have server-side sanitization.
            One could argue that it would not make sense to have sanitization on both sides but I felt the need to do our best to keep a clean and secure environment, including for testing edge cases where we might not have full control over the backend, i.e a N8N function.

            After the validator builder, I am going to start the Regex builder, ideally placing them into a DashMap to make it easier to access.
            The dashmap would be a collection of LazyCells that would hold the regex instances.

            I believe the file will be called `regexmap`, I will try to build a simple map for it and hopefully it should hold the generic regex patterns that we would need for our application.

---
# February: 01

> Daily Log for February 1sty of each year!

Source: https://kbve.com/journal/02-01/

import { Adsense } from '@/components/astropad';

## Notes


## 2025

-   **Feb**

    08:10AM

        The morning has started and I am super excited to get into the flow!

    10:19AM

        After making some breakfast and getting my rogue leveled up, I am going to switch over to some godot development.
        It is time for me to being testing some of the new UI library changes that I been making.

<Adsense />

### 2024

    -   8:00am -   `Tub`

        #### Tub

            I have to figure out a way to remove the old tub from the bathroom and its going to be a pain.
            Besides it being super heavy, almost moldy and broken, it needs to go into a recylcing dump asap.
            Ah, I think there is a solution for removing the tub, hmm...
               

    -   2:30pm  -   `Jedi`

        #### Jedi
        
            Time to integrate the jedi crate into the KBVE package!
            My written notes are a bit out of sync with my mdx notes, so I need to go back and fix that as well.

---
# February: 02

> Daily Log for February 2nd f each year!

Source: https://kbve.com/journal/02-02/

import { Adsense } from '@/components/astropad';


## Notes

## 2025

-   **WoW**

    09:24AM

        The best thing to do in the morning is to do some general updates!
        I am thinking that I should focus on updating the wow page and get more information on there.

-   **Journals**

    09:43AM

        I forgot to update some of my older journals, but there are a couple things that I need to fix up?
        A standard format is still in the works, because it has to work each year too? Hmm


<Adsense />

## 2024

-   **Dual**

    2:00PM
        
            Trying to run two codespaces at the same time, basically a test case for the edge void.
            The goal would be to emulate multiple codebase changes at the same time, eventually scaling up to 5 instances.
            There have been some suggestions on how to use CLI LLM models to help with the coding but I still need to work on the prompts.
            Furthermore, the amount of memory and overhead also increases with each instance, if everything is done with local models, however I could implement OpenAI endpoints for some instances. hmm
            I am thinking that the first split would be this instance is kept to a local reference and the main instance is kept to OpenAI.
            Basically since this is a WSL instance, it makes it easier to communicate with a local model and the Unity instance is on Windows, thus having it communicating with OpenAI.

---
# February: 03

> Daily Log for February 3rd for each year!

Source: https://kbve.com/journal/02-03/

import { Adsense } from '@/components/astropad';

## Notes

## 2025

-	**NVDA**

	01:40PM

		Another brutal trading session for $NVDA, I am actually surprised that the stock has dropped so low!
		This is a great time to pick up a large stake in the company and keep it held for next couple cycles.
		I will try to load them off at $150 again, maybe play the $140 close cuts too.
		For this week, I will write some $110 puts and see if I can increase my stake slowly.

-	**WoW**

	07:00PM

-	**JSON**

	07:13PM

		Instead of passing through the `Array<Variant>`, I am thinking we could just handle it through JSON directly?
		The json serde will be important to configure, but I am debating on how I should do it.


<Adsense />


## 2024

#### Namespace
9:35am  -   `Namespace`
The current flow for this weekend is to update the namespace of Saber and then prepare for a Steam release.
	The Namespace package will be structured like this:
		KBVE.Engine - For the core enigne
		KBVE.Services - For the SOA
		KBVE.ClientUI - UI/UX for the Client(s)
		KBVE.Events - An event / action system
One of the bigger issues with Unity and WebGL is that we are limited to just one thread, so I will have to make adjustments throughout the codebase to see how I can offload some of the gameplay to 3rd party applications. I am thinking that the Ship management should be done outside of the game client and on the website because it will be faster, easier and keep the build size small. 

Now besides the base of the namespace, I know that I can always extend it out in future games, so that does help in the long term as well. Write Once and Use Everywhere!


#### Pipeline
The other day I was looking into setting up multiple instances of the monorepo and having a couple agents work on the various projects at the same time. Basically I would let them look through these notes and then have them formulate possible code changes via atomic patches. This is still a rough work in progress but I think it could be a solid test case for HerbMail / n8n integration, I like the idea and proof of concept to work together to produce something that can be at least helpful for my future self. It will always be interesting to see these notes in a year from now.

Part of the pipeline test casing is with the NX Outpost but I think there will be room for it to grow even further. While I am currently test casing obby, I think it might be time to leave this application and look to replace it with something a bit more flexible and useful for our project(s).

#### Unity

After finishing up the basics of the login system, I believe the next move would be to setup the character builder that all the games will share across the multi-games. Going to build out the ProgressBar which will be broken down to a modular event or action within the namespace of KBVE. To do this, we will create the event handler for the Progressbar inside of the UXUI folder and then we will extend that out in the ClientUI namespace to handle the actual creation of the progress bar. I will use issue 620 to keep track of the [changes](https://github.com/KBVE/kbve/issues/620).

---
# February: 04

> Daily Log for February 4th for each year!

Source: https://kbve.com/journal/02-04/

import { Adsense } from '@/components/astropad';

## Notes

<Adsense />

## 2025

### Markets

-   09:31AM

    The tariffs gave everyone a nice dip to average cost around!
    I am looking to pick up a couple more NVDIA this week but if not, then I will keep the put profits.

### Supabase

-   12:02PM

    The `kilobase` has been a bit out-dated and needs a couple upgrades to the base supabase extension.
    I should be careful with how I approach this upgrade because we also need to fix the custom wrappers too?
    Taking on the `kilobase` project with the additional projects that I have right now might be a bit painful to balance as well.

### Rust

-   10:40AM

    Adding Serde will be important for our rust project.
    
-   12:37PM

    We can extend out the `UxUiElement` to include a function that would take in the `GString` from Godot and convert it over to the json, via serde.
    The function would look like this:

    ```rust

    impl UxUiElement {
        pub fn from_json(json_str: &str) -> Result<Vec<Self>, serde_json::Error> {
            serde_json::from_str(json_str)
        }

        pub fn from_gstring(json_gstr: GString) -> Result<Vec<Self>, serde_json::Error> {
            let json_str = json_gstr.to_string();
            Self::from_json(&json_str)
        }
    }

    ```

    This would make it easier for us to move from `GString` -> `String` ->  `str`, then in the future we can go back around and just replace that all with `Binary`?
    Using json for now to make things easier and then for performance, we can go back around and add a function to help us with the binary movement.
    In my notes, I will also include a note for `ULID` / `Binary(16)` mapping too, so that the json data is not passed around multiple times but just a hashmap that stores it all.
    This can be useful for caching and creating more complex data structures, but I might be going way too ahead of myself.

-   01:41PM

    Okay, the menu system was refactored to take the data in as json, but I am thinking that we could also optimize the allocation.
    Instead of creating new buttons each time through allocation, we could have a pool of uxui elements that we can grab and recycle?
    However that might not be worth it for now, we can come back around to it later on.

-   02:17PM

    After some quick thinking, it might make sense to create another hashmap that stores all the `ui`-elements, maybe a `ui-cache` that we can use and consolidate all the `Gd<Control>` into.
    Okay before moving forward with the `ui-cache`, I need to adjust the `JSON` from the GDScript to avoid some issues with the stringfy.
    I will handle it while I am in the car.

### Godot

-   02:33PM

    Windows build testing should start soon, there might be some issues that I need to resolve with the `rcedit`, but it would be wise to start the pipeline for it.
    The goal will be to get a steam playable out really soon and push it up into the store?
    I think it be a great treat to have the godot rust game out there for people to try, then we wrap back around and see how it works in unity.
    Having a whole new area to tackle might be interesting but also a bit dangeorus, just a side note for me.


### Floor796

-   12:35PM

    Was venturing around the internet and came across this website, https://floor796.com/#t3r3,268,593, and I think it be perfect for this journal entry.
    Maybe I will make it a habit to visit the site once a year, just to see what updates have been added to it.

## 2024

### Unity

After storing the UserData's JWT, we need to pull the player stats and general location from previous save.
The base of the character profile table currently would look like this:

```javascript

export const characters = mysqlTable('characters', {
	id: serial('id').primaryKey().notNull(),
	ulid: binary('ulid', { length: 16}).unique().notNull(),
	userid: binary("userid", { length: 16}).references(() => users.userid).notNull(),
	
});

```

Yet we need to expand the table to include not only the current stats but the original max stats.
So we should keep the `hp` column for the max health and `mp` for the max mana.
Then the `health` and `mana` would hold the current session's data within the game.
Next would be energy, which needs two names as well for the column, hmm.
`ep` will be the term for Energy points which is the max energy that they have, while `energy` is the current session for the energy.

Side note: Within the Schema.rs, most of these will be transported to Integer, so we will not have to worry too much about it on the gRPC endpoint.

The exp / reputation is currently held under the `users` table, yet I am thinking that we can have them seperated because there would be multiple characters.
The guild would have its own exp/rep and each character then would have its own internal.

The current table would look like this:

```javascript

export const characters = mysqlTable('characters', {
	id: serial('id').primaryKey().notNull(),
	ulid: binary('ulid', { length: 16}).unique().notNull(),
	userid: binary("userid", { length: 16}).references(() => users.userid).notNull(),
	hp: int('hp').default(0).notNull(),
	mp: int('mp').default(0).notNull(),
	ep: int('ep').default(0).notNull(),
	health: int('health').default(0).notNull(),
	mana: int('mana').default(0).notNull(),
	energy: int('energy').default(0).notNull(),
	armour: int('armour').default(0).notNull(),
	agility: int('agility').default(0).notNull(),
	strength: int('strength').default(0).notNull(),
	intelligence: int('intelligence').default(0).notNull(),
    name: varchar('name', { length: 255 }).notNull(),
    description: varchar('description', { length: 255 }).notNull()
});

```

For status effects like being poisoned, stunned or getting a buff, we will most likely have to create a couple new tables.

Example of the status table:

```javascript

export const status = mysqlTable('status', {
    id: serial('id').primaryKey().notNull(),
    ulid: binary('ulid', { length: 16 }).unique().notNull(), // Adding ULID for the status type
    name: varchar('name', { length: 255 }).notNull(),
    description: varchar('description', { length: 255 }).notNull(),
});

```

This table would not change too often but it would help us keep track of the different types of status from a fundamental level?
Hmm I will think it through, so then the `effects` table would be something similar to this:


```javascript

export const effects = mysqlTable('effects', {
    id: serial('id').primaryKey().notNull(),
    ulid: binary('ulid', { length: 16 }).unique().notNull(), // ULID for each effect instance
    cid: binary('cid', { length: 16 }).references(() => characters.cid).notNull(), // Reference to characters' ULID
    statusUlid: binary('status_ulid', { length: 16 }).references(() => status.ulid).notNull(),
    startTime: datetime('start_time').notNull(),
    duration: int('duration').notNull(),
    intensity: int('intensity').default(1).notNull(),
});

```

Wait! Okay there was an issue that I just realized with referencing the characters, which is by placing the character under a ULID!
Instead we should update the table to be a `cid` aka character id that is a ULID but keeping the column name the same will help with inner , left, right joins because they would not only share the same value but reference.

So the final character table would be:

```javascript

export const characters = mysqlTable('characters', {
	id: serial('id').primaryKey().notNull(),
	cid: binary('cid', { length: 16}).unique().notNull(),
	userid: binary("userid", { length: 16}).references(() => users.userid).notNull(),
	hp: int('hp').default(0).notNull(),
	mp: int('mp').default(0).notNull(),
	ep: int('ep').default(0).notNull(),
	health: int('health').default(0).notNull(),
	mana: int('mana').default(0).notNull(),
	energy: int('energy').default(0).notNull(),
	armour: int('armour').default(0).notNull(),
	agility: int('agility').default(0).notNull(),
	strength: int('strength').default(0).notNull(),
	intelligence: int('intelligence').default(0).notNull(),
    name: varchar('name', { length: 255 }).notNull(),
    description: varchar('description', { length: 255 }).notNull(),
	experience: int('experience').default(0).notNull(),
    reputation: int('reputation').default(0).notNull(),
});

```

That will make the cid the unique character id for the game!
Okay now we need to make some changes to the effects table to maintain a better structure for future inner joins.

Updated the effects table, so this is a quick reference to it:

```javascript

export const effects = mysqlTable('effects', {
    id: serial('id').primaryKey().notNull(),
    ulid: binary('ulid', { length: 16 }).unique().notNull(), // ULID for each effect instance
    cid: binary('cid', { length: 16 }).references(() => characters.cid).notNull(), // Reference to characters' cid
    status: binary('status', { length: 16 }).references(() => status.ulid).notNull(), // Reference to status.ulid
    startTime: datetime('start_time').notNull(),
    duration: int('duration').notNull(),
    intensity: int('intensity').default(1).notNull(),
});

```

After the status / effects, I should look into the skill and ability tree?
I am thinking of following a structure that would be similar to WoW talents or DnD feats but I will keep doing research.
Then there is equipment and inventory, but I will do that with credit and banking, so hmm, I suppose guild, achievements and customization?

I could keep those empty for now and then expand upon them later on.

Starting the new character off with 0 health means that it would trigger a death animation / death event from the start.
I am wondering if that makes sense? Hmm, also I am not storing the position of the character directly under the Character table, but rather have a new table to handle that.

If the character is in multiple games, there should be a way to keep track of the position without having overwrites, I am also thinking about this as I am writing.

Okay. Option 1 would be just storing the x,y and z into the character table, but we already know from previous experience that this would be terrible for performance and also for the logical problem.

Option 2 would be to create a metaphysical table that we could use to store the location relative to the game that the character is playing, thus having multiple locations saved based upon the game.

Here is the base of the metaphysical table:

```javascript

export const metaphysical = mysqlTable('metaphysical', {
    id: serial('id').primaryKey().notNull(),
    cid: binary('cid', { length: 16 }).references(() => characters.cid).unique().notNull(),
    posX: float('posX').notNull(),
    posY: float('posY').notNull(),
    posZ: float('posZ').notNull(),
    transport: int('transport').default(0).notNull(), // 0 could represent 'on foot' or no transportation
    // Additional fields for state or other dynamic character aspects can be added here
});


```

Well, almost, lets just quickly adjust some of the variables a bit.
In addition, we might want to make the cid an unqiue because there should be only one metaphysical row per character aka per cid.
We will maintain a one-to-one relationship between the metaphysical and the character, just to be on the safe side for now.
We also might want a ulid for the metaphysical table, just to be safe, when trying to move the data around multiple databases, it will help with the integrity.
Here is the updated table below:

```javascript

export const metaphysical = mysqlTable('metaphysical', {
    id: serial('id').primaryKey().notNull(),
    ulid: binary('ulid', { length: 16 }).unique().notNull(), 
    cid: binary('cid', { length: 16 }).references(() => characters.cid).unique().notNull(),
    posX: float('posX').notNull(),
    posY: float('posY').notNull(),
    posZ: float('posZ').notNull(),
    transport: int('transport').default(0).notNull(),
});

```

The `id` would be a serial primary key for performance, while the `uild` would be for data integrity amoung multiple databases.
Next the `cid` would be a binary reference to the character data, and it should be an unique reference, thus a one-to-one instead of a one-to-many or many-to-one.
The `pos` of X,Y,Z would be the position of the character within the metaphysical world.
The transport being `0` would be fine for this instance.

I believe we could also set the world and plane, but I need to double check my notes to make sure I do this part right.

We do want the characters to be able to move between world and different planes of space, but getting the math and the data structure down can be a bit of a pain.

Thinking that through, it might make sense to create another table before we do the metaphysical table, with that table being the one that handles the worlds.

Considering that the worlds can have a set amount of planes, we might have to adjust for that as well within the world table.

This is the current worlds table:

```javascript

export const worlds = mysqlTable('worlds', {
    id: serial('id').primaryKey().notNull(),
    ulid: binary('ulid', { length: 16 }).unique().notNull(),
    name: varchar('name', { length: 255 }).notNull(),
    createdBy: varchar('createdBy', { length: 255 }).notNull(), // Could be 'player' or 'server'
    creatorId: binary('creatorId', { length: 16 }), // Nullable, references the user ID if created by a player
    description: varchar('description', { length: 255 }),
   });

```

Some changes that we can make would be the `ulid` column and maybe expanding the columns to include some additional information about the world?

So we can shift the ulid to `wid` , which would be a ulid but for the world id.

That means changing the `ulid: binary('ulid', { length: 16 }).unique().notNull(),` to:

`wid: binary('wid', { length: 16 }).unique().notNull(),`

and then updating the metaphysical table with a direct reference.

`wid: binary('wid', { length: 16 }).references(() => worlds.wid).notNull(),`

The cleaned up version of the worlds would be then:

```javascript

export const worlds = mysqlTable('worlds', {
    id: serial('id').primaryKey().notNull(),
    wid: binary('wid', { length: 16 }).unique().notNull(),
    name: varchar('name', { length: 255 }).notNull(),
    userid: binary('userid', { length: 16 }).notNull(),
    description: varchar('description', { length: 255 }).notNul(),
    dimensionality: int('dimensionality').default(3).notNull(),
   });

```

We can ommit the `complexDimensions: json('complexDimensions').notNull()` for a later time period.

Part of the reasoning for leaving the complex dimensions behind is because we need to test case the Unity build for Andorid / iOS via react native and see how far we can push the view screen.

We could include a `planes` for the complex structure, which would be something like this:

```javascript

export const planes = mysqlTable('planes', {
    id: serial('id').primaryKey().notNull(),
    wid: binary('wid', { length: 16 }).references(() => worlds.wid).unique().notNull(),
    hash: varchar('hash', { length: 255 }).notNull(),
})

```

Then have hash be an indrect reference to an outside reference of the planes. 

Like a crystal field theory, which is E = q1q2/r, base theory with extended d electron orbits.

Okay I am getting a bit side tracked with the planes within a metaphysical world, might be time to take a break.

Leaving the note off on Faith! It seems that I missed that one.

Spaceballs and getting some sleep is the plan for the rest of the night!

---
# February: 05

> Daily Log for February 5th for each year!

Source: https://kbve.com/journal/02-05/

import { Adsense } from '@/components/astropad';

## Notes

## 2025

### Markets

-	03:16PM

	Good to see Nvdia spike up and down!
	I am hoping that I can walk away with the put profits and also after next earnings, oh baby.

### Rust

-	01:43PM

	The goal right now is to optimize the hashmaps but I am just a bit worried that it might still have issues down the line.
	Here is to hoping that we will not have any major problems.

-	03:37PM

	The issue that we are facing is the refactoring of the buttons, I made the stupid mistake of not following the kiss standard.
	Keep it simple safe.
	My solution to the connecting and callable will be to create a signal helper function.
	
```rust

fn connect_button_signal(&self, button: &mut Gd<Button>, button_data: &MenuButtonData, parent_node: &Gd<Node>) {
    let callback = parent_node.callable(&button_data.callback);
    
    let params_variants: Vec<Variant> = button_data.params
        .iter()
        .map(|p| Variant::from(p.to_string()))
        .collect();

    if callback.is_valid() {
        if button.is_connected("pressed", &callback) {
            button.disconnect("pressed", &callback);
        }
        button.connect("pressed", &callback.bind(&params_variants));
    } else {
        godot_warn!("[Maiky] Invalid callable: {}", button_data.callback);
    }
}


```

	Actually, I am thinking maybe we could just include a chainable `with_callable` into the `ButtonExt`, so that we can just chain that dynamically anywhere we need it.

```rust

    fn with_callback(self, parent: &Gd<Node>, method: &str, params: &[Variant]) -> Self;


```
	Okay, this will make the most sense, let me loop back around and do that instead.

<Adsense />

### 2024

#### tables

Doing more table work today! Finally going to extend out the faith column for the character table.
I believe the faith system would provide an increase in lucy and a bonus amount of healing, there might be other ways that I can extend the trait.
I know in Runescape that this skill is basically called Prayer, so I will try to reference some of that within this trait.
We could call it fate but I think faith is more align to a trait that we would want in the character table.

Current table as of 9:40am today.

```javascript

export const characters = mysqlTable('characters', {
	id: serial('id').primaryKey().notNull(),
	cid: binary('cid', { length: 16}).unique().notNull(),
	userid: binary("userid", { length: 16}).references(() => users.userid).notNull(),
	hp: int('hp').default(0).notNull(),
	mp: int('mp').default(0).notNull(),
	ep: int('ep').default(0).notNull(),
	health: int('health').default(0).notNull(),
	mana: int('mana').default(0).notNull(),
	energy: int('energy').default(0).notNull(),
	armour: int('armour').default(0).notNull(),
	agility: int('agility').default(0).notNull(),
	strength: int('strength').default(0).notNull(),
	intelligence: int('intelligence').default(0).notNull(),
    name: varchar('name', { length: 255 }).notNull(),
    description: varchar('description', { length: 255 }).notNull(),
	experience: int('experience').default(0).notNull(),
    reputation: int('reputation').default(0).notNull(),
    faith: int('faith').default(0).notNull(), 
});


```

Adding faith with this line, as an int with default 0.
`faith: int('faith').default(0).notNull(),`

As for other attributes, we could include charisma, wisdom, luck, stamina, crafting, stealth, perception, ect...
But I think we could heave those as enchantments or external attributes that could be dependant based upon the situation that they are in.

Like luck can be part of faith, while wisdom can be part of intelligence and stealth can be a subset of agility.

An increase in perception could be a combination of faith and intelligence?

There are a couple ways we can cross reference the skills, plus we can create a new table that is falls under enchantments

Under the death timer, based upon the game, we can find ways to lower the exp and reputation of the user by having them face different style of puzzles.

Okay! We should look at shipping the new table into production and building out the basics of the character table.

In addition to building out the character, we should also include a character sheet that gets generated using the SVG concept that we were talking about earlier.

Final Table for execution:

```javascript

export const characters = mysqlTable('characters', {
	id: serial('id').primaryKey().notNull(),
	cid: binary('cid', { length: 16}).unique().notNull(),
	userid: binary("userid", { length: 16}).references(() => users.userid).notNull(),
	hp: int('hp').default(0).notNull(),
	mp: int('mp').default(0).notNull(),
	ep: int('ep').default(0).notNull(),
	health: int('health').default(0).notNull(),
	mana: int('mana').default(0).notNull(),
	energy: int('energy').default(0).notNull(),
	armour: int('armour').default(0).notNull(),
	agility: int('agility').default(0).notNull(),
	strength: int('strength').default(0).notNull(),
	intelligence: int('intelligence').default(0).notNull(),
    name: varchar('name', { length: 255 }).notNull(),
    description: varchar('description', { length: 255 }).notNull(),
	experience: int('experience').default(0).notNull(),
    reputation: int('reputation').default(0).notNull(),
	faith: int('faith').default(0).notNull()
}, (table) => {
	return {
		name_idx: uniqueIndex("name_idx").on(table.name),
	};
});

```

Going to run the command to generate the mysql table,

`pnpm drizzle-kit generate:mysql`.

Afterwards, going to deploy a `dev` branch inside of the database and add the table.

Looks like everything worked out! We have the character table now inside of the database!

#### SVG

After the work meeting and getting the basics out of the way, I decided to focus on the character sheet render and what an adventure.

It seems that using multiple layers for the SVG would be the best option and trying to position them for a generic character sheet, ugh I might have to think it through.

The current SVG is about 8.7MB, which is way too much for a simple sheet, thus I will have to scale it back down.
New plan would be to isolate the images that we would want for the character sheet and then call them directly as we put the sheet together.
Now I will shift gears and work on pulling the data out of the database and rendering the image, but before I do that, I need to push through the changes to the codebase.

#### State

Earlier in the `kbve` package, I started the new state that would hold the validator and the db pool, however to keep the rolling update concept going, I believe we will integrate this new state while keeping the older one.

Slowly we will shift the couple routes that we have, register, login, ect... to the new state, but before I do that, I want to make sure that the new state will work as intended.

There was the idea of also including the a channel system using crossbeam, but I will hold off on pushing through that update until I get some of the unity SOA out of the way.

Okay! the new validator builder would come from the `jedi` crate, which means I would have to include that crate inside of the `rust_api_profile`,

---
# February: 06

> Daily Log for February 6th for each year!

Source: https://kbve.com/journal/02-06/

import { Adsense } from '@/components/astropad';


## Notes

## 2025

### Markets

-   03:37PM

    With the president making sweeping orders and the short boom and bust cycles, it feels like just riding the waves has been the best appoarch.
    Nvidia climbing back up to pre-130, I am a bit excited to see where the stock will be after the earnings report in 3 weeks from now.

### Rust

-   04:09PM

    Updating the code again to include the `UserCache` and `GUI` modules, hopefully we can extend this all out before the end of this week.
    My goals are to continue to build around the core-gameplay and make it optimize, fast and interesting!

    **UserCache**
    
    The user-cache could be just an extension of our `ResourceCache` , but I am thinking that we want to include a way to save the settings.
    Thus it would make sense to isolate the user settings, such that, it will save the data locally on the machine.
    There were a couple additional things that I wanted to include in the user cache, but that will come after the gameplay.

    **Abstract**

    The next move would be to include an abstract map that will hold some of the user values.

### URF

-   07:19PM

    Taking a quick league break but eh, I find the ARURF to be just a bit too much.
    I think I am actually geting tired of league and it might be because of hardcore wow too.

### Quote

-   09:55PM

    `a weakness in cartography, a curse of homosexuality` - from Wes's movie, the French Dispatch and I was a bit confused?
    I thought about it and I think the joke is that they do not walk `straight`.

<Adsense />

## 2024

#### sheet

Spent majority of the day working out the kinks within the character sheet!
I was able to get the SVG generated with the basic dragon frame and general lines for the text.
Sadly a decent chunk of my time was then spent re-building the validator, which I had to change because the async + sync was breaking the builder during a shared state.

I spent a decent amount of time going through the validator concept and decided that it would be best to just create a whole new builder AsyncValidator, instead of having them shared as one instance.

This does mean that I have to go back and rebuild the new AsyncValidator but it will be worth it in the long run, since I will be placing those validators inside of the jedi crate, so I can re-use them for future applications.


#### WoW

Decided to run a quick couple levels on my new paladin, holyjedi, taking advantage of the 50% exp buff to level 25!
The leveling with the pally is really easy and this buff makes grinding almost painless, I been just hacking away on the side with my controller.

#### Bathroom

Ended up spending a couple hours on multiple trips to HomeDepot!
The first issue was a leak with the bathroom, but we were able to resolve that because it seemed to be caused by birds.
They had established a nest inside of the wall, ugh and damaged the vents and basically were the reason for the minor leaks.
The humidity was not able to escape since the vents were no longer functional, so the condense water vapor basically formed a pool of water for the birds?
I am not too sure exactly how it all went down, but these birds basically turned my guest bathroom into their own mini apartment.

---
# February: 07

> Daily Log for February 7th for each year!

Source: https://kbve.com/journal/02-07/

import { Adsense } from '@/components/astropad';



## Notes

## 2025

### Haircut

-   06:45PM

    I just got probably the best haircut ever, the fade is perfect.

<Adsense />


## 2024

#### git

There was some gc and lock corruption with my git instance, which really wasted a ton of my time!

The way that I resolved it was by running these commands below, as a reference for myself in the future, when my git objects get messed up again.

```shell

cd .git/refs/remotes/origin/
rm patch-atomic-kbve-validator-fix-02-06-2024-1707281479
git gc --prune=now

```

I did have to reset the branch via a hard reset too but lets just make sure everything is back to normal.
Going to push this through and hope that there are no issues with the pipeline.


#### sheet

I was able to finish the general character creation, which is basically inserting a generic character into the database.
Afterwards, I am pulling that same character by an internal character name and rendering the data into the sheet.
While the viewing of the character is done in a task style, I believe I might have to go back and do the character creation using that same spawn task style.
I have not yet checked the performance for the image but that will be something that I want to look into as I expand the image, maybe include more abstract data?

One of the ideas was to show the character sheet's inventory but that would be another query and I am not too sure if I want to do that yet.

#### JWT

Besides the generic character creation via a cookie session, in some cases, we can not store the cookie and need a way to create the character using a JWT.
Also need to add block control over the character creation.

Okay, so spawn blocking is around all the diesel mysql operatings within the character creation!
I also updated the validator, so that there would be a character limit in the general input, which we did at the regex level.
Now the next option would be to double check the base operations around the sheet generation.
I changed the query parameters to a path based, so that would be easier to unique generate character sheets, but I do need to finish adding more information onto the sheet, itself.

I still have not yet tackled the JWT character creation, which means that I have to create a new function around that too, because the parameters might be different, hmm.


#### DnD

Ah, time for Eves Guild DnD Campaign!
I did not get a chance to get any new gear but currently we are explorering the cave basement, sadly I am not oiled enough for this adventure.
Damn, the basement is wild, they are filled with fungus spiders, oh boi!
I wonder if I can turn into Spiderman?! Before I swing, I will have to yet "Turn me into SpiderMeme Already!"
Now I am thinking if the yeast from these fungal spiders would make some interesting wine.

---
# February: 08

> Daily Log for February 8th for each year!

Source: https://kbve.com/journal/02-08/

import { Adsense } from '@/components/astropad';


## Notes

## 2025

### Snow

-   09:04PM

    The snow is everywhere!
    I should prepare to clean it up but I am in the mood to just run a quick wow dung.

### RFC

-   09:07PM

    Time to run a quick RFC, maybe on my druid.

<Adsense />

## 2024

#### Unity

Going to expand out the custom unity framework's UserDataServices!
Since we are going with an extremely modular approach, with atomic changes, I will try to keep everything isolated as possible.
The last update to the UserDataService, the constructor was only keeping track of email, jwt, level and experience, which we are going to change up a bit.
We are going to drop the level as a field and replace it with reputation, hmm, I am going to also switch the experience from float to int.

Under the `Scripts/Services/UserDataService.cs` , the public interface of IUserDataService can be extended to include these three functions:
```c#

    void SetCharacterName(string characterName);
    void SetReputation(int level);
    void SetExperience(int experience);
    
```

And then we will go ahead and create these functions, to help set them with these functions:

```c#
 
public void SetCharacterName(string characterName)
    {
      if (_userData != null)
      {
        _userData.CharacterName = characterName;
      }
    }

public void SetReputation(int reputation)
    {
      if (_userData != null)
      {
        _userData.Reputation = reputation;

      }
    }

 public void SetExperience(int experience)
    {
      if (_userData != null)
      {
        _userData.Experience = experience;
      }

    }
```

They are extremely basic right now, I will implement a get/set constructor later on to wrap around them.
I will push this out as a patch and then go back and create a new `APIRequestService` to help handle some of the interactions! I know that I am basically going to have to rebuild and rewrite this again with the Steam package, but this is part of that learning experience.

#### API

The next shift will be to integrate the character list into the game, so that the player can pick the character that they would want to play on! Part of this game dynamic would be that the main account remains on the spaceship / guild ship as the captain and these characters would be part of the crew that they send down for the different missions. I am still working out the gameplay, but I figured that I would pivot and evolve it throughout my journey as a meme developer.

Let me start with creating the base of the APIRequestService! We already did the login system earlier and we can rewrite that as its own / new system. I was thinking it would make sense to keep them split because later on, I could implement a couple different shifts to the actual login system to include captchas or additional security measures. 

The base of the script would look like this:
```c#

using System;
using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

namespace KBVE.Services
{
   public class APIRequestService : MonoBehaviour
    {
    } 
}
```

I am keeping this in the notes as a base of reference for future services, the template is pretty straightforward but just incase I forget. It is a pain switching from different languages here and there.

To maintain a single source of truth, the JWT will come from the UserData service, so we will add this function:

```c#
    private string GetJwtToken()
    {
      var userDataService = Services.Instance.GetService<IUserDataService>();
      return userDataService?.GetToken();
    }

```

This part is important because we want to maintain that single source of truth integrity. We also do not want to store the JWT outside of the Unity aka inside of a javascript method, because it should safe inside of the WASM, whereas if its inside of the JS, there could be additional security issues that we would have to account for! The leaking of the JWT is rough but with a single source of truth, that should make it easier to maintain a decent level of security.

On a side note, for handling the websockets, we will probably not use this exact JWT but rather a unique session style, to at least keep the integrity from both server and client side. 

After building out the base of the APIRequestService, I am going to test that service against the character loadout scene. One of the downsides with this game is that there is a definitely way too much going on in the file structure, so I might have to wipe it clean when I do the RentEarth build and have a more uniform and clean version of the codebase. There are so many files, event systems and player scripts, it does get a bit confusing when I am calling the different ones here and there, but that is part of the thinking process, I suppose. 

Now the new scene that I created is called `CharacterSelection`, ugh wait, `CharacterScene` and that will be after the login is successful and we will create a new script called CharacterSelection.cs, which will pull the character data from the API and provide the characters as an option to play. I will keep this very basic from the start and will go back to add improvements as I build it out.
But wait, what is the game called? I am still thinking of just calling it RentEarth and moving past the name of the game because I do not really care what to call this meme project. I think it is far more important to get a functional game out into the world that people can play.

Since we created the new service, APIRequestService, we need to go ahead and register that inside of the BootUp script for our game engine. It will live in here until we have a universal game framework / manager that can handle all of service instances on our behalf.

#### Captain

The APIRequestService seems to be functional for the GET request test case, we were able to load the 3 demo characters that the account has within this test case. Now we need to wrap the JSON data that we are getting back as an inner object within the KBVE namespace. I am thinking that it would make sense to split up the `name` for this

---
# February: 09

> Daily Log for February 9th for each year!

Source: https://kbve.com/journal/02-09/

import { Adsense } from '@/components/astropad';

## Notes

## 2025

### SubFolders 

-   02:35PM

    Nx projects are a bit clustered into sub folders, they have to be adjusted to account for it.
    Issue ticket is [here](https://github.com/KBVE/kbve/issues/3863) to help us keep track.
    During this migration of sub-folders, we might have some applications and scripts break, so we need to be careful.

-   05:36PM

    Having the group structure will make it easier to keep certain projects together.
    I made the mistake of not doing this earlier, but it will definitely help keep things organized for the future as well.

```shell
pnpm nx g move --project rust_api_profile --destination apps/kbve/rust_api_profile --skipFormat=true

```

    Moved the `rust_api_profile`, which should be fine for now!
    Let me go ahead and move the kanban next afterwards.

```shell
pnpm nx g move --project rust_kanban --destination apps/kbve/rust_kanban --skipFormat=true
pnpm nx g move --project rust_rareicon_gameserver --destination apps/rareicon/rust_rareicon_gameserver --skipFormat=true
pnpm nx g move --project next-itch-fishchip --destination apps/gamejam/next-itch-fishchip --skipFormat=true
pnpm nx g move --project saber --destination apps/gamejam/saber --skipFormat=true

pnpm nx g move --project react-phaser-fish-chip --destination apps/gamejam/react-phaser-fish-chip --skipFormat=true
pnpm nx g move --project react-phaser-travelbox --destination apps/gamejam/react-phaser-travelbox --skipFormat=true
pnpm nx g move --project cryptothrone.com --destination apps/gamejam/cryptothrone.com --skipFormat=true

```

<Adsense />
## 2024

#### Character

Within the unity game, aka rentearth, I need to figure out a way to manage the characters.
I am thinking of at least building out the basic and generic placeholders for those actions?
After I get those placeholders done, I can always go back and fix them up to be more accurate to the user experience and interface.
So we can throw out the color schemes, effects, sounds, ect.. for the time being and just focus on the general flow of these actions.

The first action would be to create a new character, afterwards we need to build a function that would handle the loading and displaying of the characters.
I will try to avoid doing the character deleting until the end, we want to make sure that there are a decent number of saftey nets in place to avoid having the character deleted by accident.

Actually I think we should move the character deleting to the website, this should be something that involves extra steps, just to make sure that the player does not accidentally mess it up.

The current error that I am running into is this:

```txt

MissingComponentException: There is no 'RectTransform' attached to the "CharacterButton(Clone)" game object, but a script is trying to access it.
You probably need to add a RectTransform to the game object "CharacterButton(Clone)". Or your script needs to check if the component is attached before using it.

```

It seems that the object does not have a RectTransform attached, going to check the prefab.

Ugh now I am getting this error!

```txt

Prefab mismatch: The instance of type Transform in the scene is referencing a corresponding source object of type RectTransform in the Prefab.
Fixing by replacing Transform with RectTransform. Some references might be lost.

```

I hate having to use a GUI to make buttons, it feels so counter productive for my brain.
The error was because the prefab was loaded under the MainCamera

Oh man, I had to work through a decent amount of UI/UX errors, but I am getting a better understanding of how the UI system works!
This was another case of me not understanding some of the RectTransform and the general depths of customization that can be done, but its part of the learning system.

I should try to build the error system to be a bit more standard, however that might have to be done during the v3 of the API, since I am still building out the different aspects.

---
# February: 10

> Daily Log for February 10th for each year!

Source: https://kbve.com/journal/02-10/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### Main

-   02:53AM

    During the migration of the subfolders, it seems that the build locations have also shifted a tadbit.
    This means that I will have to double check each execution within all the ci pipeline yamls.
    I believe the `dist` will now be under the `apps` but we shall see during the next main build. 

### Migrations Nx SubFolders

-   03:49AM

    Next batch of migrations!
    Moving CityVote into its own repo, then adding the deprecated folder.

```shell
pnpm nx g move --project expo-cityvote --destination apps/cityvote/expo-cityvote --skipFormat=true
```

-   06:05AM

    Migrating `rust_godot` to rentearth subfolder.

```shell
pnpm nx g move --project rust_godot_towerdefense --destination apps/rentearth/rust_godot_towerdefense --skipFormat=true
```

-   05:44PM

    Finishing the cryptothrone migration, now we need to add the `deprecated` folder, for apps that we need to remove.
    Later on, I will go back in and make adjustments to them.
    Next, we can move the pydiscord into the discord sub folder, furthermore, we can add the front end into that folder too.

```shell
pnpm nx g move --project rust_p16_gameserver --destination apps/experimental/rust_p16_gameserver --skipFormat=true
pnpm nx g move --project expo-lcagents --destination apps/experimental/expo-lcagents --skipFormat=true
pnpm nx g move --project expo-hqplan --destination apps/experimental/expo-hqplan --skipFormat=true
pnpm nx g move --project rust_wasm_embed --destination apps/experimental/rust_wasm_embed --skipFormat=true

```


## 2024

#### Astro

Going to take a quick break from Unity and work on the AstroVE backlog!
There are a couple components that I was missing, which I need to add, migrate and test case.
I wanted to isolate some of the basic game engine from YoRHa proof of concept and turn it into an AstroVE component.
Furthermore, I wanted to migrate over the visual novel codebase and turn that into another AstroVE component.
Finally, the biggest problem that I would have to resolve is the KBVE.com launch under the mono-repo, which is going to be a pain.



#### Bevy

While I am working on the website, I am also reading up on the bevy game engine and its integration with the egui.
My plan is to eventually move away from Unity and venture into bevy, but given that bevy is still under active development and not at a stable release, it would make sense to limit my exposure.

---
# February: 11

> Daily Log for February 11th for each year!

Source: https://kbve.com/journal/02-11/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### Migrations Nx SubFolders

-   12:37AM

    The shell command to start moving the discord software into the subfolder.

```shell
pnpm nx g move --project pydiscordsh --destination apps/discord/pydiscordsh --skipFormat=true
```

    For Atlas and Fudster, I am thinking that we need to rework those as well?
    We could place them into their own category for now too, hmm.

-   02:14AM

    Next up will be the herbmail subfolder, which will just hold the astro files for now.

```shell
pnpm nx g move --project herbmail.com --destination apps/herbmail/herbmail.com --skipFormat=true
```

    Okay needed to adjust the tailwindcss because its pulling from the shadcn package that we had.

    That leaves the atlas and the fudster project, both we can keep in the apps for now and come back around with those later on.
    Okay! Migrations are complete , let me close that ticket out for now.
    Opps, forgot to update the cargo.toml for the workspace changes.

### Clock Extension for GoDot

-   02:33AM

    Clocks aka Timers are a bit of an issue right now with our godot extension?
    I am thinking that there might be a race condition, where the timer is not yet added into the scene before it gets triggered.

### Markets

-   03:27PM

    Good to see Nvida come back up to the $130 mark and very nice to see $TSLA back down to the $330 mark.
    I am hoping that tesla goes back under the $300 mark, making it a great time to pick up a couple more shares.
    Yet I really want to offload my nvidia at around $150, so maybe getting a point inbetween both of them would be great.

### GoDot WSL Test After Migration

-   05:25PM

    Parts of the monorepo are a bit broken since we did the subfolder migrations, mainly because the paths have changed.
    Some of the locations are still hard coded, so just need to scope them all out and make the adjustments.

### ClockMaster + Timer Extension Merge

-   07:24PM

    I made a mistake by splitting these into two different files, we will merge the `clockmaster_extension.rs` into the `timer_extension.rs`.
    Then from the `timer_extension.rs`, we can just import the `Clockmaster`.
    Dropping the `ensure` function from the `TimerExt` and removing the whole `ClockMasterEx`!

    To keep track of this change, inside of the `pub trait TimerExt`, we are removing this function:

```rust

  fn ensure_timer(base: &mut Gd<Node>, key: &GString, wait_time: f64) -> Gd<Timer>;

  // Which References this impl TimerExt

  fn ensure_timer(base: &mut Gd<Node>, key: &GString, wait_time: f64) -> Gd<Timer> {
    let timer_key = format!("Timer_{}", key);

    let mut timer = if let Some(mut existing_timer) = base.try_get_node_as::<Timer>(timer_key.as_str()) {
      existing_timer.stop();
      existing_timer.set_wait_time(wait_time);
      existing_timer
    } else {
      let mut new_timer = Timer::new_alloc()
        .with_name(&timer_key)
        .with_one_shot(true)
        .with_wait_time(wait_time)
        .with_autostart(true);

      base.add_child(&new_timer.clone().upcast::<Node>());
      godot_print!("[TimerExt] Added new timer: {}", timer_key);
      new_timer
    };

    if !timer.is_connected("timeout", &base.callable("hide_avatar_message")) {
      timer.connect("timeout", &base.callable("hide_avatar_message").bind(&[key.to_variant()]));
    }

    godot_print!("[TimerExt] Timer '{}' started with wait_time: {}", timer_key, wait_time);

    timer
  }

```

    Then, we are going to remove the `ClockMasterExt` trait, as we will shift the focus towards the `ClockMaster`.
    One of the things that will make this a bit different than a `ClockManager`, will be that it has a bit more scope creep than a traditional manager.
    The biggest challenge will be to maintain both async and sync with the timers, while avoiding race conditions and mutex guard issues.

```rust


pub trait ClockMasterExt {
  fn get_or_create_timer(&mut self, key: &str, wait_time: f64) -> Gd<Timer>;
  fn remove_timer(&mut self, key: &str);
}

impl ClockMasterExt for Gd<Node> {
  fn get_or_create_timer(&mut self, key: &str, wait_time: f64) -> Gd<Timer> {
    let timer_key = GString::from(key);

    if let Some(timer) = self.try_get_node_as::<Timer>(timer_key.as_str()) {
      let mut existing_timer = timer.clone();
      existing_timer.stop();
      existing_timer.set_wait_time(wait_time);
      existing_timer.call_deferred("start", &[]);
      return existing_timer;
    }

    let mut new_timer = Timer::new_alloc();
    new_timer.set_name(timer_key.as_str());
    new_timer.set_wait_time(wait_time);
    new_timer.set_one_shot(true);

    self.add_child(new_timer.clone().upcast::<Node>());

    new_timer.call_deferred("start", &[]);

    godot_print!("[ClockMasterExt] Timer '{}' created with wait_time: {}", key, wait_time);

    new_timer
  }

  fn remove_timer(&mut self, key: &str) {
    let timer_key = GString::from(key);
    if let Some(timer) = self.try_get_node_as::<Timer>(timer_key.as_str()) {
      let mut timer = timer.clone();
      timer.queue_free();
      godot_print!("[ClockMasterExt] Timer '{}' removed.", key);
    }
  }
}

```

    Now we can create the `ClockMaster`, which will be pased upon the `GodotClass`.
    Three issues that I see with the clockmaster, as of right now, are the timeouts, destruction and resuability.
    Timeouts should keep the timer in the cache but simply mark it as inactive; the timer should remain in the cache so it can be reused later.
    Destroying the timer should remove the timer from both the cache and the Godot scene when executed.
    Resuable timers should restart but there might be a part where the godot might remove it?
    Race condition for the timer was not an issue with the wasm but it was on the mac.

## 2024

The characters might have issues with multi-worlds and cause issues if they are being played oln multiple worlds/game sessions, so we need a way to lock them out to prevent this from occuring.

#### StartZone

Going to clone over the Scene1 and call it StartZone, here I want to test case a couple different concepts that I had in my mind, including a Game Manger and the combat engine.
I am thinking that the GameManger and Combat both would be internal engines but with the combat engine extending out to a combat service, which would then be handling combat events?
The game manager would just be incharge of loading and unloading the scene cameras for now? This is still a bit of a hazy area since I am trying to go for a SOA/Events style system but I need to remember that I am limited to just a single thread.
We could have the game manager also push some of the messages to javascript via a post message, but offloading to javascript would mean that the game might have issues in an mobile build.
Sometimes these things can be a pain to map out, because of the WASM limits, ugh.
I am still going to think it through in small steps and maybe it will come together near the end, I guess that is part of the course.

The first step would be to clone the `Scene1.unity` to `StartZone.unity` and then add it into the build order.

Going back to the character scene, I would then adjust the buttons for the characters, one with an open sheet and another button to load the character into the StartZone.

For the sake of simplicty, I should work out the locations of the characters and make sure that they do not get loaded into multiple worlds?

Maybe make sure that once the character is done from the mission, there would be a timer that would prevent the character from going onto the same mission again?

I still need to work out the kinks of how I would approach this problem, but for now, I will just skip it and leave this as a note!

#### KBVE

While I am working on the Unity front, I also wanted to go over the website design, I am thinking of a black, grey, sky blue style for the KBVE website.
It would mean leaving the orange, pink and purple color style but I think it might be a better move down the line?
I am not an amazing ux designer but I am thinking the tri-color scheme that I had earlier was a bit too much for the website and I think going a bit back to a monotone would make it easier.

#### Namecheap

Need to setup time to migrate all my domains out of namecheap and to CloudFlare!
I will start with the base domains that I currently am using and I will let some of them expire because the cost basis might be too high.

#### Weather

While working on the KBVE namespace and migrating some of the older code, I am looking into how to expand the code base to include some additional features.
One of the features that I wanted to include was a weather system, including a way handle it globally but for now, I think a simple day and night cycle is enough.
My concern would be about running the internal clock, which I should migrate into a tick system?

Here is the current clockbased weather formula:

```c#


  float angle = (currentTimeOfDay * 360f) - 90f; // Shift by -90 degrees to start at dawn
      directionalLight.transform.localRotation = Quaternion.Euler(angle, -30f, 0f);

      if (currentTimeOfDay <= 0.25f || currentTimeOfDay >= 0.75f)
      {
        //  ? Night Light
        directionalLight.color = Color.Lerp(
          Color.blue,
          Color.black,
          Mathf.Abs(currentTimeOfDay - 0.75f) * 4f
        );
        directionalLight.intensity = Mathf.Lerp(
          0.1f,
          0.5f,
          Mathf.Sin(currentTimeOfDay * 2 * Mathf.PI)
        );
      }
      else
      {
        //  ? Day Light
        directionalLight.color = Color.Lerp(
          Color.yellow,
          Color.white,
          Mathf.Abs(currentTimeOfDay - 0.5f) * 4f
        );
        directionalLight.intensity = Mathf.Lerp(
          0.5f,
          1f,
          Mathf.Sin(currentTimeOfDay * 2 * Mathf.PI)
        );
      }

```

However, I think for the performance of the game, we need to rewrite some of it to use the tick system instead.

---
# February: 12

> Daily Log for February 12th for each year!

Source: https://kbve.com/journal/02-12/

import { Adsense } from "@/components/astropad";

## Notes

## 2025

### Market Trump Tar-Rifts

-   03:56PM

    The term that would best describe these tariffs, aka `tar-rifts`, where they are just a tool to cause chaos.

### Cache Manager

-   04:21PM

    The `CacheManager` would be structured similar to our other node-base, with the focus of moving the `ResourceCache` out of the Maiky and into this manager.
    I am wondering if the ShaderCache could just be broken down and turned into a shader manager, hmm.

    This is what I am thinking the basic structure would look:

```rust

#[derive(GodotClass)]
#[class(base = Node)]
pub struct CacheManager {
    base: Base<Node>,
    texture_cache: ResourceCache<Texture2D>,
    canvas_layer_cache: ResourceCache<CanvasLayer>,
    ui_cache: ResourceCache<Control>,
    audio_cache: ResourceCache<AudioStream>,
    shader_cache: Option<Gd<ShaderCache>>,
}

```

-   06:38PM

    To test the windows build, we will be using this command:

```shell

./kbve.sh -nx rust_godot_towerdefense:build-windows

```

    Keeping this in the notes, so that I can switch over to it easily.


### FoodShoppin

-   06:27PM

    Just came back from food shipping and picked up two boxes of the most fire / epic mangoes!
    These mangoes seem to come from Peru and have the perfect balance of sweetness and juice.
    Anyhow, back to the grind I go.


-   08:01PM

    Took some of the fresh green peppers and tomatoes, made a ramen soup that felt so delicious!
    For the green peppers, I boiled half of them with the water and then quickly grilled the other half, giving a wombo combo type effect to that veggie.

### MusicManager with CacheManager

-   08:06PM

    After making sure the new CacheManager compiles, the music.rs file can be the first to test it out.
    In the file, we can drop the `effect_cache` and `sfx_cache`, since both them will be just stored inside of the `AudioStream` cache.
    Before in the `music.rs`:

```rust
  // New Audio Cache!
  audio_cache: ResourceCache<AudioStream>,

  // Dropping these:
  effect_cache: HashMap<String, Gd<AudioStream>>,
  sfx_cache: HashMap<String, Gd<AudioStream>>,

  // Side-Note: These HashMaps were from the std::collections::Hashmap, which we are also dropping because of the mutex concerns.

  // ++ Future Update

  // Dropping these

  global_music_volume: f32,
  global_effects_volume: f32,
  global_sfx_volume: f32,

  // During the init() or ready(), we will link the CacheManager from the GameManager but while we have that ref, we can also link the pointer to the UserDataCache.

```

    This gives us the read-heavy hashmap as a reference and makes it easier to continue down the path of multi-threading.
    Okay, so drop those two maps and then pull in the CacheManager into the MusicManger, but only once upon the `init` or `ready` function.
    Since the CacheManager gets built inside of the GameManager, we can reference it from the parent, just like how we are doing it in Maiky.
    Right when we grab the GameManager aka its parent, we can also grab the `UserDataCache` because we will need that for the user's control of audio.

    Then the final volume value will just come from the `UserDataCache`, acting as a source of truth for it all.
    In the future, we could also scope extend out into the supabase integration, allowing the user to cross-platform save their settings BUT I feel like that is an over reach.
    We really have no reason to save data like that, but it makes sense to maybe have it so that certain core features do get saved in a remote database.

    Oh boi, I was wrong, it seems that it would make more sense to just reference the GameManager, then use that reference to grab the `CacheManager` and the `UserDataCache`.
    That makes more sense, hmm, we are splitting the UserDataCache and the CacheManager, one concern that I had was what if we also move the UserDataCache into the CacheManager but its not worth it.
    As of right now, we have three different `cache` systems in play, one is for the static objects that we will hold in the `CacheManager`, then we have the `UserDataCache`, which is for the user-data, this will have some changes and here and there.
    Finally the 3rd instance of a `cache` is through the ClockMaster aka the timer.

    Making some progress on this front, migrated the `music.rs` into the `managers` module as `music_manager`.
    I did not get a chance to drop the globals yet, I will have to loop back around to handling those once I get the audio moved over.

```rust
// Raw GD Function - Proof of Concept

#[func]
pub fn insert_into_audio_cache(&self, key: GString, audio_stream: Gd<AudioStream>) {
    self.audio_cache.insert(&key.to_string(), audio_stream); // Key -> to_string -> to_str
}

```

    Well, hmm, wait, since its already a `ResourceCache<T>` and we are calling this all within the Rust logic, we could just skip the `#func` creation and handle it all internally through rust.
    Granted, having the helper functions there would make it easier on the GDScript side to interact with the audio files, but for now, we should just focus on the Rust-internal code.
    This is because if we need to change anything, then we would have to also make sure that the `#func` have to be changed too, thus, we wait until a standard is built around it.
    All of the moving of files is getting a bit confusing for me to keep track of. 

## 2024

### Unity

After finishing up my morning work session, I am going to continue working on my the unity game! Ugh character selection and the character handler, oh boy.

This is how our Engine Initalizer looks right now:

```c#

using KBVE.Services;
using UnityEngine;

namespace KBVE.Engine
{
  public class EngineInitializer : MonoBehaviour
  {
    void Awake()
    {
      InitializeServices();
    }

    private void InitializeServices()
    {
      DontDestroyOnLoad(gameObject);

      var servicesInstance = KBVE.Services.Services.Instance;

      //  Register AuthenticationService
      var authService = gameObject.AddComponent<AuthenticationService>();
      servicesInstance.RegisterService<IAuthenticationService>(authService);

      //  Register SceneLoaderService
      var sceneLoaderService = gameObject.AddComponent<SceneLoaderService>();
      servicesInstance.RegisterService<ISceneLoaderService>(sceneLoaderService);

      //  Register UserDataService
      var userDataService = gameObject.AddComponent<UserDataService>();
      servicesInstance.RegisterService<IUserDataService>(userDataService);

      //  Register APIRequestService
      var apiService = gameObject.AddComponent<APIRequestService>();
      servicesInstance.RegisterService<IAPIRequestService>(apiService);

      //  Register CameraService
      var cameraService = gameObject.AddComponent<CameraService>();
      servicesInstance.RegisterService<ICameraService>(cameraService);

      //  Register Weather
      var weatherService = gameObject.AddComponent<WeatherService>();
      servicesInstance.RegisterService<IWeatherService>(weatherService);
    }
  }
}

```

The current design plan is a hybrid of service oriented architecture and event driven architecture.
We split the two types into different namespaces, `KBVE.Services` and `KBVE.Events`, SOA vs EDA!

To add a service on the Initalizer, we just throw in these two lines, for example adding the Entity Service.

```c#

  //  Register EntityService
  var entityService = gameObject.AddComponent<EntityService>();
  servicesInstance.RegisterService<IEntityService>(entityService);

```

Next we need to register the clock service, which will represent the global tick.


```c#

  //  Register ClockService
  var clockService = gameObject.AddComponent<ClockService>();
  servicesInstance.RegisterService<IClockService>(clockService);
```

I believe we have enough of the base services to move forward with the StartZone!

Before I get started on the next update, I want to make sure everything builds and that the rolling updates via the cicd pipeline works.
We will move everything up from the `alpha` branch to the `beta` branch, after it builds, we can then shift it up to `main` for a release.

Over the weekend, I was trying to test case multi agents working on the repo, there were some minor issues regarding them not isolating the changes and throwing a ton of git diffs.
Uhh, long story short, either I need to find a way to resolve the git cherry picks OR really isolate the agents on where they can work, which needs to be done automatically as well.

I am thinking that we we could also move the `KBVE` namespace into its own nuget package and then call it within our application, but that will be for a later time.

The character section could be split into a couple different components, hmm, thinking it through, it might make more sense

### AutoReview

During the pipeline roll out, it seems that the auto review passed on 3 of the test cases but faild on the remaining 7.

I actually think the failure in the test case was on my end, I need to adjust the test casing again, which will be easier with finish products to test against.

<Adsense />

---
# February: 13

> Daily Log for February 13th for each year!

Source: https://kbve.com/journal/02-13/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### n8n

-   02:09AM

    Need to prepare the supabase n8n edge runtimes but I been way too swamped.
    I can get that understanding of being so far behind, that it makes more sense to outsource more of the work.

### Nx 20.4

-   04:58AM

    The morning sun is about to rise and I went off tangent really quick but got some work done.
    Upgraded the Monorepo to Nx v20.4.3 and finally upgraded to the latest Astro v5.x!
    The biggest issue was getting the vite v6 support out there and operational, which the latest nx/vite supports.

-   03:08PM

    The migration works fine on the mac but now its time to test it on the WSL instance.
    Besides updating the pnpm, I need to remember to delete the `node_modules` folder and run a fresh install.

### pnpm v10

-   03:08PM

    Updating the pnpm to v10.30.

### CI - Astro v5

-   03:10PM

    The migration to Astro v5 has just one small issue, its the playwrite that needs to be installed before deployment / build.
    Need to make sure that will not be a problem on my WSL instance.
    I believe the playwrite is used to generate the mermaid graphs.

```shell 

    pnpm exec playwright install

```

    If the error comes up, it does warn us in the terminal.
    I went ahead and updated the `package.json` to include the post install of it.

### Godot User Data v0

-   05:19PM

    Testing the loading of the user data, it seems to crash the whole application, so I will have to figure out why.

```shell

./kbve.sh -nx rust_godot_towerdefense:build-windows

```

## 2024

#### Windows

It might be time to switch the build process towards focusing on the Steam and Windows build for the unity game!
While I did enjoy some of the WebGL/WASM process, I think for the sake of time, I am go ing to push forward the steam build, as it is over due.

I am not going to drop the WASM/WebGL build completely but I will come back to it later on, when there is abetter WebGPU support.

Since we are going to use Unity DOTs, which does not build to WebGL, so we have to change that to `StandaloneWindows64`.

That means editing the pipeline, `ci-alpha`, and comment out all the `WebGL`.

While I am testing the build pipeline, I am going to add the `Toon RP` as a render engine because it would help resolve some of the style issues that I was having earlier.

I made a mistake when doing the branches, I ended up doing a bit too many changes within just one branch, so I need to scale it back and rebuild the changes independantly.

Under the branch 697, https://github.com/KBVE/kbve/pull/697/files, or patch atomic unity saber render engine 02 13 2024, the idea was to change the pipeline for a custom toon one but I feel like that might cause some problems with the way we are building this application.

The inital toon shader was under the `toon-rp` package but I think it would make sense to look for a new cell shader that would work with the universal pipeline because then having it work across multiple devices will not be an issue.

Now the best way to handle this would be to look through the docs and notes, and seeing if we can reference another shader, or... worse comes to worse, we would have to build our own custom shader.

---
# February: 14

> Daily Log for February 14th for each year!

Source: https://kbve.com/journal/02-14/

import { Adsense } from '@/components/astropad';

## Notes

## 2025

### Dat Nightly Flow

-   01:06AM

    New day, new memes!
    Time to see how we go about grabbing that data from the user settings and rendering it.


### Markets

-   04:04PM

    Good to see Nvdia go up towards the $140 mark, I am hoping that it crosses back into the $150 after the earnings.

### Godot GUIy

-   04:21PM

    GUI Management has this painful peroid, where everything just looks terrible at first.
    Getting the shader to work right, then all of the position issues, ugh, makes me miss tailwind and tamagui way too much.

### GameJam 2025.1

-   04:41PM

    The topic for the Brackeys 13 aka 2025.1 gamejam was announced!
    It seems to be `ERASE` with a couple wild cards, `MIMIC`, `STYLE SHIFT`, and `SHOPAHOLIC`.
    Let me update the notes for the game to reflect that.

<Adsense />

## 2024

#### Toon

Round 2! Fight!

I am going to try and see if I can get the official unity toon shader to load up and maybe attempt to integrate it into this game project!

The goal would be to get a comical style within the game objects and the environment, but we shall see how it goes!

Okay we were able to get the basics of the cell shader to be functional, granted there is an experimental packages warning that appears.

Here is the official repo for the toonshader that we are using, aka Unity Chan, https://github.com/Unity-Technologies/com.unity.toonshader

I will push through these changes, then mess around with the sample scenes.

Okay it looks like we can disable the Itch build for now because it will keep failing, since we need to figure out how to load abstract assets.

So for now, the best step would be to setup the unity build condition, which I will place inside of the `ci-alpha`.

Here is `setup` configuration under the `ci-alpha.yml`,

```yaml

        setup:
            name: "Setup"
            runs-on: ubuntu-latest
            outputs:
              build_unity: ${{ steps.set_output.outputs.build_unity }}
            steps:
              - id: set_output
                run: "::set-output name=build_unity::false"

```

Then I will extend the condition for the saber build, `if: needs.alter.outputs.saber == 'true' && needs.setup.outputs.build_unity == 'true'`, which will help prevent the build fails that we will be facing.

---
# February: 15

> Daily Log for February 15th for each year!

Source: https://kbve.com/journal/02-15/

import { Adsense } from '@/components/astropad';

## Notes

## 2025

### MacOS Guards

-   04:58PM

    I feel bad that I forgot I could just rewrite the ffi module imports as a target grouped guard.
    The way that we would do it is like this below, rather than having to place the target line-by-line.

```rust

#[cfg(target_os = "macos")]
mod my_mod_name {


}

```
    Going from one language to another to another is getting a bit annoying.
    Hopefully we do not have to do any javascript today and just get the web browser imported and ready.

### American Gangster

-   11:30PM

    Just finished the whole 3 hour long movie and it is a straight 7 out of 10.
    The movie was filled with so much information, I am going to have a rewatch of it again after I finish all of the Wire.
    Each part of the film introduces a complex short story that could be adapted into its own film, like an onion, layers upon layers of detail.

### Godot Wry Windows

-   11:37PM

    As engaging as the film was, half my brain was looped into the unsafe wry world of browsers.
    This upcoming push will aim to have both a Windows and MacOS native browser that I plan to utilize for a customish webview.
    For linux, I am not too sure what the best option would be for this time period and the WASM builds will just be using Javascript FFI.
    Speaking of which, I have to loop back around and fix the unity javascript ffi too, ugh. 

## 2024

### Trees

Spent a bit of time building the tree cel shader!

There are a couple steps that I am learning about, including the materials, image formats and how to apply them to different objects.

Right now the bigger issue is figuring out the base three colors for the leaves and the bark.

### Pipeline

I am going to reactive the pipeline because it seems that our art style and the models that we would be using are smaller than what I expected.

The plan was to disable the alpha builds while we get the annex up and running but if the models are small enough, I think we can get creative enough with the tools that we have.

I suppose we shall see once we build out a couple levels.

The way to active the build would be to set the conditional line / variable to true.

```yaml

run: "::set-output name=build_unity::true"

```

This line will be our switch, so let us test it out!

Okay it seemed to be an error, let me try to run a bash shell to set the output?

```yaml

jobs:
        setup:
            name: "Setup"
            runs-on: ubuntu-latest
            outputs:
              build_unity: ${{ steps.set_output.outputs.build_unity }}
            steps:
              - id: set_output
                shell: bash
                run: |
                    echo "build_unity=true" >> $GITHUB_OUTPUT

```

We still need to test this pipeline but I also need to push through the remaining models.

### GitLab

I decided to begin building out a hybrid gitlab, one that will be hosted on gitlab.com directly, just incase we run into an issue with Github, and then another repo that will be our private one.

The goal of having additional repo locations is to avoid any issue with github, ideally making it so that the cicd pipeline is git agnostic.

The private gitlab instance could be a docker instance or a kubernetes setup, I am not too sure yet but I will write out a couple plans that we can use.

<Adsense />

---
# February: 16

> Daily Log for February 16th for each year!

Source: https://kbve.com/journal/02-16/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### GameJam

-   04:54PM

    A terrible mistake was made, I mixed the game jams up between the Godot Wild and Nothing Can Go Wrong. 
    Now I will have to find a way to build the game using both themes, hmm.
    The only thing that keeps coming to me my head is a chess-like game.

### TowerDefense WebView Wry

-   06:21PM

    While I should be preparing for the gamejam, I been stuck on this windows webview bug and its been getting super annoying!
    This feeling is terrible because it works fine on mac and I was really hoping that it be the other way around.

-   08:26PM

    Slowly breaking each part of the function down and it seems that the borrowing of the window handler is giving us some issues.
    Seeing the words window and handle over and over is going to cause my brain to explode.
    Turns out the issue was that webview requires additional linking in a gnu dll target, ugh.

## 2024

### Journal

I am going to test case the new renders of the journal entries within the migrated kbve.com.

The color scheme is already making the text a bit hard to read but I suppose keeping the default white font is the best move, then adding a couple hues of blue.

The next question that I have in my mind is how would I go about doing the color gradients?

The color palette that I am thinking might look something like this:

Main Color , base cyan
- Hex: `#91ffff`
- RGB: `(145,255,255)`

Additional colors
- Hex: `#08a4a7	(8,164,167)`
- Hex: `#e9ffff	(233,255,255)`
- Hex: `#4dfed1	(77,254,209)`
- Hex: `#0bdbb6	(11,219,182)`

These are not the final colors but give us a bit of range to understand how it would look.

We do need to create a new logo around these colors as well, which I will assign to an agent.


### Security

There are some older journal notes for security, we have to migrate them over to the new monorepo.

The two subjects as of right now are just `xss` and `firewall`, but we could include some additional subjects?

I think an entry for auth should be included as a future aspect, including how to handle jwt, password reset and 2fa.

---
# February: 17

> Daily Log for February 17th for each year!

Source: https://kbve.com/journal/02-17/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### Godot Wry Build

-   03:50AM

    Ended up staying up way too late at night trying to figure out the build situation.
    Sleepless nights, and there are two more routes that we can take. 
    First would be to have github actions build the rust dll using the msvc target, while the second choice would be to use a docker image to do it.

### Wry Resize

-   03:56AM

    Now the wry window does not resize everytime we change the screen size, that will be next to resolve.

### CI Rust MSVC

-   04:48PM

    Github action runner for the rust dll had some outdated actions, going to update them.
    In addition to the version change, the notes in the `rust` section should be updated to reflect it.

-   08:39PM

    Updating the MSVC github action again, the most recent issue was that we forgot to include the nightly as a rust-src.
    This next update will include and I will adjust the path for upload to be exactly where the DLL is exported.

-   10:07PM
    
    The rust dll build went as planned, it was definitely smaller too compared to the gnu build.
    That means we can continue the production of the extension, yet I should create a cycle where it automatically updates the extensions on our behalf.
    Point of climax here will be once we get more git automation running within our repo, I am going to be super excited to see that level of looping.

### Jedi - User Agents

-   05:14PM

    New issue ticket for the jedi crate, the goal being that it would provide a custom user agent upon requested.
    Example of a user agent string:
    `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36`.
    The goal would be to generate a couple of these that would be cross platform and easy for us to use in the future.
    I suppose we could also make this a typescript library too, for client side generation.

### Brackeys13

-   09:23PM

    Preparing the HTML export for the gamejam, we should not be too far from getting the rest of the pipeline going.
    Next we need to figure out how to handle the UIUX for the game, this time keeping it all within gdscript.


## 2024

### Snow

The late winter has stuck once more!
I actually enjoy the late night snow because it creates such an amazing white morning, seeing everything under a blank of snow.

### Drawer

Okay! For the new menu, we want to have multiple drawers that open on the right side of the website with slots to help control the data that gets render inside of them.

There are a couple different ways that I am thinking we could do it but we will start with the flowbite user interface because we have the library already setup.

I might also try to include a R3F version but that might end up becoming way too large.

Got the right side of the drawer to be functional, now I need to adjust how it would look by utilizing the tailwindcss configuration.
My first through process would be to just assign basic hex codes for the different tailwindcss variables, however I am also thinking of extending out the dynamic coloring option, but what would be the best way to handle that?

I also added a simple dynamic id system and simple text naming scheme.

```js


// Helper Function for replacing Hyphens and the word Drawer
function replaceHyphensWithSpaces(inputString: string) {
  return inputString.replace(/-/g, ' ').replace(/drawer\s?/gi, '');
}

let idText: string = 'PlaceHolder';

// Check if `id` is not provided or is an empty string
if (!id) {
    console.warn('Warning: The "id" prop is missing or empty when calling the Astro Flowbite Right Component.');
} else {
    idText = replaceHyphensWithSpaces(id);
}

```

This will help with making sure the id prop is passed and also let us create a dynamic `idText` from the same id that gets passed.

For the background color, I am thinking of just passing through the `kbve-menu-bg` variable, but this means that the component will not have dynamic light and dark mode.

We could resolve that right now by adding an additional property that gets passed, for this concept we could call it a `dyn` boolean, which would enable a couple types of dynamics.

Let me update the `Props` to pass in the dynamic boolean, 

```ts

export interface Props {
    id?: string;
	img?: string;
    dyn?: boolean;
}

const { img, id, dyn = false } = Astro.props;

```

Afterwards, we will have to add in a helper function to handle the dynamic colors for the form. 

There are a couple options we could include but I think we can isolate it just within this component, rather than creating more sub-libraries.

We want to adjust the SVG colors, using a primary color and we should include a dynmaic class incase we want to alter the color of the svg using javascript.

There will be two more tailwindcss variables that we will be using, `kbve-svg-primary` and then for the dynmaic variable, just adding dyn to the end, `kbve-svg-primary-dyn`.

Going to run a quick health check on the two projects that are using the Astro VE, which can be done by this command:

```shell

./kbve.sh -nx kbve.com:build
./kbve.sh -nx herbmail.com:build

```

I did notice the build throw a working with the `register` variable inside of the svelte file, `Register.svelte`, but I will go back and address that issue once I get the base of the form done.

### slots

We will go ahead and remove some of the default flowbite data that is provided by the example and place a couple slots within the drawer, which will hold the content that we want to display.

Oh wait, before I add the slots, we need to make sure that the text is also base and dynamic, similar to how we did the `bg` and `svg`.

Slot breakdown:

- after-description
- after-footer
- after-footer-button

### Style

I am going to create a style interface that I will be call

### Windows

For future reference, incase you need access to the Windows screen during setup, post install, press `Shift + F10` to open the command prompt, then Type `OOBE\BypassNRO` and press Enter.

---
# February: 18

> Daily Log for February 18th for each year!

Source: https://kbve.com/journal/02-18/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## Quote

```

3rd world problem - Damn ,the electricity is out.
1st world problem - Damn, my internet is slow.
0 world problem - Damn, I am using 8gb of ram in WSL
imaginary world problem - Damn, these reusable workflows on the cloud vm are so slow.

```

## 2025

### Markets

### CICD Reusables

-   05:38PM

    Pipes were broken, but not because of the cold but rather test casing the resuable workflows.
    One of my bad habits is going out of scope during a gamejam, but its also where I find new solutions to non-existent problems.
    Best to call it imgainary world problems, since its not a first world nor a zero world problem, its further backwards.
    The `utils-file-alterations.yml` seems like its good to go for testing, will push that all the way to main and see what happens with it.

-   06:09PM

    Next, the focus was getting the `utils-godot-itch-build-pipeline.yml`, which is another reusable workflow that I plan to call during this gamejam.
    Eventually the goal will be to make this monorepo super modular and easy to build out even faster, there might be a point where we can go from concept to full startup in less than 48 hours.

-   11:58PM

    To test the reusable workflow, we would call it under the `jobs` like this:

```yaml

jobs:
  trigger-godot-build:
    uses: KBVE/kbve/.github/workflows/utils-godot-itch-build-pipeline.yml@main
    with:
      branch: "dev"
      deploy_to_itch: true
      godot_version: "4.3"
      export_name: "TowerDef"
      project_path: "./apps/rust_godot_towerdefense/godot"
      build_artifact_name: "towerdefense_web_build"
      itch_username: "kbve"
      itch_gameid: "tower-defense"
    secrets:
      butler_api: ${{ secrets.ITCH_API }}


```

    However, I will do this tomorrow, after I finish up the core player script and the movement.

### B13

-   06:58PM

    Starting the base foundation for the brackeys game jam, this time around, we will stick with the basic gdscript and avoid calling the rust code until later on.
    Once the base game is playable and generic gameloop is done, then we can shift some of the logic over to the rust side.
    Under the `scenes` folder, we will try to build the game around just a single scene and rotate out the canvas and ui between the different game modes.
    Next, we want to link the `game` to the `project.godot`.

## 2024

### Style

The current plan is to build out a KBVEStyleSheet, which will nest our static and dynamic tailwindcss configurations.
I will try to keep this as vanilla js as possible, so that it can be called and used with any library.
This should make it easier for us to style our website and rotate out the colors as we wish.

```ts
export const style = new KBVEStyleManager();
export const dyn_style = new DynamicKBVEStyleManager();
```

These will be the two main source of truths for our style sheets.

Let me boot up the dev build using the nx command, `./kbve.sh -nx kbve.com:dev`, which runs the localhost version of the website on port 3000.

While I am fixing up the dynamic styles, I will continue to work on the curves.

The styles class looks good, going to update it and include the documentation, jsdocs, comments, ect... so that we can now utilize it across the AstroVE library.

Let me go ahead and generated the markdown for the code as well.

---

#### KBVE Style Management Library

The KBVE Style Management Library provides a TypeScript-based framework for managing and applying dynamic styles within applications. It leverages interfaces and classes to create a flexible system for handling style variables and their transformations.

#### Interfaces

#### `IKBVEStyleSheet`

Represents the base contract for a style sheet within the KBVE framework, defining how style variables can be retrieved and manipulated.

- **Methods:**
  - `getVariable(name: string, dyn?: boolean): IVariableProcessor`: Retrieves a variable processor for the specified variable name. Optionally, a dynamic flag (`dyn`) can be specified to modify the variable name retrieval process.

#### `IVariableProcessor`

Defines the operations that can be performed on a style variable.

- **Properties:**
  - `variable: string`: The current value of the style variable.
- **Methods:**
  - `getText(): string`: Returns the textual representation of the variable.
  - `setTransparent(percentage: number): IVariableProcessor`: Modifies the variable to apply a transparency based on the specified percentage and returns the processor for chaining.

#### Classes

#### `KBVEStyleManager`

Implements `IKBVEStyleSheet`, providing the core functionality for managing style variables.

- **Private Properties:**
  - `variables: { [key: string]: string }`: A key-value store of style variable names to their corresponding values.
- **Public Methods:**
  - `getVariable(name: string, dyn: boolean = false)`: Implements the interface method to retrieve and process style variables.
- **Private Methods:**
  - `replaceHyphensWithSpaces(inputString: string)`: Utility method for formatting variable names.
  - `applyTransparency(variable: string, percentage: number)`: Applies transparency to a variable based on a given percentage.

#### `DynamicKBVEStyleManager`

Extends `KBVEStyleManager` to override the `getVariable` method, enabling automatic dynamic variable processing.

- **Public Methods:**
  - `getVariable(name: string)`: Overrides the parent method to always retrieve variables in their dynamic form.

#### Exported Instances

- `style`: An instance of `KBVEStyleManager` for default style management.
- `dynStyle`: An instance of `DynamicKBVEStyleManager` for dynamic style management.

This library offers a structured approach to handling styles, allowing for both static and dynamic manipulation of style variables. Its architecture facilitates easy integration and extension within TypeScript applications.


---

#### RSPS

Going to assign a couple small goals for the Atlas library, this includes setting up the bezier curves, an automated browser window and building out the base levels of robo movements.

Before I set the goal for something too large, I think it would make sense to focus on smaller goals for the library.

The three small tasks that I have assigned to weaver are:

-   Bezier Curves. [721](https://github.com/KBVE/kbve/issues/721)
-   Selenium Integration via an interface. [723](https://github.com/KBVE/kbve/issues/723)
-   BlueStacks Integration via an interface. [724](https://github.com/KBVE/kbve/issues/724)

For the Bezier curves, we want to aim for them to be as human like as possible.


#### Aside

Since we finished up the base style manager, I want to extend it out for the aside menu and maybe style up the options for each of those options.

Well besides adding the `aside`, I am thinking of adding an additional `SWIPE` menu that we would call on the bottom.

The current issue with the aside menu is the color scheme is not yet matching what we are aiming for, hopefully we can resolve that by tonight.

---
# February: 19

> Daily Log for February 19th for each year!

Source: https://kbve.com/journal/02-19/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### B13 Global Resources

-   04:45PM

    The global resources will be held under a singleton that will make it easier to call anywhere within the application.
    By moving all our variables into there, we can use them in both the asteroid scene and also call them in the UI.

-   06:24PM

    The Omniscope will be where the weapons are fired off from and a node called `Projectiles` will hold the different bullets and lasers that get fired off.

-   09:13PM

    Took some time to add in the projectile pooling but I am glad that it worked out!
    There are still some issues with the signals, hmm, it might be because they have not fully clicked.
    Events are always a black magic for my brain.



## 2024

### Flex

The flex box for the frontpage should work on various platforms but I need to make sure that it would display them in a neat and responsive order.
One of the ways that I was thinking of handling this would be to use flex with flex-wrap, the good old flexbox approach.

I also need to make sure that the WASM will work on the main website, which is another adventure that I need to plan out.

Hopefully we can get this all resovled within this week!

The current solution to the flex box would be something like this:

```html

    <div
        class="h-full w-full items-start justify-start rounded-tl flex flex-wrap gap-4 overflow-y-scroll content-start p-3 ">
            <span>Content</span>
    </div>

```
The flex, flex-wrap and content-start help align all the `section` containers within the flexbox and it seems to be responsive!

Now I want to see how it will work with different size cards and if it can fit them in without any issues.

For testing the flexbox, I am going to create some placeholder elements and see how they would render within the box.
The first filler component is the `hero.astro`, which will be a generic hero element.




### VM

The Windows machine needed a quick restart but we were able to get the sound up and running!
Good work fudster on finding the patch!
Now there are some issues with the audio, including the decoding and the feedback is scratching or skipping.

---
# February: 20

> Daily Log for February 20th for each year!

Source: https://kbve.com/journal/02-20/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

Testing out the journal entries for 2024!

I will have to make this section a bit more unique later on but for now it seems great.

## 2025

### Post Office

-   04:30PM

    Had to quickly run to the post office and make a money order but now I am thinking about it.
    Could we deposit those money orders through a mobile app? 
    Hmm, I am going to do a bit more research on it, because it feels annoying at first but as I am selling stuff, I need a way to handle the money.
    I rather not have to count the cash.

### HUD

-   08:57PM

    Updated the icons for the HUD and now we have two major parts to finish up for tonight.
    The first will be the game's background and the second will be saving the games state.
    Hmm, let me break down the order of things that need to be done.
    
    -   Game's background.
    -   Saving and loading of the player stats.
    -   Replacing the spaceship sprite.
    -   Fixing the asteroid splitting and replacing those assets with better ones.



## 2024

### NX

I spent a decent amount of time rebuilding the NX Smartrepo pipeline, we were able to get updated to version 18 but it seems that the Rust plugin was throwing errors.
We had to downgrade the Rust plugin from the version of 1.3.3 back to version 1.2.X, which was able to then build and run without any problems.
The plugin upgrade was causing a null point error within nodejs, thus causing the whole pipeline to break!
It seems that I can never get away from null point errors, even in RUST! just kidding, it was all nodejs bullypoopy.


### KBVE

Going to update the template a bit more while the pipelines are building.

Added a dual layer to the footer, so that there is a static one at the bottom with more information and a floating footer that provides the legal information.

Next component to add into the template is the MDX hero that we had in the older KBVE.com repo.
Maybe I should rewrite it again, because it seems to be the common thing that I been doing throughout this whole project.

I decided to make an extraction engine that would help with the default information!
There are a couple things that I still need to resolve but this should help with creating abstracted content throughout the application.


### PackageHell

It seems that I had entered package hell because of the amount of dependencies were all over the place, some of them not published, causing a weird vendor loop.

Nx Graph kept looking for version 0.1.2 of `holy` but the workspace had a version of 0.1.3, which caused a weird bug in the graphing system.

We will downgrade the Rust NX integration back to a working state for now, so we can move on.


### RustWASM

Running the Rust WASM is currently with this command:

-   `./kbve.sh -nx rust_wasm_embed:trunkserve`

I already updated the ReadMe with the command, incase I forget in the future!


## Quote

> Love does not consist of gazing at each other, but in looking together in the same direction.
> — <cite>Antoine de Saint-Exupéry</cite>



## Tasks

- [X] Application MDX Migration

---
# February: 21

> Daily Log for February 21st for each year!

Source: https://kbve.com/journal/02-21/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes


## 2025

### GameJam B13

-   07:45AM

    The brackeys 13 gamejam has been a blast, finally got a better understanding of the godot signals and the way to handle the 2D animations.
    However the UI/UX has been crazy, there have been some interesting aspects but also super confusion, some parts of the UI have been driving me crazy.

-   11:40AM

    Exhaust has been done, now I need to make some updates on how to call it without it affecting the shield.
    

## 2024


### Tickets

I feel like a ticket system works well when keeping track of the conflicts, bugs, upgrades, but no one seems to really answer them.
However, I should just keep to myself and continue to answer tickets, even if it means that I am talking to myself? I feel like the premise of the tickets are just to cover yourself.

I should look further into developing out the AI ticket response system but that is still way down the pipeline.


### NVDA

It will be an interesting earnings call, I am hoping that it wont fall under `$650` but I also do not need it to really go past a `$850`.
The market will swing any away, we shall see!
The whole tech market might even shift based upon the


### NX

The pipeline froze a bit earlier during the dev cycle, I believe it might have been because of too many changes before the actions would settle.
I will try to think of a better system to handle the pull and merge requests, ideally one that can help automate the code review to a certain aspect.


### WASM

We were able to get the WASM embed to push into two different folders, one for HerbMail.com, which is a placeholder for the public facing test case.
The other one that I added today is for the next KBVE.com release, both of which are done via NX and a custom shell script.

Now the next issue would be to update the `wasm.md` to either a new `wasm.mdx` or something unique for the tool.
However I am thinking of isolating the tools to their own custom astro file.

This will just make the process of building the tools out easier for other websites too.


### RSPS

Decided to pickup another account for our adventures! Obviously I will not include the name but we shall see how far we can get with this!

I think if we plan around it and make sure everything works, then we should not have any major issues. Let us see how everything plays out over time.

---
# February: 22

> Daily Log for February 22nd for each year!

Source: https://kbve.com/journal/02-22/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### URF

-   12:43AM

    Another quick URF game before going back into the programming eco-system.
    
### B13

-   12:45AM

    The next update that I want to make would be for the heat management.

-   06:13AM

    To increase the speed of the animation, we have to adjust the `scale_speed` , which is set to a default of 1.
    The asteroid explosion felt a bit too slow, so we will double it.
    As for the short exhaust, we can go ahead and quad truple it.

-   09:19PM

    We are running the clock down for this submission!
    Got about less than 9 hours until submission is closed, hopefully we can get some of the core gameplay loop out of the way.

## 2024


### ClockWork

I am looking for another device that is a bit open source and is handheld!

It would also not have an x86 but an ARM, so that I could test case egui applications on an arm chipset / deployment. 

Granted I do have my mac m1 but I was hoping to have another linux device, probably an ARM ubuntu device, that I could do development work on while I am traveling or outside of my man cave.


### Date

The journal entries had to have a time of `12:00:00` because during the parsing, I was getting some wild timezone errors because of it.
The other option was trying to find a way to slip time into the entries but I figured that would cause problems in the future.

So it should be noted that we need to make sure that time is included in the date!

However, I know myself, I will forget to do that often, oh well.



### DND

Time for a DND session!
Today we are going to untap the wine barrel and maybe go into the sewer tunnels.

I been thinking of a new DnD homebrew item, called Odins Necklace, which would give +1/+2 AC but it would automatically lower my initiative rolls by -3 or -5.
This necklace is based upon the Cloak of Protection but I am thinking it would make sense to focus on building the paladin out to be tanky but less focus on damage. 

I am here to tank but also not die lmao.


### Comic

After the DND session, I decided to take a break on the flexbox and focus on the grid system within CSS.

To get a bit better at understanding and using the grid system, I decided it would make sense to look into a comic book style design pattern.

Thankfully GPT and Google were filled with examples and concepts, of which, I decided to translate them from the generic CSS and into a tailwindcss style.

There are some other plans that I have with the comics but I will keep them in the back burner for now.

---
# February: 23

> Daily Log for February 23rd for each year!

Source: https://kbve.com/journal/02-23/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### B13

-   12:09AM

    The gamejam is about to end and we have 6 hours until it ends!
    Sadly, I am thinking we will not be able to hit it before it ends, ugh but we are getting better at it.
    Hopefully the next gamejam, we will be better prepared for it.

### B13 Save Deferred.

-   12:22AM

    To help with performance, I am going to shift the auto-save from 30 seconds to 60 seconds.
    Furthermore, I will move it into a call deferred, so that it will not be called during the main physics loop.

### B13 Earth

-   12:34AM

    The Earth planet should spawn in at 0,0 and if any ship comes near the planet, it will show the interaction menu.
    If the player hits the interaction menu, then it will open it up for them to see.

### B13 UIUX 

-   02:17AM

    Since we only have 4 hours until the jam comes to an end, I will hold off on the v2 upgrades!
    We can shift focus after the jam ends to looking at the Q crate and come back around to updating this game later on.
    There might be issues that come with this game but we can just move past it all, half the team just left.
    Next jam, I am going to have to find better mates, maybe work around it a bit more too.
    Shifting the focus for all of v2 until after the jam ends and taking it out of the repo.

### B13 Over

-   07:38PM

    We finished up the gamejam, it was a great run and I definitely learned a bunch.
    It sucks that we had some guys just bail out and but hey, it is what it is.
    Next months jam should be shorter and easier, I hope xD.
    1 jam a month.

### Start Q

-   07:43PM

    The Q Crate will be where we hold all our godot and bevy modules, with the goal of being able to quickly reuse them in future gamejams.

## 2024

### Expo

After playing around with expo a couple times throughout my life, back in the painful days and recently with an older rentearth application, I decided to pull the trigger and integrate the expo into the NX.
The NX integration is on my plate for this weekend, but there are a couple things that I know will cause issues, like making sure the iOS and Android pipeline work for a generic application.
Then after making sure that they work for a barebone html app, the real challenge will arise... which is getting the WASM embed that we made earlier to load into iOS and Android.

I will have to keep some distance with expo because I do not want to waste a bunch of time debugging random bugs over and over.

Preparing the tamagui install, we need two npm packages, the first is the core tamagui and the second is the tamagui/config.

For the custom configuration, we will extend out the tamagui config file and add our own little twists.

Since I want to test iOS deployment as the first test case, rather than web, it would make sense for me to do this on the m1 macbook.

We will split up the branch and run `pnpm install tamagui @tamagui/config`.

Going to run a quick nx report, making sure everything is within the green before moving on.

Now I am going back to the old RentEarth repo and going to review the code that I wrote earlier, getting a bit refresher on the syntax.


### Tickets

I will try to work around the Github tickets again, at least to keep track of the changes within the monorepo!

I am doing a solid job of keeping track of the issue tickets at work but I should not be lazy, ugh becoming complacent is a terrible thing to break out of.

The loop of doing nothing!

Okay we got 6 new tickets onto the board, hopefully we can hit around 50 by the end of this month!

### Pipeline

Lets test out the pipeline for the KBVE.com build and have it push the code out into another repo!
Just like how we are building the herbmail.com, we are basically swapping out the variables with kbve.com, thus making this process easier than I expected.

Under the `ci-main.yml` , we will extend the build and deployment, by copying over the two actions and switching the variables.

* **Action One** - Build the application using NX, since we already have that setup, while I am writing this out, I am going to test case it.

* **Action Two** - Deploy the source code. We will push the `/dist/` code from `dist/apps/kbve.com` to the `kbve/kbve.com` repo and under the docs folder.

We will have it push the `dev` branch but my concern might be that it will fail because there is no `docs` folder. Now there are two options that I am thinking through, should I run the action knowing that it will fail because the `docs` folder is not there? OR should I resolve that future problem now.

Ideally we want to run the action and have it fail at that error point, then go in and resolve it from that error point; the error point is a bit of a foresight and a good spot to have it fail at.

Eh, actually I will just quickly create a patch to resolve this issue before we run into it. 
The patch for `kbve/kbve.com` is `adding docs`, which just creates the `docs` folder and places the a simple `README.md` into the location.
I could have place a `.gitkeep` as well but that is a different story.


### Parrot

The way that I am thinking of setting up the Parrot discord music bot would be to first review over the code that is involved with running the bot.
Going through each of the file and getting a solid understanding of what it all dones.

The best part of this exercise is that I will get better at building discord bots and rust!

---
# February: 24

> The 24th of February! What a wild unity day this was!
So much unity, that it united my sanity, insanity, insomnia to create sanitia; it can be described like inverse pokemon evolution but for your mind and soul.

Source: https://kbve.com/journal/02-24/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes


## 2025

### Expo

-   12:30AM

    Taking a quick break from Godot and switching over to Expo!
    The first thing will be to update to the latest tamagui and making sure expo, itself, is up to date.
    The application that we will be testing is `./kbve.sh -nx expo-lcagents:run-ios` and going through all the debugs.

-   10:13PM

    There are 3 major bugs that I been trying to resolve this past day, ugh, its been an adventure down the realm of guess and check.
    Console error is the `React.jsx` type is invalid -- expect a string (for built-in componenets) or a class/function (for composite componets) but got: undefined.
    The Error: Element type is invalid: expected a string , ect...
    Finally the 3rd issue is most likey to be the same concept.

-   10:27PM

    Testing the build out with these commands on repeat.

```shell 

pnpm install --no-frozen-lockfile
pnpm nx prebuild expo-cityvote
pnpm nx start expo-cityvote --clear
npx expo-doctor

```

    Next we need run these commands over whenever there are might be issues.


## 2024


### Camera

The main focus today will be to extend out the camera service within the Unity game engine!
The Camera Service is extremely important throughout the game and making sure we have a solid foundation around this camera system will make all future projects easier.

The plan is to slowly add more functions and features within the service, while trying our best to maintain a level of backwards compatibility.

We know that there would be a `main` camera and then virtual cameras that are controlled through the cinemachine.


### Plugins

The next aspect of the project would be to add plugins that the game would use during the build.

I added a new repo for the private plugins, to avoid having them leak out to the public or break any contract!

This repo will be `https://github.com/KBVE/unity-plugins-rentearth` and while it is private, I will only keep the plugins that we really need inside of it.

There will be two plugins that I would like to add:

OneJS - To make the UI easier to build out! I am getting tired of writing the UI within C# or Unity, this will just make it easier.
Gaia - This is our environmental handler and terrain manager!

After we get these two plugins operational, it should help make the game easier to build out!

Got damn! The first plugin was already 500 files+! We will zip those up and prepare to upload them to private repo.

Well, here I thought that 500 was a lot, but now I am looking at over 7000+ files from just the world builder, this is going to be an interesting build process.

After getting all the plugins loaded onto the private repo, we would have to test the private build process and make sure that everything runs smooth!

We could actually have the steam demo ready by the end of this month, I can see the light! Yay!

Let us review the changes, starting with the manifest.json, where we added two unity packages.

- Burst - `com.unity.burst` - This is a new compiler, we will need this in the future for dots / ecs.
- Mathematics - `com.unity.mathematics` - We can not get far without math.

Then we can overlook the lock file and `PackageMangerSettings`, leaving the `ProjectSettings` file, which just adds some additional library functions during the build process.

With all this setup, now we need maintain the files in another repo or private storage, the joys.

I been slowly migrating all the files, about 7000+ and its becoming a bit of a pain, however we are getting there. 

This should resolve all our environmental and UI issues, thus only leaving us with the character itself.

The final hurdle will be getting these assets into the repo:

- Trees
- Ground Textures
- Flora
- Flowers
- Terrain
- Stones
- Plants
- Particles

I lied, the real problem was getting two DDLs to be adding into the repo, since they are both over 100MB in size.
I am thinking about all the possible options that we could do to resolve it and it does feel a bit annoying that we are being held back by storage issues in 2024.

This means that I might just look into the Azure DevOps a bit further, ugh.


### Aceternity

Well it looksa like I might have to rethink my component library within the Astro VE!
I was looking to build my own custom astro library, but after looking at aceternity ui, it would make sense for me to also just integrate the library directly!

---
# February: 25

> The 25th of February!
Time to build the modules within modules.

Source: https://kbve.com/journal/02-25/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes


## 2025

### Init NativeWind

-   05:33PM

    Going to take a break from the tamagui and see if I can get nativewind running without any major issues.
    I will start by installing the base package and then loop back around and delete the tamagui for now.
    To get the ball rolling, we will do the basic `pnpm install nativewind`.

    After installing the nativewind, the next stage would be to setup Metro using the exisiting `metro.config.js`.
    For that we will be importing:

```ts

const { withNativeWind } = require('nativewind/metro');

const customConfig = withNativeWind({..._default});

```

    That is the sudo code that we would be using for wrapping around our withNativeWind.
    I wonder if the order of metro configurations might have been a problem with tamagui, but that is for a future problem for me to experiment around with.

### User Profile Update

-   05:38PM

    While I am installing and set

## 2024


### Git

Part 2 of the Git plan! We went ahead and setup a private repo with the source code for a couple plugins, however we need to make sure we can use them inside our unity editor.
The next stage would be to setup the script commands for setting up the sub module.

Lets start with at least setting up the variables. Wait before we do that , we need to setup a ULID for the shell file.

```shell


# Function to add optional submodule
addOptionalSubmodule() {
    local SUBMODULE_PATH=$1
    local SUBMODULE_URL=$2

    # Check if the necessary arguments are provided
    if [ -z "$SUBMODULE_PATH" ] || [ -z "$SUBMODULE_URL" ]; then
        echo "Error: Missing required arguments. You must provide both a submodule path and a submodule URL."
        exit 1
    fi

    # Check if the submodule directory already exists
    if [ ! -d "$SUBMODULE_PATH" ]; then
        echo "Adding optional submodule..."
        git submodule add $SUBMODULE_URL $SUBMODULE_PATH
        echo "$SUBMODULE_PATH" >> .gitignore
    else
        echo "Submodule already exists."
    fi

    # Deduplicate .gitignore entries
    awk '!seen[$0]++' .gitignore > temp && mv temp .gitignore
}

```

This is the basic function that will handle the git submodule setup.
We want this to be optional and not have it affect the whole repo, definitely when cloning it from one area to another.

Then we run another command to place the DLLs during the build process!

Let me update the last part of the journal and then merge the patches.



---


### Azure

The GIT LFS limit is around 250GB on Azure, thus we can place all of the RentEarth codebase with the plugins inside of a private Git LFS?

If the build does not work through Github actions, we can work around using the `git lfs` from Azure devops as a backup plan.

For the `git lfs`, we need a solid unity git attributes, here is the one that I am adding in.

Here is the [location of gist](https://gist.github.com/Srfigie/77b5c15bc5eb61733a74d34d10b3ed87) for `.gitattributes` when using Unity LFS.

I might come back and shrink this down but for now this should help a ton with the storage and handling of the complex files.


---


### JS

During the migration of the UI/UX, we need to keep track of the different watch commands.

I am just going to use this entry to help keep track.

```shell
npx tailwindcss -i ./input.css -o ./output.css --watch
```

---
# February: 26

> The 26th of February!
Time to build the modules within modules.

Source: https://kbve.com/journal/02-26/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### Android SDK

-   04:00PM

    Trying to setup the android sdk again on my WSL instance!
    This should not be so useless and painful in the year of 2025.

-   05:52PM

    The error that I am facing right now is:

    ```

    Error: spawn /mnt/c/Users/Kbvec/AppData/Local/Android/Sdk/platform-tools/adb ENOENT

    ```

    After fixing the android path, so maybe its a tool issue?

### File Watch Error

-   07:24PM

    There was a minor issue with the webpack watching way too many files, I am going to adjust the ignore and maybe that will help with th performance 
    I went ahead and updated the settings for the vscode as well, to ignore some of the node_module folders too.
    Hopefully this will resolve the massive amount of files that are being watched for no reason.

### Monorepo TSConfig.json

-   11:40PM
    
    The current tsconfig is not excluding some of the builds and files, I will have to go through and see what the issue is.
    All of this is causing the WSL's file watcher to become way too resource heavy, ugh.
    I am 100% positive that I am forgetting something, its bound to be simple too.

## 2024


### Git

Going to build out another repo for the unity game!
The current issue that I am facing is within the LFS.

```

Use `git lfs logs last` to view the log.
error: external filter 'git-lfs filter-process' failed
fatal: Assets/X/X/X/X/X.png: smudge filter lfs failed
warning: Clone succeeded, but checkout failed.
You can inspect what was checked out with 'git status'
and retry with 'git restore --source=HEAD :/'

```

In this case, I am going to reclone the LFS and build it from scratch.
If everything works out, then I will place the objects into a new repo.


### HellDiver

Taking a quick break from the Unity development and trying out the new hell diver 2 video game.

---
# February: 27

> The 27th of February!
HDRP or as I like to call it, render engine hellscape!
From the sky to water to the lands.

Source: https://kbve.com/journal/02-27/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### EXPO NativeWind

-   11:30AM

    After spending all that time, it turns out the main enemy was Nx!
    There is an open issue ticket in the Nx repo about how metro is causing problems with NativeWind but I am a bit more happy that I was able to figure it out.
    Nothing feels better than finding out that a dev tool is the cause of all your pain, definitely in the year of 2025.

-   12:29PM

    Huge thanks to [Zack](https://github.com/zackdotcomputer) for providing a working Nx Metro configuration!
    Going to test it out now and see if it solves a couple of the issues that I am facing with NativeWind.

### NVIDIA

-   09:45AM

    Was expecting Nvidia to shoot up, I guess I will keep the call premiums and let it rip.
    The $150 mark seems to be worthless now, maybe we can let it sit until next week and push new calls out.

-   12:25PM

    Brutal $125, if it drops under $120 again, then I will throw some puts up and collect that premium.

### EXPO Library

-   10:10PM

    Time to rewrite the `expo-bbq` but this time for the nativewind build!
    

## 2024

### Gaia

I cleaned up a large chunk of the rentearth repo and now I am currently updating the components within the game engine.
It does feel a bit weird to merge five different games into one final game but everything was modular and it would be like a modular style game?

This might not work as planned but I want to give it a shot, hell it be worth it if I can just get some base demo or proof of concept out there.

The main issue right now is updating Gaia to 2023, which is causing a ton of nullpoint errors! The red text is just across my screen, nonstop xD
This updated package will make adding environmental / terrain easier, as well as, managing the different biomes.

After we get this plugin updated, I will have to loop back to updating all the scenes where we use it.


### Website

While I am building the unity project, I am also using the macbook to build out the final apsects of the website.

We added a couple additional libraries but need to load them via components.

I took some time to write out the different components that we need to add into the AstroVE, basically isolating all of aceternity ui library into the astro ve.

After we wrap around those, we can expand them again after call the Astro VE directly!

There might be a bit of a downside to this approach because we have to be careful on how we handle abstract colors for different websites and themes, but I think we can figure that out as we build it out.

---
# February: 28

> The 28th of February, 75% chance its the last day of the month.

Source: https://kbve.com/journal/02-28/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### EXPO HQPLAN

-   05:25AM

    Getting the hang of expo again, before I dive deeper, I need to make sure the library is also connected and we get reusable components.
    The current command to run the expo project.

```shell
pnpm nx start expo-hqplan --clear
```
    Next, we will need to setup the nativewind library that we will be building off of.
    Instead of `@kbve/nativewind`, we might go with a bit of `expo-nativewind` instead or `nativewind-utils`, hmm.
    `windy`, or `expo-wind` both get the point across but I will stick with windy for now.

## 2024


### Work

There is a new in house engine that I been messing around with! 

At first I was under the impression it was just another basic llm but its actually a solid image analysis tool!

It takes the image, does optimizations and then automatically slices the image based upon what it detects, furthermore it can work on PDFs and videos.

I can already see how useful this would be for CCTV style security setups, because it can easily slice up humans on the camera, timestamp them and split up video into different formats.


### Phaser

Going to expand out the engine aspect of the Astro VE!

I will try to load a couple popular engines, so that we can call them without any issues.


### DnD

DnD Night! I believe it is time for the CIA to appear, hehehe.

We are doing wine tasting and mini gala style event in Eve's bar tonight, I am already wondering what type of situation would be created.

We got introduced to several different clans and companies that operate within the universe, with a bunch of them being very interesting.

I should look into making the comics during the sessions, preparing for a couple panels and writing it out. Ah wait, even as I am writing, these backstories are wild.

---
# February: 29

> Daily at Feb 29th! Rare Day in History!

Source: https://kbve.com/journal/02-29/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

This day does not exist. IT IS A NULL DAY! w00t!

## 2024

### Unity

We were able to get Gaia Pro migrated to version 2023 and now I am taking a quick break from that and finishing up the website.
For the remaining aspect of the Unity project, I will create a couple different issue tickets.
The biggest issue will be setting up the player to leave the vehicle and enter it again, this could be done via an action?
We could have an embark action that would handle the entering and leaving of the said state.


### Website

Adding astro search bar to the website!

We can at least disable parts of it before making it production ready.

### Search

The component that we want to work on today would be the search integration, which we have done in the past with the main KBVE.com website!

Part of this feature would be to integrate different search options into our engine, then work on how we want to render the results.
I was thinking we could make this dynamic but for now, I will focus on making it static and getting it out the door before coming back to it for another rewrite.

Replacing the color schemes to match with the rest of the website and then I can work on the rendering of the results next.

It seems that the Astro VE is throwing some typescript errors, so I will update the `tsconfig` and set `"jsx": "preserve",` , which should help avoid those errors.

---
# March: 01

> March 1st - Q1 is nearing!
The last month before we hit the end of the first quater.

Source: https://kbve.com/journal/03-01/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### Null Day

-   12:24AM

    After celerbrating null day, which occurs whenever we dont have a 29th of Feb but need to keep our notes in line xD.
    I will keep it updated and use it for just general testing in the future, I suppose.

### Q Crate Migrations

-   12:03PM

    Moving the manager modules over and then going to run the updated build.
    We should not have any major issues with this next crate build, but I am not too sure.
    Ugh, we will also have to clean up some of the extra imports that we are not using too.
    For building the application, we will be doing this command:

```shell

./kbve.sh -nx q:build-mac

```
    That is specifically for the mac builds.

## 2024


### Q1

There were a decent amount of changes that I wanted to implement within the first quater of the year.
Getting everything out into the public eco-system is always a bit painful because there will always be minor problems, that hold everything back.
I suppose that is part of the job, even a small issue like file storage or hard drive failure can send everything into a mess.



### Unity

We had to wipe the repo because it seems that nothing was saved to the LFS storage, causing a massive object-key problem between my windows and macbook.
I am under the impression that I might have messed up the `CRLF` and the way the line breaks are being handled by the two different operating systems.

One day, I hope windows just adopts the unix standard and we can all move on from this mess, maybe like a `Windows 20` update that just puts WSL deep into the windows integration. 
Like a combination of AtlasOS, Ubuntu and Windows to produce a master class operating system! One day we will get there, it is just a matter of time and how far the sticks are up the `micro@$$` execs. 

Okay so we are going to wipe all the repos clean once more and start again from the basics.
Setting up git lfs and making sure everything is running smoothly as possible, I transfered over the basics, like `gitattributes`, `README`, `gitignore`, `Packages` and now I am handling the hardest one of them... the damn `Assets` folder.
The most painful thing about this is making sure everything gets transfered over without any issues but I have to split them all up, as if anything becomes too big than we get failures across the board.

During the asset transfer, there are a couple errors that occur, similar to this `LFS: Client error` and the error code being a `413`. 
We can set the transfer to `HTTP 1.1` using this command, `git config http.version HTTP/1.1` which should help and incase it does not, switch it to verion 2.
I have no exact clue why this error is occuring besides something along the lines of azure networking and security, but I would avoid using the `--global` flag because it might impact your gitlab settings.

Almost done pushing through the shaders, then I need to see if I can build the application!
Afterwards, I will slowly add the minor packages that we will need, and by minor, they might be pretty major and bulky.

The amount of times that I have installed a world generator is way too high for a normal week.

Okay, we were able to get the base of the game inside of the repo, I am going to take a bit of a break on this front and focus on the gamejam. Ideally I should be able to get the basics of the gamejam done tonight and tomorrow, leaving me Sunday night to wrap up the Unity migrations.



#### GameJam

[Official Fish Jam](https://itch.io/jam/mini-jam-153-fishing)

We are entering a small gamejam that lasts just a weekend! I believe we have 72 hours to complete a fishing game, but there is a twist! There is `no water`, but we could figure out a way to resolve it.

I was thinking that it starts off in a desert / post global warming sandstorm town and the player has to find a way to bring water back to the town?
The vibe that we could aim for is a bit of that old school dragonball and a hint of trigun, with our character having that bit of vash within him.

I am still looking through Phaser and getting a better understanding of the tilemap.

Looking through an example tileset, which is `176x128`, we can assume each tile is around `16px`, thus creating a 2D array of 11 tiles by 8 tiles.

I split the Phaser engine into two different components, the first is under `astro-ve` via `header:embed:phaser` and then again within the actual website that is using the phaser.
My plan would be to create a general wrapper around the `Phaser` engine and then call that wrapper to dynamically load the game and scenes.
We could do a simple chaining, where each scene would chain to another? This would make the javascript style games a bit linear but also maintain a smaller size.
This works the best for simple pixel and retro style games, since they will not be too heavy on CPU usage and can be played anywhere.

The example of the [CyberNoid JSON](https://labs.phaser.io/assets/tilemaps/maps/cybernoid.json)
Here is the tileset as a [png](https://labs.phaser.io/assets/tilemaps/tiles/cybernoid.png)
The source for the tilemap from [phaser 3 sandbox](https://labs.phaser.io/edit.html?src=src\tilemap\get%20tiles%20in%20shape.js)

After looking through that example, I am going to look through the [Phaser Loader TileMap JSON Example from Sammes Repo](https://samme.github.io/phaser-examples-mirror/loader/load%20tilemap%20json.html)

These two examples should be more than enough to provide us with a bit of a room to play around!

Okay going through my phaser notes, I was able to pickup [Annoraaq's Grid Engine](https://www.jsdelivr.com/package/npm/grid-engine?tab=files) which we can use to help build out the map a bit.

I am thinking during the gameload, we could pre-fetch that ESM module and have it ready to be used via a `window.gridEngine`, after the Phaser is loaded.

For scene management, there are a couple options we can use:

Basic Stop / Start

```javascript

this.scene.stop('CurrentSceneKey'); // Stop the current scene
this.scene.start('NewSceneKey'); // Start the new scene

```

Pause and Resume

```javascript

// To pause the current scene and start/resume another
this.scene.pause('CurrentSceneKey');
this.scene.start('NewSceneKey'); // Use `resume` if the new scene is already running and you're just bringing it back to focus

// And to switch back
this.scene.stop('NewSceneKey'); // Or `pause` if you want to keep its state
this.scene.resume('CurrentSceneKey');

```

Launch and Stop

```javascript

// To overlay a new scene on top of the current one
this.scene.launch('OverlaySceneKey');
// The original scene remains running in the background but can be paused manually if needed

// To hide the overlay and return focus to the original scene
this.scene.stop('OverlaySceneKey'); // Or pause, depending on your needs

```

---
# March: 02

> March 2nd

Source: https://kbve.com/journal/03-02/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes


## 2025

### RE-Game + Q Crate Demo

-   09:03AM

    As we build out the crate, we want to make sure that it works on Godot.
    With that being said, we will be using the Rent Earth game demo as the test case.
    Two parts of the script, one would be to grab the latest q release and move it into the addons folder; the other part would be to update the json data from `kbve.com` npc/item db.
    To avoid having to create different item dbs for each game, we will try to keep some of the core items in sync by using the vault as a source of truth for all the data.

### Mac M4 Order

-   03:15PM

    The order had an issue processing and that was because I had a hard limit on my debit transactions.
    It seems that the Robinhood debit card has a cap of $5000, which is terrible!
    I ended up using my amex card instead because it has a limit of $9500, which is more than enough to cover this charge.
    Maybe this was an edge case where we had the rare issue of someone ordering an expensive order out of the blue, hmm, that could trigger some anti-fraud issues too.

## 2024


### GameJam

Updated the background cover with a new [bg!](https://utfs.io/f/6711c1c9-bdd9-4a3a-bc61-ecc74aaa96a8-8wxnl0.webp)

I am currently in the process of preparing the pipelines for a release build, it is a bit painful to understand all the moving parts but I think we will get there by tonight.

It really is just slowly getting the game built out, shipping it out to the public and making sure that it works without anything breaking!

A couple dry runs within the next day and by Sunday night, we should have something polished and ready! Yay!

For bug reports, I placed this [issue ticket](https://github.com/KBVE/kbve/issues/836) , holding the common bugs that we are facing in the gamejam.



### 404

Oh a quick note for myself, I should place some `index.html` files within the public folders, so that they will handle redirects and prevent some 404 random errors.
And with that being said, I believe I need to update the new 404 page as well, which I was thinking of expanding with a custom router + notification system, that way I can keep track of the 404 errors using a simple system.

While I can see the 404 errors from Cloudflare and Google Webmasters, I think having my own data point would be great. 


---

### Itch


The best course of action for the itch would be to either package the game up directly to the website or maybe just iframe the game as a whole? 

I am still working out the exact kinks that would be involved but once we get a proof of concept up and running, we can start to tweak the game around to fit our needs.
Going through the itch build, we could make a new asset page for the fish and chip, then expand it from there.

For the itch page, we will use a base of `NextJS`, instead of a direct `React` because it should help us build out the application faster.
The first step would be `pnpm nx add @nx/next`, which was able to add the @nx/next but it seems that we had a command failure! 
I am thinking it might be because we had a couple changes happening at the same time, which was causing problems.
The error was resolved with `pnpm exec nx g @nx/next:init --keepExistingVersions --updatePackageScripts` , which resolved the package scripts.

For [Itch Page Template Reference](https://hedgiespresso.itch.io/itch-page-image-templates), this includes all the information related to setting up the Itch template!

The plan for now is to render the iframe for the game within a nextjs template, bundle it all up and then release it to the Itch via pipeline.

To run the itch next template, we will issue this command:
`./kbve.sh -nx next-itch-fishchip:run` ? Oh it seems that there were some changes to the way that next applications run within the Nx monorepo!

Instead we will be doing `pnpm nx dev next-itch-fishchip` to run the website, at least in developer mode.
Maybe under the run / build, we can adjust the action once we get a decent theme up and functional.

A side note, I updated the includes for the `tsconfig.json` , allowing the `.next/types/**/*.ts`. Hmm actually I am going to reverse this because it seems to be throwing a new error that I do not want to deal with.

This is the reference guide for the [Next Static Build](https://nextjs.org/docs/pages/building-your-application/deploying/static-exports)
Based off the guide, we will update the `next.config.js` to include an `output: 'export'` and `distDir: 'dist'` because we are looking to build a static website using next.

Okay now that we got the static output done, we want to build the application, then upload the `dist` folder to Itch.

---

---
# March: 03

> March 3rd! The weather shift for this month is always wild.

Source: https://kbve.com/journal/03-03/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### Godot Build Test

-   01:56AM

    There was a weird error in our build, going to fix it now.
    The new command for the `q` crate will be the `debug-mac`, which will not only run the mac build command but also move the final dylib into the right directory for testing.


## 2024


### FishChip

The final day of the game jam! We got only a couple hours before the submission, so we need to make sure everything is good to go!

The two major things left are shifting the tilesets with the new ones and then submitting the game.

After game submission, I will go back and update the game to resolve any bugs.

It seems that the character sheet is missing some tilesets but other than that its good to go!

Archandroid fixed up the character sheet with the matching colors! So now that the character matches with the rest of the game, I am going to finish up the pipeline checks and then go back to the Itch page.

For the game credits, we will have to include all the people that help with the changes.

Developers would be:
- `BChip`
- `h0lybyte`
- `David`

Then for the 2D artists, we have:
- `ArchanDroid` - Sprite
- `Nezt50` - Tiles
- `Retornodomal` - Menu

Now for the itch page, there are a couple files that we need for the submission page.

For credits, we need to reference the original assets:

Original placeholder assets are from https://finalbossblues.com/ and were modified by Annoraaq, Raiper34, splashsky, therebelrobot and xLink.

Phaser loaded via Astro.
React / TailWindCSS.


I noticed that the scrollbar appears in the frame, maybe I need to disable that within the internal iframe?

Inside of the `page.tsx`, I updated the Iframe code.

```javascript

    <iframe src="https://kbve.com/arcade/fishchip/itch/" height="1024px" width="100%" frameBorder="0" scrolling="no" >Your browser doesnot support iframes<a href="https://kbve.com/arcade/fishchip/" data-astro-prefetch> click here to view the page directly. </a></iframe>

```

I am getting type errors for the `frameBorder` and `scrolling`, as it seems to be no longer valid, hmm, given the time limit, I will just skip them.

I think we can keep this the way it is for now and then come back to it later, probably after the jam is over.


#### WASD

By popular demand, we patched up the movement so that it would also include the W A S D keys.
I normally kept this out because I thought it might conflict with the minigames but that was just a minor error on my part.

The patch to add the W A S D was just checking for the keys being down and then having the engine move the asset.


#### Inventory

I went through the start of the inventory proof of concept!
I am aware that there might be some issues with how to handle it via iframe.

---
# March: 04

> March 4th!
The next couple steps

Source: https://kbve.com/journal/03-04/

import { Adsense } from '@/components/astropad';




## Notes

## 2025

### HashMap Pins

-   07:46AM

    The bigger issue right now with our Q crate is that we can not handle the pin / guards during a multi threading process.
    I am looking through all the possible solutions for handling the pin when dealing with multiple threads.
    All our `let pin = ` needs to be removed because trying to handle the pins is just not worth it.

### 2024


#### DiscordBot

Here is the updated discord bot compose, which I will have to switch over to a yaml file for deployment.

```yaml

version: '3.8'

services:
  redbot:
    image: phasecorex/red-discordbot:audio
    networks:
      - public
      - redacted
    deploy:
      mode: replicated
      replicas: 1

    environment:
      - DATABASE_URL_PROD_FILE=/run/secrets/DATABASE_PROD_URL
      - TOKEN=/run/secrets/DISCORD_MUSIC_TOKEN
      - PREFIX=!!
      - OWNER=/run/secrets/HOLY_DISCORD_UUID

networks:
  public:
    external: true
  redacted:
    external: true

```

A future note to myself, we could connect the `API` and have it so that the discord bot can be reset via issue tickets on Github.


#### Inventory

The inventory for the game will be under the localstorage and we will call it via nanostores.
Before I put the code for the inventory out into the public and into the game, we want to make sure the first minigame is as bug free as we can get.

Docs for [LocalStorage](https://rexrainbow.github.io/phaser3-rex-notes/docs/site/localstorage/)

What we could do is wrap this around with a try-catch and maybe wrap it once more with nanostores? 

Call Nanostores first to handle the data, if there are any issues with calling nanostores, have it fallback to localStorage.

Side note, remember to json stringify or keep the data straight binary, with json stringify it would be easier to debug but by keeping the data straight binary we get the best performance.

Confusion could arise from storing numbers as strings and having to parse it back and forth. Also there might be issues with how the pooling works out.

StackOverFlow Reference for [GameState saving via localStorage](https://stackoverflow.com/questions/76631414/phaser-how-to-keep-game-data-organized-right-way).

Here is the code snippet from `winner_joiner`, from the link above.

```javascript

// in the global scope 
const GAME_STATE_KEY = 'MY_GAME_STATE';
var GameState = {
    // ...
};

// functions to save and load the State (if you want to persist it)

function loadStateData(){
    GameState = JSON.parse(localStorage.getItem(GAME_STATE_KEY));
}

function saveStateData(){
    localStorage.setItem(GAME_STATE_KEY, JSON.stringify(GameState));
}

```

This is a bit too `dumb data` but for this test casing it should be fine.

One of the cool things about using the localStorage is that we can call it via the WASM too, in a way, it be a solid event holder for cross communication between client side applications that are running.



#### Ads

I will start the advertising process again, which includes going through the links, content and getting approval from Adsense.
I made an issue ticket earlier but if we get denied or have problems, I will create a new issue ticket around it.

The content requirement and legal documentation is a priority for this week.



#### Crossword

One way to resolve the letter spacing issue would be to render crossword style squares and then place the letters via SVG inside of the panel.
One idea on how we would handle the SVGs would be to create a set of them for A to Z , like `A.svg` to `Z.svg` and then render them as they are on the screen.

We would have to cache / preload all the SVGs ahead of time as well... hmm we could even store them into the localStorage? There could be a couple ways for me test case around this.


#### Park

I thought it would be wise to take a quick walk around a local park and setup shop!
Sometimes just programming outside, with a bit of fresh air and natural sunlight, oh it definitely hits perfect.
The spring time weather is hitting the right spot within the soul.

Now let me resolve that retry issue!

Well GPT was able to solve it really quick!

```javascript

    update() {
        this.input.keyboard.on('keydown', (event) => {
            if (event.key === 'Shift' || event.key === 'R') {
                console.log('Shift is pressed');
                this.retry();
            }
        });
    }

```

In a future update, we could include an animation when switching the scenes, maybe a small spinner or just some form of notification to the user when the scene changes.
This will help prevent the user from thinking the game is bugged out or frozen.


#### Legal

I need to transfer over and render the legal documents, oh the joys.

Majortiy of it is basic boilerplate and should not be an issue to convert over.

Let us try a bento grid out and see if it looks solid!

According to the docs, we need to include a `@tabler/icons-react` package, which is probably there it handle the SVGS.
Hmm, for the sake of time, we will just include this react library. 

`pnpm install @tabler/icons-react` to add it into the whole repo.

After adding the package, I will quickly run a report and make sure everything is good to go!

We already created the base folder for the bento, now will just add the file that we want to call.

Inside of the `kbve.com` application, we will create the `Bento.astro` component.


The `grid:bento:bento` is a referfence to the Astro VE `bento.astro` , the core base file that will hold the bento code.

We are basically splitting the code to make it easier to reuse.

<Adsense />

---
# March: 05

> March 5th!
Minor updates to the legal rendering and testing out the bento grid.

Source: https://kbve.com/journal/03-05/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### Market

-   10:23AM

    TaR-Rifts are at it again, not resolving any of the issues and just making it more painful for everyone involved.
    However, it be interesting to see where the money goes from these tariffs and if we are going to place more of them on other nations.

### Bevy ECS

-   09:35PM

    Pushed the last bit of code up but realized that I am handling the player node in the wrong way.
    We would have to dynamically adjust the sprite and character colliders, furthermore we would have to adjust the layering for the character.
    All of these need to be handled during the gd script / singleton setup, ugh, back to the drawing board I go.

## 2024

### Bento

Getting the core demo of the bento grid as a template to render within the website.
This took way too much time to resolve, I believe the amount of nested components / files made the process of debugging a bit painful.

We were able to get the general bento grid to render, which is a win for us, but we still need to get the basic react children nodes to render.

I am currently in the process of adding the `html-react-parser` and this should help us in both this bento grid and in Phaser.

The build process looks like it is working, but it seems that I am still having some issues with the `html-react-parser`!
Let me try a different approach because this seems to be a bit broken and I am not feeling it.



### React

Github [Issue Ticket - #880](https://github.com/KBVE/kbve/issues/880)

The reference is probably the most important part of the example, this should make it easier to extend out the components within Phaser.


### FishChip

Chippy fixed the displayCombo aspect for the mini gamejam!

I also help chip get onboarded for the whole monorepo, which is another huge win!

We can now expand and build more abstract applications without having to switch around in multiple repos.


## Tasks

- [ ] Finish Bento Grid
- [ ] Phaser React Integration

---
# March: 06

> March 6th!
More Chips and Less Fish!

Source: https://kbve.com/journal/03-06/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2025

### Player2DNode

-   08:21AM

    Time to take a step back, refresh the mind and rewrite the way that we are handling the player node.
    We need to make sure that the sprites are there, thus have to create a 2D Resource Cache for the Sprite2D as well.
    I will take care of that first, I suppose.

-   08:45AM

    Okay so the Sprite2d would not be in the cache and then treat each NPC as unique objects that then stay within a hashmap + vector.
    Active NPCs/Entity will stay in the Vec and inactive will go back into the hashmap.
    Renaming the `player2dnode` to `playerentity`, which we can then build out as a future proof for multiplayer as well.
    Then instead of a `player_manager`, we can do an entity manager, which will hold both the players and the NPCs that they will interact with.
    This should be an easy thing to build out, afterwards we can go back and adjust the hexgrid manager / ecs situation because we will have a better way to keep track of positions.



## 2024

### Transition

A huge chunk of my time was spent setting up the transitional views within Astro!
I was finally able to get a better understanding of javascript, global variables and the esm-style importing.
However the amount of time it takes to get everything to be functional and making sure that nothing bugs out, ugh, its rough.
My suggestion for a system like this would be to utilize a 3rd party script or entity like Partytown to help shift a lot of the javascript to a webworker or service Worker, because it would help resolve a decent amount of issues that are involved with switching from DOM to DOM.


### FishChip

The next stage in jam would be to maybe start fresh and with a clean state, since we got to understand a decent more about how the Phaser engine works.
I needed to take a break from the Unity game engine and this was the perfect mixture, because I know I have a huge amount of UI/UX that I need to use javascript for within Unity.

The new build process for the fish & chip game will be under the `apps/react-phaser-fish-chip`.

We will be using vite to build the react, phaser and any additional packages.
The command to run the application is `pnpm nx serve react-phaser-fish-chip` for now, what I will most likely do is setup the pipeline so that it pushes the dist files to `kbve.com` repo.


### Unity

I have to make sure the Unity changes are still in sync with the Azure Devops, which involves a couple different test cases and pipeline changes.
One of the major pipeline change will be to shift the build process out to Github self-hosted containers, yet the plot twist is that they will have to pull the data from the Azure LFS.
Sometimes I forgot how much I just enjoy making video games, rather than spending so much time putting it all together.

---
# March: 07

> March 7th!
The 003 and the 007.
Need to prepare the tax documents once more for Uncle Sam.

Source: https://kbve.com/journal/03-07/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### MBP M4

-   11:30PM

    Finally got the chance to setup the new macbook pro, with that amazing 128gb ram.
    However since I just got it today, I am already thinking about returning it and picking up a macbook studio instead.

### 2024


#### Airport

The early mornings are tough but what always makes it worse are the trips to the damn airport.
I do not mind the drive to the airport but the traffic and finding parking, well both of those are `deez to the hammer`.
Let me get my morning coffee and make sure my notes are a bit more in sync.


#### GM

I thought it would make sense to split some of my time up and try to read through this game master book!
My plan is to read through it here and there, making notes on every single page.
This is the same style of reading that I have done in the past, but this time I will try to convert some of those notes that I take into markdown. 
The goal of this reading adventure is to take the information and process it into future useful tools for others to use.

---
# March: 08

> March 8th!
The drunktales of Daffy and Snappy!

Source: https://kbve.com/journal/03-08/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### Ramen Soup

-   11:46AM

    Trying a new soup idea by mixing the shin ramen base with a low sodium chicken broth!
    In addition to the new broth, I am going to add some carrots, peas and broccoli but the method of doing this is a bit different.
    Before I even begin to boil the ramen, I am going to use another container to boil the chicken broth with the veggies, the goal would be to introduce some of the flavor into the peas.
    Once the broccoli is soft and almost mushy, I will bring it down to a low heat and start to the regular ramen process, afterwards mix both together into one large pot!
    Wait, no, I lied, I ended up cooking the ramen slowly in the smaller pot and going to keep the broth stored for tonight and tomorrow.
    I will have to get better at describing this process and maybe even start to make videos?

### M4

-   02:14PM

    The oil from my hands are already changing the feel of the keyboard, a bit of a disappointment since the first day of usage.
    It might just be too much power for my needs, I am very much going to return it and switch over to the mac book, damn buyers remorse already kicking in.
    There might be an excuse that I could come up with to keep it, I got 10 days to figure that out.

## 2024



### Phaser

We will be migrating the fish and chip game from a basic astro component to its own folder.
We might to add a babel setup for the vite to process, hmm.

The vite build path needs to be upgrade, all of this will be under the #880 ticket.

Folder is `/apps/react-phaser-fish-chip`.
Serve is `pnpm nx serve react-phaser-fish-chip`.


### BigMan

I am here to help fix up these damn images!

Okay, so we will be adding a couple new characters to our game, this is going to be a bit weird but I want to take logs from people and train the characters around them.

It would be like a preluded DnD style game, this will help with character development too because it is built around real humans with real emotions, but through the bulleyes of the internet, which is less of an eye.

@bigman1392: I will help with the tilemaps and general environment for the NPCs


### Bathroom

My bathroom walls are going down!
House construction is always a pain, definitely when it comes to the kitchen and the bathroom, I never felt more like a slug than this week.
I can smell the lack of water usage.

---
# March: 09

> March 9th!

Source: https://kbve.com/journal/03-09/

import { Adsense } from '@/components/astropad';



## Notes

## Tasks

## 2025

### Supabase Updates

-   09:35AM

    The Supabase image for Kilobase is starting to fall behind in updates, ugh, it might pose some security issues.
    I am thinking that we would have to finish fixing the kilobase extension but we should be able to update the base image before having to do that.

-   10:31PM

    We also have to update the pgrx version that the kilobase extension is using and we need to loop back around at fixing the tokio issues.
    Since I been using the tokio library in godot, I been getting a better understanding on how to handle the multi-threading!
    One of the mistakes that I made was using the crossbeam crate to handle communication, but I think using the tokio libraries to handle that would make more sense xD.

-   EOD

    Okay, upgrading the docker base image to 15.8.1 and then running the generic build using this command:

```shell

 ./kbve.sh -nx kilobase:container

 ```

    Afterwards, going to switch the day!

    `FROM supabase/postgres:15.1.1.78 AS kilobase` to `FROM supabase/postgres:15.8.1.044 AS kilobase` is a huge jump, hopefully nothing breaks.

### RFC

-   06:00PM

    The lava has claimed another soul, this time a poor warlock, who met his fate through nature.
    We stand here today to mourn the soul of a man who stole stones.
    

### League

-   10:25PM

    Time to run another quick match with Shaco, while setting up the new Mac Book Pro.
    After throwing brew up, I need to refresh my mind with some clown antics.

## 2024

### Nanostores

The state management is important for all our applications, I am thinking that it might make sense to migrate it all into its own library.

Right now the state management is in the `astro-ve` sub section but we could migrate that out into its own library? Isolating the types and state management will make it easier to blend data types and move between Astro, React, Phaser, ect...

So the plan is to move the `kbve.ts` , `storage.ts` and a couple of those files out of `astro-ve` and into their own library.

For now we are calling them via `data/scores.tsx` but I can already tell this will not work in the longer term.


### WS

The websocket game.
Getting the sockets to work on the client side and server side will be interesting because I also wanted gRPC to work too.
What I might do is first do the web sockets and then maybe do the gRPC afterwards? 
How far of a multiplayer game do we need to make this? Hmm. 


### Adsense

I hate having to go through all the adsense policy changes, but the big ones seem to be for light content and general lack of flow.

I am thinking I should at least add multiplayer for the Phaser game and try to sneak in a couple different concepts, maybe like a leaderboard and see what we can do from there.


<Adsense />

---
# March: 10

> Ten days into March. The Pains and Joys.

Source: https://kbve.com/journal/03-10/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### Supabase v15.8.1

-   12:39AM

    Upgrading the Supabase version and already saw a huge mistake that needs to be addressed.
    We are not building to `Arm`, even though we could but for now, err, it would make sense to focus on our x86 build instead.
    Let me go ahead and fix that right now because it will fail again!
    We also have to take out the crossbeam and make sure that the tokio multithreading would not be an issue.

### Macbook Pro M4

-   09:54PM

    Making the first journal entry from the new macbook pro, what a trip!
    Brew definitely does make this easier to build and prepare everything for this monorepo.
    I am thinking that a custom install script would be great for macbooks, will definitely keep that noted.

### Godot 4.4

-   10:42PM

    Upgrading the current project from 4.3 godot to 4.4!
    The new features are quite interesting, but this might be their best release so far!
    Metal rendering was added, oh nice!

## 2024

### WS

I started to note out the socketio integration for the phaser engine.
The goal here would be shift state management from client side to a hybrid model, allowing some more complex setups for the state.

One concept that I was thinking about earlier would be having live `WPM` competition amoung players, a bit similar to a fishing contest.

The other aspect would be to extend the KBVE site and the leaderboard concept, having some level of data would be great.


### Characters

I also want to expand upon the characters and the lore related to them.
We have two NPCs right now but they are just there as placeholders and lack a decent level of depth that would matter.

Preparing their back story, goals and general vibe within the Fish&Chip world is important, as it falls into the whole storyboard arc, but I want there to be a bit more chaos than structure.

Placing a form of structure would make sense on any authority or villain arch, but the random NPCs should have chaos built into their blood, or well code.


### Build

It would make the most sense to prepare the build path for the Phaser game.
We will have the build be within the Alpha branch!

Lets open up the `ci-alpha.yml` and then make changes there for the build.
The first step would be to check for file changes, via ` reactfishchip: ${{ steps.delta.outputs.reactfishchip_any_changed }} `.
Then we would run a build, `pnpm nx build react-phaser-fish-chip`.
We should also grab the logs and cache misses from the nx.app runs but that will be a future note.

Damn I was mistaken, I need to place the build into the `ci-beta` branch instead, so I will migrate the changes over to the beta.
An additional error that I noticed was that we would have to update the commands for the actual


## Tasks

---
# March: 11

> The 11th of March.

Source: https://kbve.com/journal/03-11/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### Nx Workspace v20.5.0

-   12:39AM

    Upgrading the Nx Workspace to the latest version, might resolve some issues with expo.
    For this, I will have to go through the `nx migrate` command and see what it does.

### Github Actions Utils Docker Publish

-   01:23AM

    There was an issue with the `utils-publish-docker-image.yml` action that I had created recently.
    It seems that one of the variables is causing a trigger error, so let me resolve that now.

    The full issue was this:

    ```
    secret name `GITHUB_TOKEN` within `workflow_call` can not be used since it would collide with system reserved name
    ```

    First attempt to resolve it would be to just rename it to another variable name.

-   04:45PM

    Based upon the updated workflow name, it seems that we were able to patch that security issue regarding the secret name.

### Gunsin

-   04:06PM

    The adventures of Gunsin, with Kin and Fudster, oh boi, these is going to be fun!
    I am hoping we do not get picked off by that level 25 elite. 
    Hmm, I will need a new axe for him, it seems that I might have solid it off xD?

### Kilobase Debug

-   10:37PM

    The debug command would make it easier to test it locally before pushing it up to the kubernetes.
    Okay, next I am going to pass in the env but before I do that, hmm there might be an issue with the storage, let me double check it.

-   11:29PM

    The next issue that we need to resolve is the `PGSodium` issue that has been open for a while, I been waiting for Supabase to replace it but has not yet happen.
    

## 2024

### Output

The biggest issue that I am seeing with this current game is the massive `fish-chip.js` file.
I am going to read through the `output-manualchunks` from the RollUpJS Guide and see what I can do around improving the [build](https://rollupjs.org/configuration-options/#output-manualchunks).


### PlanetScale

It might be time to just drop the support of PlanetScale and switch back to the Postgres / Supabase setup.
The main reason we want to do this is to handle the websocket and player movement.

### Supabase Test Reports

This is the repo for their [test reporting system](https://github.com/supabase/test-reports) and I am going to keep track of it, probably to keep watch of the changes and how they handle their reports.
My plan would be to then to migrate some of their concepts into the Outpost for KBVE.
I still been working on the Outpost generation but there is a ton that is missing that I need to improve upon! Ugh, there is almost no time.


### Supabase

For the storage of the KBVE types and general handling of it, I will just create a new library to help with it!
Generic command for starting a new library -> `npx nx g @nx/js:lib mylib --bundler=vite`.

We will create the `supabase` ts file within the `postgres` library.

---
# March: 12

> 12th of March

Source: https://kbve.com/journal/03-12/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### Kilobase v15.8.10

-   10:53AM

    It was another day at the remote office, planning or throwing bricks at the computer screen until something would stick.
    The big issue right now is trying to figure out what I can do to improve all that older rust code and get ourselves an established redis proof of concept.
    After the poc is built, I will try to include pg vector and the sol instance extension as well!

-   03:24PM

    The FFI issue that is holding us back right now is the str / String between the redis, rust and postgres.
    The solution might be very simple at first but I can see it becoming a huge problem later on.
    Hmm, I wonder if there might be a better way to handle the redis integration, maybe we could get creative and run our own internal map of the data, like a mini redis.
    This would avoid the connection and jump to the redis, basically maintaining our own internal memory map.

-   05:12PM

    I have been thinking about the redis integration and I think I have a solution.
    I will create a mini redis that will be a part of the kilobase, this will allow us to maintain the data in memory and then sync it with the redis instance.
    This will allow us to avoid the FFI issues and also allow us to maintain the data in memory, which will be faster than the redis instance.
    Hmm, I am writing this a couple times and mapping it out right now, hopefully I can get something going soon.

### Moomin

-   06:26PM

    While watching episode 2, I felt like the show was a perfect representation of questing in Silverpine!
    Wolf and all, it was a perfect representation of the zone, even the death of Fudster was a great representation.

## 2024


### Git

The branch is out of sync, going to try and get it back into sync.

This is a test to see if I blew through the cache on github actions.

It was github! Ugh! They were causing all my issues from their endpoint, oh well its been resolved.


### Supabase

Now back to the main setup and usage of Supabase!

After working through all the specs, I decided that I will hold off on the Supabase integration once more.

This time it is less of the postgres issues but I currently do not have enough resources to actually execute what I need, the revenue stream is not high enough to justify the amount that I would be burning on API calls.

---
# March: 13

> 13th of March.
The evil floor of March.

Source: https://kbve.com/journal/03-13/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes


## Tasks

[X] - Finish Preparing Fish&Chip Pipeline


## 2025

### Kilobase v15.8.10

-   12:58PM

    Looks we solved that seg fault issue and we now have a very basic loading of the barebone postgres extension.
    I believe the next step will be to setup an additional unregulated worker that operates just outside of the postgres instance.
    This external worker will run with multiple threads under tokio.

### LoL Season 15

-   1:20PM

    Before diving deep into the realm of Rust, let me hit the spoon really quick.
    One of the worst games that I played in a while, so much feeding, ugh.

### RFC HiddenCut

-   03:31PM

    The dual cutlass on the rogue is definitely way too powerful, I am actually wondering if this will also make it easier to bring all my accounts up to the lvl 20 range.
    There are about 50 accounts that we can create for the hardcore and it would be great to start adding more spare accounts into the flow.
    Now there is another option but it will not be one that I will keep in the public notes, refer to the VIP.

### Foundation

-   04:25PM

    Episode one has been fantastic, this is going to be a great show, definitely holding me over until the next season of Andor.

### Solana Postgres

-   04:50PM

    Solana as a postgres extension will be my first web3 project in a long time, I remember using python to add information into the blockchain, time has been flyin.
    I think the next step will be to setup the external worker that will be able to handle the requests from the postgres extension.
    This will be a bit of a challenge but I think we can get it done.

## 2024

### FishChip

The focus will be back on making sure the NextJS build gets sent to the `kbve.com` folder via a build process.
The first command should build the script and then a pipe command should handle the cleaning up and replacement of the build.

Okay after thinking it through, we will have the beta branch build out the application and push it.

Under the `ci-alpha.yml` we had this code block:

```yaml

            -   name: React Fish & Chip Build
                  if: needs.alter.outputs.reactfishchip == 'true'
                  shell:  bash
                  run: |
                        pnpm nx build react-phaser-fish-chip

            -   name: Upload Fish & Chip Build
                  if: needs.alter.outputs.reactfishchip == 'true'
                  uses: actions/upload-artifact@v2
                  with:
                    name: build-FishChip
                    path: dist/apps/react-phasher-fish-chip

```

And instead of using the alpha branch, we will use the beta branch to build and pipe the final `nextjs` build.

Actually, we would be running the build through the KBVE action script instead of directly running the pnpm.

So the final command would look like this within the `ci-beta.yml`

```yaml

            -   name: React Fish & Chip
                if: needs.alter.outputs.reactfishchip == 'true'
                uses: ./.github/actions/kbve-shell
                with:
                    flag: '-pipe react-phaser-fish-chip'
                    create_pull_request: false
                    github_token: ${{ secrets.GITHUB_TOKEN }}


            -   name: React Fish & Chip
                if: needs.alter.outputs.reactfishchip == 'true'
                uses: ./.github/actions/kbve-shell
                with:
                    flag: '-build react-phaser-fish-chip'
                    create_pull_request: true
                    github_token: ${{ secrets.GITHUB_TOKEN }}
                    pull_request_title: 'nextjs-react-fish-chip-built-request'
                    pull_request_body: 'NextJS Fish and Chip Built Request'


```

I will take a break from this for now!


### Jam

Time to prepare ourselves for another jam, which will include some planning and general scoping of the project!

I think the goal of doing 100 game jams as fast as I can would be an interesting way to become an indie game developer as fast as possible.

The amount of skills that I am lacking within the music and art field is also a bit sadage but I think we will be able to get through it, with time and friends, as they say.

Damn, I can already see a small game becoming born within the end of the year!


### Shogun

Caught up to episode 4 of the series, I am loving the cinematics and the character development so far!
I will try not to include any spoilers but FX is hitting it out the park with some of their new series, whoever is greenlighting them is doing a great job.

---
# March: 14

> 14th of March.
Happy Pi Day! The magical number that sits within our heart and soul.

Source: https://kbve.com/journal/03-14/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes


## Tasks

- [X] - Check on the CD account and see if it has matured.
- [x] - Take notes for a new stream!
- [x] - Prepare Travel Jam R&D
- [x] - Make Posts requesting Discord Jammers

## 2025

### Foundation

-   06:00AM

    Watched the whole first season of foundation and it hit that firefly and expanse urge that has been in my soul.
    There really needs to be more sci-fi shows like this, filled with space drama and galactic battles, oh boi!

-   11:30PM

    Season 2 already, we are going to finish this show up way too quick.
    Complacency is still a bit of an issue that I need to resolve while watching that need.

### Nvdia Tar Rifts

-   04:37PM

    Good to see the markets recovery a bit over all of this non-sense.
    From the outside perspective and looking into the scale of this issue, everything is going through a fire sale.
    If you are young, this is a great time to pick up investments but also to be safe with emergency funds.
    On the brightside, my puts did expire and that nets me a couple thousand, which I will roll into the CD.


### WellsFargo CD

-   11:40:AM

    The CD account has matured and I have to decide what to do with the funds.
    I am thinking of moving them to a new account, but I am not sure which one to move them to.
    The goal of the CD funds is to get to 100,000 reserve that will collect that nice 4% interest.
    Afterwards, I might move the funds into picking up a condo?


## 2024

### Twitch

I am thinking that once the this new PC is fully operational that I should prepare my exisiting twitch account too.

I been slacking on the streaming front, I just do not have enough content to entertain a stream long enough, but that might just be my own writers block.
They do say that the biggest enemy is one's mind.



### Appwrite

The `schema.ts` is missing some of the base templates that we would need for an appwrite instance!

I will go ahead and write them out slowly and have GPT double check them for me.

### Travel

The next gamejam starts within this weekend and its the travel jam!
The game could be named that `Davids Goliath`, granted we can not yet start the jam because its about 7 hours early since I last added this line.

We are still allowed to plan the game out.



### Shell

To finish up the shell integration for the nextjs project, we want it to clean the files and move the build files to the embed location.
The same way that we handled the previous WASM build, so we know where we have to go.

These are the results from the `./kbve.sh -build react-phaser-fish-chip` :

```

(!) outDir /home/h0lybyte/kbve/kbve/dist/apps/react-phaser-fish-chip is not inside project root and will not be emptied.
Use --emptyOutDir to override.

../../dist/apps/react-phaser-fish-chip/index.html        0.37 kB │ gzip:   0.25 kB
../../dist/apps/react-phaser-fish-chip/fish-chip.js  1,969.38 kB │ gzip: 484.77 kB

```

We can actually just avoid using the shell and pass through that empty outdir command! Yay!
That ended up being easier to manage than I would have thought.

### David Goliath

The travel tag might be a bit weird but also these notes for this year , 2024, will extend into the next day because its almost 3:39am here.

---
# March: 15

> 15th of March.
Jam Day

Source: https://kbve.com/journal/03-15/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## Tasks

[ ] - Prepare Discord Jam R&D
[ ] - Travel Jam Repo

## 2026

### Clickhouse Vector

-   09:15PM 

    My hand written notes on the clickhouse vector integration, the plan is to just drop the logflare and go with a vector dev and clickhouse integration.
    Later on I am thinking of developing a wasm-friendly client to quickly grab the information from the clickhouse.
    We could even turn our rareicon game into something similar as well, that is something that I was thinking about earlier.
    

## 2025

### Solana Soul

-   12:14AM

    Focus will be in two parts, the first is the generic module layout and basic modules for a demo application.
    Before building the main application, the demo would be like a quick precursor to the main application.

-   01:19AM

    Okay, for this crate and future application, we would place the focus on `error.rs` and build it around `thiserror` crate.
    We should also look into the logging crate but that can be next, hmm.

### Github Tj Action

-   05:29PM

    Looks like the tj-action file changes was compromised and there needs to be a drop-in replacement for the action.
    After replacing the action, I will go through all our tokens and replace them all with new ones, i.e token and secret rotation.
    I do not think there was much of a security risk but it would make sense to be safe.

### GA Matrix Round 1

-   10:38PM

    Usually I been using other people's matrixes for github actions, but I think it is time to build my own!
    The last time I wrote one was for the unity builds but now I am going to try it for the publishing of the crates, npm and pip packages.

    Something like this below would be nice:

    ```yaml

    publish_crates:
        needs: ['deploy', 'alter', 'globals']
        name: Publish Crates
        strategy:
            matrix:
            package:
                - { name: 'q', condition: needs.alter.outputs.q }
                - { name: 'jedi', condition: needs.alter.outputs.jedi }
        if: matrix.package.condition == 'true'
        uses: KBVE/kbve/.github/workflows/rust-publish-crate.yml@main
        with:
            package: ${{ matrix.package.name }}
        secrets:
            CRATES_TOKEN: ${{ secrets.CRATES_TOKEN }}

    ```

    It would make sense that I save this information inside of the [git](https://kbve.com/application/git/) notes, so more information can be found there.
    Okay, we had to run two jobs, one that would filter through the matrix to see what needs to be built and then the second job would be the actual publishing.
    This can be later updated for the pip and npm packages too.

### Nx Graph

-   08:57PM

    Nx graph has a static output that runs under :

    ```bash
    pnpm nx graph --file=./apps/kbve/kbve.com/public/nx/index.html
    ```

    Which can be used to generate an additional nx embed, combined with the report.
    Report + Graph under the projects astro page would be a nice update for the site.
    I will make an issue ticket with that as a future update, definitely when I want to switch out of rust and do some astro or javascript.

## 2024

### Travel

Travel Game Jam!
We are thinking David Goliath or a boeing flappy bird style game, hmmm.

Bell just reminded me of the `Mighty Max` concept and maybe we could use that as a base concept for the game?

There are only 69 hours left in the jam, we got this!

The repo for the last mini game was under `nextjs-react-fish-chip-built-request` , now we could go ahead and create a new one.

Okay! The demo for the pipeline looks perfect, so time to test case this with the `travelbox` gamejam.

We will have to create a new react app with the vite bundler!

Run : `pnpm nx g @nx/react:app react-phaser-travelbox --bundler=vite`

Then we would update the `ci-beta` twith this code block.

```yaml

            #   [React] -> Travel Box

            -   name: React Travel Box
                if: needs.alter.outputs.reacttravelbox == 'true'
                uses: ./.github/actions/kbve-shell
                with:
                    flag: '-build react-phaser-travelbox'
                    create_pull_request: true
                    github_token: ${{ secrets.GITHUB_TOKEN }}
                    pull_request_title: 'react-travelbox-built-request'
                    pull_request_body: 'React TravelBox Built Request'


```

Now the game build itself, mapping out the menu will be easy and we can at least start from there.
The configurations are next on the journy!

The first was the NX Project JSON for building out the application, which we can extend the `project.json` to help us handle it.

```json
    "build": {
			"executor": "@nx/vite:build",
			"outputs": ["{options.outputPath}"],
			"defaultConfiguration": "production",
			"options": {
				"outputPath": "apps/kbve.com/public/embed/js/travelbox",
				"emptyOutDir": true
			},
			"configurations": {
				"development": {
					"mode": "development"
				},
				"production": {
					"mode": "production"
				}
			}
		}
```

This way the game that gets built can go directly into the `travelbox` embed and we can work from there.

After setting up the build command within the nx project, `./kbve.sh -nx react-phaser-travelbox:build`, we can add our rollup configurtions too.

```js

      rollupOptions: {
        external: ['fs', 'path', 'process'],
        output: {
          // ES Module Output
          format: 'es', // ES module format
          // Change the output directory structure and naming
          entryFileNames: `travelbox.js`,
          chunkFileNames: `[name].js`,
          assetFileNames: `[name].[ext]`,
        },
      },

```

We will come back to this on a later date, probably need to adjust the configuration of the chunking, but it will get that initial file down.

Third step will be to make it so that we adjust the `travelbox/index.astro` to load the new travelbox build.

### TravelBox Menu

Getting started on the `TravelBox` Menu? This will be the menu of the game, while I am trying to remember the different parts of the menu haha.


### TravelBox GamePlay

The gameplay for the `travelbox` and the design around it will be a bit of a test casing for us.

## 2023

---
# March: 16

> 16th of March.

Source: https://kbve.com/journal/03-16/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2026

### Journal Backup!

-   04:11PM

    The journal integration was broken during the migration but I was able to resolve it.
    Well kind of, there is an issue with the graphs that I need to wait on, that or I might just fork it and resolve it myself.

### Avian3D for Bevy

-   05:01PM

    Deep dive into the avian engine for bevy, what I did notice was that it is a bit young and needs some additional improvements.
    The major issue that I see moving forward is enabling the `simd` and `enhanced-determinism`, I will try to get both added asap.
    We can start with the simd, since I did add 128 integration earlier.

### Bevy NPCDB

-   05:42PM

    The plan is to keep the bevy npcdb integration between the discord mud bot and the actual bevy game itself.
    This will be really interesting to see the integration between a MUD and the ISOMetric game, almost a weird experiment to an extent.
    We can go crazy and have a side chat that exists within the page too.
    So many ideas, but the execution time and getting things working is such a pain.

### Edge Function Updates

-   06:51PM

    The edge functions will be our restful api call to the clickhouse, I am thinking this would make things easier to understand and build from.
    Later on, I do want to update the `jedi` crate to handle the clickhouse integrations as well.
    Okay so the edge functions are able to query the clickhouse, now we need to make sure the axum-kbve has the integration for
    The dashboard is already hooked up so that only admins can access it, so that should then make it easier for us to restrict the proxy calls to the clickhouse.
    After this integration, we can use this to resolve the argo dashboard nginx issue!
    Later on, I want to expand kong around to further lockdown the requests that get made.
    Well actually that might not be too much of a pain since kong already can verify the jwts, so that might be easier then I thought.

### Issue Ticket Clusterin

- 09:31PM

    We currently have around 50~ issue tickets, I am going to try to create some more to help with the flow of the repo.
    There could be some prompts that I could write up to help with the information, maybe using the security
    In addition, I am thinking we expand the github dashboard, so that we have

## 2025

### M4 Pro

-   05:26PM

    Laptop has been returned, I will miss all but with the $5500 back in my pockets, I will just invest it.
    My score for the laptop will be a 9 out of 10, it still is the best laptop on the market but definitely overkill for almost everyone.
    I did not get a chance to try OBS streaming on it, but the next time I get the M5 laptop, I will.

### Github Actions Rewrite

-   06:45PM

    The actions should be ready by tonight, there are only a couple more things to resolve before we are back to a full scale pipeline.
    Biggest issue right now is the token management and the 2nd biggest issue is the file alter triggers, both of which are just time based.

## 2024


### Phaser

The majority of this day will be preparing the game jam and making sure everyone is on board!
The VS Code live share does make it easier, to be honest. I think all software should be done in a duo.
Having a buddy while doing any type of software is a huge benefit, I think pair programming should be the future, add in an AI bot or two and now you have a full team.



### JSON

The JSON Map is what holds all the information for the tileset and editing the game/map data directly through the tileset editor, [Map Editor](https://thorbjorn.itch.io/tiled?ac=MbLnMaiNXvG) and [Dev Tools](https://github.com/zewa666/grid-engine-devtools).


### Vite

There is still an issue with the vite bundler and the pathing, which I still need to resolve for the `https://kbve.com/tools/travelbox` deployment!
The best move might be to deploy the assets using an absolute location from a s3 bucket.

---
# March: 17

> 17th of March.

Source: https://kbve.com/journal/03-17/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2026

### CI Main FanOut Pipelines

-   10:21PM

    Spent the day implementing a fanout approach to the workflows.
    The idea here is to move away from a sync based main and move towards an async deployment, which then creates issue tickets for failures.
    The end goal will be to have full loops with each code change then triggering an issue ticket, follow up response, ect... 
    Afterwards, I am thinking of integrating an additional layer of automation within the pipeline.

## 2025

### File Alters

-   01:09AM

    Still a bunch of issues with the workflow but we will be able to resolve them soon.
    The pipeline takes a while to rebuild, each time we have to shift the changes.

### n8n helm chart

-   01:17AM

    Helm chart for the n8n has been ready for v1, which we need to do the migration for, thus I should create a ticket for it.
    Reference for the chart is [here](https://github.com/8gears/n8n-helm-chart).

### Branch Retirement

-   01:45PM

    With the latest changes, it might be time to retire the alpha and beta branches and stick with just `main` and `dev` again.
    We can scale back the abstraction with the branches because we can use gitlab and azure to handle our alpha / beta.
    This would make things easier to build around and maintain while making the developement cycle easier to manage.

    The removed branches will be `alpha`, `beta` and `patch` workflows.

## 2024

### Jam

The jam is coming to an end and I want to thank everyone for helping out with the Travel Game Jam!
This journal entry is a bit short because I did not get a chance to go through and convert all my notes.
The biggest plan is now to prepare for the Discord App Jam!


### TypeSafety

Okay! I understand the pain of having strict typesafety during a Game Jam but if I can find a way to help migrate that pain from the start, I think we can speed up developement even faster.

My only other take away would be to push changes during the jam faster, keeping the cylce of CI/CD as continuous as possible.
There might be some areas of tooling that I would want to look into, including automatic merging.

---
# March: 18

> 18th of March.

Source: https://kbve.com/journal/03-18/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Unreal Plugin Fanout

-   08:45PM

    There are two situations we will need to work out!
    The first is making sure that each of the unreal plugins will be published onto fab.
    However before we can even do that, we need to figure out the best way to handle dispatches.
    Then there is another major issue, the plugins need to be kept up to date with the different versions of unreal that come out.
    So the battle is basically two areas, one is a source of truth of all applications and packages.


### Astro Project Schema

  - 08:56PM
    - The proto is the first layer in our source of truth, then we wrap it into the zod layer, apply the mdx front matter and get a json of the projects, which would include [/application](Applications and packages)

### Discord SH Build Failure

  - 09:33PM
    - Looking through the notes, it seems that our main failure point that has been holding us back is the e2e, which we need to make sure that it does not continue to happen. However I did notice that we need to have more of a flow of when main gets pushes and merges, it could be that we might have to figure out a clean way to handle the backlog of pushes.

### MDX Linter

  - 09:50PM
    - Maybe we need a python script that runs through our journals that takes what I am writing and neatly flags, optimzes and turns all my journal entries into something way cooler? I am still trying to think it through, there could be something cool that I can do with it. Maybe instead of directly linting here, we could just make a secondary script that goes through the journal entries, maybe once a week and does a sharp clean up and sync, actually we could have it be daily, where it does a general sweep of the daily entry.

### Desktoppi

  - 10:11PM
    - Not the official name but I am going to clean up handy and look at making a more optimized build as a KBVE Application. But there could be some other improvements that I am thinking about having compared to the original handy application. The biggest improvement will be the way that we load and handle models.

## 2025

### Github Crate Matrix

-   01:20PM

    Damn matrix seems to fail when building a json query, the issue seems that if all the crates are false for publishing, it produces an invalid json object.
    However, the first solution would be to include a simple patch to include a placeholder object, thus I will try that first.

### KBVE Fork v1

-   01:53PM

    Forking the whole monorepo and working on it under `h0lybyte` is the goal for this Q2.
    If everything goes as planned, then we can look at the azure and gitlab pipelines afterwards, ideally making it so the monorepo can stay replicated in multiple locations.
    The repo structure will be like this:

    1.  Github for Public.
    2.  Gitlab for Private Teams + Outside Developers - focus on backend applications.
    3.  Azure for Private Internal + Code for non-monorepo behaviors, like Unity.

    Provides us with the flexibility of an open source nature with the perks of private source integrations.

## 2024


### Multiplayer

I decided to take a short break from the pathing issue and look at how I would want to implement a multiplayer.
We know that the discord embed sdk comes out today!


---


### Colyseus

I am going to start the test casing for the Colyseus example and get a general test case out there for production.

The start of these notes will be within this [repo](https://github.com/discord/embedded-app-sdk/tree/main/examples/react-colyseus) for start of the project.

So the outline of the App stack would be like this:

- React
- Phaser
- Colyseus

Plugins:

- Enabled3D , this being optional.
- Grid Engine, this being optional.



---


### Embed

The Discord Embed App Pitch 2024 starts within a month, but they are doing a small `buildathon` this week!
I am thinking that it would make sense to first go through the `buildathon` and make a moch application, this will help us debug any issues that might come up during the pitch.

I am going to write out the notes and think about how I should prepare and deploy the `Wumpus Wumbo party` an the first test case for the jam and using that as the test case. This includes loading any and all of the "abstractions".
During this process, I noted that the pathing is not working as expected, but it seems that Discord uses a reverse proxy for the pathing of the assets.

---
# March: 19

> 19th of March.

Source: https://kbve.com/journal/03-19/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Talos Upgrade 

-   06:30AM

    Spent the night trying my first talos upgrade, it was an interesting experience.
    I believe we are close to getting the wireguard setup resolve, then we can hook in the Pi and NUCs!

## 2025

### Hiddencut Belt Production

-   07:40PM

    Got my 20 perfect deviate scales and now I can make my first blue item in leather working!
    Based upon my stats, I could easily make around 50 silver to 1 gold per belt that I make.
    Since the mount will cost around 100g, I might look into running WC on multiple characters and create these amazing belts.

### Disoxide gRPC



### 2024


#### Proxy

Proxy Paths and [URL Mapping](https://discord.com/developers/docs/activities/development-guides#url-mapping)

In their notes, I noticed that they would require `Static IP Addresses`, this will not be a major problem as of right now but it could be in the future.

```js
const protocol = `https`;
const clientId = '<YOUR CLIENT ID>';
const proxyDomain = 'discordsays.com';
const resourcePath = '/foo/bar.jpg';
const url = new URL(`${protocol}://${clientId}.${proxyDomain}${resourcePath}`);
```

This is an example of the full url construction.

We might run into an issue where we might have to `patchUrlMappings`, when trying to use the react helmet!

An example of wrapping it using patch-package:

```js
import { DiscordSDK } from '@discord/embedded-app-sdk';
const discordSdk = new DiscordSDK(YOUR_APP_ID);
const isProd = process.env.NODE_ENV === 'production'; // Actual dev/prod env check may vary for you

async function setupApp() {
	if (isProd) {
		discordSdk.patchUrlMappings([{ prefix: '/foo', target: 'foo.com' }]);
	}
	// start app initialization after this....
}
```

And the warning, for future cases:

> Note:
> patchUrlMappings is modifying your browser's fetch, WebSocket, and XMLHttpRequest.prototype.open global variables. Depending on the library, you may see side effects from using this helper function. It should be used only when necessary.


#### Three

Going to take a quick break from the proxy note taking and now I am going to focus on setting up the `Three`-webGL application!

This is just to test case the `three` and `phaser` integration but keeping notes of it as well.

The initial command would be: `pnpm nx g @nx/react:app react-phaser-three --bundler=vite`

Afterwards I just quickly merged those changes with ernie and his changes, thus creating a complete set of changes.

Libraries we would need to install:

```

enable3d A standalone 3D Framework on top of three-graphics.
@enable3d/phaser-extension Allows to integrate the three-graphics package into your Phaser 3 Games.
@enable3d/ammo-physics The core Physics package. Wraps ammo.js physics.
@enable3d/ammo-on-nodejs Enables you to run ammo.js on your node.js server.
@enable3d/three-graphics The core 3D Objects package. A beautiful API for many three.js elements.
@enable3d/three-wrapper Wraps the three.js library and some of its examples in one package.
@enable3d/common Some common code used by almost every package.

```

To install all the libraries that we would need:

Run this command: `pnpm install enable3d @enable3d/phaser-extension @enable3d/ammo-physics @enable3d/ammo-on-nodejs @enable3d/three-graphics @enable3d/three-wrapper @enable3d/common`

Afterwards! We went ahead and tested the Enable3D Engine!

Build Command: `./kbve.sh -build react-phaser-three`
Serve Command: `./kbve.sh -nx react-phaser-three:serve`


#### Buildathon

Lets start the generic buildathon for this test casing!

The first package we will need is the `colyseus.js`, which we can just run `pnpm install colyseus.js` and we should be save.

Next we add in the backend packages.

```json


  "dependencies": {
    "@colyseus/monitor": "^0.14.22",
    "@colyseus/schema": "^1.0.34",
    "@colyseus/uwebsockets-transport": "^0.14.28",
    "@colyseus/ws-transport": "^0.14.21",
    "colyseus": "^0.14.23"

  },

```

To add these, we will run this: `pnpm install colyseus @colyseus/monitor @colyseus/schema @colyseus/uwebsockets-transport @colyseus/ws-transport`

The next libraries we might need are :

```json

"dependencies": {

    "cross-fetch": "^3.1.5",
    "dotenv": "^16.0.1",
    "express": "^4.17.1",
    "http-proxy-middleware": "^2.0.6",
    "uwebsockets-express": "^1.2.2"
}

```

Next would be the `devDependencies` that we could include:

```json

  "devDependencies": {
    "@types/express": "^4.17.11",
    "@types/node": "^14.14.22",
    "nodemon": "^3.0.3",
    "npm-run-all": "^4.1.5",
    "rimraf": "^3.0.2",
    "ts-node": "^10.9.1",
    "typescript": "^5.2.2"
  }

```

For now, I will skip these and switch gears back to the `enabled3d` for Phaser.

Perfect! We can start to mess around with the library now!

#### Prettier

It seems that the prettier plugin was crashing because of an astro override, I think I was able to get it resolved.

```json

	"plugins": ["prettier-plugin-astro"],
	"overrides": [
	  {
		"files": "*.astro",
		"options": {
		  "parser": "astro"
		}
	  }
	]

```



#### Ammo

The next move would be to use `ammo` for the front and backend!

---
# March: 20

> 20th of March! The Best Day of March!

Source: https://kbve.com/journal/03-20/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2026

### Unreal

-   11:50PM

    Dedicated to this new RPG.

## 2025

### Severance S1

-   08:22PM

    While working on the gRPC protocol from yesterday, I decided to take a quick break and finally watch the first season of the show.
    Lumon already has that crazy thriller vibe, even the first episode is starting off strong.


-   08:55PM

    It makes sense why this show is so popular, I might end up binge watching the whole first season in the next day or two.
    I bet this will do wonders for the neruolink project too.
    That got me thinking about what work will be like in a hundred years from now, with the rate of A.I growth, it will be wild.

### gRPC Status

-   08:29PM

    The Status concept was something that Fudster was suggesting as an application for creating an ai twitter like system.
    My idea would be to use that concept but integrate it into the Discordsh as a prototype, basically a proof of concept, maybe even an integration to discord itself.
    By leveraging the discord servers, we have a place to store the data but also have the ability to expand a server out with unique features.
    The best example of this would be Midjourney and how they integrated their AI Image generation with Discord, we would be doing the same but merging the status-like application with Discord.
    Once more this would offload a bunch of the burdens that we would face, like having to store memes and also having to look for users, since Discord has a large eco-system.
    Finally, all of these integrations will be built around tooling that can then be re-purposed for anything else in the future.

## 2024


### Enable3D

The actual location for the example source [code / repo](https://github.com/enable3d/enable3d-website/tree/master/src/examples)

The first two commands we ran this morning were: 

- `./kbve.sh -nx kbve.com:dev` - Astro on port 4321
- `./kbve.sh -nx react-phaser-three:serve` - Vite on port 4200

We will begin by looking through the examples of the `PhysicsLoader` and the options that we have.

To grab the `ammo` libraries, we will just download the whole repo as a zip , aka `enable3d/enable3d-website` as a `master.zip`.
After downloading the zip, we will add the `/src/lib/ammo/` folders, located [here](https://github.com/enable3d/enable3d-website/tree/master/src/lib/ammo), into the vite public of `react-phaser-three`!

Actually, it might make more sense to upload the `ammo` files directly to `/apps/kbve.com/public/embed/js/ammo/` and have them hosted there.
Yet for the time being, we will place them inside of the vite.

So we have placed them into two locations. 

Location 1 - `/apps/kbve.com/public/embed/js/ammo/`
Location 2 - `/apps/react-phaser-three/public/ammo/`

During the development phase, we will just call it from the relative path and then once we are ready, we can call it from an absolute path.

After that , we need to add a Location 3 , which would be a CDN, Content Delivery Network, and a Location 4 , which would be the Discord Reverse Proxy.

Location 1 - `/apps/kbve.com/public/embed/js/ammo/`
Location 2 - `/apps/react-phaser-three/public/ammo/`
Location 3 - TODO CDN
Location 4 - Discord Reverse Proxy

Now to call the `ammo` library, we can take a look at the specific ammo examples from the `enable3d-website`, here is a reference to the [search](https://github.com/search?q=repo%3Aenable3d%2Fenable3d-website%20ammo&type=code)

The current error that we are facing is a double canvas, which might be similar to this [stackoverflow problem](https://stackoverflow.com/questions/73910900/why-are-multiple-canvases-being-made-in-my-phaser-react-app)

Currently we have three canvas:

```html

<canvas id="enable3d-phaser-canvas">
<canvas data-engine="three.js r161" id="enable3d-three-canvas">
<canvas id="enable3d-phaser-canvas">

```

Here are our attempts to resolve the multiple canvas problem, we are adding these here for reference.


```javascript

      //const game = new Phaser.Game(gameConfig); 

      //enable3d(() => new Phaser.Game(config)).withPhysics('assets/ammo')
      //enable3d(() => game).withPhysics('assets/ammo')
      //enable3d(() =>  game);

      // 03-20-2024 - 7:21am Attempt to Load Ammo Physics Engine 
      // enable3d(() => new Phaser.Game(gameConfig)).withPhysics('/ammo/kripken')

      // try to handle with a game instance
      // enable3d(() => {
      //   const game = new Phaser.Game({...config, parent: gameRef.current});
      //   gameInstance.current = game;
      //   return gameInstance.current;
      // }).withPhysics('/ammo/kripken')



      // return () => {
      //   // Cleanup the game when the component is unmounted
      //   // game.destroy(true);
      //   if (gameInstance.current) {
      //     gameInstance.current.destroy(true);
      //     gameInstance.current = null;
      //   }
      // };

```

We believe it might be because we have multiple physics, with ammo and arcade, so we will remove the default physics.

```javascript

    physics: {
          default: 'arcade',
          arcade: {
            gravity: { x: 0, y: 0 },
            debug: false,
            worldBounds: true,
            emitOnWorldBounds: true
          }
        },

```

It ended up being that we were using two `useRef` and instead we had to use the `state` and two `useEffect` to handle the loading for the multiple canvas problem.

Now that we have the canvas loaded and ready, we can move forward with different types of demos with that Ammo physics engine.

### Express

The base application for colyseus is express, so let us set that up!

We will run this command to init the application, `pnpm nx g @nx/node:application express-colyseus-discord`

Afterwards, we will run: `pnpm nx show project express-colyseus-discord --web` , which will give us a breakdown of the commands.

Finally we have the serve command, which is `pnpm nx run express-colyseus-discord:serve`, we can use this as `./kbve.sh -nx express-colyseus-discord:serve`

We got port 3000 running and it says hello!

Okay! It seems that we missed a couple libraries. 

`pnpm install uwebsockets-express`.

After we get the base of colyseus up and running, we will go ahead and ship this out!

Next we will make sure the docker build works for the application, inside of a Node instance.

We change the output to be within the same folder `"outputPath": "apps/express-colyseus-discord/dist",` via the `project.json`.

Wait! I will revert that for now because of the build path that we have setup with the rust deployment. 

The goal would be to release the initial dockerfile and then loop back around with another instance to chisel the that instance.

We should also have an internal version number to keep track of the dockerbuilds during the deployment.

The two builds are located here:

- `/apps/express-colyseus-discord`
- `/migrations/docker/chisel/colyseus-discord/Dockerfile`

After the build is sucessful, we will do the two docker builds, one after the other.
Then we can do the automatic deployment via the shell command.

While we are preparing the Docker system for the Colyseus, I want to take a moment, to look over the tutorial for integrating both of them!

- [Colyseus Phaser Tutorial](https://learn.colyseus.io/phaser/1-basic-player-movement) - 4 Part Guide on how to set it up and execute all the scenes within.


### Dockerfile

The Dockerfile will be similar to the other ones that we have built in the past, our goal would be to just get a generic build out of the way.

The first build comes in at around 300MB but it seems to be functional, with the node application running on port 3000.

Going to sync this into the main branch and then build out a docker compose.

As for the `chisel` build, we would have to use esbuild, rspack or vite to combine all of the node modules into a single js esm file and then run that in a sliced ubuntu container.
Of which, I do not want to do, until maybe next week.

Now that I am thinking about it, the `outdir` would be an issue for the `dist`? I am going to run it up production and see if there are any issues with the pipeline cycle.`

---
# March: 21

> 21st of March! The Best Day of March!

Source: https://kbve.com/journal/03-21/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2026

### Dashboard Updates

-   08:15PM

    More updates to the kbve dashboard an then back to the unreal grind.

## 2025

### Disoxide v1.2

-   09:05PM

    The disoxide application has a couple crates that we do not need right now, but might need to include in the future.
    I am thinking that we migrate a decent amount of the code and functions into the jedi crate.

### JEDI v0.1.16

-   03:34PM

    After spending some time looking through the examples and test cases, it will be time to come back around to `jedi`.
    The crate will shift focus to be a multi-thread and multiplex ready crate, thus making it easier to mass produce performance at scale.
    Say goodbye to microservices and say hello to da the force.

-   04:35PM

    Migrating the jedi crate into the `packages/rust` folder.
    Need to update the file changes as well for it, making sure it tracks via readme changes.
    Updated Dashmap to v6.1 and adding rayon support too.
    Next, we will update the ammonia to v4.
    Furthermore, we can table the removal of crossbeam and have the channel system that tokio provides.

### Mage Duo

-   05:13PM

    Almost level 30, which means we are not too far from getting our mounts?
    Yessir!

## 2024


### LCAgents

For LC Agents we will setup an expo client that we can build test around and finish up a generic application + website for the client.
We can use this test case as a way to document the changes required before moving to more production ready styles of deployment. 

The developer build for LC Agents should be done before the end of this week!


### Expo

We will be taking another shot at `expo` and with the release of v50, our goal of setting up a clean and automated application should be easier!
The plan is currently to split the dev cycle into a couple side branches, eventually only taking the one that works the best for our monorepo.



### Argon

The base template that we want to use for the project is `Argon-React-Native` by `Creative Tim`, which is located [here](https://github.com/creativetimofficial/argon-react-native).

This react native theme provides everything we need to bootstrap an iOS/Android/Web application by utilizing the Galio framework, React Native and Expo, at least according to their document.

Sadly majority of the time for this template system is being spent on just setting up the damn typescript xD

The amount of work that I have to put into this might be too much for me, as the errors are all over the place, including the router.


### HellDiver

The latest patch for HellDiver has been making the game actually playable on my laptop!
Before the amount of heat, terrible performance and lag was just way too much!

The more I play this game, the more I just want to finish up RogueJester to be honest, a combination of Brute Force, Halo and HellDiver would be an epic game.

---
# March: 22

> 22nd of March. 0322. I am having a tough time with thinking about daily journal entries haha.

Source: https://kbve.com/journal/03-22/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2026

### Github Rate Limit

-   11:50PM

    The worse thing that could break our whole project is if github decides to rate limit.
    We got hit hard last time, hopefully we will not face the same problem in the future.

## 2025

### n8n v1

-   05:40PM

    I ran the n8n locally under a k3s and it looks like the new v1 chart is nearly perfect!
    It includes the redis and postgres integration, which we already have running!
    Armada has our redis instance and kilobase is our postgres database, so integrating the n8n should be easy.
    There will be two ways that we can access the n8n, the first will be through the jedi crate and the second way will be through the edge functions.

### JEDI v0.1.16

-   10:12PM

    Wrapping up some major changes to the jedi crate but I believe we will need another 3 more minor versions before adding the kubernetes helm.
    After finishing up the protobufs for redis, we can add lambda and a couple other B2B EDI integrations.
    My goal would be to expand out a decent library of protobufs that would be important for a MVP b2b application.

## 2024


### Discord

The Discord Pitch for 2024 starts at the end of this month, so a bit over a week, and we still have not yet figured out the best move to make. 

Part of me wants to dedicate a decent amount of time with the jam and other part of me seems to be very `on the fence` with the contest.



### Tamagui

The Tamagui framework might just be the best choice for the expo application that we are building, as I am having a tough time working around the `argon react native` template.

My plan was to first setup the tamagui processing and then import and use the components that fit the best for an application.

Getting the Tamagui to build and work with the NX Monorepo took a bit of twist and turning, a decent amount of alcohol-infused caffine and a huge amount of headaches. 

The biggest issue was the metro builder, the configuration of the tamagui and getting the expo router to be functional.



### Colyseus

We have the docker build ready for the server side but still have to make some changes in the server-side code to address the changes in state or state management.
Besides the state management, I will also have to build out a docker compose and finish up the automated deployment.

Side note: we could use coolify for the deployment, as BChip is using right now, but that might be for a later date.


### BBQ

My plan for this weekend is to setup an expo component library that we can use anywhere in our application development!
We are going to call this the `expo-bbq` and it will house a decent amount of our expo typescript-safe components, which will be used in `expo-lcagents` and `expo-kbve`.

I am already mapping out a couple different type of components that we could use / make.

A part of me feels that it might be a bit overkill because it would make customization a bit more rough, so we shall see how we want to move forward with it.

---
# March: 23

> 23rd of March. 0322. I am having a tough time with thinking about daily journal entries haha.

Source: https://kbve.com/journal/03-23/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2026

### Unreal Online

-   08:14AM

    Our unreal server is online through kubers!
    This is an exciting time for us, this might be the hardest project yet.

## 2025

### Redis Jedi RESP3

-   06:05AM

    Adding support for both the `bb8-redis` and our own internal redis resp3 integration.
    Our goal would be to keep a straight connection via both methods, ideally should prepare us for a cluster setup as well.
    After the redis setup, we can split the postgres, n8n and lambda next.

### CI/CD Disoxide v1.2

-   06:51AM

    Going to add both local docker support and after a couple test cases, I will add the kube chart.
    Furthermore, while I am building that kube chart out, I should also include the n8n instance because then I can place it right next to the redis.
    Keeping the n8n close to the redis will be extremely useful for performance.
    Notes on the [n8n integration](https://kbve.com/application/n8n/)

### JEDI Sidecar

-   10:41PM

    Expand the `jedi` crate to include a sidecar module that would help load the environmental variables.
    The first two areas of focus will be the general ENV pass through and `_FILE` support.
    After getting both of them out of the way, we can look into providing other unique ways of extracting the secret information, maybe vault access?
    

## 2024


### Bathroom

The upstair bathroom is almost done! Yay!
I can not wait to get back into my normal flow and having decently warm water again.


### Expo BBQ

I will try to build out the components with minor changes here and there.

I am thinking the color choice and abstraction should be built into the components, but I am not too sure yet.


### State

Nothing makes me enjoy my morning coffee, like thinking about state management!
Once I get a bit more work done in the client side, I will most definitely look into building the final client-side state management library, which I want to use every where! Muahaha.


### BBQEmbed

The BBQ Embed will handle the WebView and Iframe embeds!

We created the `BBQEmbed.tsx` within the `expo-bbq` and now we want to go ahead and render it within the `lcagents` app.

```js

<BBQEmbed src="https://kbve.com/arcade/itch" />

```


### GahAction

Time to do some of the classic github actions! GaHActions baby

Action to run the serve -> `pnpm nx serve expo-lcagents`
Now I am going to assume the build might require some work!

We will look into the publish websites with Metro, here is how we can go about doing that, [document for reference](https://docs.expo.dev/distribution/publishing-websites/).

Okay! To build out the website, we run this command: `./kbve.sh -nx expo-lcagents:export`, which exports out to `dist/apps/expo-lcagents/` and we can then make it deploy to the LC-Agents repo.

---
# March: 24

> 24th of March.

Source: https://kbve.com/journal/03-24/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2026

### Agones Unreal

  - 01:06AM
    - The plan is to build out first in class support for agones and map around making sure that ROWS is full scalable with that system. We could even look at including a Redis/MalKey value system that could help us quickly integrate data between the UE5 and our application.


## 2025

### Wow HC

-   02:40AM

    First time in a while that I saw the population dip almost near `low`, back to `medium` right now but the onlyfangs leaving might have an impact.
    The more that I play, the more that I want to make a modded version of wow that mixes in the dark and darker gameplay.
    I am very tempted to set it up but ugh, the amount of time and resources to do it.

### Redis WS

-   03:08AM

    RESP3 websockets are next! Since we already have the websockets handler setup, this part should be easy.
    Okay there is a valid connection from our websockets and the redis, also this means we could link it to discord and twitch too.
    Now we are getting to the fun and exciting parts, oh yes!

### Redis Proto

-   04:02AM

    Adding the websocket protobufs to the jedi crate.

-   06:32PM

    The redis websockets are still somewhat of an issue, in the sense that they can process the watch but are not being updated.
    I believe there might be a bit of a logical error on my end, so I might have to loop back around and see what went wrong.
    There is an option to drop back down to RESP2 and use the code below:

    ```rust

    use futures_util::StreamExt;
    let client = redis::Client::open("redis://redis/")?;
    let (mut sink, mut stream) = client.get_async_pubsub().await?.split();
    sink.subscribe("channel_1").await?;

    loop {
        let msg = stream.next().await.unwrap();
        let payload : String = msg.get_payload().unwrap();
        println!("channel '{}': {}", msg.get_channel_name(), payload);
    }

    ```

    This code was from the redis crate docs.

-   09:54PM

    The issue might be in our `spawn_pubsub_listner`, which might not be setup the right way.
    Why can we


## 2024

### Actions

We will have the actions build the changes for the `expo-lcagents` and then push the changes to the new `KBVE/lc-agents.com` repo.

After pushing the code, we will use the main branch to execute any changes and have those get deployed?

Maybe we might not need to use the main branch, but we shall see.


### Bathroom

We were able to get the upstairs bathroom almost all fixed up!
The only thing missing is repairing the shower tiles but that will be for next month!


### HellDivers

Finally got enough credits to pickup a war bond!
I am a big fan of the laser weapons, mainly because we do not have to worry about the ammo.
My play style is a bit weak, which might be because I like to keep distance and only attack monsters when they are dangerous.

---
# March: 25

> 25th of March.

Source: https://kbve.com/journal/03-25/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2026

### Blueprint Blueballs

  - 11:00PM
    - I am getting too old!

## 2025

### Yemen War Leaks

-   08:50PM

    The leaks for the battleplans within Yemen are really crazy to think about?
    Sending an order to bomb a city while just casually browsing the phone is just peak dystopia.


### Upgraded

-   11:50PM

    This movie is still living rent free, almost like if GPT were to take over a human mind.
    Having the co pilot try to autofill this journal entry... makes it even worse xD.
    All of this should be a future quest in RentEarth.

## 2024


### Actions

Time to test case the LC Agents Expo deployment using Github Actions.
There will be three main test cases that we will perform, the first would be for the web, then Android and finally iOS.

Instead of bulking up the main `deployment`, I am thinking that it would be wise to start splitting up the actions a bit.
However I am thinking before I add new action files for each deployment, I will at least try to keep them within the same `ci-main` for now.

```yaml

    lc-agents-expo-deployment:
        needs: ["alter", "deploy"]
        name: Build Expo Web LC Agents
        if: needs.alter.outputs.lcagents == 'true'
        runs-on: ubuntu-latest
        permissions:
            contents: read
            packages: write
        steps:
            - name: Checkout Repository
              uses: actions/checkout@v4

            - name: Setup Node v18
              uses: actions/setup-node@v3
              with:
                node-version: 18

            - name: Setup pnpm
              uses: pnpm/action-setup@v3
              with:
                version: 8
                run_install: false

            - name: Get pnpm Store Path
              shell: bash
              run: |
                    echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV

            - name: Setup pnpm Cache
              uses: actions/cache@v3
              with:
                path: ${{ env.STORE_PATH }}
                key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
                restore-keys: |
                    ${{ runner.os }}-pnpm-store-

            - name: Install pnpm dependencies
              run: pnpm install

```

That is the base of the action that we will be using to setup the `pnpm` before we execute any expo commands.

Okay now we have to work out the build phase, which is below:

```yaml
           # -   name: LCA Expo Build

            -   name: LCA Expo Build
                uses: ./.github/actions/kbve-shell
                with:
                    flag: '-nx expo-lcagents:export'
                    create_pull_request: false
                    github_token: ${{ secrets.GITHUB_TOKEN }}


            -   name: LC Agents -> Deployment
                uses: dobbelina/copy_file_to_another_repo_action@main
                env:
                    API_TOKEN_GITHUB: ${{ secrets.UNITY_PAT }}
                with:
                    source_file: 'dist/apps/expo-lcagents/'
                    destination_repo: 'kbve/lc-agents.com'
                    destination_folder: '/docs'
                    destination_branch: 'main'
                    destination_branch_create: 'patch-kbve-lcagents-deploy'
                    user_email: '5599058+h0lybyte@users.noreply.github.com'
                    user_name: 'h0lybyte'
                    commit_message: ${{ github.event.head_commit.message }}
                    rsync_option: "-avrh --delete"

    ```

---
# March: 26

> 26th of March.

Source: https://kbve.com/journal/03-26/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### ROWS Dashboard

    1:05AM

      The dashboard needs to be extended to include data from the ROWS deployment.
      I am going to start off with a basic proof of concept for the dashboard, then slowly look at bumping up the integration, making it easier to build around it.


## 2025

### REDIS v3

-   10:00PM

    Getting closer to resolving the websockets for redis but there is a bunch of room for improvements.
    We still have to figure out the best way to handle the gRPC but getting closer to a performant WSS.
    Eventually, the goal should be to move away from the JSON and go straight flexbuffers and binary.

## 2024


### Action

There seems to be a couple different errors within the pipeline that need to be resolved, the first one is the file change hashes not triggering the right jobs and the second is the expo build.

I am going to remove the LCA build from the ci-main, saving it here below for reference.

```yaml

    # Expo Deployments
    lc-agents-expo-deployment:
        needs: ["alter", "deploy"]
        name: Build Expo Web LC Agents
        runs-on: ubuntu-latest
        # permissions:
        #     id-token: write
        #     contents: write
        #     packages: write
        #     issues: write
        #     pull-requests: write
        steps:
            -   name: Checkout Repository
                uses: actions/checkout@v4

            -   name: Setup Node v18
                uses: actions/setup-node@v3
                with:
                    node-version: 18

            -   name: Setup pnpm
                uses: pnpm/action-setup@v3
                with:
                    version: 8
                    run_install: false

            -   name: Get pnpm Store Path
                shell: bash
                run: |
                    echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV

            -   name: Setup pnpm Cache
                uses: actions/cache@v3
                with:
                    path: ${{ env.STORE_PATH }}
                    key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
                    restore-keys: |
                        ${{ runner.os }}-pnpm-store-

            -   name: Install pnpm dependencies
                run: pnpm install

           # -   name: LCA Expo Build

            -   name: LCA Expo Build
                uses: ./.github/actions/kbve-shell
                with:
                    flag: '-nx expo-lcagents:export'
                    create_pull_request: false
                    github_token: ${{ secrets.GITHUB_TOKEN }}


            -   name: LC Agents -> Deployment
                uses: dobbelina/copy_file_to_another_repo_action@main
                env:
                    API_TOKEN_GITHUB: ${{ secrets.UNITY_PAT }}
                with:
                    source_file: 'dist/apps/expo-lcagents/'
                    destination_repo: 'kbve/lc-agents.com'
                    destination_folder: '/docs'
                    destination_branch: 'main'
                    destination_branch_create: 'patch-kbve-lcagents-deploy'
                    user_email: '5599058+h0lybyte@users.noreply.github.com'
                    user_name: 'h0lybyte'
                    commit_message: ${{ github.event.head_commit.message }}
                    rsync_option: "-avrh --delete"


    # [EXPO] -> [END]


```

After removing it from the ci-main, I am going to work on it within the `ci-alpha`, this way we should not have any issues with the `main` branch failing.

Here is our current `ci-alpha.yml` configuration for the Github Action to build the web part of the expo.

```yaml


        expo-lcagents-web-build:
            needs: ['alter']
            name: Expo LC Agents We Build
            runs-on: ubuntu-latest
            # if: needs.alter.outputs.expolcagents == 'true'
            steps:
                -   name: Checkout repository
                    uses: actions/checkout@v4

                -   name: Setup NodeJS
                    uses: actions/setup-node@v3
                    with:
                        node-version: 18

                -   name: Setup PNPM
                    uses: pnpm/action-setup@v3
                    with:
                        version: 8
                        #run_install: false


                -   name: LCA Expo Build
                    uses: ./.github/actions/kbve-shell
                    with:
                        flag: '-nx expo-lcagents:export'
                        create_pull_request: false
                        github_token: ${{ secrets.GITHUB_TOKEN }}


```

We will push this through and see where the action goes from here!

Ah it seems that by default, the `pnpm/action-setup@v3` does not run the install, so we will go ahead and put that command back in.
Now the question would be if we want to pass the node-linker as a varible or not.

Let me see if I can add something that might be missing from the Github Actions?

```yaml


                -   name: Install react-native-cli globally
                    run: pnpm add -g react-native-cli

                -   name: Install dependencies
                    run: pnpm install

                -   name: Clear Metro Cache
                    run: npx react-native start --reset-cache


```

We will try this next! Hopefully this might solve the issue with the automated builds within the pipeline.

---
# March: 27

> 27th of March.

Source: https://kbve.com/journal/03-27/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Unreal

- 10:34AM

  Another dev day for the unreal realm, yet I was not able to get as much as I had hoped accomplished.
  We still need to look at getting the auth system built out, but I am thinking that it might make sense to look at planning around the Rareicon execution.

## 2025

### Druid

-   05:00AM

    Finally got my cat form and now I am doing the macros, ugh, means I need to loop back around and fix those.

### FlexBuffers

-   06:36PM

    Time to move from JSON over to Bytes!
    The journey has been a wild ride but having the experience now and the tools, should make this transition painless.
    Goal for now would be to move the binary data among different applications through the protobuf / jedi technique, following the footsteps of how Google does it.
    There could be some additional ways to handle this in 2025 but it would make sense to build around the exisiting tools, giving us the maintaince from larger organizations but just enough speed and performance.
    The vibe here is be a honda civic type flow, extremely fast but easy on the maintaince.
    A combination of a tesla model y and honda civic r, is the best way that I could summarize this experience.

## 2024


### iOS

I believe the plan for the day will be to get the iOS and the android builds as operational as we can.

To start we will first run the prebuild script, just to make sure that everything is good to go!

`./kbve.sh -nx expo-lcagents:prebuild`

After making sure the prebuild script is fine, we can start to setup the iOS integration, using the pods and general native modules.

Next command to run will be the `./kbve.sh -nx expo-lcagents:run-ios`, which will run the iOS simulator/emulator with the application inside of it.

I been debugging the whole `iOS` setup all day and its driving me crazy! I have to take breaks from debugging the code, by `de-bugging` the universe via helldiver.



### Root

It seems that I was doing the `index.js` the wrong way!
I am going to see if I can make it functional for the app as well, hmm maybe this bug is the reason why I was having the other bugs?

---
# March: 28

> 28th of March.

Source: https://kbve.com/journal/03-28/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Isometric

- 10:44PM

  Finishing up some minor tweaks that were long over due for the bevy engine.
  I did need to talk a short break from the unreal side of the codebase, going back to my love and trusted bevy.
  While it is a bit slow to program in rust, I am really enjoying the flow and I hope to get so much better at the dev style.


## 2025

### Test Cases

-   08:05PM

    More twitch test casing, it seems that I was incorrect in my first batch of the twitch-irc-rs tests, as I thought there might have been room for improvements.
    I believe that the crate is already good enough for what we want to do and will continue to build around it.

## 2024

### Arcade

It looks like a couple routes for the KBVE website are broken, let me take some time to resolve those really quick.

Here is the base template that we will add for the `index.astro`

```ts

---
import Layout from '../../layouts/Layout.astro';
import Bento from '../../components/Bento.astro';

import type React from "react";

const title = 'KBVE.com - Arcade';
const description = 'KBVE Arcade! Play your favorite games in your browser!';

---

<Layout title={title} description={description} >

</Layout>

```

We would need to enhance the title and description, lets go ahead and place those into the Chat GPT.

Here is the title that ChatGPT came up with:

> Title: "KBVE.com Arcade - Classic & Exclusive Browser Games"

and here is the description:

> Dive into KBVE Arcade for a blast from the past with our collection of classic retro games, alongside exclusive, in-house developed fun you won't find anywhere else!
> Experience the nostalgia and discover new favorites, all playable in your browser.
> Perfect for gaming enthusiasts looking for a unique mix of old-school and innovative arcade games.

The configuration for the `arcade` collection via zod has to be updated as well, hmm, the question then becomes what should we add for that setup?

Here is the updated zod for the `arcade` collection:

```ts


const arcade = defineCollection({
  schema: z.object({
    title: z.string(),
    status: z.boolean().optional(),
    description: z.string(),
    tags: z.array(z.string()),
    footnote: z.string().optional(),
    author: z.string().default('KBVE Team'),
    img: z.string().default(''),
    date: z.string().optional(),
    url: z.string().optional(),
    icon: z.string().default('https://kbve.com/favicon.svg'),
    unsplash: z.string().optional(),
    swf: z.string().optional(),
    featured: z.boolean().default(false),
    draft: z.boolean().default(false),
    house: z.boolean().default(false),
    promoted: z.boolean().default(false),
    ipfs: z.string().optional(),

  }),
});

```

The `ipfs` is a string that we will use in the future for storing the the various files, making it easier to use.

Now we have to create three modules! The first module would be the game cover, where we would use html to display the game information, controls and any additional information.
The cover would then have a play button and upon clicking on that button, we would use an action to load one of the other two modules.

---
# March: 29

> 29th of March.

Source: https://kbve.com/journal/03-29/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### Astro KBVE

- 07:20AM

Working on cleaning up some more of the KBVE Astro page, we need to figure out ways we can improve the bento grid as well.
I am looking at making sure that the content gets displayed regardless of javascript being enabled or not.
There has to be a cleaner way to make sure that our ts , tsx and astro chain is nearly perfect without having too many issues with the flow.

### CICD Bevy

- 03:18PM

  Updating the pipeline to address the bevy crate publishing, which we should do soon so that there are no issues down the line.
  Making sure the crates do get published without any issues.

## 2025

### Warcraft Hardcore

- 05:49AM

    Level 34 Mage Hardcore!
    Lets go? Magi for the win?!

### Sidecar

- 06:36AM

    Updating the `sidecar.rs` in the Jedi crate for the twitch relay!
    Besides wrapping around the login, I find the development cycle to be way too slow and annoying, hmm.
    Maybe the best way to load the env variables for the twitch bot might be through the postgres / supabase secrets?
    But if I go down that path, then I have to peddle back and finish up the supabase integration, ugh!
    I was reading up on Nix, maybe that might be the next route in my development journey.

### Unity

- 03:57PM

    Saturday means Unity!
    We will be looking at another unity session, hopefully one that will go nice and smooth this time around.
    To be honest, I been slacking on the unity side, so I should spend a weekend or two catching myself up and finally resolving that javascript ffi issue.
    Before the session starts, let me do a quick webgl build and see where we stand.

- 04:28PM

    Unity WebGL build is failing but I can not tell exactly where the dev build is failing.
    The error logs are all over the place, maybe I have some old cache data?
    Best bet would be to clean it all up and try again, I was making room earlier and maybe I might have removed something important.

## 2024

### Ruffle

There was some issues with Ruffle being loaded twice! So it seems that there might be issues in the future with how we load the library, but for now I was able to get it working again.

This can be an interesting test case for future problems that I need to break down, including the dynamic loading of certain types of content, including the phaser or adsense.

The core of the problem was that it was importing and registering the `astro-ruffle` twice, once from the `astro-ve` library and then again with our custom library. The solution, at least in the future, would be to extend the `astro-ve` ruffle component, rather than use the one that we are using,
Yet I feel like that a decent amount of the content does not need to be included inside of the library, as it is a waste of time for everyone involved, mainly because it feels like its an offset library that I do not plan on using on any other website.

Lets go ahead and push this all up the CI/CD and make sure that it works in the production phase.

### Applications

The next part of the application process would be to setup a `video` embed, which I am going to do next!
Okay so the bento grid needs to be updated and the dark theme needs to be stripped out, partly because we do not need to support a light theme.
I rather just stick with one universal theme and focus on that point, maybe later on we can use dynamic colors to help with the light shifting?

The `dark:` tailwindcss has been stripped out from the `bento` and now we can focus on the line clamping.

### Blog

Going to migrate a decent amount of the blog posts, :O that I have saved throughout the decade of time, into their new home directory.
I honestly hope that I do not have to do this again, any time in the future.

Currently the only one that I will migrate for tonight will be `theorycraft`.

---
# March: 30

> 30th of March.

Source: https://kbve.com/journal/03-30/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

## 2026

### OWS to ROWS

- 12:06PM

  Migrating out the older OWS codebase migration into our own ROWS ecosystem with our own plugin.
  This means we will control everything from the standard ROWS endpoint to the Agones deployment.
  What I will have to do is continue to make improvements within our notes system as well, so that the data is kept secure.


### KBVE Website Tweaks

- 01:02PM

  The website needs a couple tweaks with the sidebar, seems that the icons do not load correct or dont have the proper events hooked in.
  While I am working on, maybe I should look at the redraw, making the website feel way smoother when going from page to page.
  Let me start with the pre-fetch, making sure that it is all hooked up.
  The first issue is that the dashboard is currently staff only, we could make one that is agonstic but limit what it presents if they are a user, staff or guest.
  Afterwards I am thinking that when going from page to page, we should have the sidebar collapse.
  I do think the prefetch tags are missing or we might have skipped that whole integration?
  Actually, I just had a great idea, what if I make it so that when I hover over the icons on the sidebar, I could have a drop down menu appear?
  This way we can create a quick link, making it easier to navigate around the website.

### KubeVirt

- 01:16PM

  A while back we deployed the windows server but we were missing some core features within our deployment.
  Three major issues that we left off from, the first is having a vnc that we easily access through the dashboard.
  The second isssue was making the the TCP and networking from the kubevirt was not stable and finally the third issue was getting a proper iac hooked into the windows server.
  I am going to loop through this again and see if we can hook all of them up, making it easy to manage the mac and windows deployment through the dashboard.
  This is going to happen while I am handling some of the tweaks for the website, the vnc should be easy but we will need a way to make sure that the connection is secure.

### KBVE Community Forums

- 01:19PM

  I am currently looking at an agent build out the sql schema and migrations, this way we can have our amazing forum system back.
  That same agent will then shift focus on rebuilding our media and marketplace concept.
  For reference material, I am looking at some older marketplaces that were taken offline or went out of service, hopefully we can find gaps to fill.
  My goal would be not only to make it easy for people to sell different assets, tools and services but have it agent ready too.
  Imagine being able to rent a user's agent or help provide tooling ontop of an exisiting service.


## 2025

### Logo

-   05:10PM

    If I can figure out the task settings for chatgpt, I wonder if I can have it generate more logos and concept art while I am sleeping.
    We are almost at the future, where the AI systems can start performing work for us while I am doing other things.
    Mastering the art of task handling is the next big move for me.

-   06:44PM

    The task that I am going to create next will be for a daily logo generation.
    Here is the current prompt:
    `Design a unique logo concept featuring the letters 'K', 'B', 'V', and 'E'. The logo should be creative, visually appealing, and distinct from any previous designs. Incorporate a different style, theme, or artistic approach each day (e.g., minimalist, bold, futuristic, vintage, abstract, etc.), and describe the design in detail, including the arrangement of the letters, color scheme, typography or shapes, and any additional elements. If image generation is available, provide a detailed description suitable for creating the logo visually. The logo should feel fresh and original while prominently showcasing the letters 'K', 'B', 'V', and 'E'.`
    I set the logo generation to be for each day at around 8AM.

### March

-   05:22PM

    As the day is coming to an end, I need to make sure that all the bills are taken care of before the start of the next quarter.
    Damn, the co-pilot is getting a bit annoying with the journal entries, I will have to maybe disable it for the route of `/journal/*` or something of that nature.


### RareIcon

-   05:26PM

    Build trigger for RareIcon should be the project mdx file for it?
    `apps/kbve/kbve.com/src/content/docs/project/rareicon.mdx`
    Okay, going to edit the `utils-file-alterations.yml` inside of the workflow, to include any changes for `rareicon_unity`.
    Moving forward, we will use this key as a trigger for the unity build.
    Okay, went ahead and added the file changes and trigger, we can push this up to main.

## 2024


### Blog

It seems a couple routes for the `kbve.com` were not yet added, I am going to spend the day going through them all and adding anything that would be missing.

Some of the extra blog articles and documentation would be from the Google drive that we can pull and add into the `blog` content folder, but the different `docs` have to be converted to mdx._createMdxContent

Upon looking through the future blog posts that need to migrated, there are a couple embeds that are missing within the astro source code.



### Discord

Going to update the discord page just a tad bit, maybe add an animation and fix the invite link to the Discord server.
There might be an issue with the way that we are loading the `lottie` package, which I might have to defer or find a way to prevent it from blocking the main thread.



### Project

After fixing up the blog page, we would want to resolve the `project` page with all our active projects.
I am going to just take the old source code and move it over to here, then make small changes here and there until it works out.

As we extend out the codebase, we want to make sure that we keep checking and syncing the code changes, via `./kbve.sh -nx kbve.com:sync` and `./kbve.sh -nx kbve.com:check`.

---
# March: 31

> 31st of March.

Source: https://kbve.com/journal/03-31/

import { Adsense } from '@/components/astropad';


## Notes

## 2026

### Github API

- 09:04PM

  Burning through all my github api tokens because of keda, I will have to find another way to handle the github actions and maybe avoid polling.
  We will have to make a keda-friendly way in the future to handle this situation because we really do not want the windows server or mac server to be just running.


## 2025

### Adsense Routing

-   11:40AM

    Adsense income will be extremely important as the NET 60 cycle starts to get into motion.
    As the payments come in, we need to make sure we have them go towards the right projects and funds!
    I am going to keep this here as a note, so that when I loop back around to this entry, I can go back and make sure everything moves in the right flow.
    Each deposit has to then set aside an amount for the taxes, then sit another portion aside for equipment and business costs.
    Getting the projections and the cycle started and in full force is a bit tough because the earnings are still swinging too much for each day.

### Bills on Bills on Bills

-   05:25PM

    After finishing all the payments for this month, I noticed that the surplus is a bit too high.
    We are sitting at around a couple bucks that we were not expecting, I believe it might be from the `discord` sale, maybe I forgot something?
    A massive surplus after a couple years is always a bit interesting, hmm.


### March

-   06:09PM

    End of the month, the bills are always coming through!
    The decisions that I will make this year will be important, one of them will be to unload a large amount of the domains that I hold.
    My plan is to unload and quickly sellf off around half of the domains that I have, with the goal of reducing yearl costs of renewing and also getting capital back upfront.
    The capital that I get will go straight back into REITs, that I will be holding forever.

### CICD

-   06:28PM

    As we reverted back to the `main` and `dev` branch, I wanted to loop back and start using re-usable workflows.
    The plan would be to move all changes into these isolated workflows because it will make the management easier in the future.
    Once more, the upfront costs verse future benefits always becomes an issue when it comes to debugging.
    The objection against this is that its really really pushing the over-engineering to the point that it is boarderline insanity.
    However, the skills gained from setting this up and continuing to push the boundries will out weigh anything that I am doing right now.

-   06:37PM

    Azure failed during the first run, I will have to loop back around and see where it failed?!
    It seems that there are two point of failures that I see from the logs, the first would be maybe the azure token parsing was incorrect.
    Or the second issue could be that the information for the azure location is wrong.
    Let me take a momenet and look back at the older workflow that this was based off of.
    Yup, I passed the wrong token, going to update the workflow again.

-   08:12PM

    Preparing the 2nd test and hopefully we can figure out the next problem in our pipeline.
    Let me start the next trigger once more, updating the unity version to avoid that recent build failure.
    Ah, another failure was the mismatch in the unity version, patched it now.

### gRPC Disoxide

-   10:11PM

    Time to take a quick break from the Unity pipeline and finish up the gRPC for Disoxide!
    Before we make that change, I need to update the jedi crate to v0.2.
    Ugh, I will have to also loop back around and look at updating the holy crate too.

## 2024

### KBVE

I spent most of the day fixing up the front page and learning about a couple different libraries.
I hate having to rebuild our website all over again from scratch, but it seems that it might be the best move to help us moving forward with a production ready site.
While I am building the site out, I also started to process the migration of rent earth to the monorepo, as well as a couple secret projects that I want to launch this summer.


### Hardware

I might have to take a break from the software side, mainly the front-end and go either back to doing backend or maybe an embedable device?
The UX/UI session is always fun but doing responsive design can become annoying and a huge time waste, definitely when minor screen aspects become super annoying!
For hardware, I am most likely going to focus on the flipper zero or maybe an orage pi cluster? Hmm, I will have to think it through and maybe land on a robot?


### GameJam

Preparing for the Discord App 2024! We will be building a 3D style game and hopefully we get far with the build?!
There might be concerns with how the project will go but I am thinking we can get far, as long as we focus on the mission at hand.


---

### CodePen

There are three really cool and amazing codepens that I found!

- https://codepen.io/sdras/pen/gWWQgb
- https://codepen.io/konstantindenerz/pen/poYVOpv
- https://codepen.io/yudizsolutions/pen/bGzKbwm

All of the three were amazing! I am thinking of taking them apart and adding them into the Astro VE library as a reference for future projects.

<Adsense />

---
# April: 01

> On April 1st, the world becomes my playground, a day when chaos and laughter intertwine, and everyone gets a taste of shaco's delight.
It's a glorious moment where pranks bloom like flowers in spring, a reminder to dance on the edge of madness and never, ever play it safe.

Source: https://kbve.com/journal/04-01/

import { Adsense } from '@/components/astropad';



## Notes

## 2026

### Isometric Networking

- 11:10AM

  Looking at the networking for our bevy game and trying to figure out the best way to handle the base connection.
  It might be that I am trying to run the websocket and the web transport on the same netcode, thus causing this issue, damn it.
  If that is the case, then that means we did end up spending way too much time trying to resolve it.

## 2025

### Unity CICD

-   04:40AM

    Made more changes to the base pipeline at the azure level and once the custom map is rolled out, we can start the UIUX.
    The gameplay will be to add the custom characters, then add the first custom map + item collections.
    Once all of that is integrated, we can do the first level roll out on Steam.

### JokeCity

-   09:34AM

    I have to remind myself that nothing is real today and the memes are alawys in full force.
    But that should not be a big deal, I will just stay away from the news xD.


### Twitch IRC

-   07:40PM

    Making sure that the twitch irc works, we will have to look into how the `refreshing-token` feature is being used in the crate.

## 2024

### Docker

Getting the `express-colyseus-discord` build operation on the portainer will be the goal for today!
This includes having an endpoint for the portainer communication, which would include the deployment of any changes via github actions.
We need to keep track of the X, Y, Z and maybe a couple other variables in a 3D space?

The next variable that I will be adding is the `action`, which is a string for now!
This is just extending the `TPlayerOptions` with `action` and then defining the action as a type string.



### LCAgents

We want to move the changes for LC Agents outside of the `ci-alpha` and towards the `ci-main`, so that we can keep the changes in order!
After moving it towards the main branch, we can extend out the iOS and Android build process for Expo, now we need to make sure that the current flow will work.
We might also want to automate the pull requests that it makes on the LC Agents repo as well, hmm.

Here is the pipeline that we are migrating with this push:

```yaml

        expo-lcagents-web-build:
            needs: ['alter']
            name: Expo LC Agents We Build
            runs-on: ubuntu-latest
            if: needs.alter.outputs.expolcagents == 'true'
            steps:
                -   name: Checkout repository
                    uses: actions/checkout@v4

                -   name: Setup NodeJS
                    uses: actions/setup-node@v3
                    with:
                        node-version: 18

                -   name: Setup PNPM
                    uses: pnpm/action-setup@v3
                    with:
                        version: 8
                        run_install: false

                -   name: Install react-native-cli globally
                    run: pnpm add -g react-native-cli

                -   name: Install dependencies
                    run: pnpm install

                -   name: Setup Watchman (if applicable)
                    run: |
                        sudo apt-get update
                        sudo apt-get install -y watchman
                        watchman --version

                -   name: NX Command
                    shell: bash
                    continue-on-error: true
                    run: |
                        pnpm nx run expo-lcagents:export --verbose

                -   name: NX Command - 2
                    shell: bash
                    continue-on-error: true
                    run: |
                        pnpm nx run expo-lcagents:export --verbose

                -   name: LCA Expo Build
                    uses: ./.github/actions/kbve-shell
                    with:
                        flag: '-nx expo-lcagents:export'
                        create_pull_request: false
                        github_token: ${{ secrets.GITHUB_TOKEN }}

                -   name: Create .nojekyll file
                    run: |
                          mkdir -p dist/apps/expo-lcagents/
                          touch dist/apps/expo-lcagents/.nojekyll

                -   name: Create CNAME file
                    run: |
                            mkdir -p dist/apps/expo-lcagents/
                            echo "lc-agents.com" > dist/apps/expo-lcagents/CNAME

                -   name: LC Agents -> Deployment
                    uses: dobbelina/copy_file_to_another_repo_action@main
                    env:
                        API_TOKEN_GITHUB: ${{ secrets.UNITY_PAT }}
                    with:
                        source_file: 'dist/apps/expo-lcagents/'
                        destination_repo: 'kbve/lc-agents.com'
                        destination_folder: '/docs'
                        destination_branch: 'main'
                        destination_branch_create: 'patch-kbve-lcagents-deploy'
                        user_email: '5599058+h0lybyte@users.noreply.github.com'
                        user_name: 'h0lybyte'
                        commit_message: ${{ github.event.head_commit.message }}
                        rsync_option: "-avrh --delete"

```


### Pipeline

Under the `beta` branch, we can extend out integration testing, something that I can plan around this month.
We will start with the `kbve.com` repo , which will just build the site, making sure that it runs?
The other idea would be to deploy the `beta` of the website to `beta.kbve.com`, as an additional metric, but that might be something we can look into within the future.

We will be using the `any_changed` to calculate any of the files that are changed.



### LC Agents

Here is the older code block for the LC Agents Expo application.

```js

import { registerRootComponent } from 'expo';

import { ExpoRoot } from 'expo-router';
import 'expo-router/entry';
import BaseApp from './src/app/_layout';



// The ExpoRoot component requires a React element, not a component class or function directly.
// Therefore, we create a simple wrapper component that returns BaseApp.
function AppWrapper() {
  return <BaseApp />;
}

// Pass the wrapper component to ExpoRoot.
// ExpoRoot will take care of rendering your application within the Expo environment,
// ensuring that routing and other setup is handled correctly.
//registerRootComponent();

//ExpoRoot(<AppWrapper />);

// 03-27-2024 Changes


export function App() {
   const ctx = require.context('./src/app');
   return <ExpoRoot context={ctx} />;
}

registerRootComponent(App);


// Create a new component that renders ExpoRoot with AppWrapper.
// This component will be the entry point of your application.
// function RootComponent() {
//   return ExpoRoot(<AppWrapper />);
// }

// registerRootComponent(RootComponent);
```

However there are a couple errors that are appearing in the source code, including this one:

`You are calling ReactDOMClient.createRoot() on a container that has already been passed to createRoot() before. Instead, call root.render() on the existing root instead if you want to update it.`

So there might be an issue with how we are doing the root / application rendering.

<Adsense />

---
# April: 02

> 2nd of April!
April 2nd arrives with a serene calm, the playful chaos of April Fool's Day having retreated into memory, leaving behind a day for reflection and the ordinary pace of life.
It's a day that bridges the light-heartedness of jest with the groundedness of routine, reminding us of life's delicate balance between joy and duty.
In this quiet aftermath, I find a renewed sense of purpose and a deeper appreciation for the unexpected moments of laughter and the comforting rhythm of the everyday.

Source: https://kbve.com/journal/04-02/

import { Adsense } from '@/components/astropad';

## Notes

## 2026

### Rust Docker Improvements

11:15AM

These long docker build times are definitely something we can improve upon.
We added the mold earlier but I might loop back around and see if there might be another way to improve the build times.


### Faster Axum KBVE Builds

05:22PM

We should take some of the time that we spent looking through the logs and maybe find some improvements?



## 2025

### CryptoThrone

-   01:45PM

    The unity and rust pipelines have been migrated, so the next batch will be the astro ones.

### Fred Redis

-   05:00PM

    Spent a decent amount of time looking over the `fred` crate and it might be best to replace the current redis / bb8-redis with this crate instead.
    It has everything that we need and would shift the maintenance of the redis over to something more reliable.
    I already made issue tickets regarding this update, so it will be only a matter of time before I start the switch.

## 2024


### Videos

To add videos to our websites, we have a couple options that we can take!
I am thinking that the best move would be to have one `component` within the Astro VE library and then extend that component out in various websites that would use the component.
The customization would be during the component extension, but we would keep the core configuration within the `Astro VE`, with that being said, the aspect ratio would be an issue that has to be resolved.

We could also load an image for the video and then actually load the video upon clicking the image? This way we can have multiple videos ready, depending on the topic, without causing a major lag spike within the rendering.

---


### Portainer

The next step would be to update the `portainer` route within the Rust API to help manage different stacks outside of the `Rust API` itself.
I am thinking of doing a couple different routes to help handle the docker swarm and the k8s, but I should map it out before building it.

---


### Python

I started to map out the python modules for Atlas and the plans for the initial package deployment + example.
Under the `kbve` module, we will split up the different parts of the library, one being the original atlas but the there might be three or five more parts of this module that we have to build out.
However given the scope of this requirement and the limited time that we have, ugh, we have to very careful on how we structure the next moves within the python realm.



---


### Colyseus

The next step after the docker build for the `express-colyseus-discord` would be to setup the docker compose and the k8s helm chart.
For the start of this application, we will stick with a swarm compsoe but movikng towards the k8s structure would make sense because we want this to be stateless.

Here is the basic compose that we will test case:

```yml

version: '3.8'

services:
  colyseus:
    hostname: colyseus
    image: kbve/expresscolyseusdiscord:latest
    container_name: colyseus
    restart: unless-stopped
    environment:
      - VITE_CLIENT_ID=PASTE_OAUTH2_CLIENT_ID_HERE
      - CLIENT_SECRET=PASTE_OAUTH2_CLIENT_SECRET_HERE
    configs:
      - source: lavalink_copy_copy
        target: /opt/kbve/config.yml

    volumes:
      - /opt/kbve/

    networks:
      - colyseus

    expose:
      - 3000

configs:
  lavalink_copy_copy:
    external: true

networks:
  colyseus:
    name: colyseus
    driver: overlay
    attachable: true

```



---

### API

Mapping out the routes for the deployment has to be done right this round, including making sure that the applications that we build can easily be deployed and maintained.

<Adsense />

---
# April: 03

> 3rd of April.
In dat gentle embrace of the night, my dream wove a tapestry of April showers, where each raindrop whispered tales of renewal, hope and feelings of spiritual dope.
As dawn's first light peeked through, the world outside mirrored my dream, painting everything with dat fresh, dewy promise of a new beginning.

Source: https://kbve.com/journal/04-03/

import { Adsense } from '@/components/astropad';



## Notes

No major notes as of right now.


## Tasks

-   [X] -   Preparing Bun Docker Image.
-   [ ] -   Astro CICD.


## 2026

### Websockets Envoy

- 04:45PM

  The damn websockets, what a hell ride of http 1, 2 and 3.
  I am getting closer but the amount of errors were intense, a ton of back and fourth but I was able to get closer to my goal.
  We are just a couple more days away from having our internal VMs that we can control via our own custom dashboard.
  While I am building this out, I am thinking that I should have switched to cozy stack as a baseline, but its too late now, oh well.

## 2025

### Cloudflare Wrangler

-   11:40AM

    I am wondering if there might be a way to handle the static content within a certain scope but also still have the dynamic flexibility.
    Based upon the current setup, it seems that it might not be as easy as I would have thought.
    The first idea could be to route the traffic through the generic path and key setup, throw a cache header on it all but besides the dynamic end points.
    Execution of the initial deployment failed yesterday but I made some changes to the root repo.
    Even though I stated in the deployment to skip the yarn files, it seemed to continue to install and use it, so we just dropped it all.
    Sadly this is not going to be the path that we want to take, so I will have to stick with what I had originally planned.

### Wheel of Time S1

-   08:35PM

    Damn, another new show that has hooked me in!
    It feels like a warcraft dnd campaign, with the way they are setting up the world, environment and characters.
    Already getting ready for season 2, its getting there as well!

### MiniJinja

-   10:34PM

    Plan as of right now, start with the astro static build.
    After the static build is done, we include the `HTML` comments for the minijinja crate.
    Once the build is done, we run a shell script that executes a series of sed commands to replace those commented sections aka formatting to Jinja.
    After the formatting is done, we can then run the minijinja build and have it output to a new folder.

## 2024


### Tesla

The earnings for Tesla were terrible for the future of the company and its growth!
I actually think part of the reason behind the slow down in the growth cycle would be the higher interest rates and the general brand image of Elon.
While the fed could lower the rates, as they are already hinting at cutting the rates about three times this year, the brand image for Elon is going to be tough to repair.

Overall there has been no major shifts in the way we hold shares, I will try to poor man cover call them or push the strike price out as far as I can within reason.

If the company shares drop even to the low $100, we might actually switch to doing puts, because the value is there.

---


### Apple

I am hoping that AAPL does spike back around to the mid $180s, but we might have to take a L and drop a couple hundred shares to fund our war chest!
This will be a bit tough to work out, considering the cost for the food truck and its operations are going be expensive for the first couple months.


---


### N8N

The next plan for this weekend will be to setup another instance of n8n and then finally close out the `coolify` instance , as we will migrate everything into the swarm.
Once the swarm migration is complete, we can start to spin up the `k8s` cluster and begin our stateless adventures!

---


### Bounty

The bounty system is next in the chopping block for the summer, I want to pool in around $10,000 - $20,000 for the bounty rewards, with the goal of making it easier to solve the problems within this monorepo.
I feel like once we get a couple new projects into this pipeline and have full featured functional products, aka FFF, rather than just basic MVPS, this would be the next logical step.
As more open source projects are coming to the market, we will have to find a way to reward the users that contribute to our repo.


---


### PGP

The message system is still under works! The plan is to extend out the API table and include a new webhook table.
Hmm, this part of the journal is a bit of a mess to keep on record.



---

### Bun

When building out the bun docker image, we have to take a look at the current eco-system around it, i.e `websockets`, and make sure that final image is production ready.

Our notes for [Bun](https://kbve.com/application/javascript/) are inside of the Javascript section, incase you need a reference.

The official bun images are located [here at their docker hub](https://hub.docker.com/r/oven/bun/tags) and for this test case we should take a look at their `distroless`.

It is under the tag of `docker pull oven/bun:distroless` but for the development cycle we might either use `1` or `1.1` as writing this.

The issue ticket of interest is [here](https://github.com/oven-sh/bun/issues/4836), which goes into the general structure of what we would want to do for our colyseus docker image.




---

### API

To get started with adding the `API` route, lets make sure that the current rust build is fine locally, given the recent changes to the monorepo.

We will head over to the `project.json` for the `rust_api_profile` and see that the dev command is `run`, thus we will execute `./kbve.sh -nx rust_api_profile:run` and that should place the API on port 3000.
In this situation we want to make a new route, called `actions` and have it require that we pass the `API` token and followed by the path.

Under `actions`, we can create a sub-route called `n8n`, which will handle our `n8n`-based actions via the Rust API. Since we already have the tables created, we can have the path look up the ulid for the n8n webhook and then pass the information that is being sent over to it.

We already have an n8n instance up and running, so we can use that instance to help us manage our application.

While we do have an instance of n8n already running, this would be a good time to isolate the instances, with one being in development and the other in production.

```yaml

version: '3.8'

services:
  n8n:
    hostname: n8n
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    deploy:
      mode: replicated
      replicas: 1
      labels:
        # Base Traefik Labels
        - traefik.enable=true
        - traefik.constraint-label-stack=n8n
        - traefik.docker.network=public
        - traefik.http.services.n8n.loadbalancer.server.port=5678
        - traefik.http.routers.n8n.rule=Host(`automation.kbve.com`)
        # HTTP
        - traefik.http.routers.n8n_http.entrypoints=web
        - traefik.http.routers.n8n_http.rule=PathPrefix(`/`)
        - traefik.http.routers.n8n_http.service=n8n
        # HTTPS
        - traefik.http.routers.n8n_https.entrypoints=websecure
        - traefik.http.routers.n8n_https.rule=PathPrefix(`/`)
        - traefik.http.routers.n8n_https.service=n8n
        - traefik.http.routers.n8n_https.tls=true

    volumes:
      -

    networks:
      - n8n
      - rust
      - public




networks:
  n8n:
    name: n8n
    driver: overlay
    attachable: true
  rust:
    external: true
  public:
    external: true

```

We can have the n8n public facing from the start but eventually we would want to proxy this out as a subfolder? Hmm.

<Adsense />

---
# April: 04

> 4th of April

Source: https://kbve.com/journal/04-04/

import { Adsense } from '@/components/astropad';


## Notes

Automation for the n8n is done! We are just going through the different endpoints to make sure that it works as planned.


## 2026

### Single Draw Call Sprites on Bevy

The main focus for the day was to get single draw calls out of the way for the bevy engine.

## 2025

### Markets Post LibDay

-   04:47PM

    Damn, markets just did a back to back 5% drop, which is insane!
    Now the question is when to come in and start to buy cheaper stocks, hmm the chaos is going to be wild.
    We could see another drop next week, once the options start flowing in.

### MiniJinja

-   07:06PM

    The game plan for now is:
    1. Astro build website
    2. Run shell script to replace the commented code with the minijinja.
    3. Then Import the minijinja template.

    After doing some additional research and we could use Askama instead?
    Another option would be to just move into the Disoxus but we still want to keep our astro-like website.

## 2024

### KBVE

Minor tweaks to the front page! Just to get the general flow out of the way.

The pictures for the slider below are terrible and need to be updated.

The `carousel:highflyer:wave` component was missing the slider varaibles, which would be the images that would be inserted into the gallery.
I am thinking that we put the most basic images that will match the color scheme, mainly with the color of cyan.

For now, I am going to place a bunch of cyan-color based images from unsplash!
In the future, I think we should try to build up our kbve unsplash profile and create a bunch of photographic art for everyone to use.


---


### Mail

The plan for the day is to research the `mailu` instance!

It seems that the `Mailu` server does not support swarm.
Here is the issue ticket as a [reference](https://github.com/Mailu/Mailu/discussions/3128), as it seems the maintainer does not plan on supporting the swarm.
However they do have a k8s setup, so we could go down that route and use that for the mail server.

If Mailu is going to give us a problem, then we can shift over to the `Docker MailServer`, while test casing the `mailu` changes.

Here is the guide that we will be [following and using as a reference.](https://docker-mailserver.github.io/docker-mailserver/latest/examples/tutorials/basic-installation/)


---

### 404

The new 404 page will be ready by this weekend but I do need to focus on the Discord App Pitch, which might delay a bunch of progress on the website.

<Adsense />

---
# April: 05

> 5th of April. Godzilla has awaken.

Source: https://kbve.com/journal/04-05/

import { Adsense } from '@/components/astropad';



## Notes

## 2026

### Bevy Plugins

10:15PM

  These are just notes for my bevy plugin concepts, I am thinking that we dedicated a decent amount of the time towards building different plugins.


## 2025

### Disoxide

-   04:26PM

    The websockets have to be adjusted twice, once for our custom RESP3 Redis Envelope and again when we swap it out for Fred.
    I will take a quick break on that and shift focus on the Unity issues before the meeting.
    Stashing some of the changes and will revist this error when I have a clear thought, ugh.

### Unity

-   04:47PM

    Finishing up the Chipi animations?


## 2024


### EarthQuake

There was a rude morning shift of plates by mothernature!
She made the whole NYC shake a bit but it was just a mild wake up call for our natural fears.

### Discord

There are a couple problems with the Discord App Embed that I want to work out and resolve, this includes how we are handling the different URL Mappings.
For this quick session, I am going to take it apart and see if I can resolve it with Fish & Chip.

I am thinking that the first step would be to isolate the different folders and then work within that scope.
`kbve.com/public/embed/discord` will be the main location for the embeds, then an additional folder for each `DiscordEmbedSDK` application.
For this test case, we will have two, `dreambound` and `fishchip`, but I am open to expand it out to a couple more as I test case.
I lied, I believe we will have a third folder for this test case well! Okay now let me start with the basics and work around that for this application.

### Email

After looking through the options for a mailserver, the one that stands out the most for what we are building is [Stalwart](https://github.com/stalwartlabs/mail-server).
It has a rust backend and is supported through an EU grant for Open source technology, which is a huge +1 for the application.
The software has a decent amount of progress and provides an all-in-one solution that we were looking for, however my bigger concern would be the amount of storage that email servers would take.
We could address this concern by keeping the emails only for 72 hours and/or forwarding them over to our GMAILs, but this is all for a future date.

<Adsense />

---
# April: 06

> 6th of April.

Source: https://kbve.com/journal/04-06/

import { Adsense } from '@/components/astropad';


## Notes

Prepare the side account for the IRS bill.

## 2026

### Isometric

Majority of the day was spent working on a bevy game that uses wgpu!
We aded some ambient creatures and worked on the general and casual vibe for the game.
A large amount of the time was spent trying to get the pixel shader to be operational and not look like trash xD.


## 2025

### Fred BB8

-   07:04PM

    While I was refactoring the redis wrapper to use a thin linear layer, I came to the understanding that it would make sense to swap out the bb8.
    Replacing the bb8-redis and redis crate with the fred crate because it solves a decent amount of the issues that those two previously could not.
    Each rewrite, puts us further back in the timeline but it improves the stability and understanding for the long term.
    I suppose this is the rough part of rust, having to refactor over and over.
    Thus, the next refactor after this refactor will be to use flexbuffers and binary.

-   08:17PM

    One of the changes with this refactor will be taking out the bb8 pool system and using a multiplex from fred.
    I understand this but it does feel a bit weird to do.
    We will have to do it again when we updated Postgres to version 17 on the Supabase image.
    In a normal pool, we would have multiple connections and use a borrowing method for each of the connections within the pool.
    Hmm, I will have to write this out a bit more and maybe it might fully click.

-   09:31PM

    Updating the temple state, hmm.
    Dropping the `pub redis_pool: Pool<RedisConnectionManager>` and replacing it with a redis client from the fred crate.
    Wait, I was confused on the whole pool concept, but I think I understand it a bit more.
    

### The Wheel of Time

-   09:25PM

    Season 2 of the Wheel of Time is turning out to be even better!
    This series better not go the way towards of Game of Thrones.

## 2024


### DreamBound

Preparing the docker build for the DreamBound platform and the state management within the structure.
We had to move all of Erni's codebase from this repo into the `kbve` repo, but did not get a chance to refine and process the codebase.

Part of the code migration was a bit of a pain because of the typescript safety, however we were able to convert and ready most of it.
The next step would be to make sure everything gets wrapped into a single docker Image.

For the `dev` cylce, we will be using this command: `./kbve.sh -nx express-colyseus-discord:serve`.

As for the production image, we will be running `./kbve.sh -nx express-colyseus-discord:build:production --export`.

Going to go ahead and push these changes through, as the most recent build had a failure.
I am thinking the build failed because we had two additional files that we did not need, so lets see if that was the case.


### Food

The best meal that I had today was a classic maggi soup made by my aunt!
The taste of India hit all the notes that I was look for, savory, sweet, spicy, ect... there could be a food truck that only sold this meal and it would make thousands a week.

<Adsense />

---
# April: 07

> 7th of April.

Source: https://kbve.com/journal/04-07/

import { Adsense } from '@/components/astropad';



## Notes

Prepare the side account for the IRS bill.

## 2026

### Firecracker VM

the idea here is that while we have edge functions for micro services, I was thinking that we use firecrackers for the python scripts.
This means if we need to quickly utilize ffmpeg or maybe take a PNG and convert its background to PNG, all of these random tasks can be done using a python script.
Later on we can even go as far as extending it out so that it automatically creates shader atlas from PNG images too.

However, the main focus is to get a couple functional services out and about, with them all operating safely.

## 2025

### TempleState

-   12:47AM

    Next part of the `jedi` package will be to refactor the whole `TempleState` to use the fred package instead of the `redis` package.
    Hmm, this will be a big change, but I think it will be worth it in the end.

## 2024

### Rust

These are the notes from Remy regarding the first file of the `kbve` package!
I am going to place them here and then move them into the library.

For Password character checking, Remy suggested this:

```rust
  match password.chars().count() {
    // Check if the password is long enough (e.g., at least 8 characters)
    0..=7 => return Err("Password is too short"),
 
    // Check if the password is not too long (e.g., no more than 255 characters)
    256..=usize::MAX => return Err("Password is too long"),

    _ => ()     
  }

```

Here is an example of the fold method for checking the characters:

```rust

  let conditions = password.chars().fold([false; 4], |mut acc, c| {
    let acc1 = [char::is_uppercase, char::is_lowercase, |c: char| c.is_digit(10), |c: char| !c.is_alphanumeric()].map(|f| f(c));
    (0..4).for_each(|i| acc[i] |= acc1[i]);
    acc
  });

  if conditions.into_iter().fold(false, |acc, cond| (acc|!cond)) {
        return Err(
            "Password must include uppercase, lowercase, digits, and special characters"
        );
    }

```

If we expand the `acc1`, then we can do this instead:

```rust

let conditions = password.chars().fold([false; 4], |mut acc, c| {
    let acc1 = [char::is_uppercase, char::is_lowercase, |c: char| c.is_digit(10), |c: char| !c.is_alphanumeric()].map(|f| f(c));
    (0..acc1.len()).for_each(|i| acc[i] |= acc1[i]);
    acc
  });

  if conditions.into_iter().fold(false, |acc, cond| (acc|!cond)) {
        return Err(
            "Password must include uppercase, lowercase, digits, and special characters"
        );
    }

```

Here is a better way of writing the `sanitize_path` function:

```rust

pub fn sanitize_path(input: &str) -> String {
    let mut sanitized: String = input
        .chars()
        .filter(|c| matches!(c, 'a'..='z'|'A'..='Z'|'/'|'?'|'@'|'%'|'$'|'#') )
        .collect();

    if sanitized.chars().count() > 255 {
        sanitized.truncate(255);
    }

    sanitized
}

```

Next, we have a better way to do the ulid string to bytes: 

```rust

pub fn convert_ulid_string_to_bytes(ulid_str: &str) -> Result<Vec<u8>, String> {
  Ulid::from_str(ulid_str)
    .map(|o| ulid.to_bytes().to_vec())
    .map_err(|_| "Invalid ULID string".to_string())
}

```

And vice versa, for bytes to string:

```rust

pub fn convert_ulid_bytes_to_string(ulid_bytes: &[u8]) -> Result<String, String> {
    let 16 = ulid_bytes.len() else {
        return Err("Invalid ULID bytes length".to_string());
    };

    // Convert the slice to an array
    let ulid_array_ref: [u8; 16] = ulid_bytes.try_into().map_err(|_|"Failed to convert slice to array")?;

    // Convert the Ulid to a string
    Ok(Ulid::from_bytes(ulid_array_ref).to_string())
}

```

We could clean up the `cors_service()` function as well:

```rust

pub fn cors_service() -> CorsLayer {
    let orgins = [
        "https://herbmail.com",
        "https://kbve.com",
        "https://discord.sh",
        "https://hoppscotch.io",
        "http://localhost:3000",
        "http://localhost:4321",
        "https://kbve.itch.io",
        "https://html-classic.itch.zone",
    ].map(|url| url.parse::<HeaderValue>().unwrap());

    CorsLayer::new()
        .allow_origin(orgins)
        .allow_methods([Method::PUT, Method::GET, Method::DELETE, Method::POST])
        .allow_credentials(true)
        .allow_headers([
            AUTHORIZATION,
            ACCEPT,
            CONTENT_TYPE,
            HeaderName::from_static("x-kbve-shieldwall"),
            HeaderName::from_static("x-kbve-api"),
        ])
}

```

Last two were the health check, which would look like this:

```rust


pub async fn health_check(Extension(pool): Extension<Arc<Pool>>) -> Result<
    Json<WizardResponse>,
    StatusCode
> {
    let connection_result = task::spawn_blocking(move || { pool.get() }).await.flatten();

    match connection_result {
        Ok(_conn) => {
            Ok(
                Json(WizardResponse {
                    data: serde_json::json!({"status": "online"}),
                    message: serde_json::json!({"health": "ok"}),
                })
            )
        }
        _ => { Err(StatusCode::SERVICE_UNAVAILABLE) }
    }
}

```

and finally the `speed_test`, which would look like this:

```rust

pub async fn speed_test(Extension(pool): Extension<Arc<Pool>>) -> Result<
    Json<WizardResponse>,
    StatusCode
> {
    let start_time = Instant::now();

    // Use `block_in_place` or `spawn_blocking` for the blocking database operation
    let query_result = task::block_in_place(|| {
        let mut conn = pool.get().map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;

        // Execute a simple query
        diesel
            ::sql_query("SELECT 1")
            .execute(&mut conn)
            .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)
    });

  query_result?;

  let elapsed_time = start_time.elapsed().as_millis() as u64;
    Ok(
        Json(WizardResponse {
            data: serde_json::json!({"status": "time"}),
            message: serde_json::json!({"time": elapsed_time.to_string()}),
        })
    )
}

```

Bonus function , getting the environmental variable function:

```rust

fn get_env_var(name: &str) -> Result<String, String> {
    let file_path = env::var(name);
    if let Ok(_) = &file_path {
      return file_path;
    };

    let Ok(file_path) = env::var(format!("{}_FILE", name)) else {
      return Err(format!(
        "Environment variable {} or {}_FILE must be set",
        name, name
      ));
    };

    fs::read_to_string(file_path).map_err(|err| format!("Error reading file for {}: {}", name, err))

```

<Adsense />

---
# April: 08

> 8th of April.

Source: https://kbve.com/journal/04-08/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### Markets Tar Rifts

-   04:40PM

    Brutal swing down, just confirming that dead cat bounce theory xD jk jk.
    I was debating to trade SPX earlier this morning but honestly, this is just too wild to keep track off and its worse than a casino at this point.

### Flexbuffers

-   06:14PM

    Damn, even before I could finish the websockets, I am going to postpone it and move forward with the gRPC/FlexBuffers.
    My thought process is that I must have either skipped something or missed something in the documentation, ugh, I am just getting a bit too burnt out trying to figure that out.
    If I refactor the code to include the u8/binary then maybe I could find where the thin command issue might be from?
    As for the event pubsub, we had it working before in the redis / bb8-redis setup, so there might be just a slight change in the logic when using the fred multiplex.
    Step one will be to check the flexbuffer crate that is under the jedi, I think I already did add it but I will double check.


-   08:34PM

    One of the parts that gets a bit confusing is the isolation of the json and binary, since both need to have their own optimizations.
    Had we gone down the path of creating an unified binary, there might be a cost in performance that would not be worth it.
    Thus, we will have duplicate code but it should be worth it in the end.
    There is still room for the MessagePack and Captain, but it might be something that we will have to do much later on.

-   08:56PM

    There will be a split in the Transport Layer and Application Logic Layer that I need to do when figuring out the right paths to take.
    The websocket will take both the JSON and Binary, but as the data comes in, we will have to map and split it, a bit of a highway that takes both cars and trucks.

## 2024


### Python

Time to mess around with python, continuing from yesterday!
I had taken a break from doing anything with the P & Y, that I forgot so many basic things related to the library and language.

---


### LCA

There are some sections for the LC Agents that need to be updated but within those updates, we need to expand and brush up on the Expo-BBQ library as well!
Ugh so many different libraries that have to be worked on, yet so little time to focus on them all.

To get the base of the `apps/expo-lcagents` started, we will run `./kbve.sh -nx expo-lcagents:serve` and wait for the metro bundler to do its magic.
FYI, the time it takes to bundle and prepare everything is so slow, I can feel the pain from the little javascript engine that could.

We will add the new `about.tsx` section and while doing that, I am going to add a new library called, `expo-linear-gradient`.

To add this library, we will do `pnpm install expo-linear-gradient` and then make sure to setup the expo, iOS, android configurations. In this case, the iOS will need to have the pods rebuilt.

After doing that, we would look at adding more components into the Expo BBQ!

Sadly, I was not able to get a bunch of the different components up within the package today, but instead had to restructure the way that the router functions within expo-lcagents.

I migrated some of the routes into the `tabs` folder and plan to abstract away the navigation to `_nav.tsx`, there was a decent amount of learning to do with expo and react native, but I am getting the hang of it.

---
# April: 09

> 9th of April.

Source: https://kbve.com/journal/04-09/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### Market Tar Rifts

-   04:40PM

    Just like the last time we had a market crash, things just flip over really quick.


### DiscordSH Research

-   07:55PM

    Okay! I am thinking that a quick way to grow up the DiscordSH website would be to make a card game built into the bot?
    We can then use the `discord.sh` to host the different cards that would be displayed and collected, then offer a trading platform for them.
    The main site would still be a topsite, this would just be a way to advertise the website and get people to visit the website.
    As for the card game, we could work out the exact specifics that would be required, but I am positive that we can make it work, given the resources that we have.

-   08:06PM

    Anime Wifu Bot/Game?
    It seems that there is massive demand for this type of game as well, hmm.
    I am not too sure how I feel about it but it would be interesting to see it built out and maybe could be offered as another / additional bot?
    I am also wondering what the costs would be to run both of these bots at the same time, I think the server should be able to handle it.

### WoW Hunters

-   08:05PM

    Hunter and Mage run, but this time we use the boar to gather all the mobs together and then have the mage do the AoE damage.
    The boar would act like the tank and eat the hits from the different monsters, while the mage does the frost blizzard damage?
    The more that I am thinking about it, the easier that it will be.

-   11:43PM

    Looks like we were running priest and mage this time, but I think the combo should be tested in the future.

## 2024


### Discord App Pitch

The docker build seems to error out for the Discord App Pitch 2024 game, so lets take a look at the error and see what we can do to resolve it.

The Docker build on action #1273 had this error:
`apps/express-colyseus-discord/src/rooms/MyRoom.ts:1:30 - error TS2307: Cannot find module '@colyseus/core' or its corresponding type declarations.`

and then we went ahead and did the `pnpm install @colyseus/core` and then I will push this through and see what the next error might be.

There were a couple other errors, but that might have been either a typescript error because the the module was missing OR our typescript configurations might be wrong.

Yay! We were able to get the docker to build and publish, now its time to update the docker compose and add in our game files into the build process.


### Charles 

The new power supply is in and I will go ahead and swap it out.

If the power supply is not the issue then the bigger issue would be the amount of power that is coming out of the outlet, ugh, that would be terrible for us.



### GHA

We need to update the Github Actions to perform test casing and integration testing across the board, but this might be a bit more painful than what I had expected.

Besides updating the actions to perform intergration testing, we also need to update the deprecated node v16 instances within our actions, bumping it up to node 20.

Part of this issue might be our node 18 usage as well, so going through all the code and making sure that we are using only node v20 as of right now.



### Python

After we release a new python library version of atlas, we would want a function that gets called to help bump the version up by `0.0.1`, so in our action we release version `1.0.3` and now we want it to automatically bump it up to `1.0.4`.

For this situation, we can take a look at how we handle the cargo version bump and use that concept as a base for the automatic version bump.

Here is a base function that we can use to help do this!

```shell

# Function to bump the Python package version
bump_python_package_version() {
    local package_dir="$1"

    # Ensure the package directory is provided and exists
    if [ -z "$package_dir" ] || [ ! -d "$package_dir" ]; then
        echo "Error: Package directory is missing or does not exist."
        return 1
    fi

    local pyproject_file="$package_dir/pyproject.toml"

    # Ensure the pyproject.toml file exists
    if [ ! -f "$pyproject_file" ]; then
        echo "Error: pyproject.toml not found in $package_dir"
        return 1
    fi

    # Read the current version from the file
    local current_version_line=$(grep '^version = "[0-9]*\.[0-9]*\.[0-9]*"' "$pyproject_file")
    if [ -z "$current_version_line" ]; then
        echo "Error: Version line not found in pyproject.toml"
        return 1
    fi

    local current_version=$(echo "$current_version_line" | grep -oP 'version = "\K[0-9]+\.[0-9]+\.[0-9]+')

    # Increment the patch version number
    local base_version=${current_version%.*}
    local patch_version=${current_version##*.}
    local new_patch_version=$((patch_version + 1))
    local new_version="$base_version.$new_patch_version"

    # Replace the old version with the new version in pyproject.toml
    sed -i "s/version = \"$current_version\"/version = \"$new_version\"/" "$pyproject_file"
    echo "Version bumped in $pyproject_file to $new_version"
}

```

Now for us to execute this command, we have to add it into the shell command.

```shell

    -pythonbump)
        [ -z "$2" ] && { echo "No package directory specified. Usage: $0 -pythonbump [package_directory]"; exit 1; }
        package_dir="$2"
        bump_python_package_version "$package_dir"
        ;;

```

Finally, after the package is release, we will run: 

```
./kbve.sh -pythonbump apps/atlas
```

Besides the version bumping, I am thinking of making a simple command that we can use to get started with python development, at least a bit faster.

Since the `venv` needs to be activated and based upon the different types of applications, it could get a bit messy, definitely with upgrading around it.

My solution would be to add a `py` flag within the kbve shell and have it handle it for us, hmm maybe it would look like this:

`./kbve.sh -py atlas` and then have it run these two commands:

`source apps/atlas/.venv/bin/activate` and then followed by `code .` to open it up in VSCode.

To do this setup, we will go ahead and add the python_venv_activate function:

```shell

python_venv_activate_and_run_vscode() {
    local directory_name="$1"
    local venv_path=""

    # Check the first potential path for the virtual environment
    if [ -f "packages/$directory_name/.venv/bin/activate" ]; then
        venv_path="packages/$directory_name/.venv/bin/activate"
    # Check the second potential path for the virtual environment
    elif [ -f "apps/$directory_name/.venv/bin/activate" ]; then
        venv_path="apps/$directory_name/.venv/bin/activate"
    else
        echo "Error: Virtual environment 'activate' script not found."
        return 1
    fi

    # Activate the virtual environment
    echo "Activating virtual environment from: $venv_path"
    # Use `source` to activate the virtual environment
    source "$venv_path"
    
    # Open Visual Studio Code in the current directory
    echo "Opening Visual Studio Code..."
    code .
}


```

Then under our custom flags, we will add the `-py` to the rest of the commands:

```shell

    -py)
        [ -z "$2" ] && { echo "No project directory specified. Usage: $0 -py [project_directory]"; exit 1; }
        directory_name="$2"
        python_venv_activate_and_run_vscode "$directory_name"
        ;;

```

So now we can just call the `-py` flag to help automatically setup the environments, making it easier for us to build and rotate around the different projects.

---
# April: 10

> 10th of April.

Source: https://kbve.com/journal/04-10/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

Double check the shell execution.


## 2025

### Expand

-   08:29PM

    I just got a great idea for resolving this panel expanding issue!
    Instead of focusing on just the same panel box growing and shrinking, then having those additional issues, I will just an off canvas panel.
    This off-canvas panel will act as a place holder for any and all modals and components that need to be rendered ontop of the exisiting layers.
    Okay, so that means we will have to figure out the best way to shift over to the panel.
    Hmm, in order to get the panel ready, I will have to also go back around and upgrade the tailwindcss from v3 to v4.
    With this update, it means that kbve.com style will be broken and so will our native wind template.

### Upgrading

-   10:07PM

    The plan is to upgrade the tailwindcss and the additional packages that we have within the `kbve.com` and `native-wind` template.
    We would be upgrading all the tailwindcss internal packages as well, furthermore, we would have to upgrade the Astro to the latest.
    Okay! Time to begin this adventure and lets see how long it takes to get this all done, ugh. 

    Here is the breakdown of the commands that we will be executing:

    Step A0 - upgrading the tailwindcss - `pnpm add -D tailwindcss@latest postcss@latest autoprefixer@latest`
    Step A1 - upgrading the smaller internal packages -  `pnpm add -D @tailwindcss/forms @tailwindcss/typography`

    Step B0 - upgrading the Astro to the latest, `pnpm dlx @astrojs/upgrade`
    Step B1 - testing the upgrades so far, then running a `pnpm astro check` to see if there are any issues with the current code base.
    Step B2 - Wait, we can not just run that command, we would have make sure that the `project.json` has a check for each project that Astro is inside of.
    Step B2.1 - Looks like we have some typescript errors and a couple failures with the development build, lets move towards a new step to focus on resolving those issues.

    Step C0 - We need to migrate the tailwindcss configurations for v3 to v4, including updating the tailwindcss pipeline.
    Step C1 - The postcss changed with v4, so let me install that next `pnpm add -D @tailwindcss/postcss`, then update the `global.css`.
    Step C2 - Looping back around, there was a breaking change in starlight, so I will make that adjustment as well.
    Step C3 - Running the `pnpm nx reset` , clearning out the cache and maybe we need to clear up some of the cache and modules, to avoid possible issues.

## 2024


### Python

Today is going to be a heavy day of sneeks.
The big phat python that hopefully will not wrap around my server or neck.

Earlier, I went ahead and updated a decent amount of the `atlas` code base, preparing it for the future production environment, including test casing it on docker.

Yet, sadly, even the weird edge cases become a huge pain! But its been long over due, at least since last year, so it makes sense that I invest some heavy time into it.


### FastAPI

To get started, we will add both the `fastapi` and the `uvicorn[standard]` to our standard poetry book, as they will provide the main entrance to our software stack.
Majority of the codebase will be within the `kbve_atlas`, with a `main.py` file located outside of it.
This `main.py` file will be the router that we use to handle all the python routes, including any micro-service that we might need down the line.
Under the current build, I am thinking of keeping a bunch of the services within an isolated python instance and then using our Rust API to handle the communication between them, ideally using a queue style system.


### Main.py

Now the adventure of integrating the `main.py` with the FastAPI.

Here are the core functions we are going to migrate!

The first is the google/rss news feed:

```python
async def google_main():
    #rss_url = "https://news.google.com/rss?hl=en-US&gl=US&ceid=US:en"
    rss_url = "https://feeds.bbci.co.uk/news/world/rss.xml"
    rss_utility = RSSUtility(base_url=rss_url)

    try:

        soup = await rss_utility.fetch_and_parse_rss()
        rss_feed_model = await rss_utility.convert_to_model(soup)
        formatted_feed = RSSUtility.format_rss_feed(rss_feed_model)
        print(formatted_feed)
    finally:
        print("Done RSS")

    pass
```

While doing that change, I realized we could decor the poetry_main and coindesk_main.

```python

async def poetry_main():
    poetry_client = PoetryDBClient()
    try:
        random_poem = await poetry_client.get_random_poem()
        print(f"Title: {random_poem.title}\nAuthor: {random_poem.author}\n")
        print("\n".join(random_poem.lines))
        await poetry_client.close()
        print("\n Closed Session")
    except Exception as e:
        print(f"An error occurred: {e}")

        pass

async def coindesk_main():
    coindesk_client = CoinDeskClient()
    try:
        bitcoin_price = await coindesk_client.get_current_bitcoin_price()
        print(bitcoin_price)
    finally:
        await coindesk_client.close()

        pass


```

Added a decorant / base wrapper around the get command to make the movement of services faster and easier.

The decorants can be extended out, which will be within the `util` folder of atlas, but for now we should have more than enough to execute what we would need.

Next, we can add the broadcasting for `ATLAS`, holding our chat and the a couple of the basic or general machine learning commands.

To add the broadcasting, we will first add the library that was recommended by the FastAPI Team.
Shell Command: `./kbve.sh -nx atlas:add --name=broadcaster[redis]`

One of the things that I just realized is that we will need an internal Redis server, ideally one that can be accessed by Rust, Python, n8n, ect...

Hmm, creating a redis cluster within the swarm does make the most sense, with a redis entity on each node within the whole swarm?

We could also try to setup a redis bridge that would let some of the microservices sub/pub data from? This might just be all food for thought, I still need to do some more test casing.

Going to take a bit of a break from FastAPI and prepare to setup the broadcaster, we could also setup the relay through it as well! Hmmm....


### NX

The Nx flag on the `./kbve.sh` aka `-nx` seems to be only taking one arguement and none of the additional flags.

This is going to be a quick fix around it, just quickly update the shell file so that it can take multiple additional flags and keeping the older part of the shell code within the file.

After a week or so, I will go back and update the code.


### Broadcaster

The next goal for the day will be to setup a Pub/Sub for our C A R P stack! Oh the joys!

To start the broadcaster, we can use this code block:

```python

@app.on_event("startup")
async def startup_event():
    await broadcast.connect()


@app.on_event("shutdown")
async def shutdown_event():
    await broadcast.disconnect()

```

Yet the issue is that `on_event` of `startup`/`shutdown` has become deprecated and instead we would have to use `@asynccontextmanager` and the `lifespan` decorated.

So lets update the code to look something like this:

```python

@asynccontextmanager
async def lifespan(app: FastAPI):
    await broadcast.connect()
    yield
    await broadcast.disconnect()

```

To launch the current `ATLAS` , we will be using `uvicorn main:app --port 8086` however we might not have access to the redis right now on the mac, so lets swap that out to memory. 

Here is the quick swap to memory:

```python

broadcast = Broadcast("memory://")

```

---
# April: 11

> The season was filled with grey clouds, a hint of cold air with a dash of darkness.
I have this urge to find some red tea and a chicken sandwich, this itch must be resolved.

Source: https://kbve.com/journal/04-11/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

Cooking stream? When and Where?

## 2025

### Tailwindcss v4

-   02:00AM

    Finally made the switch to v4, but that means that we will have to make the switch to react v19 soon too.
    I am glad that I took a break from the mobile development because that would have driven me insane to work on v18 to v19 for react native.
    Both sites build but there is still some breaking changes, like backdrop blur and ring issues, but they can all be resolved with some quick replacing.

### Python Nx

-   02:30AM

    Before even touching the python environment, it would make sense to update the @nxlv/python plugin!
    For this, we are just doing a minor version bump, should not affect anything.
    Next, I will test that out with updating the library of components.

-   05:03AM

    Agno seems like a great library to test out!
    The bigger question would be in figuring out what standard model and embeddings we should use, because then it would make things easier to build across multiple people.
    Looking at the gwen series and that might be the best choice for now, going to add that into the flow.

### Wheel of Time S3

-   10:25PM

    Season three has been compact but filled with side stories, something that I love!
    The world building is amazing and the characters are so well developed, that its great research material for the RareIcon.


### RareIcon Dual.

-   10:05PM

    The website will have the game but we can use it as our CDN as well!
    I am thinking that it would make sense to build our first CDN, that layers ontop of existing ones like Cloudflare, part of this would be to make lottie files easier to access.
    When grabbing the SVGs and lotties, we know that they are a certain size but having it all stored within the idb layer and cache layer would be great for performance.
    Object A loads from the CDN, which includes the cloudflare layer, and then inserts it into the idb client-side.
    Actually, it be really interesting if we could IPFS the files too, moving the load out of a central server and since these files will be small, it should be a great start towards building our first CDN.
    The SEO and marketing benefits of having RareIcon be an icon CDN will be great for the game too.


## 2024

### Logging

For the Atlas program, we will use the built in logging system that comes with `uvicorn`!
To do this, we just import the logging and grab the `uvicorn` logger, like this below:

```python

import logging
logger = logging.getLogger("uvicorn")

```

Then we have three functions that we can use:

```python

    logger.info("[info]")
    logger.warning("[warn]")
    logger.error("[err]")

```

In the future we would want to integrate a way to move specific warnings out of the logger and into a metric system.


### Atlas Template

We have two options for the template system, i.e. loading static files from `template`.
However, I suggest we opt for simplicity on the backend by returning a generic HTML template and dynamically loading the JavaScript.


### KBVE Front Page

Going to take a quick break from the python realm and see if I can mess around with the front page and its code for a bit.
I noticed that the wavey carousel seems to break the viewpoint and cause the x to over extend on the mobile phone, creating this weird white space bug!
Oh the joys of CSS and responsive design, another adventure down the meme design mindduck, let me get started.

To get the dev kbve website up and running on port 4321, the default astro port, we run this command:

`./kbve.sh -nx kbve.com:dev`.

I am thinking the fix for this would be to wrap the VE widget, like below:

```js

	<div class="">
		<VE widget="carousel:highflyer:wave" slider={waveslider} />
	</div>

```

Then inside of the `class` , we slap around some basic tailwindcss to help us account for the various situations, including the overflows.

Actually I am thinking we could just scratch both of those components, the wave and the scroll effect and maybe start with a fresh full screen landing page.

Now the question is what would we make this page about?
Here is what I am thinking as the base so far:

```html

	<div class="w-full h-screen">
		<div>Hi</div>
	</div>

```

We start with a `w-full` and `h-screen` to at least make sure the landing page takes the whole screen.

---
# April: 12

> Dat April 12th.

Source: https://kbve.com/journal/04-12/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### Sealed Secrets

-   03:57AM

    Time to do the dirty deed of setting up the sealed secrets!
    I updated the kubernetes documentation with the proper steps, I will have to make some adjustments here and there but lets try it out!

### 2024


#### Framer

My plan for the day is to work with Framer Motion and get a better grasp of the react library!

The hero / landing component needs to be updated but how I would do it, hmmm, its still a bit in the air.


---


#### Charles

The biggest issue with Charles is the amount of heat that it is pushing out, ugh. 

However I am thinking I got a brilliant idea on how to manage it, but it will require a bit of work-within-the-art style of management.


---


#### Python

The docker contianer for python has been the main focus for today!
We are looking at exactly how we can expand the unit and make use of the changes that come with that area!
The problem with integrating the `pyautogui` library is that we would need a display for the function to operate within OR we can shift focus on a headless instance.

Given the nature of OpenCV and plan to utilize the `window` a bit more, it does make sense that we look at setting up a GUI / Graphical instance of Ubuntu with VNC, but there might be issues with how we get to this point.

Hmmm, I am going to try and think through the best ways that we can reach our goal within our given time limit.

Splitting up the Python library into two different ones does make sense as well.

---
# April: 13

> 13th of Unlucky April.

Source: https://kbve.com/journal/04-13/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### RimWorldRun

-   08:40AM

    Taking a quick break from programming and resetting my mind, instead of league or warcraft, I decided to run a quick rim  world session.
    An interesting mod that I saw, called Multi Floors, has gotten my attention and it feels like its a great mod.
    My concern is that if the raiders that do land on my fort or if my older parts of the fort break, does my whole tower collapse?
    The goal of this run will be to see if I can take the whole thing down.

### Tax Man

-   10:31PM

    The worst feeling about April is uncle sam's visit!
    He is always looking at my pockets and waiting for his cut, ugh.


## 2024


### Castle

My cousin just recent opened up their new home!
The cost for this house was close to a million for them to build but it is massive, interesting and feels like a little mansion.
The project was called the `Castle of Edison` by the developer, because of how high the ceilings are and the amount of open space that the house presents.

They were able to fit about 100 people in there and from the outside, you could not even tell there was anyone one.


---


### War

The world seems to be just inches away from a global war. I do not have much to say about this feeling but it is looking closer towards becoming a dangerous eco-system across the different regions.

My fear is that it will escalate here within the southern regions of the Americas, once the threat is in our backyards, then the FUD is going to sky rocket.

---


### Ubuntu 24

With the recent annoucement of Ubuntu 24 LTS beta, it will be time to slowly migrate everything from the QEMU/KVMs and Dockerfiles to GHAs/Gitlab actions.
This will be a rolling update that we 


---


### DockerFile

The current plan is to split the Dockerfile for ATLAS to focus on building out the core functions, VNC, python 3.12, x11 , ect... then shift the setup to an `entrypoint.sh`.

In case anyone runs into an error like this: `ERROR: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?`

Open `Docker Desktop`, go to `Settings` > `Resources` > `WSL INTEGRATION` , then make sure that `Ubuntu` is selected. 

Incase we run into an issue where `Poetry` cannot be found, we can set the path for it within the `Dockerfile`:

```
# Ensure the Poetry bin directory is in the PATH
ENV PATH="/root/.local/bin:${PATH}"
```

The amount of hours that I have spent going through different options and debugs! Ugh!

Next error on the dockerfile build:

```

2024-04-14 00:58:12 rm: cannot remove '/tmp/.X1-lock': No such file or directory
2024-04-14 00:58:12 rm: cannot remove '/tmp/.X11-unix/X1': No such file or directory
2024-04-14 00:58:12 rm: cannot remove '/root/.Xauthority': No such file or directory
2024-04-14 00:58:12 xauth: (argv):1:  unable to open display ":1".
2024-04-14 00:58:17 Enter VNC password: stty: 'standard input': Inappropriate ioctl for device
2024-04-14 00:58:17 fgets: No such file or directory
2024-04-14 00:58:17 stty: 'standard input': Inappropriate ioctl for device
2024-04-14 00:58:17 x11vnc -usepw: could not find a password to use.
2024-04-14 00:58:18 WebSocket server settings:
2024-04-14 00:58:18   - Listen on :6080
2024-04-14 00:58:18   - Web server. Web root: /usr/share/novnc
2024-04-14 00:58:18   - No SSL/TLS support (no cert file)
2024-04-14 00:58:18   - Backgrounding (daemon)
2024-04-14 00:58:19 NOTE: You must install tkinter on Linux to use MouseInfo. Run the following: sudo apt-get install python3-tk python3-dev
2024-04-14 00:58:19 Xlib.xauth: warning, no xauthority details available

```

Okay! Next error is debug 44, but we are making progress in the setup!
We have the ubuntu container built out, fixed a formatting issue within RSS Utility and we were able to connect to the container on the noVNC web panel.

For Debug 45, we are going to update the entrypoint script once more because of a black screen / display error.

```

RUN apt-get update && apt-get install -y \
    wget \
    curl \
    software-properties-common \
    x11vnc \
    dbus-x11 \
    xvfb \
    xauth \
    tightvncserver \
    novnc \
    net-tools \
    python3-tk \
    python3-dev \
    gnupg2 \
    gnome-terminal \
    gnome-session

```

We are also going to add `dbus-x11` package inside of the Dockerfile.

Yay! We got the Docker application to run with display and the terminal window!
Making progress! Now we want to update the FastAPI that is running within this contianer to proxy our noVNC.

---
# April: 14

> 14th of April.

Source: https://kbve.com/journal/04-14/

import { Adsense } from '@/components/astropad';

<Adsense />


## Notes

## 2025

### RimwWorld


-   11:00AM

    So much time spent on debugging rim world, that I forgot that I was suppose to take a quick break from gaming to do programming.
    It was a wild loop of desync issues but we were able to get a stable game flow going!
    Now the plan is to build around it.


### NanoStores

-   9:13PM

    Optimization for the nano stores is the goal for tonight, we want to handle the offloading and processing via events.
    This would keep our alpine and svelte units extremely light weight but also have the ability to handle complex tasks?
    I am thinking that we use the indexdb for long term storage and the localStorage as a medium for state management.
    The way we can handle this is to let nanostores be the tool that is directly handling both, since we can swap the file engine on it without any major issues.
    Eventually we could go into building the canvas on the worker and then have the js library do a hot swap.

## 2024


### Zed

Just grab Zed on my m1 and trying out the IDE!
So far it seems great as lite vs code alternative, but this is just the first hour of messing around with it.

The Ui/Ux is already better than what I was expecting, I think it will replace my obsidian very soon.
The speed is also on point, I can easily move around without having any major problems.

`But dat vim lyfe. NeoZedVim doe.`

Looks like Pyright on Zed is throwing some missing import errors.
I might have to include some toml to help fix them.

Here is what we added so far:

```toml

[tool.pyright]
include = ["kbve_atlas"]
exclude = ["**/tests", "**/__pycache__", "**/*.venv"]

[tool.pyright.behavior]
reportMissingImports = true
reportMissingTypeStubs = true
reportOptionalSubscript = true
reportOptionalMemberAccess = true
reportGeneralTypeIssues = true
reportFunctionMemberAccess = true
reportUnusedVariable = true
strict = true
typeCheckingMode = "strict"

[tool.pyright.environment]
pythonVersion = "3.12"
venvPath = ".venv"
venv = "myenv"
stubPath = "typings"
typingsPath = "typings"
analyzeTypeshed = false
autoSearchPaths = true
```

I will have to get back to fixing that once I get the websocket issue resolved.


### PieThorn

The next update for Atlas would be to fix the proxy for noVNC and the FastAPI!
We want to add some level of auth and protection, at least during the dev cycle before we get deeper into that mixture.

My current plan is to just directly proxy the websocketify library within FastAPI, if that ends up being too much work, I suppose I could switch over to either node or rust to get the job done.

But then I would not learn anything, where would the fun be in that then?

The next question on my mind, before booting up another episode of toyko vice or smoking a quick, what would be the next couple goals within atlas.

We have the discord app pitch to finish up, which is due within 2 weeks, getting this part of the code out of the way before going back to phaser, UGH.


### noVNC

This bash command, from `entrypoint.sh`, is running the novnc:

```bash

websockify -D --web=/usr/share/novnc/ 6080 localhost:5900 &

```

What could do is just basically move that command out and basically replace it within FastAPI?

We know that the novnc static files are stored in the `usr/share/novnc` and then we need to do the websockets after that.

Lets throw up the 3rd episode of Tokyo Vice and see if we can bang this out within the next hour.

Granted if this works out, as I see it in my mind, we could then setup a custom auth as a middleware to handle some of the security needs.

Afterwards, it is just packaging up the docker file and doing some quick integration tests with our docker swarm and portainer.

For the authentication, we could just use an API key style, yeah this will be cake walk once we get the reverse proxy resolved.

---
# April: 15

> Uncle Sam. 15th of April.

Source: https://kbve.com/journal/04-15/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### RimWorld

-   4:04PM

    Spent majority of the whole day on the game xD
    There are no major notes today besides the yearly review by Uncle Sam.

-   07:30PM

    I need to make a quick note on the plugins that we are using in 1.5x , maybe making a mod list for it all.
    I should also look into how mods get published too.

## 2024


### Charles

This entry has been delayed a bit because there was a ton of changes that we had to do with charles.

---
# April: 16

> April 16. The Dues

Source: https://kbve.com/journal/04-16/

import { Adsense } from '@/components/astropad';

<Adsense />



## Notes

## 2025

### NanoWorkers

-   04:08AM

    If I can find a way to get all the workers, shared, web and service to work idb and nanostores under just a single usable library.
    I tried to do this earlier when I was in Italy but not no major luck, so maybe I can loop back around and try it again.

### OffCanvas Svelte

-   08:05AM

    The goal would be to build the svelte component to handle 10,000+ entities but without having a huge performance hit.
    Since the human eye can only handle so many views, we could use a `virtual scroller` to only show the items that are in view.
    The plan would work like this, ughhh, the sharedworker pre-renders and stores HTML cards, using a seeding or sync data method where the entities are built in the background as an off canvas.
    We then pull only a batch of visible cards into a pool and then swap the cards out as the user is scrolling horizontally, creating an infinite scroll effect or illusion?.
    Finally we can use the `{@html html}` to inject the HTML into the view, hmm, that might defeat the purpose of using Svelte.
    This becomes an interesting situation where we want to build around svelte's static nature of optimization but still have this dynamic virtual inner DOM.
    I suppose the argument here could be made that we are trying to use the wrong tool in the belt, but that is part of the learning process.    

## 2024

### Charles

We are back online with Charles!
Yay! This has been a long time coming, almost since end of October that we would have an operational and self-hosted ML project.
A ton of effort has went into getting here, I can not wait to see where we go from this point.

The plan for charles right now is to setup the promox instance with the functional GPU passthroughs, ideally extending out the vGPUs.


---

### Python

Updating the monorepo's python install to make sure it is `3.12` for now, I will try and prepare another update for `3.13` once all the other libraries are updated and ready.



### k8s

The next move would be to prepare the `k8s` migration for our docker and docker swarm.
We will most likely use a `kre2` as our base kube framework, its a nice blend of upstream k8s and k3s but with security in mind.

---
# April: 17

> Daily Log for April 17th of each year.

Source: https://kbve.com/journal/04-17/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Svelte v5

-   09:00AM

    Spent most of the morning trying to debug these god damn svelte issues with vite 6 and inside of astro but made some decent progress.

### Lottie

-   06:30PM

    Finish the day off a bit early, got a quick trip to Edison and we got the carousel to finally render without any major issues!
    The entries for the day are short, most of my notes are scattered around in my journal, will have to loop back and adjust them.

## 2024

**Milestone**

This is will be the official one year mark for our journal system!
Now I have to migrate the older entries into this vault, which might be a bit painful because I definitely missed some earlier entries.

I do need to find a way to atuoamtically pull in my tasks , but that will be a future holy problem.

**Python**

Let us open up the python stack and see what we can do!
First we want to make sure that the Dokcer build works as intended.

```shell

cd ~/github/kbve/apps/atlas
docker build -t exampleapp .

```

However I am thinking we could split the docker image and build process a bit more?
Maybe we make a `v01d` docker image and then use that as the base for what we want, hmm.

## 2023

**Astro**

-   I am running into weird issues with Astro 2.3.0, going to delay the upgrade until I can resolve them.

-   Started to make a Windows 11 template for the RSPS Project, but damn it seems to be a pain to get it all optimized and secure.

-   Should we keep raw daily notes? Or would it be too much information? Hmmm.

-   While I am in India, I just finished setting up my NR accounts, it feels interesting being a dual citizen. The idea that I can be on the other side of the world and live a completely different life style.

-   It was a bumper to see Starship flight get scrubbed.

-   Damn really had to put quotes on the title to avoid the YAML error.

The error is here:

```ini
7:18:30 PM: [astro:content-imports] can not read a block mapping entry; a multiline key may not be an implicit key
7:18:30 PM: file: /opt/build/repo/src/content/_bin/_daily.md?astroContent=true:4:4
7:18:30 PM:  error   can not read a block mapping entry; a multiline key may not be an implicit key
7:18:30 PM:   File:
7:18:30 PM:     /opt/build/repo/src/content/_bin/_daily.md?astroContent=true:4:4
7:18:30 PM:   Code:
7:18:30 PM:     3 | title: {{date:YYYY-MM-DD}}-Daily
7:18:30 PM:     > 4 | date: {{date:YYYY-MM-DD}}
7:18:30 PM:         |    ^
7:18:30 PM:       5 | category: Daily
7:18:30 PM:       6 | client: Self
```

I had to wrap the title inside quotes to help with the mapping. >.>

## Notes

1 Year Mark! W00t

---

## Quote

> You were not born a winner, and you were not born a loser. You are what you make yourself be.
> — <cite>Lou Holtz</cite>

---

## Tasks

-   [x] Fixed Obsidian
-   [x] Added MDX again into Obsidian
-   [x] Need to add a template system for the daily notes.

---
# April: 18

> Daily Log for April 18th of each year.

Source: https://kbve.com/journal/04-18/

import { Adsense } from '@/components/astropad';

<Adsense />



## 2025

### RareIcon Title

-   06:37AM

    Updating the title scene for rareicon game, as it was something that was long over due and I been too lazy to finish it.
    Going to get into the habit of triggering more builds and updates, since they take 30 mins to finish up.

### Ubuntu 20 LTS

-   07:38AM

    I missed the memo that Ubuntu 20 LTS runners are no longer on github actions!
    That means I will have to update the CI Runners.

-   01:33PM

    The runner was updated, preparing another test build.

## 2024

**Homepage**

I am getting a bit more comfortable with the framer motion and how the animations would work!
But damnm does setting up the whole homepage feel like a pain, getting the perfect website for KBVE will be always a passion project.

**Python**

The split in the dockerfile, we will put the v01d configuration within the `migrations/docker/v01d/` folder and should use the github actions to build a docker image for `v01d`.
After building that Image, we can go back to the python build and pull it as a base?

Under the `Dockerfile` for the `v01d`, we will use this as the base template:

```docker

### Use Ubuntu 22.04 LTS as the base image
FROM ubuntu:22.04
### Interactive Shell must be disabled.
ENV DEBIAN_FRONTEND=noninteractive
### Apt-Get Install
RUN apt-get update && apt-get install -y \
    wget \
    curl \
    software-properties-common \
    x11vnc \
    dbus-x11 \
    xvfb \
    xauth \
    tightvncserver \
    novnc \
    net-tools \
    python3-tk \
    python3-dev \
    gnupg2 \
    gnome-terminal \
    gnome-session

# Install Python and Poetry using deadsnakes PPA
RUN add-apt-repository ppa:deadsnakes/ppa && \
    apt-get update && \
    apt-get install -y python3.12 python3.12-venv python3.12-distutils python3-pip && \
    curl -sSL https://install.python-poetry.org | python3.12 -

# Environment variables to configure
ENV HOME=/root \
    DISPLAY=:1 \
    XAUTHORITY=$HOME/.Xauthority

# Ensure the Poetry bin directory is in the PATH
ENV PATH="/root/.local/bin:${PATH}"

# Updating NodeJS to v21.
RUN curl -fsSL https://deb.nodesource.com/setup_21.x | sudo -E bash - && \
    sudo apt-get install -y nodejs

```

This should give us the noVnc, node 21 and python 3.12!

We are getting the node 21 from [nodesource](https://github.com/nodesource/distributions?tab=readme-ov-file#ubuntu-versions), which I should add into the NodeJS documents.

I should then update the `main` action to build this image and upload it to the dockerhub.

The next push forward should help resolve the build issue with this entry.

## 2023

**India**

-   Went to the hospital for my yearly check up and it was an interesting system. So I pay around 1000R and get a "full body" checkup, from almost every major medical branch. It was a bit time consuming, about less than 2 hours in total but it was definitely better than having to schedule a bunch of different doctors. Furthermore, since they all work in the same hospital, they could give secondary reviews and be able to cross-pin among different areas of a concern. I will try to make a quick reference about this for anyone that might want to do medical tourism within Gujarat, India.

-   After the hopsital trip, I did a casual photo shoot at Sonia Studio and it was magical. First time experiencing the depth that a photographer goes to get the best shot of a person, besides just the angles, lights and timing. Will I ever want to do modeling again in the future? Nah. Was it fun? Yup and for many other reasons as well.

-   Now its about 1pm and I decided to meet up with a local and chill at his work. He basically runs a safety & maintainece company for a buddy of his

## Notes

We will have to update the journal entries and the way that they look.

---

## Quote

> Love does not consist of gazing at each other, but in looking together in the same direction.
> — <cite>Antoine de Saint-Exupéry</cite>

---

## Tasks

-   [x] Finish yearly medical check.
-   [x] Check prices on electric tuk tuk / rickshaws / ricksha.
-   [x] Scope out local tailor for pants.
-   [x] Ant Spray for the house in India.

---
# April: 19

> Daily Log for April 19th of each year.

Source: https://kbve.com/journal/04-19/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Lottie Alpine

-   07:39AM

    Turns out that the shared worker was unable to offload the lottie worker and after a decent amount of hours being spent, ugh, I will just revert.
    While moving a decent amount of work off the main thread was the idea, but since there are these abstract limitations within the way workers operate, it might be best to just hold off.
    The situation becomes one where we end up going in circles that just ends up burning me out and wasting time.

-   08:22AM

    Lottie rewrite and adjustment, I am going to move the logic back into the alpine plugin and move forward.
    It was working fine for what we had previously and we can just build from there.
    Adding the SEO tags and meta information is important, so I can probably do that while I finish up the gRPC integration.

### Panel

-   08:28AM

    Quad panel setup is the next goal, we should have 4 of them pre-rendered and cached, that we then animate based upon.
    The panels would be like this:

    ```ts
    export type PanelDirection = 'top' | 'right' | 'bottom' | 'left';
    export type Panel = {
        direction: PanelDirection;
        width: number;
        height: number;
        x: number;
        y: number;
    };
    ```
    
### Warcraft Hardcore

-   01:16PM

    Quick shadowfang keep run before going back to doing some programming!
    I did want to get hidden cut up to level 40 soon, thus it would make sense that I try to do daily runs on my champions.


### Unity Delay

-   08:10AM

    Pushing the unity development back a week is good for now but means we are getting closer to the end of Q2 of 2025 before we even get to a launch.
    So many little things that are in the way, I am starting to find the whole project starting to become a bit daunghting.
    On top of that, each of these refactors puts us back a step, thus making the movement forward more of a pain.
    BUT I would be lying if I did not enjoy the random challenges each step presents, the progress, learning and experience is worth years.

## 2024

**GHA**

The Github Actions are throwing too many errors for me to handle without overthinking.
Thus the next step for the night would be start placing dynamic sha hashses into each pull request + branch within the automation system.
I was looking to avoid this before because I figured it would create too many pull requests, yet it seems to be causing more build failures and slightly becoming a pain point.

So my solution to this would be to create a globals job before the altar and then call it like this example below:

```yaml
jobs:
    build:
        runs-on: ubuntu-latest
        outputs:
            sha256head: ${{ steps.hash.outputs.sha256head }}
        steps:
            - name: Checkout code
              uses: actions/checkout@v2
            - name: Calculate SHA-256 Hash
              id: hash
              run: |
                  echo "::set-output name=sha256head::$(echo -n ${{ github.sha }} | sha256sum | awk '{print $1}')"
            - name: Log SHA-256 Hash
              run: |
                  echo "SHA-256 of the commit is ${{ steps.hash.outputs.sha256head }}"

    use_hash:
        needs: build
        runs-on: ubuntu-latest
        steps:
            - name: Use SHA-256 Hash
              run: |
                  echo "Using SHA-256 Hash in another job: ${{ needs.build.outputs.sha256head }}"
```

Going to place this within the `ci-main.yml` and call it throughout any of the pull requests that create a new branch.
Now I will push this file change through the main branch and see how it performs.

**v01d**

The current `v01d` is misisng the nvidia and cuda drivers, so let me start fixing that up.
We want to install the cuda drivers for nvida, so here is what we can do from the dockerfile aspect.

```
E: Conflicting values set for option Signed-By regarding source https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/ /: /usr/share/keyrings/cuda-archive-keyring.gpg !=
E: The list of sources could not be read.

```

Okay, going to update the dockerfile and remove the original cuda keys.
I went back to the docs and here is what we got:

```shell

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin
sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/12.4.1/local_installers/cuda-repo-ubuntu2204-12-4-local_12.4.1-550.54.15-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2204-12-4-local_12.4.1-550.54.15-1_amd64.deb
sudo cp /var/cuda-repo-ubuntu2204-12-4-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda-toolkit-12-4

```

When the docker shell is frozen, you know you been too far! xD
It seems to freeze up on the libllvm15 library, maybe that might be an error from the amount of data that we are pulling?
Hmm, maybe I should restart the docker build.

Looks like the `v01d` dockerfile builds without any issues on the local end, going to prepare the official build next.

When looking at the github actions, there are two options in figuring out if files have changed.
It can be either : `kbve_all_changed_files` or `kbve_any_changed`, in this case, we will do the `_any_changed` for the file paths.

3:47pm - It seems we ran out of space during the docker build for this image, hmm maybe I can go back to the drawing board and figure out another way to handle this.

The `Nvdia` image comes with three types, `base`, `runtime`, and `devel`.

The other option might be to use an exisiting image, this [Fooocus-API](https://github.com/mrhan1993/Fooocus-API) seems to fit perfectly into this project.

There are three paths that I see, the first would be having the `v01d` use the nvidia-based image for its own docker container and the second would be to extend out the foocus api dockerfile.

The third path would be to just drop `cuda` support within the base image and shift it over to a shell file that would install the needed drivers, outside of the base image.

**Docker**

The main `kbve` dockerfile seems to fail at building, I am going to traceback some issues that might be the cause?
I will start with making sure the `pnpm-lock.yml` for the whole repo is up-to-Date, as I noticed that it was still under an older version.

Hmm, that was the error, so we can move foward with our `v01d` build.

For some reason the pnpm lock is still becoming a pain point, maybe I need to look back at the node versions that are split amoung the different docker files.

Preparing everything to node v20 or node v21 might b

## 2023

**India**

-   Visiting the inner city this morning and it was wild! The food smells amazing but the crowd is mind numbing and the traffic is insane, damn I almost got hit by a tuk tuk / rickshaw at least 3 times.
-   Currently trying to fix the issues with SendGrid and Ezoic. It seems that Ezoic's DNS is replacing the SendGrid CNAME by dropping it. When trying to place the CNAME inside of the Ezoic DNS panel, it seems to say that it can not proxy it. I rasied a community ticket on their forum, hopefully they can get it resolved but if they can not then we might use a 3rd party domain.
-   Upgrading Coolify to v3.12.31. Before upgrading, I am going to execute an AWX backup stack. This is another test case for a full scale backup, including the SQL database but excluding snapshots.
-   Integration of Portainer and Coolify still has some issues, including volume and network management. I will rise an issue after doing more R&D between both applications.
-   Starting the AppWrite Register for Astro.

## Notes

No notes to sync.

## Tasks

-   [x] Upgrade Coolify to v3.12.31.
-   [x] R&D for automated RAW image conversion.
-   [x] Rollback Astro upgrade because of errors.
-   [x] Pay off any additional CC debt(s) for the month.
-   [x] Leverage 100 shares of $SPY again for the week.
-   [x] AppWrite -> Register -> https://github.com/KBVE/kbve.com/issues/122
-   [x] Scope out local tailor for pants.
-   [x] Ant Spray for the house in India.

## Quote

> Many men go fishing all of their lives without knowing that it is not fish they are after.
> — <cite>Henry David Thoreau</cite>

---
# April: 20

> Daily Log for April 20th of each year.

Source: https://kbve.com/journal/04-20/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Unity RareIcon

12:09PM
Back at the grind
On the design ideas you tossed in — batching my acknowledgments so we don't lose them:

60 units with scaling , like spawn staggering  archetype specialized JobPriorities is the cheapest fix. LogisticsSystem (dynamic role ppressure rebalance) folds into phase 4's unified score.
Cave then ConstructionSite flow then separate ticket, touches BuildingDef and spawn pipeline, not JobSystem.
Farm → Village (garrisoned workers, food, shelter, upgrades) → big gameplay evolution. Means: buildings own a set of "resident" unit entities, unit's "home" overrides wander-back behavior, upgrade rails for building tiers. Worth a dedicated design doc.
Barracks → Keep → Castle (with mushroom farming and brewery) → fits the same upgrade-tier pattern as Village. Probably a shared BuildingTier component and per tier production rules.

the fact is they are not, which means something is wrong, should have a check in place for when doing these said tasks , how do we know its complete, why didnt it get completed?
Resource entity not be gathered? Was attacked? ect...


## 2025

### WebWorkers

-   12:05PM

    There are a decent amount of issues with the front-end and I think it might be time to call in for some help.
    My idea would be to either contract it all out or buy an existing out-sourcing company?
    Building an out-sourcing company would make sense for the long term because we could give those developers internal work but I do not want to handle it all.
    Thus a semi-ownership / partnership would be the best way to go about it?

## 2024

**Blaze**

As part of the traditions, it might be wise to partake in a quick sesh.



**Docker**

I should update the docker lists on the monorepo, so that it be easier to find the images.
For now I will add the [Express Colyseus Discord](https://hub.docker.com/r/kbve/expresscolyseusdiscord) and then once v01d gets built and RelationTableAliasProxyHandler, I will add that as well.


**CICD**

Going to disable the outpost report generator for now because it seems to be causing an error by adding back a broken locked pnpm.
Under the CICD pipeline, we went ahead and added sha hashes to each of the automatic patches that the `ci-main` produces!
I will also go ahead and do the same with `beta` and `alpha` within the next couple weeks, slowly integrating these changes throughout the pipeline.


**Fallout**

We are about to watch the whole `fallout` tv series, from start to finish!
I am actually super excited to see the whole thing, I heard it was great.



**Fooocus**

I am thinking that the best way for us to use `fooocus` would be to start with their docker image as a base, then add our atlas into that base image?
There is still some planning that we need to do before adding that in, hmm, I am going to draw it out and then see what steps that I need to make to get it done.



## 2023


**India**

- I spent most of the day running around the main city, looking for new clothes, belts and shawls!
- Starship ... well update. it went rip.

## 2018

An entry from 2018 was found but I need to make sure that I can read through it all before I write it up into a new journal.
I am keeping this here to remind myself to arrange a future myself to be a bit more responsible.
I will gohead and update the names that are on the list or older journal because they do not need to be linked unless they are a reader ofthis joural , community meme=bmer or just straight staklking lol

## Notes

B L A Z E.

---

## Quote

> To be what we are, and to become what we are capable of becoming, is the only end of life.
> — <cite>Robert Louis Stevenson</cite>

---

## Tasks

-   [x] Rocketship Watch Party

---
# April: 21

> Daily Log for April 21st of each year.

Source: https://kbve.com/journal/04-21/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2025

### Svelte Panels

-   09:52AM

    Going to replace the alpine panels with that quad panel setup using svelte instead.
    The eventual goal would be to replace all the alpine plugins with pre-compiled svelte components, keeping the alpine for dynamic virtual DOM changes and future concepts.
    Basically design and build using the Alpine library, then if its worth keeping, we loop back around and turn it into a svelte component.

## 2024

I am thinking of updating the journal entry so that it becomes less deep nested.
It gets a bit annoying to nest in the different entries, I like the flexibility that comes with the mdx format.

**404**

The 404 Page has been updated!
It looks a bit better now compared to what we had before, tbh I might go back and desplit the `AstroVE` , as it made sense in the start but it seems to become a bit overkill.

**Astro**

Going to update the Astro to version 4.6.x and then update a bunch of NX plugins.
We will be migrating to the latest Nx aka 18.3.x and then upgrade Astro extension to the latest version.
However there are two plugins that we still need to update, the first being the python and then the rust, however I will do that after I update the website.

## 2023

**India**

-   I spent most of the day eating and relaxing.
-   The next phase will be setting up AppWrite register, login and profile.

## Notes

Cleaning up the default journal entry format within the mdx.

## Tasks

-   [ ] Homepage 2024 Update
-   [x] No major tasks left.

## Quote

> The most certain sign of wisdom is cheerfulness.
> — <cite>Michel de Montaigne</cite>

---
# April: 22

> Daily Log for April 22nd of each year.

Source: https://kbve.com/journal/04-22/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2025

### Svelte 5

-   08:00AM

    Got the panel openning inside of the svelte 5 component!
    We can slowly phase out some of the alpine integrations once we get the HTML pre-rendering to work out any major issues.

### Helm Discordsh

-   08:04AM

    The older discordsh helm template has an issue with the cluster roles, which we need to fix.
    Okay the issue with the cluster roles has been resolved as of right now, so we can go ahead and push up the next couple changes.
    After everything builds, we can update the deployment charts with the new image.

-   02:59PM

    The most recent deployment of discordsh is operational at version 1.2, and I went ahead and checked the redis registering too.
    As a basic tradition, I will review over the performance and start making tweaks to the redis.
    Added some missing files and now going to push that up, will do another review next.

### Astro Tweaks

-   05:21PM

    Since we are not going to be using React, going to go ahead and remove that from the Astro configurations.
    After that, we can make some tweaks to the `askama.astro` template, including the removal of the `Layout` template.
    The information from the layout will have to be generated ahead of time.

### Kubernetes Ingress

-   05:53PM

    For the gzip compression, we have to update the nginx to pass through the gz files from Axum.
    After making sure that the files do not get double compressed, we still have two more tweaks to be made.
    Gzip all the static files inside of the dist folder and update the axum to include the basic cache layer, both of which can be done easily from our end!
    The goal will be to hit the 100 performance metric across the board on the Google Pagefind.
    Wait, we could just run through the astro compress, which seems to be able to handle that for us, thus it be just the axum that we need to append.

## 2024

The journal entry for today will be a bit behind because I have to update the template that we are using!

## 2023

**PAN**

-   Finished getting my PAN number in India and all my accounts are open! Time to plan and start to generate `Rupees`. I can generate about 5 Lakhs or 500,000 rupees tax free each year, so I guess that will be the current goal. Furthermore, UPI seems to come to US / International numbers at the end of this month.

**Appwrite**

-   Currently looking over the Astro repo on AppWrite, which is located here, `https://github.com/appwrite/demos-for-astro/` and the specific file of interest is in their lib folder, `appwrite.ts`.

-   I went ahead and added their AppWrite.ts file into the KBVE repo and going through it. The concept seems pretty straight forward and we have not ran into any major issues so far.

-   Back on the AppWrite integration, I believe their might be CORS issues between the API/AP (https://ap.kbve.com/) and the main website, https://kbve.com/. The first move would be to get the user management resolved, including the

**Crypto**

-   Following up on this story from @Fudster, [Colorado Accepts Crypto for State Taxes](https://abcnews.go.com/ABCNews/colorado-state-accept-cryptocurrency-payment-taxes/story?id=83066842) It is nice to see the organic growth of crypto from the gov. entity side. Accroding to their website, they accept crypto payments through `PayPal Cryptocurrencies Hub` and the official guidelines can be seen on their [payment portal](https://www.colorado.gov/revenueonline/_/#1).

## Notes

Cleaning up the default journal entry format within the mdx.

## Tasks

-   [x] Homepage 2024 Update
-   [x] No major tasks left.

## Quote

> The most certain sign of wisdom is cheerfulness.
> — <cite>Michel de Montaigne</cite>

---
# April: 23

> Daily Log for April 23rd of each year.

Source: https://kbve.com/journal/04-23/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2025

### Astro Askama

-	12:03AM

	Released v1.3 of Disoxide and the website is slowly getting its form!
	With the basic redis integration out of the way, the focus will be on the cache control and then it will be the supabase linking.
	As for the front end, I still need to finish the quad panel and migrating the rest of the alpine code over to svelte.

-	08:35AM

	Next round of askama updates will be around getting that perfect 100 lighthouse score, gives us a solid area to aim for and then we can drop a decent chunk of the alpine.
	As for the supabase loading, we can wait a bit on it since there is still some work that we need to do with getting the quad panels to be operational.

- 	03:05PM

	Okay, making some progress with the sidebar and handling the bigger issue, which is the i18n.
	The plan would be to load all the different keys for each language and then build an astro collection holding the translations.
	If it works out fine, I might make it into a library and add it back into the kbve website for our collections.
	The loading of the i18n keys, values and basically the whole database should be done via the shared worker but we want to make sure that it will not be an issue.
	I think there might be a couple ways we can address this, but I also need to make sure that we update the axum with the new folder for i18n.
	Under the assets.rs file, a quick edit to include the ServeDir for `i18n`, and that should be fine on the rust-side of things.
	
```rust

	.nest_service("/i18n", ServeDir::new("dist/i18n").not_found_service(get(custom_404)))

```

	That should make sure the next docker image build serves the json files from that folder without any issues.

### Astro Toast

-	05:45PM

	The toast can be added in two ways, we could create our worker and then delegate the toast tasks to it.
	However, I am thinking that we move into an event based system that then modularizes each of the scripts into their own workers.
	The event system and message system would move amoung the shared worker, client and N-workers, using events to trigger the deployment.
	I can already tell that I will have to rewrite this all again in the future, but for now this is part of the learning system.

-	05:49PM

	After making the basic toast module, aka toast.ts, I am going then adjust the client.ts to handle it.
	We want both a subscription based way of triggering the toast and also a custom event system!
	This should give us the ability to handle both live events and events triggered from the main thread.

-	06:56PM

	After looking through all the code and building it out, I decided that it be best to just throw it all out and start fresh again.
	I am thinking that it would make sense to structure it around a notification system that sits within the idb.
	The toasts will just act as a UX medium for the user to see the title and the core message, while the idb holds the full notification.
	This means we can extend it out to include the redis watch and anything from the supabase end points as well.

### Astro Notifications

-	07:00PM

	The notification system should be simple enough so that we can loop back to finishing the SW / i18n reloading.

### MusicJams

-	03:04PM

	The song is Swimming by Goth Babe Point Mugu, I need to remember to add that into the music bot!
	A quick side note for that plug from Zs youtube music stream.

## 2024

**Journal**

More changes to the website! The feeling of fixing up the daily journal has been a long standing pain for my eyes, so I am going to try and tackle it today.
I am thinking the focus should be on optimizing while crafting an unique experience for the future readers, including myself.

```javascript
<div class="sm:order-2">
	<div class="relative rounded-lg pt-[50%] sm:pt-[100%]">
		<img
			class="absolute start-0 top-0 size-full rounded-xl object-cover"
			src={journalEntry.data.img}
			alt={`journalEntry.data.cardImageAlt`}
			draggable={'false'}
			loading={'eager'}
		/>
	</div>
</div>
```

We should wrap this container with code that would optimize the image URL and also see if we can pass through the unsplash ID , then apply changes to the URL to make it faster for us.

I decided to to have the source be `journalImage` and added this code block in the start of the journal.

```javascript
const journalImage = journalEntry.data.unsplash
	? `https://images.unsplash.com/photo-${journalEntry.data.unsplash}?crop=entropy&cs=srgb&fm=avif&q=85&w=1024`
	: journalEntry.data.img;
```

This will help us control the way the size of the image that is being loaded, before we were loading nearly 100MB worth of images, which is not worth it!
I swapped out the `eager` with a `lazy` as well, so the site now loads super fast and will lazy load the images as we scroll down.

**Menu**

Time for me to play around with the Preline Menu! Coming from the flowbite flow, this UI library seems to be structured in a similar matter, so it won't be too hard for me to get the flow.

The dropdown for the menu is a bit off center, I am thinking that it might be a css issue with respect to the screen size, hmm.

Let me update the links on the menu!
So we will link off to the docs, but I might want to work on that too, hmm.

**Search**

Maybe we could add the document search directly to the front page of the website?

Looking at the source code for the `SiteTitle.astro`, err, I mean `Head.astro`

```javascript
import StarlightHead from '@astrojs/starlight/components/Head.astro';
```

We can import the `StarlightHead` , I am wondering if we could import the search and then place it on the front page directly.

```javascript
import StarlightSearch from '@astrojs/starlight/components/Search.astro';
```

Hmm this ended up being a bit too complex for me to do while I am half Zzzz, so I will try it again tomorrow.

**Github**

Lets update the Github contributors , filtering out the bots and myself! Then maybe trimming the list down to about the top 10 contributors.

```javascript
// Filter Users
const remove_github_users = [
	'github_actions',
	'actions-user',
	'h0lybyte',
	'github',
];
const github_avatars_filtered = github_avatars.filter(
	(avatar) => !remove_github_users.includes(avatar.login),
);
const github_avatars_leaderboard = github_avatars_filtered.slice(0, 10);
```

Simple filtering and slicing got the job done!

## 2023

**India**

-   Damn! 17 days left in India for this vacation! I definitely will miss this place, the internal clock is already ticking. The next time I am around India, I might make plans to visit the Himalayas and also expand around Asia, definitely need to put Japan on the list.
-   I am currently debating how I should setup the AppWrite Register. I am thinking I will do the classical way first and then maybe create a widget, `react-appwrite-widget` , to handle the Register? Hmm.
-   I decided to stick with a simple register / login / account flow for now but will expand it later on once I find more usage for it. The three are under tasks.
-   Expanding the user profile via its own astro component, I have to be careful not to hit the API too much while building out the basics. We could store the basic user information into another nanoStore, so we do not have to pull from the API all the time. The issue is related to https://github.com/KBVE/kbve.com/issues/183

## Notes

The journal system has to go through another change that should make it easier for us within the template level.

## Quote

> Do you know what my favorite part of the game is? The opportunity to play.
> — <cite>Mike Singletary (basketball)</cite>

## Tasks

-   [x] Connect AppWrite with /account/register/
-   [x] Connect AppWrite with /account/index aka Profile?
-   [x] Connect AppWrite with /account/login/
-   [x] Prepare weekly 0days.

---
# April: 24

> Daily Log for April 24th of each year.

Source: https://kbve.com/journal/04-24/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Advertisement Network

-   03:32PM

    There was this idea of creating a small ad network that was just 88 by 31 images for normal people to use.
    We could integrate it into github repos, personal sites and all the nine yards, basically making it easy to work with and build around.
    One of the issues would be that since the images keep changing, how often does github cache it and where would the URL match the image?
    The very basic part of this would be to give kbve credits some additional value outside of our games but also it would be a cool way to integrate the said ads into our eco-system.
    The small banner ads could appear in our minecraft servers, website and even in-game, like in Rareicon.
    These notes are just around this concept, I am keeping them here to remind myself in the future about it.


## 2025

### Astro Web Workers

-   10:12AM

    Rewriting all of the web workers to use dexie and comlink again.
    Tried to roll my own but there was just way too much to account for and to update, so I figured it might make more sense to work with exisiting tooling.

-   07:31PM

    The problem that ended up taking me out, almost burning me out, uhhh was just the damn localStorage!
    I thought the localStorage could be used between the web workers and I was mistaken, it seems that only the indexdb can be.
    That means in the future, I will just stick with building out using Dexie and keep the nanostores as a thin cache layer.

### VSCode Live Share

-   09:42PM

    Its been well past a full day and they are still down!
    I am a bit upset that I can not quad-code without having that full connection but it is fine for now.
    Well the next best thing for me to do is just deskflow amoung all the systems until it comes back up.

## 2024

**Edit**

Another amazing feature of starlight is that we can edit the documents right then and there!

All we had to do was update the starlight configuration and add in this:

```ts

editLink: {
				baseUrl: 'https://github.com/kbve/kbve/edit/dev/apps/kbve.com',
			},

```

**Theory**

After migrating over the applications, the next step would be to add our theory page!
However, I am thinking about the other sections too, but I do not want to get ahead of myself.

Lets us begin the theory migration!


**Discord**

Updated the Discord Page to fit into the new style!

## 2023

**India**

-   The day has been crazy! The heat is a killer. :O

**KBVE**

-   The main focus would be to get the GraphQL to work across the whole KBVE main page and then extend it to various applications.

-   It seems that we will have to use a mixture of GraphQL and REST, as there seems to be some areas where REST is faster.

## Notes

More Updates!

## Quote

> Just be patient. Let the game come to you. Don't rush. Be quick, but don't hurry.
> — <cite>Earl Monroe</cite>

---

## Tasks

-   [x] Register, Login and Profile via GraphQL.
-   [x] Register WISE account.

---
# April: 25

> Daily Log for April 25th of each year.

Source: https://kbve.com/journal/04-25/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026


### MC

-   7:05PM

    I am trying to keep my usage to an understandable limit, but it sure seems to be an issue!
    Anyhow, I have about 10-20 more patches that I need to apply to the MC gameserver, but still have not yet gotten approval from ModRinth.
    Maybe it might be time to setup the CurseForge for the server instead, or maybe it might be because of the bugs?
    Both are valid points that I need to address in the MC universe, however I am glad the online playerlist is functional.
    With that being said, let me prepare the next version of the MC release with the patched Apple skin configuration issue.


### Unity Rareicon Steam Rewrite

-   10:17PM

    The rewrite of the steam code has started, since we are in the process of getting the demo approval, having the steam integration ready would make sense.
    Once we get approved, that means we can easily start to roll out demo deployments!
    I am thinking that we keep it vanilla for the first week and focus on getting multiplayer opertional asap.
    The first idea I had was to do a casual multiplayer through steam networking rather than dedicated servers because that would keep the costs down.
    Having our own dedicated instance that would be running could be too much, but I did see openfront io and maybe if the game gets popular enough, we could do a global server.
    I was looking through some of the general concepts of that game and it would be really cool to implement something like that in our game?
    These are just notes aka food for thought.

-   10:54PM

    The current bug that we are facing is that the simulation does not account for building fast enough and some minor ui issues.
    We might need to also get a launcher that would be semi-operational and displays the i18n, supabase and steam login, ect..
    The launcher window would be running as the game is booting up and preparing, something that I have done in the past games as well.
    After the game launches, it will switch from a launcher window to the settings window, that way we do not have to destroy but rather keep some of the data there and swap it out.



## 2025

### Andor Season 2

-   02:00PM

    The second season of Andor is out and the first three episodes are amazing!
    I feel like I am about to watch a whole movie series again, this is some of the best Star wars yet.
    I dont want to give out any spoilers but top tier acting and writing.

### Disoxide v1.4

-   03:28PM

    Getting a near full CICD might be possible soon for our disoxide, but that might be just a bit too much for now.
    We trigger the builds via the `README.md` for disoxide and after the release is done, we need to grab the latest sha of that image.
    With that latest image, update the helm templates and then finally minor bump the following pre-release.
    This is just quick notes on maybe a `rancher` command that we could add into the kbve.sh to handle this for us.

### Astro KBVE UXUI

-   06:42PM

    Another shot at figuring out unique ways to handle the user interface and user experience!
    I am going to try and keep the internal core as close to vanilla javascript, this way if I need to use it in React or Rust in the future, it wont be an issue.
    The plan is to expand the `window.kbve` with a state called `uiux` which will hold a nested nanostores map.
    

## 2024

**API**

Looking back at our 2023 notes, its wild to see the shift in changes.
We migrated out of Appwrite/Strapi and ended up back to writing our own API!
Yet back then, the times were very simple.

**Projects**

Migrating the KBVE Projects over to the official docs!
A couple issues with the migration, some of the mermaid graphs did not go through and need to be fixed.
The solution might be to just go back and import the astro file that would handle the mermaid, but I am wondering if they have an inhouse one for Starlight.

**Migration**

There are more migrations that need to be done to the official website but we are making some headspace towards it.
A couple proof of concepts were added and tested, but now its really the large amounts of data that needs to be shifted over.
The documentation needs to be reviewed, changed and updated across a couple hundred different asset classes, furthermore, a couple hundred stocks still need to be added.


## 2023

- Astro -> React -> GraphQL/REST -> Appwrite -> Strapi
- The chain of command might seem a bit too much but I think it should help wrap up most of our front-end journies. Afterwards, I will clean up and prepare for May dev logs.

## Quote

> Winners never quit and quitters never win.
> — <cite>Vince Lombardi</cite>

---
# April: 26

> Daily Log for April 26th of each year.

Source: https://kbve.com/journal/04-26/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### MC Pipeline

-   11:29PM

    The pipeline for getting mods published on curseforge is next on our list.
    We can then maybe figure out a way to build our own launcher ontop of that, maybe even one that bundles everything together?
    Like a custom jar download, patch everything and then run without needing any extra headaches.
    Then on the flip side, we could update isometria to then be a full minecraft browser based client, with our own assets that lets anyone play without needing to download the game.
    This would boost our player count and maybe even make the game a bit more interesting, while prodiving us with more players.


### RareIcon Landmarks

-   02:22PM

    Getting the landmarks out of the way and then going to figure out the best way to get general rendering for the different hex worlds.
    I am thinking that clicking on the hex tiles should then take you to a "world", this allows the player to enter a low poly 3d world, treating our hex tiles as a map.
    There might be some layers to consider, but I believe we could pull this off with some careful planning, at least something within the near future.

### KBVE Website

-   04:45PM

    Minor updates to the website, I definitely need to find a solid youtube video for the main page.
    Furthermore, I might look at finding a soft off-main thread rendering, maybe using a worker and canvas element?
    This way we can have some cool animations that would not block the main thread.

    XData tags are something that I need to add into the website, that could help us in the future!
    While react does not directly support data tags, I believe including them would give us some gains in the future.

### Unity 

## 2025

### Unity

-   06:15PM

    Deep diving into unity for majority of the day and then going to focus on multiplayer.
    The kilonet package needs to be rebuilt because it seems that the Unity transport is wrong and needs to be removed.
    We will have to build in a way where we are using websockets first and then add the UDP/TCP direct support later on.
    I am thinking that we might just use the websockets overall, ugh.

-   11:00PM

    The webgl build completes but it seems to fail to run and giving us a weird error?
    I am thinking that it will be an issue that I can look into after updating the binary streaming tomorrow.

## 2024

Just working on the internal aspects of the KBVE Monorepo!
I am thinking about the best way to handle the layout system right now.

**Arcade**

We made some minor changes to the arcade earlier this week!
I am hoping to wrap up the changes before the end of today!
The hero looks terrible and needs to be updated to fit the arcade, also we need to remove the scrolling.

**Webmaster**

Started to build out the webmaster tool, which was built a couple times in the past.
I am just updating the older codebase and rewriting the basics of it.
Hmm, other than that, its been a slow Friday!

**Dockerfile**

Its a bit late at night and it seems that Ubuntu 24 release has caused some of the dockerfile / docker images to break.
Ugh I will focus on these tomorrow.

## 2023

-   Learning GraphQL. Okay we got the basics of the AppWrite integration, i.e login, signup and user profile but there is no subscribe yet.
-   The newest restaurant that I enjoyed was `Indian Spices 4U, Manjalpur, Vadodara` , and it was damn amazing. They have an all you can eat / lunch special, so starve yourself for the whole day and then binge out on amazing egg dishes. I recommend asking for boiled eggs on the side, with no salt/pepper and then dropping them crushed into the curry gravy.

## Quote

> It is one of the blessings of old friends that you can afford to be stupid with them.
> — <cite>Ralph Waldo Emerson</cite>

---
# April: 27

> Daily Log for April 27th of each year.

Source: https://kbve.com/journal/04-27/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### NVidia Five Trillion

-   11:15AM

    Crazy to see Nvidia cross the five trillion mark, I am thinking that it might even see the six mark within the next few years.
    The reason is not just because of the crazy AI and datacenter race but I think that their general consumer market is still extremely under served.

-   12:34PM

    I am placing a $205 put, about 10 contracts for a quick $1K.
    The position of openning another 1000 shares is not a big deal, because I did end up wheeling a couple of them earlier, this is just a way to continue to go with the flow.
    My other concern is that I need to merge some of my accounts, because then I could run more wheels around the stock, definitely because it trades more than just weekly, almost bi-daily.


### Steamworks RareIcon Demo

-   12:23PM

    Getting rejected by steam sometimes is the worse because their UI for setting up the store pages is terrible!
    I find it extremely confusing and painful to work with and given their size, I would have assumed they would have mastered this dashboard.
    If I was working at Valve, I would dedicate a whole year on just optimizing and improving their damn steamworks, ugh, it is so painful.

### Github Actions Down

-   12:33PM

    I am not a big fan of when I can tell that github is down, I might be on here too much to run into each error that occurs.
    Even when I am just casually utilizing their eco-system, but what is crazy is that as I am writing this from my notes, I see the search degrade error notice come out.

### Uniti Crate

-   12:43PM

    There are some issues with the current unity crate package that we are looking to build, the first one is that there is a lack of RS docs.
    If we can resolve some of those issues within a timely matter, then moving forward with the crate publishing might not be too big of a deal.

### KBVE Forums

-   12:43PM

    As I am resolving some of the crate issues with Uniti, I am also looking at the forum situation, since we still need the dbmate migrations resolved.
    The proto was updated earlier this week, now we need to get the core migrations to pass our internal e2e.


## 2025

### Redis XADD XREAD

-   01:02PM

    Time to update the protos to include the ability to XADD and XREAD aka Streaming!
    Since we have the fred crate, the streaming code is already in place and we just need to wire it up.
    The goal will be to shift all the binary over to another protobuf called RedisBinary or RedisStream, then just handle it like that.
    This means any binary that comes into the websocket would be treated as stream data and we can move the non-binary to the JSON commands.
    This should give us the best of both worlds without running too deep into issues.
    There would be room for improvements, we could also introduce a CapnProto later on too.
    Okay let me update the `redis.proto` within the Jedi package to include the Redis Binary stream!
    Afterwards we can update the redis wrapper to include the new stream data.

-   04:14PM

    After generating the new redis xdata streaming protos and adding them into the jedi crate, I am going to write them up on the rust side.
    The initial plan is to keep the basic redis commands within JSON, as stated earlier and I am just recapping my memory but we will process the binary first and in a different loop.
    New protos get converted to rust code using `./kbve.sh -nx jedi:proto` and afterwards we will import them to the `redis_wrapper.rs`.
    Now the fun begins with the functions!
    


### Unity Buffers

-   02:52PM

    We are currently building it around using json but once we get the basic debugging out of the way, we will just stick with binary.
    The goal might be to just serialize the NPC Manager and send it over the wire but that might not work either.
    Damn, multiplayer can become a pain to do the first round, I am thinking that it might be too much data that is moving back and fourth, ugh.
    I am getting a headache just thinking about it, gahhh.

## 2024

**Shrek**

I believe it is time to rewatch the whole Shrek series from start to finish!
Not just the three main movies but all the side movies!
I will become one with the shrek universe.

**DockerFile**

Oh let me swap the Ubuntu version to 22.04 and see if it works with that version!
Let us push the build up from this point and see if it works.


**Webmaster**

The webmaster tool has only a couple links for an average website owner, I am going through the notes and looking for any other additional tools to add into it.
Hmm, maybe afterward getting through the basics, we could add some special AI tooling? 
Like a tool that could go through the website and offer possible changes or improvements to the website?

**Legal**

The legal documents are still on the older template, I am going to swap them over to the new template.
Afterwards, I will still have to dive deep and replace some of the static content from the template system, which I been doing slowly.


## 2023

- Spent most of the day cleaning up and preparing my luggage for the trip back to India.
- Parker sent me this open source lawn mower, [Open Mower](https://github.com/ClemensElflein/OpenMower) and it really seems like a great idea down the line to look into. Imagine launching a landscaping business where you use robots to manage all the lawn care for your clients!
- AppWrite integration test casing is probably where I will spend most of my time today on. I ran into some issues with the GraphQL and sending out verification emails. It seems that Ezoic keeps removing our SendGrid CNAME / information, thus putting our emails back into the spam folder.

## Quote

> The world makes way for the man who knows where he is going.
> — <cite>Ralph Waldo Emerson</cite>

---
# April: 28

> Daily Log for April 28th of each year.

Source: https://kbve.com/journal/04-28/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2026

### Nx Migrations v22.7

-   11:43AM

    Updating the Nx to v22.7.0 using the `pnpm nx migrate latest` command.
    I am not too sure why its hanging but it should update soon, getting that out of the way before I move back to the rareicon upgrade.

## 2025


### Mystery GameJam

-   11:10AM

    Got an invite to join a game jam for a Mystery game that combines puzzle solving and a visual novel element.
    It is right up my alley but I might not have the time to do it.
    Looking back at my older visual novel code, a complete rework and refresh might be possible with the shared worker libraries that I have recently written.
    On top of that, the new tailwindcss has some of the features that I was looking for, like shadow text and 3D transforms. 
    I told them that I will think about it and get back to them.  

### OpenFront

-   06:45PM

    Enjoying this small RTS io game, it has a bunch of room for improvements but it is fun to play and watch!
    As for what I am thinking, it might be interesting to build something similar in the future, maybe when I want to build in phaser again.


### FlexBuffers Redis

-   07:03PM

    Updating the websockets again to use flexbuffers for the redis streaming.
    The plan is to create a `flex.rs` module that would hold all the flexbuffer related structs and then bridge them to the proto files.
    Afterwards, we can go ahead and build the functionalities for the flexbuffer streaming within redis.


### CowArc

-   08:48PM

    Rewriting the code again but this time I want to focus on a CowArc style, where we wrap the binary in both a cow and an arc.
    Should be good enough for what we want to build!
    Okay actually we can just end up using the bytes crate, so we can just skip the CowArc for now!

## 2024

## 2023

- Currently integrating Svelte into AstroJS, but running into some development problems with Astro v2.3.1? or v2.3.2?. Vite is throwing some errors here and there within the rollUp, so I am currently in the process of debugging that. Afterwards, I aim to integrate AppWrite into Svelte, so that it can execute a bit faster than the current React setup. While React is able to get the basics done, there is a bit of a delay between each action, around ~600ms because it has to communicate with the API (from AppWrites end), I am trying to see if I can resolve that , or at least make it less noticeable via the UX/UI end. One of the aspects I was thinking of was to store the user information locally after login, to have an almost instant load WHILE only having `update` and `delete` require a connection/load.
- `Something went wrong installing the "sharp" module` - Sometimes I hate the sharp module with a passion, I am going to wipe the local installation clean and start fresh from the dev branch. 
- Next issue was that Search via the MDX page was throwing some weird errors and honestly I am a bit too tired to figure out why it was giving a pain. I am assuming its because I forgot something to render or messed up the JSX / react syntax, but to make it easier, I decided to migrate it out of the MDX concept and make it its own .astro page. While I wanted to make it all uniformed via MDX template, certain areas might not be worth the time. Furthermore, I disabled the bing / you searches because they were giving errors of CORS on certain browsers.
- I would say this is a bit of a major update to the website, as I begin to migrate + add more into the framework.
- Under search, I expanded the options and included `reddit.com` and `stackoverflow.com`. The results are not within the iframe but instead they open in new a window/tab; I will gladly add more options/parameters down the line, including expanding into images and GPT/LLVM.
- 8:37pm - It seems that my idea of having a general namespace and then running a custom templating system out of that is just a bit too much. I will go with a more simple widget style and just import the widgets directly, instead of having them all over the place. I just get confused and there just so many options and ways to do things... that it just too much. Sometimes I over-engineer everything and it might not be the best, BUT it was dope to have emoji-style templating, even if it was a complete waste of time, rip 50+ hours I spent lmfao. I did learn and gain so much knowledge from the experience, so it might not have been a total waste.
- 8:40pm - Just saw a dude on a bike get nailed by a tuktuk / rickshaw, he was okay but was driving in the wrong direction and going a bit too fast. Duck the traffic here in India is insane.


## Quote

## Task

---
# April: 29

> Daily Log for April 29th of each year.

Source: https://kbve.com/journal/04-29/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Forum

-   02:10AM

    The official forums will be under kbve.com/forum but I have some things that need to get resolved before I can really push it out there.
    We will need to link up the marketplace as well, hmm, that might have to be another commit or so in the morning.

### Unity Rareicon Pipeline

-   12:33PM
    
    We had the older pipeline hooked up with azure and it did build the webgl of rareicon.
    Now we are going to swap that out and have rareicon get built using either our own self hosted runners or keep with github actions.
    I am not too sure how long it will take to have it get built, but it will be interesting to see.

### Modrinth MC

-   12:46PM

    The current issue with the minecraft server is that the cicd pipeline for some reason is having a tough time confirming the mrpack.
    This is leading to the client crashing and not updating, i.e connecting with an older client-side mod.
    I was really hoping this would be easy to use, but might have to switch back to curseforge instead.

### Bevy Crates - Bevy Behavior

-   01:50PM

    There are about 13 level zero crates that we need to publish,  I am currently going through them, making sure that they are all good to go.
    Our focus will be to get most, if not all of them near production grade before the end of the week.


### Holy Crate v0.2.1

-   02:30PM

    We should update the holy proc macros to include everything we will need for the forum, but also include anything else in the future that we might need for unity.
    The proc macro will be our centralized location for all security related layers, then later on we can do some str and cow level tweaks, so that its easier to clean up the strings.

### Garden Peppers

-   04:28PM

    The season is still a bit later that I would have liked, but I am going to plant some spicy peppers, maybe even try and get some seeds to sprout.
    In the future, I should setup a germination box, maybe pick one up from amazon.
    Actually, this might be a good reason to pickup a 3D printer, it would be dope to just print little pots for plants.

### Unity Character Selection

-   11:15PM

    Added the character selection and now I am going to flush out the UI!


## 2025

### CC Bills 2025

-   01:00PM

    Before I go out to grab some quick food and goodies, I need to make sure that everything is squared for the end of the month!
    We want to make sure that everything is paid for and that the cash surplus is extended out further than the 15k mark.

### Bytes

-   02:02PM

    Rewrote all of the redis functions to be lifetimes but ended up going back.
    Nothing is worse than rewriting your whole rust eco-system, only to have to revert it because you decided to use a crate instead of rolling your own.
    Each time I roll my own internal system, I remember that it might not be worth it because then I have to maintain that system!
    Not everyone can be the tanstack guy xD.
    After adding the bytes and making sure that it builds, we can handle the nested streaming within the websocket.

-   06:45PM
    
    Updating the redis_wrapper.rs to include a bunch of additional helper functions and utility calls, eventually rewriting them in the future into a chainable object?
    Part of this exercise is to treat it like a set of light weights, where we keep lifting and placing it down, slowly adding more weight as we get better.
    The issue that I am seeing right now is that we are trying to have both the JSON and Binary within the same websocket.
    That connection could either return valid JSON or Binary.


## 2024

The main focus will be getting the launch ready for KBVE website and application.
Ugh the account page is still super buggy, but I think we can still move foward with the way it looks, at least in our initial launch phase.

**About**

Going to make changes to the about page, and testing some of the code generation via offline models.
Honestly they are getting way better than I expected.

**KILLTONY**

Always a great way to start off the mondays!
Another addition to the collection, the show was a solid 6/10!
Some of the acts were really bad but overall, it was a solid episode, damn tony hawk lookin old.

**Invoice**

I am preparing the invoice management and generator, making it easier to keep track of all the records and services.
This is going to be a bit tough to mix in the old code with the new code, but I think we can get somewhere decent with it by the end of May. 

## 2023

Pre Launch has been pushed back over and over!
While it sucks to have to delay the MVP, it is great to see the backend and frontend stack evolve and become more mature.
I think Astro still has a long way to go but so far I have been impressed and amazed with how fast it has grown.

## Quote

> Sometimes being a friend means mastering the art of timing. There is a time for silence. A time to let go and allow people to hurl themselves into their own destiny. And a time to prepare to pick up the pieces when it's all over.
> — <cite>Octavia E. Butler</cite>

---
# April: 30

> Daily Log for April 30th of each year.

Source: https://kbve.com/journal/04-30/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Rareicon Demo

-   12:57AM

    Getting close to launching the demo, I am a bit excited!
    We got the steam store approval, now we just need to grind through the minor bugs.
    For gameplay focus, I am thinking just more updates around the combat loop, better controls for units and fixing that drag selection bug.

### Forum Emojis

-   10:47PM

    Removing all of the extra emojis with SVGs will definitely make it feel a bit smoother.
    I am still not a huge fan of the forum, there might be more room for improvements, but I will look into it later on.

## 2025

### ANDOR

-   09:06PM

    The second season of Andor has been amazing, now I am thinking I should have rewatched the first season before jumping into the 2nd but its okay.
    

## 2024

**Invoice**

There will be a couple ways that we can handle the invoice system, but I will try to keep it simple from the start.
We could split the invoice and draft into two different aspects.
First part of the invoice is to limit the amount of capital that a single invoice / order can have.
I am thinking that multiple invoices will be fine and splitting up orders is better for the risk management.

Rather than the end user having a bulk order with just a single invoice, we will save the bulk order into a draft and then split up the final order into multiple invoices.

This way we can also setup terms and conditions for each of the items and orders, certain invoices can be cash or crypto first before delivery or COD, while other invoices can be NET 30 or something insane like a 99 year invoice.

This is a great library for signatures, called Signature Pad, which I will add into the javascript notes.

Inside of the `invoice` table, I am thinking of removing the boolean for public.

```
public: boolean('public').default(false).notNull(),
```

We can replace that with a `visibility` that starts off with a number scale, with 0 being private and then 10 being public.
This gives us additional options later down the line to control how the invoice can be pulled. 

Okay! The new invoice table looks great, going to generate the mysql using

```shell

pnpm drizzle-kit generate:mysql

```

then going to branch off the `main` database, aka `patch-invoice` and then prepare the deployment.
After the deployment has been inserted into production, without issues, we will go back around and generate the new SQL structure for the Rust backend.

Okay! The rust models were generated without any issues but the protobuf did throw an error when dealing with the decimals.
We have two options, the first is to just move all the data into integers OR represent them as a string and handle the overhead.
For now, I am thinking the best move would be to hold them as strings because we are not too sure what level of precision we want to use.
USD is at around 2, by default, but I have seen situations where it can reach upwards of 4-6.
[Bitcoin](https://kbve.com/crypto/btc/) is already at around 8, so it just seems wise we use strings for now.


**Search**

I am going to setup `FindItFaster` for my VS Code, but that extension also needs a couple libraries to be installed on the ubuntu instance.
We will grab the three libraries that it uses:

```shell

sudo apt-get install fzf ripgrep bat

```

**Auth**

Time to start the tradition of setting up auth! Oh boy!
We have been doing this like if it was acid, got to go back around and do auth over and over, until it is perfect, lul.


---

## 2023

**Videos**

-   The material, NiTiTol, from this [Veritasium video](https://www.youtube.com/watch?v=vSNtifE0Z2Q), through me into a deep research/wiki-loop on material engineering this whole morning.

-   Also another cool video, The Galactic Menagerie, Star Wars by Wes Anderson Trailer https://www.youtube.com/watch?v=d-8DT5Q8kzI


**Programming**

-   Going to update the Strapi API to the latest version, v4.10.1 because it seems to address the yarn build bug that was giving me issues the last time that I tried to upgrade/update.

-   6:00pm - I started the process of updating the API, it was pretty straight forward with upgrading the packages and then deploying the version v4.10.1. There were no major database migrations but I backed up everything to be safe.

-   Next mission is to upgrade AppWrite from 1.3.1 to 1.3.3 , which I am doing right now. There are some issues that I need to address between the AW and Strapi API, including the unique keys/index. The update seem to work out well and the database migration did not throw any issues.

-   7:00pm - Refactoring the KBVE.com codebase by removing old / dead astro files that are no longer required. This is to help improve performance and to clean up the workspace, so that others can easily navigate through and not have any issues. There are instances where certain files get referenced twice, once via the Namespace and then again directly via import.

-   I have to restructure the name convention and I believe that keeping it extremely basic will be better in the long term. Thus I think it would make sense to use the term, `Widget` , and place all the `Element` / `Action` into that area and the migrate them out again in v2 of KBVE.com. Mapping out each widget seems to be a waste of time right now, as I keep rotating different file names and file types without keeping something straight forward.

-   Another interesting error that I am having is with the email(s) going into spam. The issue is actually not on my end but rather that our advertisement platform, "Ezoic", throwing errors ecause it is unable to proxy the CNAME from our email provider, "SendGrid". It has been almost two weeks and currently still waiting for them to resolve it. :/

**India**

-   Had to grab a quick meal earlier in the day, so I decided to try the local KFC at the InOrbit mall! While I am not a big fan of having fast food, the tandoori chicken was delicious and not too expensive! The legs were not too greasy, chicken was cooked almost near perfectly and the blend of spices were on point! These guys are making a huge mistake not bringing this dish into the US because it would become an instant hit across North America.

-   11:00pm - I am about to start winding down, going to grab some mineral water and a salt paan before getting ready to sleep.

---

## Quote

> Happiness mainly comes from our own attitude, rather than from external factors.
> — <cite>Dalai Lama</cite>

---

## Tasks

-   [x] Strapi Update.
-   [x] Pay Credit Cards.
-   [x] AppWrite Update.

---
# May: 01

> Daily Log for May 1st of each year.

Source: https://kbve.com/journal/05-01/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Copy Fail

-	08:56PM

	After finishing the talos upgrade, the first failed in the middle of the night, had to do it agian this morning.
	The issue is that we only have a single node instance, we will have to prepare to expand to a trio fairly soon, that way we can keep the cluster running through rotations.
	Anyhow, we still have a couple things to resolve until then.

### Rareicon v0.1.2

-	10:39PM

	Preparing the next build, maybe this time the windows version will be with working shaders.
	However I am thinking of 


## 2025

### Binary Websockets

-	03:03PM

	Going to aim at finishing up the binary websockets today and hopefully we can get the client side going too.
	We want to websockets to work with binary first and then fallback to JSON.
	After we get that going, we can work on the client side workers to connect and handle the binary data.
	If we get both of those wired, we can do the Unity client next.

### Proto Enums

-	04:08PM

	The biggest issue with the proto files is that we can not get them to generate the right rust code with serde because of the enums.
	Two options that we can do, one would be to wrap them in a custom structure or try to find a way to include the serde attributes without breaking the generated proto.
	Updating the build.rs within the Jedi crate again and it seems we were able to get the protos to generate the correct serde code!
	Now we need to update the flex.rs with additional utility and helper functions to handle the binary / json serde data.

-	04:54PM

	Okay! Figured out the problem, it seems that our Field struct is already built to handle binary data, `u8` but we are doing `str` in our `FieldData`.
	Lets go ahead and rewrite the `FieldData` to be a `Vec<u8>` and then we can convert it to a string when we need to.
	Updated the FieldData to use `Bytes` instead , with the goal of keeping that protobuf wire format while still supporting the flexbuffer.

### ZeroCopy Removal

-	10:53PM

	Removing some of the older zerocopy code from the redis_wrapper.
	Here is the code below that we removed, I will keep it here as a reference for the future.
	I might take a shot at this again in a couple months.

```rust
/// TODO: ZeroCopy WebSocket Format
/// ! START]
#[derive(Debug)]
pub enum ZeroCopyWsFormat<'a> {
  JsonText(String),
  Binary(Arc<Cow<'a, [u8]>>),
}

#[derive(Debug)]
pub struct ZeroCopyWsRequestContext<'a> {
  pub envelope: RedisEnvelope,
  pub raw: Option<ZeroCopyWsFormat<'a>>,
  pub connection_id: Option<[u8; 16]>,
}

/// ! [END]
/// 
```

### Redis Wrapper

-	10:55PM

	Updating the redis wrapper to use the changes from the flex module.
	I did not get a chance to add XTRIM and a couple other x-data commands because I think it would make sense to get the generic linking out of the way first.
	Once we can confirm that nested streams are working aka x-data through websockets, then we can loop back around and add the batch and trim commands.
	XGroup is a bit tricky because we will have to link the connection_id to the group, so that there is no weird crosstalk among the groups and the conncetion_ids.

## 2024

**Rust**

Nothing says a great start of the day than having Rust issues that you have to resolve!
We got two major issues with our database command:

1. kbve Crate

```

error[E0277]: the trait bound `diesel::sql_types::Json: Deserialize<'_>` is not satisfied
  --> src/models.rs:93:5
   |
93 |     pub items: Json,
   |     ^^^ the trait `Deserialize<'_>` is not implemented for `diesel::sql_types::Json`

```

2. erust Crate

```
error[E0412]: cannot find type `Json` in this scope
  --> src/state/dbmodels.rs:84:16
   |
84 |     pub items: Json,
   |                ^^^^ not found in this scope


```

We are testing these with these commands:

```shell

cargo publish -p kbve --dry-run

```

For the kbve crate, it looks like we were missing a `serde_json` feature, but let me commit this and run the test again.

Next, just to be safe, remember to run a `cargo check`.

Okay! Instead of messing around with the serde_json directly, I am going to just pass `use serde_json::{ Value as Json};` as the Json representation for that model and move forward.

Finally we have the erust issue, which we need to resolve!

So we know that after we create the erust models using the shell script, we need a way to patch it.

```shell

            sed -i 's/(Queryable, Debug)/(serde::Deserialize, serde::Serialize, Default, Debug, Clone, PartialEq)/g' ../erust/src/state/dbmodels.rs
            echo "Patching the DBModels"

```

We can use this method below, to patch the `dbmodels.rs`

```shell

            { head -n 4 src/models.rs; echo 'use diesel::prelude::*;'; echo 'use serde_json::{ Value as Json};'; echo 'use serde::{ Serialize, Deserialize};'; tail -n +5 src/models.rs; } > src/temp_models.rs && mv src/temp_models.rs src/models.rs

```

We need to insert the rust code below into the `../erust/src/state/dbmodels.rs`

```rust 

use serde_json::{ Value as Json};

```

Okay! Here is what we can do using grep, 

```shell

grep -q 'use serde_json::' "../erust/src/state/dbmodels.rs" || sed -i '5 a use serde_json::{Value as Json};' "../erust/src/state/dbmodels.rs"
echo "Patching Part 2 of the DBModels"

```

This should patch the dbmodels to use `Json` without having any issues, both seem to run fine with dry runs as well.

While we wait for that to build up and move along the pipeline, we can focus on the register method once more for KBVE.

**Register**

The register function will require updates on both the client and server side! Oh boy, this is going to be another one of those days.

We need to change the error system on the `register` function within the KBVE API.
The older error system needs to be replaced with the x-kbve shield style, so we can capture the error headers outside of the rust application too.
Oh, I need to also include a `127.0.0.1:4321` in the CORS policy for the application.

As we wait for the branch to pull into production, we can start updating the next couple functions during this build phase, hmm while I cook myself some beans.

```rust

return spellbook_error!(
				axum::http::StatusCode::BAD_REQUEST,
			 	"email-exists"
		);

```

Above is the older rust code, which works fine but we need to sort out the return json, so the client-side code can easily figure out what is going on.


```rust

      let mut headers = axum::http::HeaderMap::new();

			let header_name = axum::http::header::HeaderName
				::from_str("x-kbve")
				.unwrap();
			
      let header_value = axum::http::HeaderValue
				::from_str(&format!("shield_{}", "email_exists"))
				.unwrap();

			headers.insert(header_name, header_value);

			return (
				StatusCode::INTERNAL_SERVER_ERROR,
				headers,
				Json(WizardResponse {
					data: serde_json::json!({"status": "error"}),
					message: serde_json::json!({"error": "email_exists"}),
				}),
			).into_response();

```

This is now the updated rust code, which sends back a header with the error code and displays the error within the message.
I suppose we could just send the data back with the error code because the status error could be handled via the `StatusCode` but I am thinking that there might be edge cases in the future where we need the data to hold additional information and the message to be for the end-user.

The great part of n8n is that we can also no-code some temporary routes to help us with test casing and those edge cases.
I am currently writing an automation that would generate an invoice through n8n without using the Rust API, this gives us the flexibility to move fast without having to break the Rust API.


## 2023

- 8:00am - My new alarm for the morning is this [Electric Speed](https://www.youtube.com/watch?v=1PV55o9AsTg) song and it has to be the best song to get you up out of bed. Do not use it for anything but as your alarm, so you can Pavlov yourself out of bed.
- 10:00am - Got ready, did a couple set of squats and pushups, now about to venture into the main city and do some site seeing.
- 12:15pm - After a couple hours of walking around and getting into the flow, now I am about to sit at my favorite cafe , jam out and do some programming sessions.
- 1:00pm - Restructuring the media section of the knowledge garden and will start to include content that I found to be interesting and entertaining. One of my future plans was to summarize podcasts into short 3-5min DOC LOFI songs but that is definitely later down the line as the AI-generated music scene is still a bit rough.
- 3:00pm - Took a quick break and toured around an university art show but they would not allow photographs, which makes sense because the artwork could is copyrighted. 
- 4:00pm - Came back to the cafe and now looking through the flutter docs and need to sync the `kbve.com` repo with my online IDE. I am looking over flutter again and I might need to take a break from Astro and update the Flutter application to the latest before launching. Let me begin the quest of fluttering my brain cells into a cyclone of psychological fallacies. 

## Quote

> To follow, without halt, one aim: There is the secret of success.
> — <cite>Anna Pavlova</cite>

---

## Tasks

- [ ]

---
# May: 02

> Daily Log for May 2nd of each year.

Source: https://kbve.com/journal/05-02/

import { Adsense } from '@/components/astropad';

<Adsense />


## Quote

> You give before you get.
> — <cite>Napoleon Hill</cite>

---

## Tasks

-   [X] Get AstroJS -> Flutter SAPI Working.

---

## 2026

### Argo Syncs for Unity Cache

-   05:25AM

    Up all night doing the damn argo syncs, really wanting to get that near perfect score.
    Majority of the issues are just rbac and/or de-syncs because of updates, so it is just time consuming, ugh.

-   02:45PM

    The current goal is to get the unity game to build without breaking, hopefully we can get the cache to work this time around.
    This is a bit of a loop, we are trying to get the pipeline to become functional but also making optimizations at the same time.
    I would not recommend this method all the time, but sometimes it is what it is.

### KBVE Release v1.0.129

-   08:13AM
    
    The KBVE website release is being prepared, I did not get a chance to save it.
    We will have to update the arc runners as well, but we shall see.

### Arc Runner Self Hosted

-   08:12PM

    Wow it is already 8pm, but it seems that we still have not yet gotten the unity to run correctly in our self hosted runner using DinD.
    I am a bit surprised that we have these issues, I figured we would have solved them by now.
    One of the other issues is that our self hosted image did not have any e2e tests, which caused it to automatically fail.


## 2025

### WeBinaryBytes

-   01:11PM

    Got the binary websockets operational but I am thinking that it might be time to refactor it all again!
    We can loop back around and see if there are changes to the core functionality that we want to make.
    Maybe a better format for the data that is coming in and out of the Jedi crate.

-   01:33PM

    Updating the `Jedi` proto to include all the additional fields and preparing the hybrid binary/json format with both proto and fbs.
    I should include support for captain proto as well but that will be for a later time.

### JediEnvelope

-   04:35PM

    Updating the `JediEnvelope` to include the new enum bitmask operations for the intents and services.
    I also added a couple reserved states so that it can be expanded out in the future.

```
JediEnvelope
  └── pipe()
        └── process()
              └── emit()
                    └── publish()
```

    That is the current structure that we will be going for when dealing with the JediEnvelope.
    The modular design should allow us to easily add new services and features without breaking the existing code.
    Hmm, okay, I think we now have a solid plan for the v0.2 release of the jedi crate.


## 2024

**API**

Okay there were some problems with the pipeline that built out the `rust_api_profile` and the `api`, both of which need to get merged into one application.
However when I will get to merging them and making them into a single uniformed application is a talk for another day!
A dirty API is part of the hobby, err... I mean learning experience?

**YT**

There was this classic music application that I had built in React, which would automatically play YT music from my own playlist, based upon my mood?
Well I am thinking of brining that back and then adding a couple additional sounds that can be played in the background with the song.
Maybe a bit of the ocean breeze or a flow of rain in the background, there are some concepts and styles that I want to integrate with this application.
This is just a quick break from the usual flow!

There are two options that I could take with building this out, one would be to use WASM and have something run at a more native level OR stick with using a javascript framework.
My current plan is just work with a generic js framework, maybe later on I will make a more customized option? Hmm, okay so let us go with svelte!

The question now is where do I want to place the application, I am thinking that placing it within `/tools/` and `/music/` would make sense.
Basically have the tool located in multiple locations, with `/tools/` giving more a generic feedback regrading the tool, including the developer display, while having `/music/` be more public facing.

Expanding out the music section is also in the works, how I will go about doing that is whole quest in itself.

## 2023

-   I spent a sold amount of time getting the hang of Flutter again. The amount of times I have seen the word widget has driven me insane.
-   Morning ? Mid : Spent some time walking around a small park and finally had a `frankie` and it was okay, not as hot as I had hoped but the flavor made up for it.
-   Mid Day: Ezoic just fixed the email server issue! w00t! I can finally send emails without them going into spam xD!
-   5:15pm - I am chilling at the local library and trying to integrate a client-side database inside of Flutter. Part of me enjoys the abusive relationship because it feels great to resolve the bugs but at the same time, it slowly feeds into my Sith viewpoint of Google. They really have an amazing framework but damn, they really know how to drop the ball in certain areas. If it were not for some of the cool people that I have met through my fluffy flutter adventures, I would have definitely just jump ship and head over to react native or just skip straight to Unity.

---
# May: 03

> Daily Log for May 3rd of each year.

Source: https://kbve.com/journal/05-03/

import { Adsense } from '@/components/astropad';

<Adsense />

## Notes

May flowers doe!

## Tasks

## Quote

> In three words I can sum up everything I've learned about life: it goes on.
> — <cite>Robert Frost</cite>

## 2026

### Steam Rareicon Demo

-   01:56AM

    The demo release is almost ready, just a couple more things that we need to work out.
    We should have unit testing as a job, then have it confirm before handling the migration.
    So the pipeline automatically builds the game, then uploads it as a beta branch.
    Afterwards we do a custom job run that then plays the beta release of the game on various systems, then prepare a migration from beta to release.

### KBVE Droid Stale

-   05:12PM

    The droid service worker seems to crash out sometimes if the browser window is running way too long.
    I am thinking we need a safe way to reset it when they become active, I wonder if I can do it all inside of the "@kbve/droid" package instead.
    

## 2025

### Birthdays

-   03:00PM

    Too many birthday parties! It feels like another June 1st xD
    Okay, now that I am home and zoned in, I am going to finish up the redis pipeline.

### Jedi Redis Pipeline

-   03:34PM

    The pipeline will be as modular as possible with the goal of creating a lego block style for coding.
    Yet there might be an issue with async because some modules might not play too well with the abstracted lifetimes, i.e communicating with an external database.
    The current question is how would we go about handling the connection_id situation, the first step could be just doing a simple arc string and encompassing it all as a request struct.
    Yet that ended up leading us down a terrible path where we just created too much bloat and abstraction structs.
    This time around, I will try to avoid that problem and find some logical solutions to each of these issues that arrive.
    First one that we are coming across is the meta data layer and how to keep that in the flow.
    Updating the proto file to include a 5th field, that will be `bytes` and holding the meta data.


## 2024

Time to build out the dashboard on `/dashboard` route!

## 2023

- 10:00am - Going to prepare myself to visit a local temple, which includes climbing a kilometer flight of stairs. The workout and stress from all that walking is definitely going to be terrible! However the views are going to be amazing and can not wait to be in the sky.
- 5:00pm - That was an intense trip, my feet are sore as hell. I am going to take a short rest and fix up some of the codebase, eat a small meal and get some rest.

---
# May: 04

> May da 4th be with you!

Source: https://kbve.com/journal/05-04/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### RareIcon Heal Swarming

-	04:03AM

	There are some issues with the economic collapse that we have to address.
	First we should make sure that they find better healing spots.
	Production halts are pretty bad after a large attack, we definitely need to resolve that.
	Builders die before they finish repairs, then creates a weird loop of repairs and damage.
	Then we have the issue of food drain, since there is no food in the storage because everyone is eatting.

### Rareicon Tokio and Uniti Integration

-	07:32PM

	The tokio and uniti integration is important step for our game, because we want to setup multiplayer for the rareicon.
	The idea will be that we can have players controling a shared empire and also have PvP, so that it be player verse player, with their own empire.

### Minecraft Discord Bridge

-	11:58PM

	Preparing the minecraft and discord bridge, later on we can look at irc and discord bridge too.
	I am thinking that since it might be super popular, compared to our other games, we should keep them split up.


## 2025

### Pipeline JSON

-	08:45PM

	Getting the JSON data out of the pipeline will be interesting because we already have it as a Bytes format.
	So what we would want to do is convert the bytes to a Json str.

## 2024

**Dashboard**

We are starting to build out the dashboard for KBVE!
I am actually exteremely excited to see how it comes together, we already got the basics of the board done, with moveable blocks.
Now the next step would be to build out different components that each block will be using!

To avoid overloading the browser, I am thinking that we stick to around 10 blocks, hmm.

Now getting each of the minor components built out will be interesting, definitely with `esbuild`, I wonder if we can do a test case first?

**ESBuild**

The best way to handle this might be to isolate the different components into a single file each, a bit like a gear system.
We do not want the blocks to become way too complex either, as it would cause lag within the browser.

The way that I am thinking of handling this would be to create a `engine` folder and then parse through each script file and use `esbuild` to create the javascript files.
But how would we go about doing that? Hmm, we could start with a basic command, `build:graph` and have it execute this command:

```shell

esbuild src/components/Graph.jsx --bundle --outfile=public/graph.js --minify --sourcemap --platform=browser --target=es2020 --jsx-factory=React.createElement --jsx-fragment=React.Fragment

```

This command tells esbuild to:
    
    *   Bundle the `Graph.jsx` file.
    *   Output the bundle to `public/graph.js`.
    *   Minify the output.
    *   Generate a source map.
    *   Set the platform to browser (handles browser globals like `window`).
    *   Target modern JavaScript (es2020).
    *   Properly handle JSX for React.

Explanation of Key Options:

*   **\--bundle**: Bundles all dependencies into one file.
*   **\--outfile**: Specifies the output file.
*   **\--minify**: Minimizes the output.
*   **\--sourcemap**: Generates a source map.
*   **\--platform**: Specifies the platform (node or browser).
*   **\--target**: Sets the ECMAScript target version.
*   **\--jsx-factory** and **\--jsx-fragment**: Sets up JSX processing for React.

This aspect of the notes could be added into the javascript library.

I am thinking that we utilize the esbuild that is within nx, thus we have to convert that shell command over to the project.json!

For the situation that we are in right now, we wanted to make sure the esbuild works, so here is the raw shell command that would generate the graph.js.

```shell

pnpm esbuild apps/kbve.com/src/engine/Graph.jsx --bundle --minify --platform=browser --outfile=apps/kbve.com/public/scripts/internal/nodegraph/graph.js --jsx-factory=React.createElement --jsx-fragment=React.Fragment --external:aframe-extras

```

This produces the final graph file, yet there is a missing `a-frames`, however I am sure we can resolve that with some fixes.
The other downside is a massive file, ugh, the js file is around 2.2mb.

```json

"graph": {
			"executor": "@nx/esbuild:esbuild",
			"options": {
				"entryFile": "apps/kbve.com/src/engine/nodegraph/Graph.jsx",
				"bundle": true,
				"minify": true,
				"platform": "browser",
				"target": "es2020",
				"define": {
				  "process.env.NODE_ENV": "\"production\"",
				  "global": "window"
				},
				"external": ["aframe-extras"],
				"outputPath": "apps/kbve.com/public/scripts/internal/nodegraph",
				"outputHashing": "none",
				"outputFileName": "graph.js",
				"jsxFactory": "React.createElement",
				"jsxFragment": "React.Fragment",
				"sourcemap": false,
				"tsConfig": "apps/kbve.com/src/engine/nodegraph/config.json"
			  }
		}
```

This was the esbuild for the nodegraph but there were too many errors to deal with, so I will just make a shell command to handle this for us.

Its official ESBuild and dynamically loading this graph is a huge pain, I will just move on.

## 2023

- 12:00pm - Review the notes on the iOS / Flutter. I will have to transfer them over to this knowledge bank later this week. There are two core pillars that I have to make sure that I get right for deploying future iOS applications. The first will be getting flutter to actually build and sign the application, so for that I will run `flutter doctor -v` and see what it requires for the iOS / iPhone build. It seems that I will need xCode and CocaPods, it was pretty straight forward for getting the xCode, as I was able to grab it from app store.

- The CocaPods aka a Swift package manager that Flutter uses for iOS development was easy to install, just had to run `sudo gem install cocoapods` and then agree to the xCode license.

- The next pillar is the development and pipeline, currently I am able to build the iOS application within the development eco-system. However I will have to figure out how to setup the CI/CD for the application, ideally making it so that once the commit is made on the `main` branch, it will automatically deploy the application to the Apple App store.

- 3:00pm - Going to prepare to pack up my luggage! It seems that my grandparents have some older suitcases, so I am thinking of letting them have mine, while I go grab some new ones. I am going to travel to either the `CromAs` or `InOrbit` mall and pickup two new suitcases. The total cost was around 15000 Rupees and they were pretty solid hardshell cases, they look and feel like a CSGO crate haha.

## Quote

> If you want your life to be more rewarding, you have to change the way you think.
> — <cite>Oprah Winfrey</cite>

---

## Tasks

- [x] Install and update xCode / CocoPods.

---
# May: 05

> May 5th - Weather Be Making Me Drink a 5th.

Source: https://kbve.com/journal/05-05/

import { Adsense } from '@/components/astropad';

<Adsense />

## Quote

> Trust your hunches. They're usually based on facts filed away just below the conscious level.
> — <cite>Joyce Brothers</cite>

## 2026

### Minecraft BB Model Fixture

-   06:15AM

    The minecraft models for the planes did not load correctly, thus creating this pink and black shader effect.
    We were able to get some of the fixed and resolved, but will have to loop back around and handle the other aspects like animations.
    Voxel style development can continue once we have more integration setup.

## 2025

## 2024

**ESBuild**

Stayed up all night messing around with the ESBuild, that my mind has melted.

**Dashboard**

Now what does the Dashboard need?
Hmmm...

**Music**

Maybe I switch back to working on the music application, to get my mind mind off it.

The Jukebox was able to get into the basic prototype, yet there a ton of updates that I need to add into the tool.
I believe I can knock out the button improvements within the next patch, then fix the mobile autopausing.


**Python**

If I get a bit more pissy with javascript, I might have to take a break and go to python.

---

### 2023

-   9:30am - Woke up a bit earlier today, got ready and headed out to the border part of Vadodara, known as Gotri. I asked a fellow friend to bring me some Goldbond lotion from America, which my grandparents love and its a bit hard to find here in India.

-   11:15am - Looking over the `kbve.com` repo and noticed that there needs to be some updates that I have to do for the day.

-   11:25am - Quick break from travel / coding and going to relax, watch some game trailers and sip some coffee. The Unreal 5 game engine demos have been crazy! I can not wait to test out Unreal when I get back into the states, I will not be diving too deep into that engine, as I am still learning how to master Unity.

-   12:30pm - I am looking over the CI/CD for the Android deployment. Its been a couple years since I messed around with this, I remember doing it before in Jenkins and again in Gitlab, so I am sure it will be even easier with Github / Git Actions. Later down the line, I will look into doing hybrid deployments, including a combination of private and public repos, to avoid any future issues of licensing / conflict of interests. (i.e if I am using a paid Flutter theme and want to include it inside an open source project! We would host the paid theme inside a private repo and let the open source project pull the code during the build / deploy phase.) Here is an interesting article that goes over what I am looking to [setup](https://dev.to/matijanovosel/deploying-flutter-applications-to-google-play-using-github-actions-j8a).

-   For the releasing, I am going to use the actions from this developer, [Subosito Actions](https://github.com/subosito/flutter-action) , and the two specific ones that I am interested in are the `android` and the `ios`.

-   2:15pm - I really hate the breaking changes in Flutter! Okay to grab the parameters from the path, you have to call `state.pathParameters['pathId'];` with pathId being the variable that you pass through. In our situation we will only be passing one pathId through-out most of the application. The user-information will be stored inside of the HiveDB for now and I will have it make the net request after pulling the information from HiveDB. So in the case of looking up the stock asset, it will check the local instance of the asset and if it does not find it, then it will make a net request for the updated json from the static kbve.com api. I am thinking if there is no internet, then have the application perform the best it can using the local storage data. Side note, the local storage for the mobile applications will be in their default documents folder or downloads folder.

-   6:00pm - Okay I am going to remove the deep nest and keep everything at max depth of 1, so that I can streamline everything else into a simple and easy flow. So instead of `asset/stock`, it will be just `stock` or `crypto`. This will be with all content and mainly so that I can keep everything type-safe and organized later down the line without having too many constraints and dead code to deal with. There might be some SEO/SEM impact from the link structure change, but I think its safe to do it right now rather than later down the line.



---

## Tasks

-   [ ] -   Check out 3 new cafes within the day.
-   [x] -   Update Astro on KBVE.com repo to the latest version.

---
# May: 06

> May 6th, the day the game changed, I made my move and rearranged dat frame.

Source: https://kbve.com/journal/05-06/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Firecracker Updates

-   06:59PM

    The firecracker ecosystem needs to run python code without running into issues that might hold us back.
    I am thinking that we could even later on hook up cloudflare token and make abstracted runner subdomains?
    Like this, `v01d-fear-factor-40.kbve.com` , which would then be the firecracker vm running the specific python script that is tasked to do the job?
    This would mean we could have our core API and then a nearly infinite sub-domain-based api that runs basically mini-virtual machines to do small tasks.
    The first task might be converting a video to a mp3 or maybe taking a PNG and making it transparent.

### Unity Rareicon Shader

-   08:18PM

    Good news is that we got the shaders operational on the android phone, but the bad news is that the performance is really bad.
    I am not too sure if the terrible performance is because of the virtual device itself or if the APK boots way too much information.

## 2025

### Andor

-   05:40PM

    I am dying to see the next three episodes drop for Andor!
    Episode 7 to 9, another movie drop, lets go.

### Pipe JSON & Flex

-   06:06PM

    We handle both the flexbuffers and the json together, I am thinking that it would be wise to first build them both out via the jedi crate.
    Quickly refactor the pipe_redis to use `Logic_$Command_$Payload` as a common structure and then include functions for both.
    I was thinking of unifying the functions but that might be an issue because of the zero-copy and the different data structures, that it might be wise to just split them.
    We can re-use the binary functions in the future but for now this should be fast enough for what we want to do.

-   07:10PM

    After creating the JSON and Flexbuffers for the 5 basic commands, we now have to link them together with the envelope.
    This should be easy because we would only have to update the `process` function under the Envelope trait for Jedi specific envelope.
    Under the process function, a quick and modular pipe would resolve that issue.


### Pipe WatchMaster

-   02:25AM

    I was up all night trying to figure out the best way to handle the rewrite of the WatchMaster and maybe even the TempleState.
    The TempleState already keeps track of the Redis Pool and the active connections via the WatchMaster.
    Furthermore, the TempleState is our AppState for Axum too but we already wrapped it inside of an Arc entity.


-   07:26PM

    Updating the `Watch` and `Unwatch` commands to use the bitflags, for that I need the right flag combinations!
    I am thinking that we will use these ints to represent the combined state:

```rust

define_multi_flag_checks!(
    (xadd, [Redis, Stream, Add]),
    (xread, [Redis, Stream, Read]),
    (watch, [Redis, Heartbeat, Read, Stream]),
    (unwatch,  [Redis, Heartbeat, Del, Stream])
);

```

    This should make it easier to handle the `watch` and `unwatch`.
    I might have to be careful on how I go about to handle this because I ran into an annoying issue in the past where it would double watch and there is a bit of leak here.
    The management of the keys that we are watching has to be handled from both the redis side and also the rust side.
    
### India Strikes

-   05:48PM

    Keeping a close watch on the missile strikes, hopefully nothing goes too bad between both nations.
    This feels like another gaza situation, where India might just use the terror attack as an excuse to launch another massive war.
    The bigger issue is that it will end up creating more terrorists in the long term, its a classic situation of a butterfly effect.




## 2024

**JukeBox**

The jukebox client side code has been updated but a couple more patches that I need to build out.

**Resend**

The Email recovery still needs to be fixed, I am going to add the API directly into the Rust codebase!
However there might be a couple aspects of the code's flow that I need to look over, do we want to have a captcha before the email recovery?
I understand that it might be a bit weak on the UIUX but the security issues that can arise by not having some level of protection on the path might be a pain in the future.

Let me add a couple schemas to prepare for the Resend API Integration:

```rust

#[derive(Debug, Deserialize)]
pub struct RecoverUserSchema {
	pub email: String,
	pub captcha: String,
}

```



---

## 2023

**India**

- 9:00am - Going to miss this amazing breakfast place, for under $3 or 200 Rupees, I get nearly a full course meal. It keeps me fed throughout the day but damn them eggs do produce some deadly methane gas xD

- 9:30am - Restoring the `asset.astro` and the `media.astro` paths to avoid some broken links when navigating through the menu on the main website.

- 10:30am - Read this great article from [SemiAnalysis No Moat](https://www.semianalysis.com/p/google-we-have-no-moat-and-neither) that goes over the lack of a moat from Google / OpenAI within the eco-system of Ai/mL, yet this can have some issues further down the line, including investment and capital markets, whom bet on companies being able to `secure` a moat. I believe that a hybrid source movement will remain the best course of action as of right now.

- 11:00am - Currently looking up the works of `Ursula K. Le Guin` and her universe of `Hainish Cycle` because she coined the term `Ansible`. The first piece of her work that I am going to read while taking this rickshaw is `Winter's King`. 

- 3:00pm - Currently on my last interview for a new job that I might start in June! I am excited but I might also decline because the amount of pay is not worth the amount of work that they might demand. We shall see, I usually enjoy working for startups but seeing how they conduct their interviews and testing has been very off-putting. I might also not get the job because I did decline to sign any NDAs until I felt more confident with the company.

- 9:00pm - Going to start to integrate Rive into the Flutter application! I have had great experience with Lottie but I been finding that they have a bit too limited animations for my taste and I do not feel like integrating React into Flutter at this time. If everything works out as planned, then I will remove Lottie from the `kbve.com` source and replace it with Rive as well.

---

## Quote

> Kindness in words creates confidence. Kindness in thinking creates profoundness. Kindness in giving creates love.
> — <cite>Laozi</cite>

---

## Tasks

- [X] Double check AirIndia tickets.
- [X] Dentist checkup.
- [X] Tiles for the new bathroom.
- [X] Adding Jio sim card for UPI.
- [X] Bulk ordering glasses.

---
# May: 07

> May 7th - The Daily Journal

Source: https://kbve.com/journal/05-07/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Discord Bot Crash

-   04:49AM

    Looks like the discord bot seems to have a crash, I need to figure it out.
    Did it grab the wrong token when we deployed the minecraft server?
    
-   10:34AM

    Turns out that it was just an issue after we did a restart during the copyfail update.
    We should be back to normal, just need to prepare the next update.

### CityVote Website

-   04:45PM

    With the Hanta virus brewing, I was thinking that it be cool to build a custom page around it for cityvote?
    We could use claude to break down some of the papers and get a generate proper reports.
    Then we could slap a map to show some of the areas where there might be active cases?
    Ideally we would make CityVote a modern website, that would provide all that information but also make it easier to expand and grow the website.
    It would fill that gap where we need information but not make it too heavy for KBVE as well.
    I will get the flow going for it asap, since we have the time and resources for the website.


### Rareicon SVGs

-   06:09PM

    Expanded the Rareicon library of icons, I am thinking that if we can continue, then it will look amazing!
    We should definitely aim to get more into the flow of presenting the SVGs?
    I am thinking of even building a UV tool around the firecracker concept but that will come to another day.



## 2025

### Andor

-   03:05AM

    Just caught up on all the recent Andor episodes and its been nearly perfect!
    This has been some of the best star wars to this date, up there with the clone wars tv show.
    I will avoid place spoilers but the geo politics was extremely on point and well done.
    I can easily relate the events back to core parts of history too, ahhh the self reflection is going to be soo dope.

### TempleState v0.2

-   07:24PM

    Finally finished the temple state and redis pipeline with multi-protocol support!
    The initial stage will be to use json and binary through a flexbuffer.
    Afterwards, I want to expand with better protobuf, flat buffer and captain proto support but that will be once the client side is done.

-   09:35PM

    The pain of linking the next jedi crate to disoxide, then praying that everything wires up!
    I will feel so bad if it fails because that means my rewrite did not go as planned, which could be even worse down the road because that means I might have to rip the whole crate apart.

-   11:57PM

    Yay! Looks like things are working out well, I should take a quick break and then get back to finishing up the rest of the pipeline.

## 2024

**Resend**

The plan is to map out all the structures again, converting the javascript code over to Rust code!

The recovery 

```rust

#[derive(Debug, Deserialize)]
pub struct RecoverUserSchema {
	pub email: String,
  pub service: String, 
	pub captcha: String,
}

```


Resend API to request an Email


```shell

curl -X POST 'https://api.resend.com/emails' \
  -H 'Authorization: Bearer re_secret_token_1245656' \
  -H 'Content-Type: application/json' \
  -d $'{
    "from": "onboarding@resend.dev",
    "to": "delivered@resend.dev",
    "subject": "Hello World",
    "html": "<strong>it works!</strong>"
  }'

```

Here is a basic rust function for sending out the resend api request:

```rust

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use serde_json::json;
use std::error::Error;

// Asynchronously sends an API request to resend an email
async fn send_email() -> Result<(), Box<dyn Error>> {
    // Set up the client
    let client = reqwest::Client::new();

    // Headers
    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_static("Bearer re_123456789"),
    );
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));

    // JSON body
    let body = json!({
        "from": "onboarding@resend.dev",
        "to": "delivered@resend.dev",
        "subject": "Hello World",
        "html": "<strong>it works!</strong>"
    });

    // Send the request
    let response = client.post("https://api.resend.com/emails")
        .headers(headers)
        .json(&body)
        .send()
        .await?;

    // Check the status and optionally print the response text
    if response.status().is_success() {
        println!("Email sent successfully: {}", response.text().await?);
    } else {
        eprintln!("Failed to send email: {}", response.status());
    }

    Ok(())
}

```

Granted this will still need a decent amount of work, including better thread management and pulling the data from the database.

## 2023

- 9:00am - I was thinking it might be interesting to gamify some of the boring morning tasks? Granted this was a shower thought but it would be interesting to develop an AI-based mentor / digital character that would reward for completing certain tasks on time? This could be combined with different pre-built personality language models, so you could have your pet digital monster become aggressive and berate you for not doing pushups? I am just writing my thoughts, hoping that I do not forget them later down the line. The idea is not have a companion that drains your mental health, but rather let you customize it based on your own personal motivational factor(s). I might not find a devil daemon calling me a fat slob for skipping 10 pushups haha but I would not want to impose that onto a younger child, if it were a gamified application.
- 10:30am - Traveling to the local temple for the last time before I head back to the states, I actually enjoy coming here in the morning because some of the stray dogs come in and its cute to watch them engage with the locals, including them getting treats for being awesome. 
- 12:30pm - Sync the notes. It looks like the pass tool is currently broken, so I am going to try and figure out what I can do to fix it again. I believe the issue might be the way that I am handling the javascript within AstroJS, I will go through some guess and checks and see if I could resolve it that way. It works in `dev` mode but after the SSG, the `generate()` function seems to be missing or broken, so lets see what the issue could be.
- Error @ 12:30pm: 
  ```javascript
  (index):166 Uncaught ReferenceError: generate is not defined
    at HTMLButtonElement.onclick 
```
- Going to try and push the pipe through `alpha` and then test case it via the Netlify build. Okay, looks like that resolved that issue. I was missing the `is:inline` when calling the 3rd party external scripts, okay going to move back to updating the AppWrite.
- 1:15pm - Updated AppWrite to 1.3.4, then did a quick database migration! I am wondering if there might be a way to do an update without taking the whole API down but I noticed that it could cause corrupted shards, so I suppose it might be best to keep it the way it is right now. 
- 2:45pm - Getting ready to go shopping around a local mall district. I got over 30kg worth of free space in my luggage, so lets see if I can find anything interesting to buy. Before I head out, I think I will test case some of the local pipelines that I been building, including one that is known as `cook-ai`, which is a small mL model that helps you make amazing recipes! 
- 4:00pm - Looking over all my blueprints that I have written for KBVE and starting to parse through them and organize them into something a bit more meaningful and structured. 
- 5:45pm - Great background video, [The Micro Education Business Model - How To Monetize Your Knowledge](https://www.youtube.com/watch?v=XgAMayF-JZY)! This would be great material for a lofi mix :D
- 11:15pm - Doing some speed tests, I noticed some issues here and there but I think I could hit 90s+ across each metric if I address some of the problems from PageSpeed. 
- Last Test was https://pagespeed.web.dev/analysis/https-kbve-com/j7ervvivzh?form_factor=desktop 
	  - 99 Desktop , 84 Accessibility, 75 Best Practices and 100 SEO.
	  - 85 Mobile, 77 Acc, 75 Best Practices and 100 SEO.
- Let us see if these recent updates will boost us up to 90s+
## Quote

> Minds, like bodies, will often fall into a pimpled, ill-conditioned state from mere excess of comfort.
> — <cite>Charles Dickens</cite>

---

## Tasks

- [x] Upgrade AppWrite to 1.3.4
- [x] Fix the Tools -> Pass
- [ ] Review all the blueprints and being to shift them into private documents.
- [ ] Review MDX plugins and write a plan for steps to resolve known and future issues.

---
# May: 08

> May 8th - The Daily Journal

Source: https://kbve.com/journal/05-08/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Arcade Expansion

-	01:37AM

	There are a bunch of old phaser/laser games that I want to port over to our arcade.
	I am hoping that maybe we can also convert over some really basic games too.

## 2025

### Websockets KBVE

-	03:08PM

	Adding the websockets into the shared workers, making it easier to communicate!
	One of the goals might be to do a zero-copy from the javascript side via the shared workers to the rust code via websockets?
	This way the binary data would be the same from both sides.
	Since we already setup the comlinks, we can easily register the ws-worker and get the basics out of the way.

## 2024

**Resend**

We should be building out these API endpoints a bit faster but I got side tracked with the Steam integration!
Solo leveling through these projects can be a bit of a pain.

Okay! So let us look at the package structure for kbve:

Under `entity`, we will add a client folder + mod, then start building out the `resend.rs`.
This resend API will be rewritten later on but for now we just need the basics of it out of the way!

Going back to the `RecoverUserSchema`, we want to add a quick sanitize method, to clean the variables that are added into the Schema.

```rust


#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct RecoverUserSchema {
	pub email: String,
	pub service: String,
	pub captcha: String,
}

impl RecoverUserSchema {
	pub fn sanitize(&mut self) -> Result<(), String> {
	
		// Sanitize Email
		let limited_email = crate::utility::sanitize_string_limit(&self.email);
		match crate::utility::sanitize_email(&limited_email) {
			Ok(clean_email) => {
				self.email = clean_email;
			}
			Err(e) => {
				return Err(e.to_string());
			}
		}

		// Sanitize Service String

		// Santize Captcha Token

		Ok(())
	}
}


```

We can use the `sanitize_string_limit` and `sanitize_email` functions to help us clean up the email.
Afterwards we have two more strings to clean up, the service should be easy, so we will just clean that using the string limit.

Actually this would be a great time to test out the `ValidationBuilder` and move the sanitization into that area!

We already have a sanitization for the email built into the validationbuilder, so we can skip that part BUT we will need to build two new regexs for the `service` and `captcha`.

For future references, services would only be 3 to 32 characters and alphanumeric, so here is the regex that we can add into the `regex_extractor`.

```rust

pub static SANITIZATION_SERVICE_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"^[a-zA-Z0-9]{3,32}$").unwrap()
});

pub fn extract_service_from_regex(service: &str) -> Result<String, &'static str> {
    if SANITIZATION_SERVICE_REGEX.is_match(service) {
        Ok(service.to_string())
    } else {
        Err("Invalid service format")
    }
}

```

Then we add the `extract_service_from_regex` into the functions that we will call within our validation builder.
Okay this will help with the service cleaning, then there is the captcha token cleaning that we need to do next.

```rust

pub static VALIDATION_TOKEN_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$").unwrap()
});

pub fn extract_captcha_token_from_regex(token: &str) -> Result<String, &'static str> {
    if VALIDATION_TOKEN_REGEX.is_match(token) {
        Ok(token.to_string())
    } else {
        Err("Invalid token format")
    }
}

```

The only thing we want to do here is be a bit more specific with the tokens.
Okay, these look great! Lets go ahead and add them back into the validationbuilder.

```rust
use crate::utils::sanitization::{
	extract_email_from_regex,
	extract_github_username_from_regex,
	extract_instagram_username_from_regex,
	extract_unsplash_photo_id_from_regex,
	extract_discord_server_id_from_regex,
	extract_ulid_from_regex,
	extract_username_from_regex,
	extract_service_from_regex,
	extract_captcha_token_from_regex,
};
```

After importing them, we need to add them into the rules for calling them within the validationbuilder.

Let us run a quick dry run with our changes, there is probably a couple errors that we need to account for.

```shell

cargo publish -p kbve --dry-run --allow-dirty

```

Okay! I just realized I made a mistake and that the validation builder was moved to the `jedi`

For this situation, we will just move the changes we made to the OG validation builder into the `jedi` package.

In this case, we will be using this shell command to check:

```shell

cargo publish -p jedi --dry-run --allow-dirty

```

Okay! Both packages are building, so I will go ahead and move those up a branch!

We do need the `jedi` package to build and release, then go back and fix our sanitization function. 

## 2023

- 9:30am - Dropping by the local Lenskart and asking my uncle to make two quick pair of aviator glasses for @sean and @ziggy9263. I have given this shop close to 20 pairs so far, I am definitely their customer of the month, may even become their customer of the year.  
- 11:00am - Final visit the dentist to get some quick teeth cleaning! Through all of this, it seems that our dear friend, Fudster put me onto a quick quest. It is always interesting to be drugged up by a dentist and then open a bunch of unix terminals to setup a virtual machine. I enjoyed being in the dentist chair, half baked, typing away linux commands. If this was in the US, I am pretty sure the dentist would have violated several ethical boundaries for what I was doing haha.
- 12:30pm - Going to look over the current backend setup and see what needs to be updated. Overall the system looks healthy with no massive errors in any area. The main operating systems are still up to date, I looked over the unattended update logs and everything seems fine on that end. 
- 5:00pm - Looking at tiles for remodeling the home and bathroom in India! It was interesting to see that electronic upgrades are more costly than doing general service to the house. I suppose it makes sense because labor costs in India are extremely cheap, as there is a large pool of workers. Yet the tech market within India is extremely inflated and it comes mainly from the excessive tariffs that are imposed on imports. 
- 7:00pm - I think its time for me start researching into VCs/Venture again, just going to do some core / basic data gathering. I realized that I could add up to a million contacts onto the HubSpot CRM, so I am going to go through my older emails and reach out to some VC funds and build up an initial cold list. There are two main issues within the VC field that I am seeing, the first is the insane amount of capital going into machine learning / A.I-based startups and the second issue is that the rising interest rates is squeezing and limiting the general funds that they are willing to risk / invest. In addition to the rising rates, the recent bank collapses have also decreased the amount of risk that funds are willing to take.
- 7:30pm - Going to start a developer environment with a new hybrid cloud setup. I was looking at some of the recent changes with vCluster and I think its right about the best time to do a couple edge test cases from scratch. There will be two phases for this, the first will be doing everything manually and keeping track of the scripts, configurations, ect.. and the second phase will be to use Ansible-Tower to automate the deployment of the whole setup. I do not expect any of this to be successful but I am down to see where I hit failure, last time it was with the storage.

## Quote

> Courage is what it takes to stand up and speak; courage is also what it takes to sit down and listen.
> — <cite>Winston Churchill</cite>

---

## Tasks

- [x] Finalize materials for the house.
- [x] Migrate rupees from bank balance to fix deposits.

---
# May: 09

> May 9th - The Daily Journal

Source: https://kbve.com/journal/05-09/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Arcade Updates

-   03:19PM

    The goal for this week is to get the base arcade operational, maybe even try to bring back some classic flash games.
    However these are all small scoped projects, so maybe the focus should just be on targeting those small issues first, then we can make improvements past it.
    Part of me feels like the website could definitely use more improvements, but we will have to wait and see on all the minor issues first. 
    The Solitaire game is up and just needs more tweaks.

### Rareicon Website Release V0.1.4

-   04:14PM

    The JSON-LD structured data update, which will make it easier to move towards more structured data.
    Afterwards, we could polish the 404 page and then loop through all the icons and further improve upon their visual representation.

## 2025

### Steam Markets

-   05:40PM

    The best move for our unity game might be to focus on a quick launch into Desktop for Windows, Linux and Mac + Steam integration.
    Afterwards, we can increase the scope, thus it be making a couple small games and once they are launched, played and we build a community.
    This should be our main focus for the rest of the year.

### XREAD

-   08:00PM

    Damn Redis and XREAD! AHHH!
    I was stuck on trying to figure out why I had so many issues and it was something so small and minor!
    First we were packaging the binary with the wrong id, instead of `$` as the id, it was suppose to be a `0`.
    Then there was the issue with not getting the right response too, patching that next.

## 2024

**Resend**

The majority of the morning was spent refactoring the Diesel query to be async with a blocking spawn.

Now we need to prepare the front end for the recovery! Yay!

The async blocking does not have the right error code setup, which means that I will have to go back and update them.
Furthermore, we will need the jedi package to be updated and published, if we want to call the password function, since I forgot it the last push.

The blocking does need a couple new integration test cases, which will be added into the gitlab later tonight!
Another idea that I was thinking about was extending out the database pool options and including a read-only connection.
We could shift some of the queries towards the read-only database, specifically the invoice fetching and maybe some of the general character / profile fetching.

I still need to think these through, hmm, how would we setup the read-only connections, without causing too much confusion?

Actually, taking the rust-api-profile concept but instead of having any of the write routes, we could make another rust application that would be specific to the read only routes?
This way we would not need to do any additional programming, just not include any of the write-able paths and make it like a `read.kbve.com` api? Hmm...

**Jedi**

The JEDI crate does need a function that will help with checking if the password is valid!

We will extend out the `ValidatorBuilder` with another function called :

```rust

impl ValidatorBuilder<String, String> {
  pub fn password(&mut self) -> &mut Self {
    self.add_rule(|s: String| {
      match validate_only_input_password_without_regex(&s) {
        Ok(()) => Ok(s),
        Err(e) => Err(e.to_string()),
      }
    });
    self
  }
}

pub fn validate_only_input_password_without_regex(password: &str) -> Result<(), &'static str> {
    if password.chars().count() < 8 {
        return Err("Password is too short");
    }
    if password.chars().count() > 255 {
        return Err("Password is too long");
    }
    let has_uppercase = password.chars().any(|c| c.is_uppercase());
    let has_lowercase = password.chars().any(|c| c.is_lowercase());
    let has_digit = password.chars().any(|c| c.is_digit(10));
    let has_special = password.chars().any(|c| !c.is_alphanumeric());

    if !has_uppercase || !has_lowercase || !has_digit || !has_special {
        return Err(
            "Password must include uppercase, lowercase, digits, and special characters"
        );
    }
    Ok(())
}


```

This chain function will be used to verify if the input password is valid for an account. 

The only other issue is that we can not wrap the whole ValidatorBuilder inside an Arc.

Anyhow, after adding these functions, we will run a quick package check:


```shell

cargo publish -p jedi --dry-run --allow-dirty

```

Looks good to me! Going to push it up the repo!


**Website**

The recover and register modals were commented out and will be their own isolated pages.
Part of this is because the hcaptcha is way too heavy and pointless to load on every page call.

I actually think the way that the we are calling the structured data is incorrect.
Do we need to extend the description beyond a sentences? Like is it suppose to be the `meta` description? 

## 2023

- 10:00am - Just had 500mL of cold brewed coffee that was aged in whisky and rum barrels! It might have been a bit too much caffeine to start the day, I feel like my heart trying to escape my body. Besides the overload of energy, the taste was amazing, the hints of whisky and rum notes are noticeable through initial taste and near the end. It blends so well that the exiting bitterness that comes with normal brews is almost gone! Overall it was nice to meet the creators of the brew, however they are still in the experimental stage and have not yet done any social / digital work. I was kindly given some concentrated powder to take back to the US with me, think of it like instant coffee? They said they would reach out if they need any digital work done, but I know that my costs might be too high for them.   

- 12:30pm - Weighing out both bags, it looks like I have about 20kg of free space, thus I am going to go H.A.M and buy a bunch of shawls and then maybe use the remaining left over weight to grab rare spices that are a bit tough to find in the US.

- 2:30pm - Went shopping to grab shawls and ended up going to the shop owner's home, we had tea and he talked about his past and how his kids have all moved to the UK/Canada. How I went from buying items at his shop to some how going to his home was probably the weirdest adventure lmao. I needed around 15 shawls and the type that he had in his store were the lighter material, which makes sense because its the warmer season here in India. He told me his winter stock is currently in storage at his home, so we decided it would better if I head over there and look through his inventory. When I got to his home, I was amazed with the amount of stock that he had, the dude could run his own department store from his house! His wife and her family have been hand making some of the styles but lately its been hard for them to stay afloat because of the market has been flooded with cheaper and machine made scarves. I ended up buying a couple hundred dollars worth from him, he was super excited because I basically gave him a couple weeks worth of business in less than two hours. When I am back in the states, I will try to take some cool pictures with them!

- 5:00pm - Going to take a break from the heat and relax at a new local cafe, man there are a ton of them here, almost every street has a new cafe popping up with their own twists to coffee and tea. This makes sense because the population density is high and there are no major companies that control the sector, i.e think more mom & pop cafe shops and less Starbucks / DD.

- 6:00pm - Researching on ways to improve the page load of KBVE.com and looking at why some aspects of the website seem to score so low. I might have to remove some of the bulk images that are being loading from UnSplash and remove some of the extra javascript code that we are not using. 

- 6:30pm - Okay it looks like our spell book seems to be causing a painful first page load. I am thinking that might be worth removing the splash component and then seeing how the site performs. The splash is cool but it might not be worth it in the long term, as it might be annoying and a bit of a waste to then scroll down. Speaking of which, I do need to start thinking about how I will handle the content that should be displayed on the front page. We could also remove some of the wait listing and shrink the footer to be more compressed and clean. Overall the changes could easily decrease the total size of KBVE by 10%, across the board.

## Quote

> It does not matter how slowly you go as long as you do not stop.
> — <cite>Confucius</cite>

---

## Tasks

- [ ]

---
# May: 10

> May 10th - The Daily Journal

Source: https://kbve.com/journal/05-10/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### IRC Gateway

-   01:30AM

    The gateway looks like its operation but its extremely slow, I will need to figure out a way to speed it up.
    Maybe we make the main thread for the chat send the message directly, or find a way to handle it a bit better.

### Flowers Allure

-   04:10PM 

    Went shopping around for more flowers and I am starting to really enjoy that fresh scent.
    Going back to my trips through India, they would use flower petals to make incense, so the connection between the plant and my soul just hits that spot.

### Minecraft Smoke Test

-   07:13PM

    There is a situation where the minecraft builds seem to pass our e2e but they are definitely broken.
    This has a weird effect on the gameplay loop because then it knocks the server out for new players, who get the update and then their client crashes.
    I will have to take steps to make sure that it does not happen!

### KBVE Forum Flow

```mermaid

flowchart TB
    CH["ClickHouse<br/>analytics/events<br/>rankings/reports"]
    PG["Postgres<br/>truth/RLS"]
    RW["Rust worker<br/>materializer"]
    AX["Axum<br/>Askama SSR"]
    VK["Valkey<br/>SSR cache"]

    PG -- jobs --> RW
    RW -- batched events --> CH
    RW -- writes hot payloads --> VK
    AX -- read first --> VK
    AX -- fallback --> PG

```


## 2025

### Steam Community Marketplace

-   03:13PM

    Did a bit more research and it seems that there is a 10% developer fee that comes with item transactions.
    I think it be a better move to implement some "Soulbound" items in our game that then get traded via the steam community marketplace?
    The goal here would be to avoid having to deal with micro transactions directly in-game, kinda having a bit of an exclusive market.
    As I think more about it, hmm, one could argue that it be the OSRS Party hat system, where we have limited one time drops?
    

### Local Redis Streams

-   03:18PM

    As the websockets get messages, we need to store them locally in the clients database and this would be a basic long poll.
    Before I get a chance to build that out, I see some micro optimizations that I can do within the main thread to help move things along.
    My goal would be to a `tools.ts` that holds a bunch of minor utility functions to make things easier in the long run.
    Here is the current bridge:

```javascript

// * Bridge
export function bridgeWsToDb(
	ws: Remote<WSInstance>,
	db: Remote<LocalStorageAPI>
) {
	const handler = proxy(async (buf: ArrayBuffer) => {
		const key = `ws:${Date.now()}`;
		await db.storeWsMessage(key, buf);
	});

	ws.onMessage(transfer(handler, [0])); 
}

```

    This could be further optimized by not having the await and moving it all into a fire and forgot style.
    We are already transferring the ArrayBuffer from the websocket worker to the database worker, so this micro optimization would be to make that bridge as fast as possible.
    Ideally, we would want a way for the websocket shared worker to talk directly to the db worker but shared workers can not talk to each other.
    Thus having the main thread act as a "master" would be the solution for now.

### Bitwise Ops

-   03:55PM

    Going to update the `data.ts` to include the bitwise multi-flag operations.
    I was hoping that we could have this done via protos but that will have to be for another future rewrite.
    This is the codeblock that I will place for the multi-flags.

```javascript

export const MultiMessageKind = {
	RGET:     MessageKind.REDIS | MessageKind.GET,
	RSET:     MessageKind.REDIS | MessageKind.SET,
	RDEL:     MessageKind.REDIS | MessageKind.DEL,
	XADD:     MessageKind.REDIS | MessageKind.STREAM | MessageKind.ADD,
	XREAD:    MessageKind.REDIS | MessageKind.STREAM | MessageKind.READ,
	WATCH:    MessageKind.REDIS | MessageKind.HEARTBEAT | MessageKind.READ | MessageKind.INFO,
	UNWATCH:  MessageKind.REDIS | MessageKind.HEARTBEAT | MessageKind.DEL | MessageKind.INFO,
	PUBLISH:  MessageKind.REDIS | MessageKind.MESSAGE | MessageKind.ACTION,
	SUBSCRIBE: MessageKind.REDIS | MessageKind.MESSAGE | MessageKind.READ,
} as const;

```

    Initially, this would be just in the `.d.ts` files but I plan to move the whole shared worker eco-system out and into the laser npm package.
    This means in the future , we can have a single bundled javascript file that would hold all our shared workers and packaged into a `window.kbve` that we can use in any framework.

### Unity DevSession

-   08:00PM

    Making great moves!
    Okay, we are trying to figure out a basic way of placing items onto the map, I think we made some solid progress with it as well.
    The goals would be to get some minor bugs out of the way, place the new map and generation for it and finally do the Steam integration.
    With all of that out of the way, we can get a demo up and running for people to wishlist and play.


## 2024

**TailWindCSS**

I am thinking of adding a bunch of the different tailwindcss code fragments into our `javascript` page, this way it will be easier for me to reference them.
However one of the issues that I want to resolve is rendering the tailwindcss, so that it would be easier to see.

The question then becomes, how would we go about rendering the tailwindcss and displaying the same html/tailwindcss code?

We can go ahead and add a library called `html-react-parser` which should help us render the tailwindcss code.

**El Portal**

The best way to start the day off is with some fresh El Portal!

**Tools**

I decided to move a couple tools out of the `/tools/` folder and into their own respective areas.
The jukebox is back inside of `/music/` and webmaster tool is moved over to `/webmaster/`.

**Webmaster**

I decided to dump a decent amount of information that is related to general SEO/Webmaster stuff into one large mdx file.
The goal will be to aim at updating or adding 3 mdx files each week, eventually I will place bounties for someone to help improve them.

The webmaster documentation is not 100% complete but I did add a decent amount of information , tables and general examples.


## 2023

- 10:00am - SSS - *Shiitake, Shower and shave* and out the door! My last official day in India and its giving me the feels. I am going to miss this place for the time being, the society, the flow and the memories. I suppose I will not miss the random cow dung, monkeys throwing dung and the historic slums but the light and darkness create a vibrant eco-system that I can only define as karma. 

- 12:00pm - Going through the general updates for the website, I can not seem to get a basic or static result from the pagespeed tests, they keep throwing me into a random loop of scores. Sometimes I am hitting high 90s and then several sessions later, I am hitting low 60s? I can not tell if its Google or Ezoic (which is displaying Google ads?) or Cloudflare or something that I messed up within my UI/UX. The best course of action might be to just disable everything and then slowly add back content that helps with the flow. Okay lets remove the splash and the general advertisement above the fold! Maybe that might help with the flow of the website and the content. 

- 1:00pm - I removed the splash page, the floating buttons and added aria-labels to the footer buttons. I am going to go through the code base for the main page again and see if I can remove anything else that I will not need for the time being. I will have to update the Oracle component as well and have all the images load at an extremely lazy method, as they are taking a bunch of resources and data up that we do not need to offer. I suppose we could just remove all of the background images for the specific listing and place more gradient style backgrounds with slow loading images upon the hover? We could also swap the idea of a light/dark mode with a slim and heavy mode? Where the website loads with a simple bases and then if they press the heavy, it then takes them to the app. The concept we are going for might be to keep the astro layout as simple and fast as possible! With the visual aesthetics and heavy performance inside of the flutter application. 

- 1:30pm - Upgrading Astro to 2.4.4, Appwrite's Pink library to 0.0.6 RC-12. and the Astro sitemap to 1.3.1. While I am able to upgrade the components and the general website, the cache for the website does not seem to update. I will have to create a new action within Github to clear the Ezoic cache. I could have the cache get cleared via n8n or through AppWrite but I feel like having it done via Github actions would make the most sense. The idea being that we want to put the least amount of stress on our own private systems and offload as much and as many tasks to 3rd party tools and/or applications. The trade off is worth it in the long term, as we expand our collection of websites, we can make sure that the scaling will not hold back our system.

- 2:00pm - I am trying the cache system again from Ezoic and it seems to be a bit more annoying than I remember. Furthermore, I am having a bit of a tough time clearing the cache, so I will have to look further into how they are handling it. Upon doing some more deep diving, it looks like there might be a conflict with Cloudflare's cache settings and those by Ezoic. We could have a situation where there is a double cache going on, which might make it a bit more painful for the website to be a bit more `live`, as updates might take upwards of 48 hours to dispatch. One solution would be to have some of the more active pages be limited in the cache to just under one hour? Maybe even disable all cache for news and the front page? If we put back up the chat and forum, we could also look into disabling that? These are some thoughts I will go over while I walk around the city before departing. The good news is that there are no issues within flutter, which makes sense because its just a monolithic javascript file aka dart.js that loads everything.  

- 2:30pm - A great read on how [Unsplash](https://unsplash.com/blog/the-service-powering-unsplashs-beautiful-imagery/) handles their backend stack! I love how they organized themselves into a small but productive team, something that I think a lot of startups should take note of. You do not need a massive team to get the job done, just a strong and core collective with simple mission and structure. Granted the initial look at their infrastructure map might seem a bit perplexing but its really simple at the heart. You have an extremely large data set of images and then make it fast enough for the whole world through caching and optimization. I like their take on the newer technological stacks and honestly sometimes it just might not be worth the energy at the time. Why switch your whole database from Postgres to some random new database to only save 10% of speed while breaking all your tools!? It would make more sense to focus the time on growing your business and then going back to re-tool down the line or outsourcing it to battle-proven operations.

- Ah! Got a new amazing... high, ugh low?... score of 58 on PageSpeed! I guess it might be time to ask the Ezoic team what the fish is going on.

- 6:00pm - We were able to figure it out! It was a Google advertisement issue that caused multiple issues then stack on top of each other. Actually it was worse but we wont throw them under the bus, because they will never care and honestly its just a shitty and sand thing overall. 

## Quote

> Silence is the sleep that nourishes wisdom.
> — <cite>Francis Bacon</cite>

---

## Tasks

- [ ] Get onto a plane.
- [ ] Tom Hanking around the Terminal.

---
# May: 11

> May 11th - The Daily Journal

Source: https://kbve.com/journal/05-11/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### IRC Chat Upgrades

-   05:46AM

    Getting some of the IRC bugs resolved for the chat kbve!
    Later on I will have an integration so that kbve.com/chat/ also works with the chat.kbve.com integration.
    Having a dual layer integration will be great, then we can work out the relay channel integration afterwards.


### Ruffle integration

-   06:19AM

    Bringing back some of the classics, I might have added ruffle like three times now to the site.
    Robot unicorn attack and maybe some other classic flash games, we definitely should look into that.

## 2025

### Unity MM Items

-   01:48AM

    Taking a quick break from the rust flow and going to focus on the unity dev side!
    Looking through the inventory engine code and this seems like it will be easier than expected.
    We got the first "DefensiveBlock" almost done, added a health bar and now just need to turn it into an item.
    

### KBVE Deployment

-   05:59PM

    I need to finish patching up the KBVE.com deployment, its been a while since we had an update.
    The issue is in the `utils-astro-deployment.yml` , which I am going to patch up tonight and then use that astro deployment to finish up the items.
    Bascially, I want to keep all the item configurations on the KBVE Astro docs and use astro to build the json data.
    After the json data gets built and pushed out, I will have the unity editor pull that data and build the items that we will be using in RareIcon.
    This means that future developers and players have a single source of truth for all the items that we will be using the game.
    Okay, I think the astro build is ready to be pushed up and we can do a quick test of it.

-   06:22PM

    Looks like the astro build is a bit broken, damn the svelte 4 to svelte 5 is going to be a pain to fix.
    Let me work through each of the files that are being referenced and maybe I can knock it out within the next couple hours.
    Before I begin, let me update the astro build and also save some of the CI changes.
    The upgrade will be from Astro v5.7.2 to v5.7.12, so we should not have any major breaking changes, hopefully.
    Testing the sync first and it looks like that part of the code is working.

-   07:55PM

    Okay! Looks like we got the build and general issues resolved for astro kbve.
    Let me go ahead and now finish up the build pipeline.
    Now the issue is over the cache control with KBVE.com, hmm.

-   09:31PM

    A decent amount of hours into trying to fgiure out why the build does not work on  KBVE, its a bit of a pain!
    So we are getting an output from the build but its just exiting way too early and I need to figure out why!
    The dist folder is empty for kbve.com but not for discord.sh, so something is going wrong.


## 2024

**Music**

I believe the best way to start a Saturday morning is jamming to music and maybe even making a couple beats.
With that being said, the jukebox is overdue for some minor graphical updates and a decent music dump should be added.

The genre of focus will be DnB? or should I go out of the electro realm and maybe do some Rock/Metal?
Oh options, thoughts and ideas! Let me S-S-S and maybe as the water flows through my hair, I will come up with a good game plan for the day!

To fix the buttons, we just had to pass the `border` class name and to add a bit of fun, I will throw in a quick `hover:scale-110`.

Okay! Cleaned up a bit more of the `/music/` MDX file and added more information, hopefully making it a better to understand.

Going through each of the songs from the DnB playlist, I think it might be time to add a couple other genres to the player!

`Electro Swing` and `Indie` are the next two that I want to add and expand upon.


**Rust**

I will have to go back and refactor some of the code, removing the match and using a ?-mark operator instead.
This was long overdue, but I think I have enough time to refactor it all without breaking anything.

**League**

Time to play a quick league match, it will be weird once the split hits and all the items get changed up again.
But 2nd tier upgraded boots!?! I am super excited to see what this will bring to the gameplay.
The game is turning into trash.

**DnB**

Time to add some drum and bass!
There is about 700 songs that I would like to parse through and add, but the amount of time to listen to them all and making sure they are worthy of going to the jukebox.
I should have a vote system or feedback? At least to help remove any songs that might not be up anymore, hmm.

**Cypress**
Preparing the error testing and making sure that the tests will work.

---
# May: 12

> May 12th - The Daily Journal

Source: https://kbve.com/journal/05-12/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Blackjack updates

-   05:15PM

    Just minor blackjack updates, preparing to utilize ecs at the javascript level, maybe even include a better shared array buffer method.
    Granted we might not really need ECS for this type of game, however it be interesting to see what we can utilize within its eco-system.
    Afterwards we can apply this to the solitaire game.


## 2025

### KBVE Rewrite

-   02:00PM

    After thinking it through, the issue might be a silent vite problem with svelte 5 and the pre and post processing.
    Moving forward, I will try to write libraries to be framework agonstic, avoiding the issue of svelte or react migrations.
    The whole moving from react 18 to react 19 was a huge pain, having to do a svelte 4 to svelte 5 would just make it worse.
    There are migration scripts out there but honestly after doing the axum migrations, it feels like I am not moving fast enough to keep up with the breaking changes.

-   09:37PM

    The first step would be to build the meta file for the layout!
    Here we can focus on the meta title and description, but also the social information and og tags.
    This should not be too hard to setup.

### Droid Lib

-   04:58PM

    Taking a quick break from the astro situation before having to do a refactor for it!
    The droid library was something that I wanted to do for a while now, and I been getting better at using javascript workers.
    The goal would be a modular worker collection with service, shared and dedicated workers that all handle different tasks.
    I will try to build this out without causing too many issues down the road.
    On a side note, I do hate having to write tests but it is what it is.

-   06:39PM

    Adding the module support for the droids library will make it easier to then load the supabase and phaser as workers.
    This means that in the future, we can setup a pretty fast and isolated worker system that gives us a vast amount of flexibility.
    There is a down side, since there is no free lunch, which is that there will be a slight delay between loading the modules and the actual events.
    One way to handle this would be to run our own internal event engine that then would make things even more modular and easier to work with?
    Let me think this through before I go any further, I might loop back to the KBVE rewrite.

## 2024

**Happy Mothers Day**

We did a quick calendar event with the family!
I started to do this thing where I buy a bunch of different slices of cake, that way we can have a bit of each kind.
All the cakes except the carrot were on point.


**Cypress**

I fixed up the Cypress testing for KBVE.com and now I am going to deploy the github action under the beta branch to perform the tests.
Having AI help with building out the test cases is huge for development.
No one ever wants to write the different unit tests and integration testing, but AI is nearly perfect with helping build the different test case functions.
Now let us see if it performs well with this next couple git code pushes.

**Updates**

I made a quick list of all the updates that the monorepo needs, but I will hold some of those updates back to avoid breaking anything.

---
# May: 13

> May 13th - The Daily Journal

Source: https://kbve.com/journal/05-13/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026


### Firecracker Endpoints

-   03:13PM

    We will have two types of firecracker deployments, one that will be focused on one-shot runs, this can be useful for things like turning a transparent png into a webp.
    Or we could be converting an online video into a mp3, regardless this is mainly just to make easier to program and test around.
    Where this system will shine will be the ability to dynamically create endpoints for us to call!
    The pipeline will then become idea to python or node, once its a popular enough endpoint, we can expand it out into the rust code. 
    Another area where this will be useful might be turning websites into markdown files for ai agents.
    

### Axum KBVE Build Speeds

-   06:51PM

    A decent amount of the next updates are going towards trying to improve the astro and axum build for kbve.


### Pool integration and optimization

-   08:13PM

    Before I go to grab some cofffe, I am going to focus on getting the replicas connected and utilized to avoid hitting our main database with older queries.
    We should maybe look at a valkey cache integration as well, but maybe the application itself could hold a cache, this would be an interesting way to handle it.

## 2025

### Bento Grid Astro

-   01:05AM

    Going to rebuild the bento grid for KBVE.com and try to use droid to offload the rendering and handling of the bento grid.
    I am thinking that we will have two grids, one that is managed by the off canvas and another that is handled by the main thread?
    Damn, actually I think it would make more sense to just focus on getting the grid out there and moving forward with the JSON.

### Unity ECS

-   05:20PM

    Migrating over from GameObjects to the ECS system.
    This might be a bit of a pain, but I am going to test case it before adding it into the RareIcon eco-system.
    That also means we would lose the Discord / web build, damn that will be a major blow to my original plans but hey it might be just worth it in the long term.
    Focusing on a Steam release should just be the goal, the rest can be for another day in the future.


## 2024

**Cypress**

I am going to update the [javascript](https://kbve.com/application/javascript) notes with cypress documentation and information.
We should also include a basic cheatsheet, that has the generic commands as a reference.
Added a couple tables that outline the different cypress commands to run when building out the unit tests.

Next update to the Cypress will be adding the integration test for login!
We will skip register because of the captcha.

**Rome**

Its a shame that rome is no longer an active tool, it would explain the errors that I was getting with it!
So I updated the javascript document with a replacement tool, called Biome.js.
While reading through the docs and setting up the extension, I saw an interesting github action called Review Dog, this was something that I was looking to build myself in the future.
The review dog action basically helps streamline the automation of code review!
2024 is the year of automating some of the most boring aspects of development, unit testing and code reviews.

**JukeBox**

A couple future updates for the Jukebox?
We should keep track of the songs that are being played, i.e a decently played id list, so that it does not play the same song again.
This might be because the pool of songs is a bit too low, so the odds of a repeat are going to be higher!
In addition to keeping track of the songs that have been played, I believe a skip option and maybe a ban/remove option?
I will keep these ideas here for now, then whatever ones that need to be added, well I will first place them into the music mdx directly and then build them out within that week.

We could also make it so that the first video on pageload could be a default KBVE Jukebox video, that will be like 3 to 5 seconds long and it will act as a buffer, to prevent the first song to automatically get added.

---
# May: 14

> May 14th - The Daily Journal

Source: https://kbve.com/journal/05-14/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### RedStone Minecraft Mechanics

-   11:34PM

    I am currently looking at doing some JNI updates to my custom minecraft plugin, so that we can have custom red stone modifications.
    These would then expand into our custom firecracker containers as well, allowing the player to execute some more advance level stone logic?
    I am still on the fence on how I want to do this exactly but I am laying down the ground work towards it.

## 2025

### CICD Astro KBVE

-   01:15AM

    While building out the bento grid, it would make sense to finish up the astro build pipeline between our github repo and the gh pages.
    Testing this build pipeline would make sense because before the next meeting, I need the updated KBVE website operation with the JSON content.
    It is a shame that we did not get to resolve the svelte 5 issues but this rewrite was long over due.
    As for the future of the KBVE website, it is looking great, definitely if we can get the bento operational and get to utilize the droid library.

    Okay slight changes to the cicd, a couple stupid errors but I am also half asleep working on this, ugh.
    It feels like I am making my own deathstar, except for my soul.

### Andor

-   03:10AM

    Just finished the final episode of Andor season 2!
    It ends perfectly into the Rogue One and that is exactly what I wanted, now would be a great time to rewatch it and maybe the legacy star wars too.
    Ahh, a bit excited because its been so long since I seen any of the OG movies and this would be the perfect time to watch it again.

### Bento Droid

-   03:20AM

    The Bento grid module will operate like this:

```
   Worker Thread (mod-bento.worker.ts)
        |
        |  ──> BentoTile → emits → { type: 'injectTile', tile }
        |
        ↓
   Main Thread (uiux.emitFromWorker)
        |
        ├─> injectBentoTile(tile)
        └─> injectBentoCanvasTile(id, options)

```

    This means we need to update the uiux to include a bridge or an emit-style helper function to transfer over objects that get created by the workers.
    There are three ways we can do this, but for now I am going to try and maybe proxy + transfer the objects.
    If that fails then we could manually do a post message but that would be outside of the comlink communication and we do not want that.

### KBVE HomePage

-   06:31PM

    The homepage is finally coming along, there still some minor changes that I need to add but I think I can do it both via static astro AND through injection.
    Okay, this is good because we just need to move over the docs and should be able to launch a solid website within the next 48 hours.
    
-   08:40PM

    Docs are next! I am testing the astropad build and there does not seem to be a problem so far.
    Since it builds, the next move would be to change the vault symbolic link.
    Okay the movement of the journal entries seemed to not have any major problems, hopefully we can keep it going without any more major problems.
    I will have to delete the older one

### Droid Canvas Worker

-   06:47PM

    There was an issue with how I was importing the canvas worker on the droid library but I was able to get it resolved.
    Next issue to handle will be migrating the rest of the doc files over to the new site!
    Once that is done, I will loop back and fix any of the issues with the new collections, aka journal and arcade.
    Finally, I will add the discord, contact, support and misc routes and then we can switch over to the new website!


## 2024

**GME**

The $60+ pop this morning was insane!

**Lottie**

Updated the [javascript](https://kbve.com/application/javascript/) documentation for Lottie and included a quick lottie-web example.

**RareIcon**

Currently planning out a quick mini game jam for the next couple days!
We could combine all of the previous games into one unified game and then pipeline it out to Steam.
The theme for the gamejam is `Aqua` and I am going to head towards a Zelda-style mockup.

**TailwindCSS**

I updated the documentation around the TailwindCSS within the javascript docs, and now it would be time to migrate all the tailwindcss examples into the document.
Yet before I do that, I need to build a new component to help render the tailwindcss as a preview.
I am thinking of using this `html-react-parser` library to help render the example tailwindcss code.

We had to add a syntax highlighter and decided to change the default code layout to be "shadesOfPurple", which looks great in both light and dark mode!

---
# May: 15

> May 15th - The Daily Journal. The MixTape.

Source: https://kbve.com/journal/05-15/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Nvidia 2026 Q2 Earnings

-   10:03PM

    The stock has been having a crazy, I just need to be careful not to get left holding the back with these crazy swings.
    I should have played that 225 to 230, but it was too late, I was way too tired.
    Anyhow, I am looking at those 225 for monday, we shall see how bad it gets before I am hit with that.

## 2025

### Journal Migration

-   12:06AM

    Moving the journals over to the new website, hopefully we can make some changes that make it easier to see the journal entries too!
    This should not be too hard to do, just a bit of pain because we want to make sure it builds without any issues.


## 2024

**CSS Buttons**

I am going to update the TailwindCSS components within the javascript docs!
After that I will to remove some of the python libraries within the atlas package.
Let me also get back into the habit of [creating issue tickets too!](https://github.com/KBVE/kbve/issues/1559)


**RareIcon**

The new /apps/ folder that needs to be pushed is the `rareicon-game`, part of this new application will be to migrate a bunch of the fish and chip code?
Ideally turning this into our final 2D pixel game that we can continue to build and ship out to Steam!

I really want this under my CV, so I will try my best to rush this through without causing too many issues.

**TailwindCSS**

The MDX might become a bit too bloated with the code examples, so maybe we could split the the tailwindcss into its own sub-folder?
I am thinking that we create a `_javascript` folder within the `/docs/application/` , then create additional mdx files for the different code blocks that we want to preview?
This is just so that the mdx file does not become way too large, as we add more and more?
However, I am not planning to add any examples outside of just the tailwindcss components, so maybe we might be fine for now.
I am just typing this up as I think it through, we will continue to add more components the way that we are doing it right now but later on we might look at another way.


**Python**

Time to do some late night python coding before I go to sleep.


## 2023

- 10:00am - Ah! I was assigned to a put call over the weekend and did not realize that I was forced to purchase SPY for $415.00 a share. There might have been in a mistake in the automated hedgefund or a bug because of the timezone change since I came back from India. This means that I will have to go back and go through the codebase to see where I made the mistake. I believe that I might have hardcoded the timezone change, rather than making it a function. I suppose one of the solutions would be to grab the program's IP address, figure out the location from that information and then convert the said location to the right timezone. In addition, have a default config variable for the timezone where the application is running, incase it is under a VPN. 
- 12:00pm - Sent most of the morning doing basic chores and fixing up the MDX files. I think we also spent a couple hours playing a bit too much league but the binge of One Piece totally made up for everything. Luffy is da King!
- 2:00pm - One of the issues that I been having was figuring out how to handle the UX/UI for the MDX entry files. 
- 4:00pm - Finally got the Obsidian package to work on Windows again. It seems that I have not opened the application in such a long time that the whole vault crashes during the cache period. The solution to the problem was to create a secondary vault, next close the broken cache* vault, then delete the broken cache* vault and finally create a new vault from the location of the broken cache*. I am not too sure if this is a common bug to address, but if it happens again then I guess I will have to make a tutorial about it.
- 5:00pm - Going through the `Manga` notes right now and there are some issues that I already see on rendering them within Flutter and Astro. Going forward I might have to combine the md and mdx files, however it feels so backwards to do so.

## Quote

> Once we accept our limits, we go beyond them.
> — <cite>Albert Einstein</cite>

---

## Tasks

- [x] Sync Obsidian on Windows with the Github Vault.
- [x] Improve the UX/UI on the MDX files that are being rendered by Astro.

---

---
# May: 16

> May 16th - The Daily Journal. Python Adventures.

Source: https://kbve.com/journal/05-16/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Firecracker Billing

-   09:13PM

    Majority of the day was around getting the billing resolved, but not yet deployed.
    The goal would be to create our own internal tracking system for firecracker deployments, so that it be easier to scale.
    I do want to include edge functions as well, then maybe expand it out to include cloudflare workers too.
    If I can make a wrapper around their workers, I could probably do the same with amazon's eco-system as well.
    In a weird way, I guess I am rebuilding theo's storage but with my own layer ontop of it?


## 2025

### Droid Event System

-   05:19PM

    Now that I got the base of the mutli-worker system setup, the next part would be to setup an event system that the whole library would follow and utilize.
    Instead of placing the event calls and functions everywhere in the code, I think it be wise to create a simple event master singleton that would basically be in charge of handling and processing the events.
    This will live on the main thread and proxy any requests that need to be done.
    For me to do this, I suppose I need to setup a `types/event.d.ts` that would hold all the events information that we plan to use.


-   05:51PM

    After adding the basic DroidEventBus and the event types, the next move would be to attach it to the `window.kbve.events`.
    This would make it easier to access and reference outside of the droid eco-system.
    Since we will be doing that, let me update the globals for the library to hold that additional system.
    Damn, there is a race condition that I just can not really resolve with the tools that I have right now, the way that astro page load fires and the way that the workers are loaded, ugh.
    I am going to revert to a simple while loop execution and move on because its just not worth it.

### KBVE Website Migration

-   08:43PM

    One way that we could handle the migration would be just to take the older website code and slap it back into the new site?
    We can keep it there and make sure that the production line is back to normal, granted some of the older modules will still be broken but the site will actually update.
    I am still thinking about the best ways to handle this and I did not want to have some of the older boilerplate but having to rebuild it all will be a pain.

### RareIcon AstroKBVE

-   08:40PM

    Adding a playable RareIcon demo to the KBVE website.
    This is my 3rd attempt at trying to build a solid integration between the React eco-system and the Unity webgl game, hopefully it goes a bit better than last time.
    Majority of this code will be take out and re-used on the rareicon website but that will be for the future.
    For this, I need to install the `react-unity-webgl` package and then setup an `App.jsx` for loading the webgl game and preparing for its execution.
    There is a slight downside, majority of the arcade is still broken and I need to get that resolved.

-    08:57PM

    The multi threaded build was disabled, so I am going to loop back around and update that!
    Making it a bit easier to migrate to worker usage via the react unity library.
    There are a couple more downsides to doing this, the game might not work on itch, so we might have to account for that in the future.
    Yet I want to try and get the game build and operational for the react unity bridge side of things.

### Rancher Memory Usage

-   11:11PM

    There seems to be an issue with the memory and cpu usage within the rancher setup.
    My educated guess is that there are some hleath checks that are failing and causing a weird ripple and bubble effect, so I will have to switch back over and see what the issue is based upon that.
    I noticed that the health check for the discordsh is wrong, so that needs to be updated too.
    Furthermore, the health checks for the supabase need to be updated too, so that means I will have to set aside some time to just go through each instance and see what the problem might be.


## 2024

**Python**

The next update to the python library will be to manage the VNC instance directly.
While we wait for the next branch to reach production with the properties file for Runelite, I will start test casing the different click styles and the data movement.

I decided to add a function to stop the runelite client, which follows the same logic as the start function.

Incase I forget, the location to build the Atlas library is `/apps/atlas/` and the command to run the build is `docker build . -t myapp`.
It really is taking a hit to my CPU, this might make development work a bit of a pain as the library grows.

We could offload the integration testing once it gets stable to portainer but even then, there would be such a high usage in resources! Ugh!

After pushing the updated `default.properties` to the runelite outpost, we can pull it within our updated python script and place it where it needs to be.
Current location : `https://kbve.com/data/outpost/runelite/default.properties`

We know that the default profiles would be stored in this location: `~/.runelite/profiles2/`

When the Runelite loads, it creates a `profiles.json`, which is here:

```json

{"profiles":[{"id":-1,"name":"$rsprofile","sync":true,"active":false,"rev":-1,"defaultForRsProfiles":[]},{"id":41056315715238,"name":"default","sync":false,"active":true,"rev":-1,"defaultForRsProfiles":[]}]}

```

I need to now download the default.properties from the outpost and then name it `default-41056315715238.properties` , with the id from the profiles.json.

**LoL**

League just did a major update with their patch 14.10!
I am kinda excited for the new items and the return of my old favorites.

**Music**

Going to try to aim at around 30 more songs into the jukebox this week.


**Bullet Train 2022**

Just finished watching the bullet train, it was a solid piece of work!
The storyline ties together very well and I was entertained throughout the whole movie, it gets a solid 8 out of 10 in my review.

## 2023

- 9:00am - When I was taking my mom to her doctor's office, I noticed that they were using a full react-based eco-system! The patients would have tablets, where they would sign forms, fill out and double check their information, schedule and more!
- 12:00pm - Spent some of the time going through the Unity project. I still need to do some updates here and there with some plugins however they might break the game in other areas. I believe test casing or a system to test case the game might have to be on my agenda down the line.
- 2:00pm - Quick workout session , some minor chores, damn laundry!
- 3:00pm - One Piece, league and programming session aka Memegramming! I am trying to rotate out of Shaco and into Senna, but getting the build and learning the play style have been some issues that I wanted to resolve. Found out that Luffy pumps his own blood to get stronger but also shortens his own life.
- 7:35pm - Read this interesting article about the `Boot Girls` aka [NPR Boot Girls](https://www.npr.org/2023/05/16/1176175801/boot-girls-atlanta-private-parking-enforcement) and its an extremely cool concept! Imagine buying a 3D printer and making unique set of keys that can unlock car boots and then selling them?! It reminds me of the blue ocean and its a great start up besides the ethics involved.

## Quote

> Chance is always powerful. Let your hook be always cast; in the pool where you least expect it, there will be a fish.
> — <cite>Ovid</cite>

---

## Tasks

- [ ] Adding Search back into the KBVE Homepage.

---
# May: 17

> May 17th - The Daily Journal. Display is the Play.

Source: https://kbve.com/journal/05-17/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Minecraft Item Templates

-   11:10PM

    Similar to the OSRS setup, I am thinking of building an internal wiki style of all the minecraft items.
    This way it be easier to keep track of their unique data points but also expand it to include any custom items that we will want to include in the future.
    Examples of this will be custom food dishes and our airships, but also any unique weapons and armour as well.

## 2025

### Unity Dev Session

- 03:40PM

    Preparing before the next unity dev session!
    There are a couple things that I was hoping to resolve before this meeting but I did fall behind in some situations.
    Since we did not get a chance to finish the kbve site, but its okay, it should be ready by next week.
    As for the pre-meeting preparing, I just need to make sure that the local webgl build finished without any issues.

- 03:50PM

    The panel still looks a bit dicey and maybe we can get that ItemDB implementation out of the way?
    I suppose since each item would have its own ULID aka 16 byte reference id, we can use that for this.
    When adding the item into the game, it should have the ULID as a reference, which should then be in the payload.
    So when placing the item, instead of sending the prefab name, we would send the ULID, which would then get processed by a web worker + indexdb.
    This means we can keep the scope of data transfer small and make it easier to abstract away some of the issues.
    Unity sends the event of `Item->Use()` with the `ULID` of the item.
    The React component then gets this `ItemEvent` and it uses the `ULID` to represent the item that was being used.
    By having this one-to-one relationship, we can then make the inventory easier too, by sending a `Map` of the `ULID`?
    Actually it be an `Array` with the `index` being the slot that is being used in the `inventory`?
    Hmm, the actual data structure that we use wont be too important because we can easily swap around it.
    That means we need to keep a local image on the Astro side as a reference.

- 04:28PM

    ItemDB - The concept could be tough to maintain in the long term. We can even reduce some of the informal stats as well.
    `[*] => [[Structure], [Defensive], [Crafting]]`, this is the enum style that we could introduce!
    The item schema could be stored inside of the `ItemDB` and then we just import it into the `Astro Config` for the collections.
    I wonder if there might be two ways to handle the `ID` which could be through a `BigInt` and `ULID`?
    The `BigInt` would be just the rolling IDs for internal indexing, then we can keep the `ULID` for searching quickly?!
    This is the `ItemCategoryFlags` that we can utilize for the base operations of the enum.

```js

export enum ItemCategoryFlags {
    None = 0,
    Weapon = 0x00000001, // 1 << 0,
    Armor = 0x00000002, // 1 << 1,
    Tool = 0x00000004, // 1 << 2,
    Food = 0x00000008, // 1 << 3,
    Drink = 0x00000010, // 1 << 4,
    Potion      = 0x00000020, // 1 << 5
    Material    = 0x00000040, // 1 << 6
    Resource    = 0x00000080, // 1 << 7
    Skilling    = 0x00000100, // 1 << 8
    Combat      = 0x00000200, // 1 << 9
    Structure   = 0x00000400, // 1 << 10
    Magic       = 0x00000800, // 1 << 11
    Quest       = 0x00001000, // 1 << 12
    Utility     = 0x00002000, // 1 << 13
    Depletable  = 0x00004000, // 1 << 14
    Legendary   = 0x00008000, // 1 << 15
    Vehicle     = 0x00010000, // 1 << 16
    Pet         = 0x00020000, // 1 << 17
    Soul = 0x80000000,
}

```
    Okay we can use this as the core enum and flags for the base item set, I will combine enums later on once we have a couple more items added.


### Unity RareIcon Session

-   11:10PM

    The session went great and we got the blueprinting out of the way!
    Now the players can place items without any major issues but there could be some minor improvements, one being that the objects are being marked in the default layer.
    Okay, after finishing up the general build and test casing, we can move forward with adding some of the farming style logic to certain items.

## 2024

**Display**

The docker image is having some issues with the display, which I need to fix!
Having multiple displays would be a nice feature in the future doe.

Spent the whole day trying to figure out what the issue was with the display and it seems that we were using the wrong vnc server software.
However I believe we also had some issues with wayland on ubuntu!

Yet after countless hours and league matches, we were able to make a breakthrough.
Now there are still a decent amount of steps required before we can move forward, including the migration of the websocketify into the FastAPI.

**League**

I am doing terrible since the recent item changes, I think they buffed almost every champion to an extent that the damage output is insane!
The solution would be to shift a bit more towards an off tank shaco build, where I can use my clone to start team fights more often.

**Roast**

The roast of holybyte was a great event, 10/10, it was exactly what I was expecting and it still delivered beyond it.

## 2023

- 8:00am - Need to get back onto the workout flow here in the states! Damn I have to stop being lazy, maybe for fun, I should make a GPS based alarm clock? The only way to turn off the alarm clock is by going to a specific GPS location. So instead of a snooze button, it would be the GPS location that would turn it off. This was a shower thought but I think it would be an interesting concept to build out.

- 11:00am - I been holding off too long for my Twitch stream, I think it might be interesting to bring it back up? Granted there will not be any viewers but it would great to record some of the games, specifically the gameplay, and maybe develop software that could parse through the data and grab unique clips? This could be extended out to other areas later down the line as well. Too bad that I am trash at league or the the content would have been great to watch haha.

- 12:45pm - Traveling to eye doctor and comparing it to the doctors office yesterday, this office is super old school. They keep all their records in files and take a rather long time to process their patients. From what I noticed, they could hire an extra person that would slowly transfer over their records to a hybrid-cloud, one where the data is stored locally and within 3rd party data warehouses. The time it took to get from patient to queue was around 15 to 20 mins, including the double checking of the records, insurance, forms, ect.. this could easily be scaled down to 5 mins.

- 1:15pm - I should start to create more issue tickets regarding what areas that I need to focus on, this way I am not all over the place. After going through all the issue tickets, I will get back into programming and then head over to the mall.

- 1:30pm - Oh I had another idea for the GPS based application, I could sync it with a map style, so that I could sync with others that might want to go to the gym or to the park. The other side of this would be to make it easier to automate the sync of activities, like going for a hike or going onto an adventure?!

- 2:00pm - The search on the main page was broken, going to go ahead and address that really quick. I think the style for the search can be improved later down, but for now, it would make sense to not over complicate things.

## Quote

> The least movement is of importance to all nature. The entire ocean is affected by a pebble.
> — <cite>Blaise Pascal</cite>

---

---
# May: 18

> May 18th - The Daily Journal. More Adventures

Source: https://kbve.com/journal/05-18/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Nvidia Earnings Q1 FY2027

-   01:15PM

    Preparing to sell a bunch of $235 call options, I am thinking that the stock will definitely not moon.
    There is not much else going on, I think that China's limited purchase of Nvidia hardware will hurt them in the long term.

## 2025

### RareIcon Dungeon

-   12:25AM

    I am trying to figure out the best way to build an endless dungeon crawler style game loop.
    The concept we are going for is known as "planar drawing of a graph with minimize edge crossings", basically a collection of rooms that have certain styles.
    Instead of building just random rooms over and over, I will try to pre-generate a bunch of exisiting rooms and then fill in the empty areas with randomly generated rooms.
    This way there will be randomness in the pathing and flow but some core rooms will remain the same.
    I need to do more research before I can get this resolved.

### Spider Rose

-   02:43AM

    The idea for a spider rose type base-building concept, where instead of just having pipes, the player can use pixel-style webs to link their base.
    These webs would act like pipes but also provide defense, hmm, a bit like a spider silk pipe network?
    I am still thinking through exactly how I could implement it, this would not be something that I could do over night but we could add small steps towards it.

### Smart Toilet Pixel Art

-   03:30AM

    While watching Love, Death + Robots, there was a smart toilet and for some reason, it be perfect to have in the game.
    It would be a bit of a gag-like item but also an interesting meme-style , ah no nevermind.
    I should definitely avoid this, I just realized as I was making it... its been already done xD.

### Crawler with VContainer

-   05:10PM

    After thinking it through, maybe the best move would be to build a bunch of prefab dungeon rooms and then using injection and asset addressable, load them as needed.
    This will make it easier for multiplayer because it be the same layouts shared through the content but if we have a couple hundred random rooms, it should not be too much of an issue.
    We then just focus on linking the corridors and hallways.

## 2024

**Proxy**

Going to try and proxy the websocketify today, with this being a past battle that I have had, its basically going back to an unsolved problem.

Lets go ahead and add the `websocketify` proxy into the Python package using this command:

```shell
./kbve.sh -nx atlas:add --name websockify
```

This will help us with setting up the websockify proxy within our FastAPI.

Before adding the new python script, we will remove the older chatroom example from the main.py, I will keep that code here for a reference in the future.

```python

@app.websocket("/chatroom")
async def chatroom_ws(websocket: WebSocket):
    await websocket.accept()
    await broadcast.send_messages(websocket, "chatroom")

```

then followed by migrating out this part of the code block.

We will update the `novnc_client.py` with a new double instance of the websocket proxy.

Inside of the `main.py`, we want to make sure that the `novnc_client` can also listen start the websocket proxy between the vnc instance on port 5900.


**Resume**

The resume project was something that I started a while back, I am going to revisit it again and maybe this time it will be a bit easier since I picked up some additional skills with javascript.
I believe the hardest part will be figuring out how we want to save the resume data and offering a PDF render from the javascript information.

The Resume App has been outlined and the libraries that I want to use are prepared, now it is just a moment of assembly and making sure everything works out.
There are times that I think it is best to go deep into a MVP / prototype but we did this earlier in early 2023, but I am more confident that we can get a near production ready tool out into the public.

One of the biggest objectives of the resume builder would be to automatically submit the resume on my behalf.

**Browser**

Going to add a browser into the `atlas` docker image!
What an adventure with setting up Chrome , the lack of native arm support was a pain to deal with too.


## 2023

- 9:00am - Mornings are still an emotional adrift with an aura of haziness, damn I hate jet lag. However it has been getting better, I might have to sleep earlier than 12am, so I believe that its my brain just saying I am getting too old.  I added a new habit of asking `Bard` how I felt about it and seeing what it tells me!

  > Bard : **Jet Lag and the Aging Brain**
  >
  > I hate jet lag. It makes me feel like I'm in a constant state of fog. I can't seem to focus, I'm always tired, and I'm just generally irritable. I've been dealing with jet lag for a few weeks now, and I'm starting to think that it's not just the time change that's making me feel this way. I think it's also my brain.
  >
  > As we age, our brains naturally slow down. This can make it more difficult to focus and concentrate, and it can also make us more susceptible to sleep disturbances. Jet lag can exacerbate these problems, making it even harder to get a good night's sleep and wake up feeling refreshed.
  >
  > In addition to the cognitive effects of jet lag, it can also have a negative impact on our mood. When we're sleep-deprived, we're more likely to experience irritability, anxiety, and depression. These symptoms can be even more pronounced in older adults, who are already more likely to experience mood disorders.
  >
  > If you're struggling with jet lag, there are a few things you can do to ease the symptoms. First, try to adjust your sleep schedule gradually. This means going to bed and waking up a little bit earlier each day until you're back on your regular schedule. You can also try using light therapy to help regulate your circadian rhythm. Light therapy involves exposing yourself to bright light in the morning and avoiding bright light in the evening.
  >
  > If you're still having trouble sleeping, there are a few over-the-counter medications that can help. Melatonin is a hormone that helps regulate sleep, and it's available in most drugstores. You can also try taking a warm bath or shower before bed, as this can help relax your muscles and make it easier to fall asleep.
  >
  > If you're experiencing severe jet lag or mood disturbances, it's important to talk to your doctor. They may be able to prescribe medication or recommend other treatment options.
  > Jet lag is a common problem, but it doesn't have to ruin your vacation or business trip. By following these tips, you can minimize the symptoms and get back to feeling your best as soon as possible.

- 11:00am - Good to see $SPY go back up towards the $415+ mark, this means I can sell off at least 100 shares that were assigned to me. I been just rolling them daily to collect the premium that comes with those shares. I wonder what bard might have to say about this too?

  > Bard: -   "Patience and Risk Management"
  >
  > The stock market had been on a downward trend for months, and I was starting to get worried. I had been assigned 100 shares of $SPY, and I was hoping to sell them off before the price went any lower.
  >
  > One day, I checked the stock market and saw that $SPY was starting to go back up. I was relieved, and I decided to sell my shares. I was able to sell them for a profit, and I was glad that I had waited.
  >
  > I had been rolling my options contracts daily to collect the premium, and I was happy with the results. I had made a good amount of money, and I was able to reduce my risk.
  >
  > I was curious about what Bard would have to say about my situation. I asked him, "What do you think about my decision to sell my $SPY shares?"
  >
  > Bard said, "I think you made the right decision. The market was on a downward trend, and you were able to sell your shares for a profit. You also reduced your risk by rolling your options contracts daily."
  >
  > I was glad to hear Bard's approval. I felt confident that I had made the right decision.
  >
  > I continued to trade options, and I was able to make a good amount of money. I was grateful for Bard's advice, and I was glad that I had asked him for his opinion.
  >
  > Here are some additional thoughts from Bard:
  >
  > 	- it is important to be patient when trading options. The market can be volatile, and it is important to wait for the right opportunity to sell your shares.
  >
  > 	-  It is also important to manage your risk. By rolling your options contracts daily, you can reduce your risk and increase your chances of making a profit.
  >
  > 	  -   Finally, it is important to do your research before you trade options. There is a lot of information available online, and it is important to learn as much as you can before you start trading.

- 12:15pm - Time to start the quest of setting up Ryujinx and Yuzu to see if I can get my hands on a playable version of Zelda: Tears of the Kingdom! I am super excited to see all the dope mods that will be coming out for the game! I will start with Ryujinx first because its on `choco` already and it makes it so much easier to setup and install. I will try and write out a guide, with the help of Bard and Bing? They tend to make things a bit easier, I suppose. Lets ask Bard for help! Yay!
  I will create the notes as ryujinx.mdx under applications. [KBVE Ryujinx docs](https://kbve.com/application/ryujinx/)

- 4:30pm - Going to the local mall with the mom duke, hopefully she finds something worth wild to buy. I am going there to see how bad inflation gets and to take a nice walk around.

- 7:30pm - Holy mushrooms, the mall looks so dead and vacant! Everything is overpriced or really expensive, like the meals are insanely over priced. My normal Starbucks coffee was also way over priced and the amount of calories that I consumed, I understand what it feels like to be an American again.

- 7:45pm - Time to break down the tasks and see what I should aim to finish up today? I am thinking it might be great to finish up the React-based API project that I was eyeing for a while to wrap up. Oh I got Zelda, Tears of the Kingdom up and running! It looks great on the laptop, but sadly I do not have a mapped out controller to play the game right now.

## Quote

> When the world is so complicated, the simple gift of friendship is within all of our hands.
> — <cite>Maria Shriver</cite>

---

## Tasks

- [x] Setup Legend of Zelda: Tears of the Kingdom.

---
# May: 19

> May 19th - The Daily Journal. VNC is my soul.

Source: https://kbve.com/journal/05-19/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2026

### Isometric

-   10:00PM

    Back at the isometric and bevy flow, taking a quick break again from unity.
    My goal now will be to get the cross platform gameplay out of the way before preparing for a steam release.
    If we can get the rareicon demo out before the end of this month, then we can take all of june and july to prepare for the isometric release.
    This then gives us some time to also prepare for the chuck release, if everything goes as planned, we can have three solid demos out before the end of the year.

## 2025

### VContainer PCG Maps

-   05:04AM

    After some back and fourth testing, we were able to load the prefabs into the map!
    Now there are a couple more side objectives that I want to do before really going deep into the lore side.
    The rooms sadly are still not being connected, so I need to adjust for that.

-   07:33AM

    To be safe, I am going to trigger a build for the vcontainer and see if there might be any issues on the webgl build.
    Damn I just made a mistake, forgot to include the scene, ugh, I will run another build again later today.

-   09:18AM

    The next update should focus on making sure the newly generated room gets linked with the seed room.
    While the current script that generates the room seems to overlap the first prefab with the seed room, which can be an easy fix.
    The anchor needs to follow the exit but also we might have to look at another way of building the said rooms.
    One of the errors that I did recently notice was that the RareIcon Crawler was not placed under the grid, which could have caused issues with the generation.

-   10:52AM

    Looping back around we can make some minor changes again to the logic that we are using for the VContainer lifetimes.
    We should run an `IStartable` that will scan specific tilemaps, to build a basic history of the tiles that are going to be placed.
    Omg, I am way too slow, I just realized that I could just bake the data that is in the scene!
    This could make things easier in the long term, ideally allowing us to make sure that the generated maps do not affect our home base.

### Unity TileMap Baking

-   11:29AM

    For baking the tilemap, we will have three files to help with the flow and management!
    Since we are still in the experimental stage, I will keep this all inside of the `Assets/Dungeon` for the time being, atleast until we got something really operational.

### MMExtension Migration of Map v1

-   09:19PM

    Moving the basic script that holds our map generator and item deployment into the MMExtensions, this way we can keep things in sync!
    I fixed the csproj file to reference the Unity and the modules that we are using, hopefully this will make it easier to manage the extension without having to open Unity itself.

-   09:47PM

    All the files are migrated and now we can look through any issues that we might have!
    After loading and updating the script based off what we have, then we can move forward with the bake migration.

## 2024

**VNC**

The VNC adventure still continues and this time we are going to switch over to kasm!
I really wanted to make my own based upon the vnc format but kasm is growing so fast and it provides almost everything that I need, it just makes sense to build ontop of it.

We did a couple moch images earlier this morning but I am ready to build it all again.
Furthermore, I think we should update the notes from just `rustdesk` to something more along the realm of either `vnc` or `RDP`.
Creating a new application document to keep track of everything would make sense and it should be a habit that I need to practice more often.

```dockerfile
FROM lscr.io/linuxserver/chromium:latest

RUN apt-get update && \
    apt-get install -y \
    wget \
    python3 \
    python3-pip \
    python3-tk \
    python3-xdg \
    python3-dev \
    python3-venv \
    python3-distutils \
    pulseaudio

RUN ln -s /usr/bin/python3 /usr/bin/python

RUN wget -O /usr/local/bin/runelite.jar https://github.com/runelite/launcher/releases/download/2.7.1/RuneLite.jar

RUN curl -sSL https://install.python-poetry.org | python -

ENV PATH="$HOME/.local/bin:$HOME/.poetry/bin:${PATH}"

RUN poetry --version

WORKDIR /app
COPY . /app
COPY entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/entrypoint.sh

RUN mkdir -p /var/run/pulse && \
    pulseaudio --daemonize && \
    pulseaudio --start

RUN poetry install

ENV PATH="/app/.venv/bin:$PATH"

EXPOSE 3000 8086

```

I am going to keep a backup of the older dockerfile in this journal entry, so that I can reference it back again in the future.

I really wish I did not have to go on multiple quests to just get these small errors resolved.
This makes me really hate Ubuntu, Python and their whole eco-system, way too many random configurations and not enough easy fallbacks.

**Docker**

When deploying the Dockerfile , we can pass the shim using `docker run -it --shm-size=256m` , the `--shm-size` flag.
To run the application, we will use:

```shell
docker run --name myapp_container -d -p 3000:3000 -p 8086:8086 --shm-size=2g myapp
```

This will open the two ports that we need and set the shm-size to 2G.

Hmm, so we have two options:

The --no-sandbox option is required, or --cap-add=SYS_ADMIN to docker run command

Here is a quick chain command:

```shell
docker build . -t myapp && docker stop myapp_container && docker run --name myapp_container -d -p 3000:3000 -p 8086:8086 --shm-size=2g myapp
```

---
# May: 20

> May 20th - The Daily Journal. VNC is my soul.

Source: https://kbve.com/journal/05-20/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Post Earnings Nvidia Q1 2027.

-   07:00PM

    No major surprise from the earnings, I will take my couple grand from the call options and move forward.
    I was really hoping that maybe the china trip recently would open up talks between the CCP and Nvidia, ideally getting some of the GPU flow back into action.

## 2025

### KBVE Hero

-   02:22PM

    Adding a hero element to the website, one that will be vanilla html first and then have some kind of react-based animation.
    How I will go about handling it? Well that is going to be the real question, I am thinking about how fancy I should make it.
    We could make the hero element also include a search, that would then link to the google search, which is long over due.
    The hashtag based search was something we built before and removed, so adding it back would make sense.

-   02:51PM

    I am debating on how I should make the element interactive, I am thinking that the best way would be to add a couple dice rollers again.
    Under the rollers, I am thinking we would add the search bar + search results, but that can be done on a later date.
    The creative side of my brain is taking a couple hits, ugh.

### Dice Dive

-   04:07PM

    It is that time again, rolling deep with the dice flow again.
    This is the third time that we are doing the dice rolling via react and running into similar problems that we faced before.
    Emphasis on the face because the roll values and the dice face are not matching up, but that is usually a combination of euler and physics.
    This is just prep work before we implement the dice rolling in unity, tbh, which I feel like will be easier than this.

## 2024

**Python**

The main issue with python this weekend was the fact that the docker image was running into ARM / M1 issues.
Today, I decided to switch over to the x86 and its been cake walk.

Shell script for running the docker container!

```shell
docker build . -t myapp && docker stop myapp_container && docker run --name myapp_container -d -p 3000:3000 -p 8086:8086 --shm-size=2g myapp
```

**SB**

We are migrating to SeleniumBase and its looking great so far!
There are some minor changes that I need to address, including the display issue but its looking great so far.

**Gentlemen**

Finished the whole netflex tv show, it felt like a perfect mixture of a TV show and a movie.
The classic Guy richie flow, a great way to setup the characters and overall storyline too.
I am excited to see where he goes next!

**Taxes**

Just when I thought I was done with Uncle Sam, I am about to find out that I owe them even more money, ugh.
The worst is not having the right calculated cash flow set aside and then having to sell assets to cover the liability.
Those sold assets will also trigger another tax cycle next year, its starting to get rough out here.

## 2023

- 8:00am - I am slowly getting back into the flow of the EST time zone! Today was a bit slower day as I had a couple personal issues to handle.

- 2:00pm - Going to take a break from programming and play some video games, I am thinking of heading back into Ascension and playing my duo-shadow bear tank build! The World of Warcraft private server is really great for just taking a solid break and getting into that fantasy brain rot of smashing buttons and eating elves lmfao!

- 5:00pm - About to head out to car shop for my father because his SUV is about to reach its end of life. It is a bit weird to look at ICE vehicles after operating a Tesla for a couple years but he needs to move cargo around all day and does not feel comfortable yet with an electric mode of transport. I was really hoping that a 500 mile Tesla cyber truck at $40K would be on the market by 2023, but it seems that might be too far away from reality and his car is definitely going to die off before we get a chance to get him that. Our current strategy is find a mid-size SUV that is pre-owned within the past 2-3 years and has a solid history. The main car in our scope is the Acura RDX from 2020-2021 and decided to test drive one of them today. The car is smooth but the kick is a bit slow for me, I am too spoiled with my adult go-kart to even think about going back to this style of driving.

- 7:00pm - Time to refractor and start the register widget. I am going to go through the repos and servers, doing some general security updates and backups. It looks like my ansible scripts are doing a great job at keeping a rotating cluster of SQL databases, including storing the backups in multiple locations. However the `MongoDB` area is a bit rough, it looks like the backups might have failed, so I guess I will have to spend some time fixing those up tonight.

- 9:00pm - Going to read up on the patch notes for the new Astro version.

- 10:00pm - Updating to Astro v2.5.1 and a couple other packages as well for the main website. It looks like most of the updates will not impact our website and the local build was a success, so I will go ahead and push everything all the way up to main. While I am doing that, going to throw up some quick WoW and maybe a league match in a bit? Hmm.

## Quote

> When you reach the end of your rope, tie a knot in it and hang on.
> — <cite>Franklin D. Roosevelt</cite>

---

## Tasks

- [ ] None Today! Chill day!

---
# May: 21

> May 21st - my Daily VLog! Just kidding!

Source: https://kbve.com/journal/05-21/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### KBVE Homepage Update

-   12:08PM

    I am going to reverse some of the fancy video and hero styles and aim again for just straight 100 on lighthouse.
    A full 100 across the board for it would be amazing, and I think that I could get away with it, if we can do some smart moves ahead of time.
    Deferrals for the javascript and freeing up the main thread will be our first goal, but I am positive that the adsense will definitely hurt us in the long term.

### Deferral Scripts

-   01:29PM

    The next move for today will be to focus on getting some of the deferral scripts that we need to implement.
    This is a core improvement in terms of speed but also helping with the main thread issues we been facing when running some games.

### Tower Defense

-   02:40PM

    Major refactor of the tower defense arcade is next, I am thinking of modularizing all of the code.
    This way we can maybe come up with a creative way for the agents to add more units, cards and concepts into the game?
    There was this idea of having special wave battles after each 10 turns, then there is the other idea of having multiplayer.
    If we can get a solid pipeline setup, I might be able to quickly build a small multiplayer server that only uses about 50mb of ram, and offset the CPU usage.
    We could even go further and integrate it with the Discord SDK too, since we are not really using any shared workers, allowing us to play the game via discord.


###


## 2025

### NVDIA Drop

-   02:02PM

    Crazy day for the market, I was not expecting a pull back this fast but here we are.
    This gives me time to buy back all those covered calls that I sold earlier.

### CapitalOne Bank

-   04:00PM

    It is time for me to open a new bank account, as I am going to need one that makes working with India a bit easier.
    I am thinking for tax reasons, to move all my India related transactions into Capital One.

### GSAP Free

-   06:24PM

    GSAP library is now all free at version 3.13!
    This is great because I been really wanting to use the library but did not want to pay for it.
    Good work on webflow for helping them get it all out there.

-   06:44PM

    Updating the GSAP MapApp for the front page of KBVE.com!
    The goal would be to create a cool storyboard ui style, a bit like a comic book meets a visual novel style approach.
    Spent way too much time trying to get these animations to work right within a factory style, hopefully its worth it in the long term.
    I feel like AI is great at getting the very basic MVP up and running, but has a hard time getting the animations and creative flow going.
    So I guess that is good news for future web devs, start moving into animations and 3D effects because thats where the future is.

-   09:09PM

    Going to loop back around and restructure the store so that its a bit easier to reference.
    I was thinking that it would make sense to use the UIUX within the worker to do this but since this is all experimental, it might not be worth it.
    If the animations do not work out within the next couple patches then I will have to move on to something else.

## 2024

**Docker**

Nothing says a great morning like starting up the day with a docker instance!

Instead of writing the notes out here on how I fixed it, I think I will get into the habit of updating the documentation around the Docker problem.
This time it was migrating over to the buildx platform, which now that I think about it, ugh it does make sense why this is now part of docker.
The whole ARM / x86 situation is rough for us developers but it keeps food on the table.

When expanding the buildx documentation, I did not include a working step by step example of building ARM+x86, I think I will do that when I mess around with rust again.

The updated shell for a quick reference:

```shell
docker build . -t myapp && docker stop myapp_container && docker rm myapp_container && docker run --name myapp_container -d -p 3000:3000 -p 8086:8086 --shm-size=2g myapp
```

```shell
docker logs -f --until=2s -name myapp_container
```

To clean the docker workspace up:

```shell
docker system prune all -a
```


This should become a tool that we can use in the future, making it easier to manage the container as well.

In the dev cycle, we could pull the most recent "dev" branch and then do docker build test cases for it?

**4:34PM - Daily Scope**

All of the general dockerfile cheatsheet information has been updated!
I still need to go back and redo the setup guide for Docker, but that will be for another time when I am also doing it.
This means that I need to also update the logos on the main website to reflect the changes to the documentation.

Okay so instead of the random company logos that are on greyscaled on the front page, we would just replace them with SVGs of the different application documents?
This way they would provide a quick and easy access point to our website's information.

There might be a better way to keep track of the journal, part of me feels like I should extend out the timestamps but then it would be way too much information and make things a bit boring.
I could twist and turn as my mood feels, I suppose.

**Cafe**

A trip to the caffine man is much needed, the question would be if I need any more red bulls or a change of programming location?

**Python**

These are additional personal notes regarding the minor updates to the Atlas python library.

Hmm, I think we can remove the `pyvirtualdisplay` and try to grab the display, `x11` directly from the python script and see if we can work around that.

**Chrome**

The joys of chrome! Going to update the PPA to use Roberts latest version, which is currently sitting at 124.
Nevermind, still getting wild chrome errors, ugh!


## 2023

- **1:00pm** - I woke up late today :C
- **1:30pm** - After getting my thoughts and mind ready, I hoped onto fixing up the CSS a bit more for the search. I was able to grab the Iframe but have yet to apply the custom CSS into that frame but from my understanding that I will not be able to do it because of security issues, i.e the external server is a different domain (since its on Google.com) and the results are on KBVE.com, which would mean cross origin errors. The only other solution I could think of was to just replace the whole search engine when switching from dark / light mode? We could do that within the Search.jsx file and by checking the localStorage for the current skin settings. This might be the only optimal path or finding a color scheme that would match both the dark and light mode theme. I do like the idea of not having the ads blend too much into the search content, but rather make it known that these X ,Y and Zed results are a form of Advertisement. As for the usage of the engine? We are already hitting around 100-200 pageviews/searches per day as of right now but I am sure as we add more features and concepts, it could grow into something a bit more unique for a certain type of people. One of the extensions within the search that I been looking into was trying to remove the bias weights that google assigns to each user when conducting a search. The goal of that concept was to aim at having similar results across different accounts within the same region.
- **2:50pm** - Need to prepare myself to do some lawn care, so I think it be wise to take a quick break from the general flow of programming and get some generic exercise. I might even wash the cars really quick too, damn I am starting to get those `father` vibes, next thing I know, I will be complaining more about my old age. I low key still want to be a crazy old grandpa, yelling at random people, it is truly my meme spirit animal.
- **3:00pm** - The integration of GPT based search engines would be great but I am bit lost on how I should do it from both the backend and the frontend. I think the best approach would be to slowly add a couple generic GPT engines from 3rd parties as the backend before focusing on our own version. At the same time, we could then look at the UX/UI from the front end?

## Quote

> Let the future tell the truth and evaluate each one according to his work and accomplishments. The present is theirs; the future, for which I have really worked, is mine.
> — <cite>Nikola Tesla</cite>

---

## Tasks

- [X] Minor tweaks to the CSS.

---
# May: 22

> May 22nd - 22 Guns.

Source: https://kbve.com/journal/05-22/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### New 404 Page

-   03:21PM

    Adding the new 404 page and then going to loop back around and finish some of the other issues that we had!
    I believe we had an issue with the rareicon game window too but I will look at resolving that soon.

-   05:30PM

    I will keep the lottie design and move forward, need to get the discord page up and running next.
    Since we already have 2-3 versions of it, I will just merge them all into one.


### RareIcon BrowserApp

-   12:40PM

    I want to make sure that RareIcon "BrowserApp" works on the main KBVE website, then I will migrate it over to the RareIcon domain.
    Now I need to handle the bridge without having too many issues when it comes to the flexbuffer, which will be another painpoint to handle.

### Discord Page v3

-   07:20PM

    Finished rewriting the new discord page, it looks solid for now and maybe we can do some more updates later on!
    I am enjoying the updated

-   09:56PM

    Website deployment! The new website is being deployed and there will be some issues that we will have to resolve.
    The second issue is with the Lenis scroll script, so I am pushing that up right now.
    While that is being resolved, the first issue was the missing PWA configuration file, that is already sent out and the new KBVE site is being built as I write this.
    Let me queue up the next site patch, hopefully we can get this all resolved before the end of this week.

## 2024

**Docker**

Updated the Docker notes and added some quick tables.
I believe make a tool that could generate simple docker scripts and maybe one that can help build docker composes would be great!
This would a bit of complex tool to build right this second, but I will start mapping it out once I get a better feeling for python.

Okay! Added the github action to build atlas, which should execute on the `main` push.

With the `atlas` being released under this [link](https://hub.docker.com/r/kbve/atlas)


**GUI**

The next part of our adventure will be to be to connect our WASM build to our docker image!
There are a couple ways that I am thinking of handling this, we could have the python script display a small box that shows the internal server is running.

Wait we can just drop the GUI! I just got the perfect idea, we could just have the default application open chrome and load our website.
This way we can just have our website host our front facing application?

Hmm, let me see if I can setup a quick test case for it.

We want the image to talk to atlas directly without having any issues, hmm, maybe we have it go to the dashboard upon loading?

While the main branch is building, I wonder if we could extend out some example buttons to provide for Atlas.
Actually, while the Atlas loads the dashboard, we could pass somthing through the url?



## 2023

- 9:00am - Getting ready for the markets to open and going to sell some weekly calls. I am currently looking to get rid of my [$SPY](https://kbve.com/stock/spy) at $415 and a couple hundred TSLA for around $200 this week. The premium for it all was around $1000 that I will collect for this trade, which I do not need right now, so I am going to put them all into $O, which ended up being around 16 shares. Those 16 shares will now make about $4.08? a month in dividends and if I include the cover on the $[O](https://kbve.com/stock/o) shares, then its closer to around $4.25 a month. My goal for this year is to get $O to make around $1000 a month in dividends, afterwards I will try to get $[STAG](https://kbve.com/stock/stag) past $1000 a month in dividends. 
- 11:00am - I am currently rebuilding the [Portainer](https://kbve.com/application/portainer/) eco-system and having all my laptops and desktops connected to its edge system. The goal will then be to deploy web scrappers onto those edge containers as a test case.
- 12:00pm - I had to rewrite the City Vote scrapper a couple times to get the hang of constructors, specifically those that operate within the scope of A sync inside of JavaScript. I am a bit rough in the Nodejs department, so I think its time to do some practices.
- 4:00pm - Looks like my $SPY are going to get assigned today for $415 a share, which is fine because I will then write a $415 put and collect another premium tomorrow.
- 5:00pm - My docker eco-system on Windows has been running issues after a recent update and it seems to be because I also had rancher desktop installed. The rancher desktop had changed my default WSL settings to its own ubuntu instance, which had caused issues when docker was looking for its own instance. The solution was to remove rancher and all instances of WSL, then re-install [docker](https://kbve.com/application/docker) again.
- 6:00pm - It looks like coolify does not automatically deploy the newest updates, thus I will have to find a way to setup an automated deployment or see if there is a custom plugin out there that could do it for me. 
- 9:00pm - Taking a break, playing some league and watching Barry! The final season of the show is amazing, the plot thickens and overall its been an amazing show. NoNo Hank has been absolutely brilliant!

## Quote

> Think as a wise man but communicate in the language of the people.
> — <cite>William Butler Yeats</cite>

---

## Tasks

- [x] Updating Portainer Eco-System
- [x] Capital Refactoring for Q4 2023

---
# May: 23

> May 23rd - 2 to the 3.

Source: https://kbve.com/journal/05-23/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Astro KBVE Build Preview

-   04:40AM

    Adding a quick build preview command because it would make more sense for us to do it that way since we are not getting errors.
    The classic works in `dev` but breaks in `production`, I suppose we can use astro tests to figure that out as well but that will be after this bug.

### Dice Fiber Problem

-   04:51PM

    The biggest issue that is breaking the kbve website right now is the react fiber!
    I am thinking its just an issue with how Astro and React are handling the client side code and its becoming a pain point.
    I decided to drop my rating for Astro to `8.7/10`, and its slowly reaching that B tier, which is a shame.

-   05:06PM

    Maybe we nest the dice into another component using a reference point and calling the fiber directly.
    I am not too sure if this is because of react `19.1` or if something in our library is missing, hmm.
    This is a bug that might just not be worth it for now, so I will just leave it as an endless spin for now.

### KBVE v3 Website Deployed

-   08:02PM

    Okay, the website has been deployed further and we got the shared workers operational, at least from what I am seeing for now.
    Since tomorrow is the Unity meeting, I figured it would make sense that we shift focus back towards the ItemDB and get that setup asap.

-   08:10PM

    The ItemDB will just be the `/itemdb/` + `$name` and we can just build it like that, making it easier to reference.
    Now how we build the zod for the itemdb will still be an issue that I need to resolve, ugh.

## 2024

**SCAR**

I was thinking about the different ways that we could handle the plugins within our library.
We want to make sure that there are a couple open source plugins that people can access and use without any costs, this will also make it easier for future developers to build their own plugins.
Yet we also want to make sure that there is a way to provide these users with a plugin store, ideally one with premium software too.

Now the question is how would we go about offering the premium plugins?
I am thinking that the two main bindings that we can offer would be in C and Rust, then a third option for just straight Python.
As for Javascript, since it is integrated with the website, we could just work that into the mix at the client side. 

I have a basic idea for the plugin shop in the my head. 

**TailwindCSS Buttons**

We still have a bit of ways to go with the next generation of buttons.
I started to mess around with a couple proof of concepts earlier in the day!

**Home Page**

Let me update the SVGs on the front page of KBVE, replacing the random company logos with something a bit more fitting, maybe a reference to our documentation.
The five svgs for the front page will be a direct link to our notes.
Furthermore, we will be removing that featured image for now until we have something worth wild to place there.

## 2023

- 6:00am - I got the notification of the $SPY assignment, so besides getting ready for the market, I need to do some quick workouts. I might take a nap because I am tired doe!
- 9:00am - City vote does need a new website, layout and a general sense of direction. The best move to make would be to get the initial foundation and business plan laid out. The scope of the plan should include the basic cashflow, growth and purpose of the website.
- 11:00am - Rebuilt my scan setup, with the files being automatically stored into Google Drive. One of the other areas that I was looking into was setting OCR, so that every file that I scan would automatically generate a document with OCR. The problem that I was facing right now was getting it to perform a bit better? It would have some issues with characters, even though they were printed? This means either the OCR software is a bit outdated or maybe I need to create an All in One / AiO type setup. I think after I finish up the Cityvote and have a bit more time on my hands, I will have that be my next project, an open source OCR software that uses multiple libraries and some machine learning to get the based position markdown output from any document and/or image. 
- 3:00pm - I will be looking through, reading and learning how to build async constructors in JavaScript for most of the night. Boring!

## Quote

> There is a wisdom of the head, and a wisdom of the heart.
> — <cite>Charles Dickens</cite>

---

## Tasks

- [x] Help family member with Medicare.
- [x] Lawn care.

---
# May: 24

> May 24th. Journal of Information.

Source: https://kbve.com/journal/05-24/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Weekly Unity Session

-   07:59PM

    Another great unity session!
    We are tackling the NPC issue and making sure that the entities we spawn will go ahead and start attacking the player defensive structures.
    Our goal would be to then to eventually move on to loading and building the items via json from the Astro.
    The current plans are:
    
    1. Build ItemsDB within Astro then load each of the items into Unity
    2. Build a NPC Prefab Pool of monsters that would build into the "NPC Wave", similar to gears and call of duty zombies.
    3. Add PGC with hallways and prefabs, extending the map out dynamically, so each play through wont be exactly the same map.

    After we get those three out of the way, we can start to focus on the farming and cooking skill.
    Once those skills are done, we can do blacksmithing, which will go into the creation of ammo and then alchemy, which will go into the creation of the potions.

    This should be enough to help us move towards a steam demo.

### Baker Issue

-   09:56PM

    Resolving the baking issue with the data not being saved in the right folder, now it updates it within the right asset location.
    Now I am going to try and resolve the item loading before the next meeting, thus making it easier for us to start the initial stage of a steam release.
    I am super excited because once the updated item build system is in place, I can finally start to import the 100+ items without having to worry too much.
    As for the dialogue and storyline, that will be also interesting to build out but will require some time to plan out. 
    How would we go about doing the quests, I suppose they will be straight forward simple ones from the start?!

### RareIcon v0.3 Build

-   10:15PM

    While waiting or the updates to be processed, I will go ahead and begin a passive build with the recent updates that we finished today.
    Actually I am not too sure if the builds would be ready, I will have to double check the scene and see if there were changes made to it.

## 2024

**API**

Preparing the API keys and the plugin shop!
The API key will be important for both KBVE and the ATLAS project, now the question would be the best way to implement them.

I am thinking that the API Key would be the AES salt and that we store the Argon2 hash of the key?
This way we can create an environmental vault that the user would encrypt with their API key before sending it over to the KBVE API for storage.

I will continue to map or graph out the way we would do it.

**Atlas**

We can extend out some of the `khashvault` storage variables, I am thinking of adding a couple new ones that will help store the messages from the fastAPI that is running inside of the ATLAS.

I would have made more progress with this system but there have been problems with handling the state management, including the process of grabbing information and rendering it again upon update.


## 2023

- 9:00am - It's hump day! Time to get cracking at the general vibes of Memegramming. 

- 3:00pm - Time to crack the fingers and get into the full programming flow! I think I will do a quick rush of getting all of the scrapper running and at the same time, do some quick unity too!+

- 4:45pm - Going through all the unity files and decided that it might not be worth the time to update the packages. This would just break a couple of the core features and concepts within the game, which we do not want to do right now. While it is great to have some of the plugins handle the character model, world building, ect.. the draw back is that their updates have game breaking changes and sometimes it is a pain to fix through them.

- 7:00pm - I will start to go through and break down two specific file types, the first will be the GlobalValue.cs and the other will be the PlayerStats.cs. My first train of thought would be to see exactly how the player model is currently reacting within the environment and how it is setup within the whole game. I suppose one additional area would be to see how the character reacts with an online API, however I will make sure the game can be played without having the need to use an active internet connection. 

- 9:30pm - Okay besides AppWrite

## Quote

> Where there is charity and wisdom, there is neither fear nor ignorance.
> — <cite>Francis of Assisi</cite>

---

## Tasks

- [x] Take out trash
- [ ] Finish Unity API Login - Not Done, pushing it till next day.

---
# May: 25

> May 25th. Dat Long Weekend Doe.

Source: https://kbve.com/journal/05-25/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Unity Salmon

-   03:33AM

    Getitng closer to setting up the astro collections to unity workflow!
    The base of the script is done, now we just need to tweak around the movement of data between the astro collection and the unity game.
    A bonus will be integrating the same logic into phaser as well, then we got the same items across both engines, damn if we get the godot going, then its perfect!

-   05:03AM

    Updating the sorting layer and we are now getting somewhere with the different items!
    Still need to finish the addressable assets, which I will start doing now.

## 2024

**API**

After mapping out the API for the front-end, I am thinking that we can start with a small script that will help us out with moving the logic around and then we can rewrite it again later on?
Writing a rough POC and then rewriting it again later as a MVP, seems to be the best approach as of right now.


**GameDev**

I hate game development because it takes so much time to debug random bugs. 

## 2023
- 8:00am - @h0lybyte I am going to have to sleep again, my brainfog is way too heavy. However the insane jump in stock value for $NVDA was wild! Watching some people turn 10,000% - 20,000% profits from trades has been insane to watch. So many lottery winners but I am sure that the price will crash a bit down once those contracts get exchanged and settle by next week. 
- 9:00am - I was laying down on the bench and thinking about the future of $NVDA. The company will continue to benefit the most from the AI revolution, they basically got to ride the crypto wave and now are getting another jump from the mainstream push of mL
- 3:30pm - @h0lybyte Fixed up the journal a bit! I am thinking of making it so that there is just one entry per each day. This way when I keep doing the daily journals, after a year, I can always come back and see what I wrote in the past, basically a year ago! This is still a creative way to doing the journal, but I wanted to add my own twist and turns into the mix.
- 3:45pm - @h0lybyte Another concept that came to my mind was adding a bit of a visual novel abstract layer to each of the entries. So that instead of reading them all as a boring webpage, I could extend it out into its own unique journal. The only logical step afterwards would be to hide prizes, gifts and concepts into the journal entries for the fans/viewers.


## Quote

> The more light you allow within you, the brighter the world you live in will be.
> — <cite>Shakti Gawain</cite>

---

## Tasks

- [ ] Restructure Unity login API.
- [ ] Rebuild the journal entry format.

---
# May: 26

> May 26th. Where is my brain? xD

Source: https://kbve.com/journal/05-26/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Unity Custom Item Script

-   01:23AM

    The custom item deployment script is almost ready and afterwards we can work on the custom item effects.
    With each prefab that gets deployed, we might have to adjust how we go about the actual deployment too.
    I am thinking that we might use a vcontainer setup, similar to how we are deploying the prefabs.

### Starlight Graph

-   02:09AM

    The graph seems to fail on view transition, so maybe we can find a way to reset it.
    Here is the snip that I used to for reloading the plugin.

```js

document.addEventListener('astro:page-load', () => {
    const graph = document.querySelector('graph-component');
    if (graph?.setup && typeof graph.setup === 'function') {
      console.log('[STARLIGHT] Re-running graph setup');
      graph.cleanup?.();
      graph.setup();
    }
  });

```

    This should run the graph after each view transition.

### WishList RareIcon

-   03:08AM

    Sweet, just made a dope wishlist button for rareicon, which will be op.
    For marketing reasons, I should also start building out the markdown codes to quickly add around in discords.
    I should also start preparing the main website for game too, ugh, so many things that I need to do before the game is even ready.
    Collecting wishlists will be rough but I think I will be able to get it out of the way, I can see us reaching around 1000 wihtin a month but past 10k is going to be rough.


### ItemDB

-   05:05PM

    Without having github being down and slowly me to a crawl, I was able to get a couple more of the concepts out of the way.
    The assets now get stored into the addressables, which will make it easier to call and deploy them.
    We still have to do the pool integration and making sure that they can be added and consumed without any draw backs.
    For this, I will have to build the right "stats" component, maybe even extend the more mountains to include the stats and bonuses, hmm.
    There are a couple ways that we could go about this, but I believe damage reduction would be the most important.
    The balance of power creep is always going to be a pain moving forward.

-   06:23PM

    Now we need to figure out the best way to link the stats from an item and the character, hmm.
    We should make it so that items could also be used by NPCs but that will be for a later time, as for now, we can just focus on the characters.

### MM ExtendedHealth v0

-   06:31PM
    Taking the `MoreMountains.TopDownEngine.Health` component and then extending it out as a "HealthExtended", which will then hold the full scope of stats.
    This means we can easily apply those stats to different structures, NPCs, players, ect.. without having to reinvent the whole wheel.
    The stats will be stored under a `StatsData` which will include the mana, energy, stamina and any additional stats.
    As for effects, I believe we could also store them into this component, since it will already be running through a tick base system.

-   10:33PM

    The next update to the system will look like this below but before I can really break it down, I should focus on creating the first couple files.
    These will be scoped to the specific areas that I want to resolve.

```mermaid

graph TD
  A[Prefab Spawned via VContainer] --> B[CharacterHealthExtended]
  B --> C[Injected with TickSystem]
  C --> D[Registers ITickable with TickSystem]
  E[TickSystem as Singleton] --> F[Runs Tick Loop Every Frame]
  F --> G[Calls ITickable.Tick with deltaTime]
  G --> H[CharacterHealthExtended.Tick]
  H --> I[Regenerates Stats with mana, stamina, energy]

```

    



## 2024

**MTG**

Meeting up to play my trump deck!
I did not get a chance to turn it into a commander deck, but I will do that in June!
Ugh, summer is already here? Time is moving way too fast.


## 2023


- The time stamps are a bit messy for this note because there were a couple failures during the migration to the newer journal system. 
- The Asynchronous loading seems to be working fine within our first test case inside of Unity but it automatically replaces the cut scene window. So I am thinking we need a button within the loader that the user presses again to go to actually enter the level, I am thinking of calling it `Skip` or `Next` which will be disabled initially on load and then enabled once the asynchronous function has loaded the next scene. 
- Besides spending time on the Unity project, I decided to go back into the rs project which I believe I will go ahead and end for the time being. I will return to that aspect once I get a couple concepts clear up from my plate. I believe that I am spreading myself a bit too thin for the current amount of work and backlog.

## Quote

> I have not failed. I've just found 10,000 ways that won't work.
> — <cite>Thomas Edison</cite>

---

## Tasks

- [x] Test case the asynchronous unity loader with the visual novel cut scenes.

---
# May: 27

> May 27th. Tony Reincarnation.

Source: https://kbve.com/journal/05-27/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### 10th ItemDB

-   05:51PM

    The 10th item was added into the itemdb!
    Actually we could be close to hitting that 25 items before the end of the week, but they still need to be polished and fixed up.
    I believe it would make sense to get a decent cluster of basic items added into the game, then we test them out and loop back around for any adjustments that need to be made.
    One issue that I just realized was that the tick system might have to be adjusted for not just damage but for crafting and farming, so a skill tick.
    I will have to adjust the schema for the different item classes, not just the drop rates and rarity but also what those items can repair and utilize.
    While expanding the item library, I should split the notes on the development from the unity side.

-   06:30PM

    Item 12! The Air Fryer!
    I should expand the recipes on KBVE and integrate them directly into the game.
    The company that will be creating this air fryer will be `Krispee`, the perfect name for a future air fryer company lmao.


### 14th ItemDB

-   07:26PM

    Next item to add will be the one that might help with the lighting, skull candle?
    Lets go ahead and ship something similar, ah wait bees too, okay that will be item 15th, aka hive and 16th the bees wax. 

### 16th ItemDB

-   08:44PM

    Bees Wax!
    If I can get the production of items even faster, than we could easily hit around that 100 items goal within end of june.
    Anyhow, I am going to try and filter through my whole list, looking for as many items that I can think of and add into the game.
    I will try to also link them ahead of time, so that they will not be all over the place, forming a bit of a logical chain.
    This will make the automatic integration of them into the game even easier.
    The bees wax will be used for the candles and medicine for now, I will try and expand it out for other things later on, maybe like weapon stuff.
    Oh besides medicine, I should use it for soap too, hmm okay but that will be for the future.

### ItemDB Use Integration

-   05:57PM

    The item prefab creation is good to go and we have it insert into the asset database, but there is still a decent amount of work to do.
    I am thinking that it be interesting if we could wire up a placeholder for the Steam / Multiplayer while we deploy the orchestrator.
    These are just notes for myself, I will loop back around to them incase I forgot the flow.

## 2024

**Python**

I am still trying to figure out the best way for me to run kubernetes!
A part of me wants to run the kubernetes , aka a k3s, inside of the Atlas docker image but that might be too much work.
I could integrate the portainer cli and maybe have atlas make calls to any docker instance! Hmm, so many options and yet so little time to figure them all out.


**SCAR**

Even if we get SCAR setup, it might just not be worth it, I am thinking of skipping that part directly and focusing on automating some of the chrome-based things.

**OVH**

It looks like our OVH dedicated server is reaching its max size!
I am going to have to either upgrade that dedicated server or wait until the contract runs out?

Actually given that we moved the majority of our main database to PlanetScale, we might not even need this dedicated server.
Hmm, the contract ends in December, so we have some time to renew and maybe ask for upgrades.

## 2023

- 9:00am This was a rough Saturday morning as well, I might have to start sleeping a bit earlier because it is definitely getting a bit too late.
- 10:30am - Finally bought my cooking skill cape on `TwitchKBVE` on OSRS and started to look into certain profit makers for the account that I can do while I am afking it. ;)
- 3:00pm - The major focus for the day will be getting the CityVote scrapper to be functional under a new docker container that uses the Node-Python as a base.
- 11:00pm - I am thinking of trying a new main support because of Shaco bans, I tried Senna but she really was not my play style, so I am going to pickup Sej again! She plays a bit different from the rework, I do miss the stack of ages build on her. Back then you could have like 3-4 Rod of Ages stacked and have a ton of AP / HP / Mana over the course of the game.

## Quote

> Make it a rule of life never to regret and never to look back. Regret is an appalling waste of energy; you can't build on it; it's only for wallowing in.
> — <cite>Katherine Mansfield</cite>

---

## Tasks

- [x] Migrate to a NodeJS/Python development environment.

---
# May: 28

> May 28th. Tony Reincarnation.

Source: https://kbve.com/journal/05-28/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2025

### Nvdia Earnings

-   11:55AM

    I am cover calling about 500 shares this week, with the strike of $145.
    My guesss will be that the ai chip bans will be a concern but long term they will still growth within the ai field.
    Even if LLM is going to slow down, the audio and video realm is still all open season.

### Flat Tires

-   01:58PM

    I noticed a drop and going to go get a quick patch before I just change them.
    My whole set is messed up, I got like three different brands on my car right now, damn nails.

-   03:52PM

    After getting it patched, I should make this an item in the game as well.
    We are really just making as many random items as we can at this point haha.
    This will be key 24 in our goal to hit 100, I might even try and aim for 1000 items.
    The crafting system will be interesting for this, but should not be too painful, actually I wonder what 100,000 items would look like in this type of system.
    Just a crazy level of crafting, just constantly able to build new things and deconstruct into new items.

### Tick System

-   02:00PM

    The tick system has to work with the characters, items and deployments.
    While the current more mountains system is coroutine focused, this will make scaling a bit of a pain.
    I am thinking that event and global tick should help.


### Item 25

-   05:33PM

    About to add the 25th item to the collection, just trying to keep a solid record of how long it takes to add each item.
    I am currently looking at a way to streamline the core item production, but a part of me just loves the creative side, gah.
    Maybe I will try to aim at around 2-5 items a day, then focus on the direct integration, this way I do not have a huge backlog of items or burn out.
    This is going to be the portable battery back and we can follow it up with a power cell afterwards.
    Portable power pack will have less wattage output but provide the ability to quickly be moved around, whereas the power cells will have less stats but more power storage and output.


## 2024

**Python**

More test casing on the loading of python modules, but I should finish up the API keys and also launch the resume builder.
The part that I am having a tough time is figuring out the best way to store the data!

I could make the API Keys client-side only, so the user has to copy it from that point and then AES-encrypt the API data with that api key?

It just feels really rough to write out and draw out too.

**Adsense**

I applied again to adsense, but we shall see how it all goes.
We do have all the links working but the amount of content might still be a bit limited at first.

**Tires**

The new Shane Gills show is perfect background entertainment!
I think it was a bit of a slow start but overall, it finds its unique spot, I think 6 episodes were a bit too short and a full 20-30 episodes a season would have been better.
They could easily grow the characters out, even take a break from the linear tire shop and throw the characters into a whacky adventure.

## 2023

- 9:00am - Organizing my personal kanban will be the main goal for the day. I am a bit sad that I wasted so much time not updating and keeping it organizing. I might have to set aside around 15mins a day moving forward to maintain the board or it will fall into a huge mess!
- 11:00am - I set aside a couple main goals for this week, I am thinking of making sure that I expand the tool library on KBVE, with the goal of having over 100+ tools within the next 3 years. After around 20-30 tools, I will go back and organize the tool page to be a bit more straight forward, including categories for developers, webmasters, gamers and memers.
- 1:00pm - Expanded the Coolify and Portainer storage on the main dedicated server because we were running out of space, I am so grateful for the [LVM](https://kbve.com/application/lvm) notes for reminding me how easy it is. The next step might be to create an ansible script that will automatically check the file size for each instance and then make a judgement call to expand the storage. 
- 8:00pm - Listening to Fudster is exactly like injecting cancer cells into my brain. The more you listen, the faster the stages evolve. 
- 9:00pm - Finally got the shiv updated and I have all of the puppeteer running under an asynchronous factory. Now I am going to add JWT authentication and then we should be good to go with building out a basic SaaS-style tool! I will initially make the tool free for users and then add a credit system later down the line. The balance of free tools and paid advance usage will be an art form of human behavior. 

## Quote

> Laughter is not at all a bad beginning for a friendship, and it is far the best ending for one.
> — <cite>Oscar Wilde</cite>

---

## Tasks

- [x] Update the storage on production containers
- [x] Improve the City Vote Scrapper

---
# May: 29

> May 29th. Start of Summer.

Source: https://kbve.com/journal/05-29/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### NVDA Cover Calls

-   03:45PM
    
    Yay! We were able to buy back all those covered calls and honestly, I should have went for a spicy route of $140 instead of $145.
    To be safe, that $140 would be a good move for tomorrow, just to finally unload some of those shares.

### Unity Orchestrator Inventory Item

-   04:47PM

    The orchestrator for the items need to account for stats that might be dynamic, like `fearResistance`, which should affect the `fear`.
    We can test the dynamic allocation of the stats but we also need to render them as well.
    Thus after we adjust for the inventory item part of the prefab but also integrate it into a `uiux` component?
    So after finishing up this basic option, we can switch over to that uiux module to help with displaying the stats and dialogue.

-   06:13PM

    Next update will be for the `ICharacterRegistry` interface that we will then use to help build a singleton that holds the references to the characters.
    Since we have that reference to the characters, it will make it easier to quickly grab them.

```c#

public interface ICharacterRegistry
{
    void Register(string playerID, Character character);
    void Unregister(string playerID);
    Character GetCharacter(string playerID);
}

```
    Placing it under the namespace `KBVE.MMExtensions.Orchestrator.Interfaces`, so that it be easier to reference.
    Now we can build out the next part, which will be the the actual CharacterData singleton.
    Our goal for that singleton will be to find each character quickly at the global level.


## 2024

**Heat**

Oh the weather is starting to get hot and my room is feeling it!
I am in my underwear and staying indoors why my body bakes next to these 4090s.


**Resume JSON**

The schema is located [here](https://raw.githubusercontent.com/jsonresume/resume-schema/v1.0.0/schema.json) and it would make the most sense to use it.
Rather than having to write our own schema that no one would be really using, this would make it easier to keep everything to some level of a standard.

**Astropad**

We can migrate some of the `astro-ve` into the `astropad` library that we will be using down the line.
During this process, we can clean up a decent amount of the plugins and folder stucture to make it cleaner and easier to use.
I will backtrack my dynamic plugin system but keep that within the `astro-ve` and for the `astropad`, we will use a more simple file system.
The plan would be to keep all our tooling and visual components the way they are right now but slowly rewrite them into simple astropad structures.
A good way to think about astropad would be to be a helper library that will eventually be built around starlight.

To start the Astropad, we will run this simple generation command.

```shell
nx generate @nxtensions/astro:lib astropad
```

This will create our boilerplate for the astropad that we can then call and use as we please.

I made some slight changes to the `tsconfig` for the Astropad, hopefully these minor changes will make it easier to import the different tools and components from the Astropad.

**Invoice**

While we are building out the Resume application, I want to migrate over the invoice application into the Astropad.

## 2023

- 8:30am Happy Memorial Day! I did not have any major plans for this weekend, I am still in the grindset mode but my sleep schedule is still a mess.
- 11:00am - Going to look over that Magic shell script that Ziggy found and see if I can add that into KBVE. One of the ideas I was having for it was to integrate a basic GPT into the questions that the user types into the application? So it combines the audio return of yes / no but also gives you a GPT generated response via the typewriter effect. Its a bit tough to describe the product, as I can already see how to build it out within my head. Putting the pieces together will be the focus.
- 4:00pm - Quick league matches with the homies, doing some chores and then going back to updating some of the applications. 
- 5:00pm - One of the things that has been stopping the puppeteer from scraping is anti-bot protections that websites have. So I am thinking of ways of going around it, not for any other reason but science. Within the industry, this is known as the Cat and Mouse game, where developers on both, red and blue teams, are trying to beat each other. 
- 9:30pm - Going to see if I can get a mock version of the magic conch shell up and running! There are two ways I could do the background image of bikini bottom, I could add it into the background scene or I could load it.

## Quote

> Chaos and Order are not enemies, only opposites.
> — <cite>Richard Garriott</cite>

---

## Tasks

- [ ]

---
# May: 30

> May 30th. The Rimmy John of the World!

Source: https://kbve.com/journal/05-30/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Item 31 - Fish Taco

-   02:35AM

    Taking a quick break from the CharacterData orchestration and decided on the next item!
    For id 31, we will do the classic, fried fish tacos!
    Going to push that up now, but damn, I should look into hiring a person to just help me with the itemdb.

-  02:40AM

    The next item will be the "Grilled Fish Burrito" which will be a more complex item that will require some additional work.
    Making these items late at night is definitely a fun way to unwind after a long day of coding, but its also making me hungry, gahh.
    Lets go ahead and throw this up too before going back to the CharacterData orchestration.
    Item 32 - Grilled Fish Burrito.

-  02:51AM

    Next item will be the mexican pizza like clone, we will call it the tex mex pizza.
    Afterwards, I will do some BBQ ribs, burgers and maybe some other cool dishes that I can think of.

-   03:59AM

    Item 37 , swiss cheese and item 38 will be cheddar cheese.
    Actually we should throw in pepper jack too for now, hmm that means we will need tomatoes and a pasta sauce too?
    Damn, all of this cooking is going to be wild, easily get to 100 items from just the cooking alone.

### Character Registrar

-   02:53AM

    While building the next couple items, it would make sense to focus on the unity side again.
    I did not like the fact that we had to hardcode the character event register but its okay for now.

-   04:15PM

    Okay so the registrar loads the first origin character, but it needs to loop through all the other characters that would be added.
    There are three issues that I am trying to address, the first is that we are hardcoding the search for `PlayerID1` , which we don't want to do.
    Second issue is that multiple playerIDs can exist, so it loops back to the first issue as well.
    Finally the third issue is that there are multiple characters per playerID, the goal for the Registrar is to place all that of data into a complete map.
    Eventually we can move this into a rust-based ffi papaya map, moving away from this C# dictionary approach but that will come with other concerns and issues that we do not want to deal with.

-   05:31PM

    In a situation where an additional character loads in or a friend joins a lobby, we need to handle that event and make sure there is no de-sync.
    Thus, we need to include an additional helper.


## 2024

Taking a quick break from Programming and just melting my mind in that sweet sweet baby rays of RM!

Updated journal comes later on.

## 2023

- 9:00am - Going to see if I can sell a couple cover calls and covered puts on a collection of stocks. I am looking to see if I can get into another position on $NVDA , I am looking at $380 puts this week. Furthermore, maybe enter $TSLA at under $190 and $SPY again for under $420.
- 11:00am - Restructuring the AI cloud functions so that we can encapsulate it all into microservices. We are currently running about 3-5 different instances within KBVE but we could abstract out another 10-20 more 3rd party instances, that are then wrapped inside of the KBVE cloud functions. 
- 3:00pm - Woke up from a nap, going to go install a backup camera onto two of the older cars in my family's fleet. The total install cost for two 7 inch backup cameras comes in at around $400 each, I am trying to see if I can get it down to $700 or maybe work out another deal with the guy.
- 5:00pm - The shadow magic conch shell is looking better and better! I should throw up a test case for people to see under the official url of [conch](https://kbve.com/tools/conch/). I hope everyone enjoys the absolute memes that this tool will become.

## Quote

> Friendship, like the immortality of the soul, is too good to be believed.
> — <cite>Ralph Waldo Emerson</cite>

---

## Tasks

- [ ]

---
# May: 31

> May 31st. End of May.

Source: https://kbve.com/journal/05-31/

import { Adsense } from '@/components/astropad';

<Adsense />


## 2025

### Unity ItemDB

-   10:02AM

    Updating the `ExtendedHealth.cs` script to handle the bonus stats from item usage.
    That means we will have to step back and take a look at the StatData script first, including some additional parts that we missed during the first time we created the script.
    There will be three or four variations to the stats, from a flat percentage bonus, to a static bonus via items and also temporary bonus.
    Furthermore the static bonus via items can be a factor of what the player has in their inventory, our goal here would be to encourage the player to build up and utilize the items.
    Wait, even past that, we have to account for the equipment for each character, ah this can become complicated very quickly.

### NPC Orchestrator

-   05:08PM

    This will handle the spawning and the usage of the different NPCs on the map!
    Our goal would be to prepare the NPC MDX, so not only will be able to add items at a large scale, we can also start producing the NPCs at the same rate.
    As for the NPC animation and the state management, both of those can be handled with this system.


## 2024

Got a great idea for a new tool, I figured that I might build it out really quick since I am stuck on the invoicing and resume tool.
The worst feeling in the world is when you can not finish a tool and then you start another tool, and then you dont finish that one and start another tool.
It is like the ADHD programming problem.

Yet I think the key is to find ways to make the different and unique tools work together, kinda like building multiple lego sets but the goal is not to actually build out the final set but rather discover the different pieces that you can make?
Like imagine you have a single 1 by 1 lego piece and then you realize that it is easier to build with 2 by 2 square pieces! Yet sometimes you need to split the 2 by 2 with 4 of the 1 by 1 pieces.


## 2023

- 10:00am - Most of this day will be spent working on the Conch react script but also figuring out the basics of the cloud functions. The idea here will be to isolate as much of the script(s) that I am building and move a certain amount of the logic into cloud functions. I do also want to move certain functions into their own worker threads but that will be something that I can work on later down the line.
- 1:00pm - It looks like we can continue development of RogueJester but at a limited scale, at least until we get a better understanding of the whole project. Starting Monday, we will begin a month of active but slow development. We will be doing about 3 weeks of development currently but hopefully it is enough to get the whole game to at least beta / demo.

## Quote

> Love yourself first and everything else falls into line. You really have to love yourself to get anything done in this world.
> — <cite>Lucille Ball</cite>

---

## Tasks

- [ ]

---
# June: 01

> June 1st. New month, new crimes.

Source: https://kbve.com/journal/06-01/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2026

### Factorio Spider

-   10:38PM

    Working on a quick factorio spider mod, with the goals of scaling it out to other monsters.
    The spider will be part of the KBVE foundation for factorio mods, our goal will be to have around 10 or so mods into our integration cycle.
    Afterwards I am thinking of making a level and rpg system, maybe even include a quest system?
    So many endless options once we get the core loop built out.

## 2025

### Steam Integration

-   08:30PM

    Spent most of the day just finishing up the steam integration and preparing the launch of RareIcon.
    There is still a bunch of work to do, but its a great feeling to start seeing the progress of my first indie game.
    I am excited to build up wish lists and get a fully function game out there into the eco-system!

## 2024

**Mind**

I got 34 reasons to fix the memes, 42 reasons for life and 99 problems. BrainRot is flowing through the airways.


**RJ**

A couple more attempts at getting rough this rimworld challenge but this game got me way too salty, the combat system is too trashdev for me.
I might just have to bump the difficulty down to normal because the starts of this gameplay is way too rough.

**Credit**

While I am at it, need to double check and make the monthly rounds on the credit system.
I find june and december to be those two special months where you want to perform a quick capitalism health check.
Making sure everything is good to go and paid off.

## 2023

- 9:00am - Markets are doing great so far but we shall see how long it lasts, the usual debt ceiling drama always shakes up the movement. I been thinking how many people are generating millions from this uncertain drama, it seems almost manufactured to generate absolute absurd amounts of wealth. These covered calls, puts, err... well the whole wheel system has been doing great in these drama filled markets. Hopefully I can grab another 100 shares of $SPY this month, it would be crazy to see if rally into all time highs while the general economy seems to be in an earthquake fault zone.
- 3:00pm - A quick league session and some general meme gaming as I restructure my time and brain. 
- 5:00pm - I went food shopping and noticed that certain prices have been dropping and cooling off. Part of me wants to start keeping track of the prices of certain core items, like eggs and fruits? Then maybe start to document their prices as a reference! I am sure there are already apps and services that do this, so I felt like it would just be a personal concept, maybe not really worth too much time to invest into it. 
- 8:00pm - Looking through the whole

## Quote

> We should not judge people by their peak of excellence; but by the distance they have traveled from the point where they started.
> — <cite>Henry Ward Beecher</cite>

---

## Tasks

- [ ]

---
# June: 02

> June 2nd. Break Off.

Source: https://kbve.com/journal/06-02/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2025

### Steam Integration

-   05:50AM

    Sent the review in for the coming soon page, which means we can start to collect wishlists by the end of this week.
    Next couple shifts will be focused on just the steam integrations and making sure everything loops together without any major breakage.

-   04:20PM

    The full library will be under the `MMExtensions` as SSDB, which we be a lifetime that holds all our steam code and will be built for just mac, linux and windows.
    As for the spacetime integrations, that part will be a bit rough from the start but I think we could adjust for it.
    The way that we resolve the core issues that might be with steam integration is going to be a bit tricky because I am not 100% sure how the internal system works for friends and cloud saves.

-   11:10PM

    Finished the basic layer of the steam integration, got the lifetime and vcontainer operation, which means that we can move forward with the abstraction + wrapper.
    There a couple things that I wanted to setup and build for the asset.

### NVDIA

-   03:30PM

    Sold 8 calls with the strike of $140 and another 8 are being prepared for $145.
    Going to roll this into finishing up the steam integration.

### R3 + ObservableCollections

-   11:00PM

    Finished reading up and studying both the R3 and Observable Collections , it makes more sense to include these into our game and utilize them.
    This can help speed things up before we add ECS and Burst, oh man I am excited to try these guys out!
    Cysharp is the only reason that I am willing to use unity at this point, they basically are the overlords of these amazing libraries and concepts.

## 2024

**Meme**

Had to take a moment of break from programming, at least to get back into my flow because I am really running into some wild and annoying problems within my docker image.

**Adsense**

Yay! We are officially adsense approved and back on track of getting everything prepared for the Adsense Beta program.

This will be important for generating revenue for our free to play game, something that can cause issues down the line.
We also have a couple other side options, but the main one will be from Googles end because they have the best inventory to offer. 


**RimWorld**

Going to continue to take some breaks from python, its eatting away from my soul.

## 2023

- 6:00am - I was able to get the Conch setup with GPT, now I am looking to setup multiple different models for the user to pick and choose from. I had a bit of a late sleep, if you could even call it that but rather a small nap. I am tired but I am also glad that I got a bit more hands on experience with using Nanostores!
- 9:00am - Before the market opens, I shall take a bit of time to go through my edge instances and start to update the deployments. There are a couple instances that have not yet been updated since late last year, but they were all docker containers that did not have direct inbound connections, thus I was not too worried about them. Some of the major issues during this process was that there was no auto update and redeploying, even through I had watchtower looking over the instances. The auto-scaling seems to be no longer working but that might have to do with the fact that certain containers were degraded, thus I may have to double check my healthchecks.
- 11:00am - I am going to rewrite the cloud function of `6479653d74613fd2766e` and create a completely new one! I am going to stick with the default naming culture for now before creating a bit more of an unique structure. Within the timeline, I want to set aside around 10-20 cloud functions that we can execute within KBVE by the end of the year.
- 3:00pm - Almost had to sell around 400 shares of $TSLA at $215.00 mark, but I extended that mark to next week to $230. Hopefully I can keep the extension going before having to sell shares. Ideally we get a small pull back from the markets but we shall see, that $428 on the SPY is definitely something that I was not expecting. I might try to enter a position in $AAPL next week with a covered put.
- 7:00pm - I started to build out the automated cloud deployments for my functions but there are still some issues that I need to address. Getting the NET Code and Python deployment out of the way might be the most important thing to tackle this month, so I can start to run those functions within the cloud.
- 9:00pm - Reviewed and started to take notes on the security within the cloud function deployment, I believe that the final step would be to integration between a payment / credit system and the the deployment of the cloud functions, then we have a full SaaS system!  

## Quote

> The eye sees only what the mind is prepared to comprehend.
> — <cite> Henri Bergson </cite>

---

## Tasks

- [x] Start learning more about open runtime.
- [ ] Create automatic open runtime deployment.

---
# June: 03

> June 3rd. Atlas Updates!

Source: https://kbve.com/journal/06-03/

import { Adsense } from '@/components/astropad';

<Adsense />

## 2025 

### Unity R3

-   12:49AM

    Starting the r3 integrations, should make things a bit more interesting and reduce the boilerplate.
    After finishing up the assembly defs, I am going to push up some more examples and move test cases out of the unity branches and into the main repo.


### Astro Content Configuration

-   06:42PM

    Going to clean up and refactor them the content configuration, which can be used again to help us with future content management from the MDX level.
    Okay! So a custom types folder that holds everything, which then gets imported and used in the schemas, that are than imported and used in the Astro context.
    This should be the perfect loop going forward.

-   08:38PM

    While we split the schemas up into different files, I need to be careful not to over work it and make each part too isolated.
    ahh.


### Steam RareIcon

-   09:08PM

    Steam just responded back with a terrible message, apparently the RareIcon does not have a solid enough description.
    Let me think through what would be the best way to resolve it, hmm.


## 2024

**Atlas**

After establishing the API, the next step was building out the plugin system and the different ways we can utilize python.

**Music**
I am currently going through about 300 new songs that I need to add into the jukebox.
The greatest part of preparing the next batch of music is that it feels like going through a time machine, when I first listen to chillstep to how I slowly migrated to lofi hiphop.

The real hack is to create a secondary youtube account where you just listen to a bunch of music that you like and then the algo find more songs that are related!
My playlist is filled with new music that I have to listen through each day xD

## 2023

- 1:00pm - All those late nights and lack of sleep has caught up, I am in such a daze. The first thing I might have to do is to double check my server's networking. We spent a decent amount of the late night / early morning going over the different types of networking. The idea was to give local IP addresses to LXC containers but had a bit of a tough time doing so. The big risk with Networking is that it is super confusing unless you have experience and get an understanding of what is actually happening. I honestly rather just let existing software handle this for me, as I consider it all black magic.
- 4:45pm - Going to sync this repo before I begin to update the whole website to a new theme. The new theme is part of the plan of getting all of KBVE up to date across the board, ideally towards something greater! 
- 7:15pm - I am going to go over a couple popular dashboard themes and see if I can replicate some of their unique functions into the current build of `kbve.com`. I noticed that I do not have the best eslint standards and maybe I should look into addressing those issues and see if I can improve my current setup.

## Quote

> Listen to what you know instead of what you fear.
> — <cite>Richard Bach</cite>

---

## Tasks

- [ ] Update Full Website / Migrate to new Flowbite Theme.

---
# June: 04

> June 4th. AstroPad

Source: https://kbve.com/journal/06-04/

import {
  Adsense
} from '@/components/astropad';

## 2025

### Steam RareIcon

-   12:37AM

    The rejection message for the steam store hit hard, but they are right, need to be less focused on the story and more on the game loop.

### AstroKBVE Schema 

-   03:03AM

    Making more changes to the schema for the itemdb, questdb and npcdb.
    Furthermore, I still need to migrate the older content directories over to the new astro template.
    This is making me think that I need another couple versions of me, but I am either too slow or have terrible networking skills.
    Delegating some of the work within this monorepo will be tough.

## 2024

**AstroPad**

Migrating all the extremely old astro components to the AstroPad, then going back and moving in the newer Astro VE and finally moving some of the AstroAzure components into the library.

After these changs, we can aim for a NPM release! Having them all within their own package will make it easier to use in the future as well!

**RimWorld**

I am adding a bunch of different workshop mods and then I will package them into a zip or something like that, so it would be easier to move them around.

Having a dedicated multiplayer server would be extremely cool, so that anyone can connect and play on the instance. Ideally we would want to make sure that the mods do not cause a desync but we could fix around those errors too using python.

Open CV automation for the main host would be really cool but might be a bit too much for the time being.

**Music**

A simple bash script to help automate the edit of the mdx when a new track is found.

We can expand upon it as we slowly build it out but it will help move the process of adding new songs.

I suppose we could have the script also grab the title from the tag by just using curl to grab the youtube link and then grab the title?

That might be worth an update down the line after getting it to work at this basic level.

The way we would run the command would be like this:

```bash

./kbve.sh -nx kbve.com:music --args="--file=edm --title='Fred again.. - Billie (Loving Arms)' --ytid=XqUZcHBsU5I"

```

So if I want to add a new song, then I would so just run this command,

```bash

./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Frank Ocean x Moderat - Chanel x A New Error (Fred Again Mashup Remake)' --ytid=zM0YGiaRfko"

```

Okay, it was able to edit the file with the new song.
Now let us see if it can do it again with another song?

```bash

./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Bon Iver - Perth (JacM Chillstep Remix)' --ytid=BJ1WADbGYIE"

```

Okay so we can have it add songs back to back. Now the next step would be to create a branch for each additional song that gets added?

There could be a couple ways we could go about it. Let me get some quick rest before doing the next couple set. Before I forget, let me commit the other song on my list.

```bash

./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Tep No - Pacing (Elkoe Remix)' --ytid=BA01rTCQ3Bk"

```

Forgot that Elkoe had a Dust bootleg floating around!

```bash

./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Elkoe - Dust (Bootleg)' --ytid=1ty84eT-PAo"

```

<Adsense />

## 2023

- 7:00am - Most of the morning was spent looking into how I should handle svelte within this `kbve.com` repo, but I need to open up Unity and dive a bit deeper into that workflow.
I was able to clear up the invoice for Silver and we should be holding a meeting later today regarding the future of the game.

- 9:00am - Looking over the UI/UX and there are a couple things that we could improve upon, including the mini-map and general flow of information on the screen.

- 12:00pm - RJ Meeting! I will come back to this aspect and update the notes regarding this issue.

- 4:00pm - Going to try the Unity Cloud build and hopefully it will be able to build the application without any major issues.
I will have to look into how to setup the whole Unity DevOps, but from my basic understanding, it looks pretty straight forward!
We might try and have both repos active, one on Github and one of Unity cloud but it might end up becoming a bit too costly to run in the long term.

## Quote

> The person who lives life fully, glowing with life's energy, is the person who lives a successful life.
> — <cite>Daisaku Ikeda</cite>

---

## Tasks

- [X] - Fix the Git LFS / Github build issue with Unity. UPDATE: This task was just removed from our log.
- [ ] - Integrate Unity Cloud builder for RougeJester.

---
# June: 05

> June 5th. AstroPad

Source: https://kbve.com/journal/06-05/

import {
  Adsense
} from '@/components/astropad';

## 2025

### Codex Test Run

-   05:25PM

    Testing out how good the GPT codex is and its ability to operate within a monorepo!
    That means I need to start adjusting the `kbve.sh` or better yet, I could make a new shell script to help bridge the codex changes.
    I wonder if there might be a safe way to handle it, maybe setting up an endpoint for it to communicate through?

### IObject Schema

-   04:25AM

    Updating the schemas for not only the IObjects but preparing them for the observability.
    `IObjectSchema` will be the single source of truth again for the ItemDBs.

### Steam RareIcon

-   05:08PM

    We approved and now have a straight path to success!
    Going to finish some of the schema changes and focus on making sure the editor can create the right quests next.
    Afterwards, I want to loop back around to the UI and maybe de-couple more of it from the scene itself.

-   05:30PM

    The marketing plan to reach over 1000 wishlists will not be too hard because of the friends of friends system, but going into the 10,000 mark will be a pain.
    I am thinking the best way to do that will be to ask if some communities would like to help in exchange for in game items, basically extend the lore out for them to be involved.

## 2024

**Music** 

Adding the `Rock` genre to the jukebox and damn, it is such a pain to label music.
Do I want to include folk or maybe blues, ugh, I will just throw it all into this label for now and move forward.

We want the jukebox to focus on unique and outcast style music, things within the indie nature or music that is tough to find from the mainstream.

The overall goal of the jukebox is not to compete or replace any pandora or spotify, but rather help people find and listen to unique music that would be super fast.

```bash

./kbve.sh -nx kbve.com:music --args="--file=dnb --title='Ray Volpe - Laserbeam (ÆON:MODE Remix)' --ytid=jjoos7UMfe4"

```

Expanding the music collection will take some time but I am enjoying the little bits of adding unique songs here and there.


```bash

./kbve.sh -nx kbve.com:music --args="--file=nujazz --title='Lord Apex - Love Me or Hate Me' --ytid=86ukyi4w6rY"

```

Add in the Yamashita! 

```bash

./kbve.sh -nx kbve.com:music --args="--file=nujazz --title='MF DOOM X Yamashita - Rae Sparkle' --ytid=_b99ARr8Zmk"

```

The next couple songs that I need to add are the:

- Windy Ladies
- Dancer Ain't Nothing , ah found it! Yes!
- Melody Go Round - Also found this one, remastered too, yessir!
- Great Slider
- Air Book - got it!

Command example of adding these songs are below:

```bash

./kbve.sh -nx kbve.com:music --args="--file=nujazz --title='MF DOOM x Yamashita x Tanda - Dancer Aint Nothing' --ytid=qAnNPGUhOws"

```
---

```bash

./kbve.sh -nx kbve.com:music --args="--file=nujazz --title='MF DOOM x Tatsuro Yamashita x Tanda - Melody Go Round ' --ytid=ojGwEt5e44A"

```

---


```bash

./kbve.sh -nx kbve.com:music --args="--file=nujazz --title='MF DOOM x Tatsuro Yamashita x Tanda - Air Book' --ytid=kYu9GLhHme8"

```

So the only two songs that are missing are the Windy Ladies and the Great Slider, I will try to upload those into the KBVE YouTube channel and then come back around and throw them in here.

Oh! I remember this great nujazz style song that we could add into the document.

```bash

./kbve.sh -nx kbve.com:music --args="--file=nujazz --title='ZHU - Paradise Awaits (LCAW Remix)' --ytid=iKW41jbJcWM"

```

Perfect! This way I can continue to work on different areas at the same time too.

Let me add the white flag next :D

```bash

./kbve.sh -nx kbve.com:music --args="--file=dnb --title='Delta Heavy - White Flag VIP' --ytid=3YHNTXYLn8k"

```

Now I am testing the groq.com api to help me generate the commands, just to double check and it is doing a great job!

```bash

./kbve.sh -nx kbve.com:music --args="--file=nujazz --title='Matty Rico - Topic' --ytid=SfgLPHM-hMY"

```

Now there are some changes that I still need to make in the prompt but by providing more examples , it was able to handle it without any concern. 


**Graph**

Updating the Graph MDX under Projects because it might have been lost in a stash.

We can start with adding a basic outline and then add any additional information that we would need.

**Cryptocurrency**

Going to take some time and update the Cryptocurrency section on KBVE.

There are a couple cool tools that I could add into the page but for now getting the most basic information thrown onto it would be the move.

<Adsense />

## 2023

- 7:00am - Most of the morning was spent looking into how I should handle svelte within this `kbve.com` repo, but I need to open up Unity and dive a bit deeper into that workflow.
I was able to clear up the invoice for Silver and we should be holding a meeting later today regarding the future of the game.

- 9:00am - Looking over the UI/UX and there are a couple things that we could improve upon, including the mini-map and general flow of information on the screen.

- 12:00pm - RJ Meeting! I will come back to this aspect and update the notes regarding this issue.

- 4:00pm - Going to try the Unity Cloud build and hopefully it will be able to build the application without any major issues.
I will have to look into how to setup the whole Unity DevOps, but from my basic understanding, it looks pretty straight forward!
We might try and have both repos active, one on Github and one of Unity cloud but it might end up becoming a bit too costly to run in the long term.

## Quote

> The person who lives life fully, glowing with life's energy, is the person who lives a successful life.
> — <cite>Daisaku Ikeda</cite>

---

## Tasks

- [X] - Fix the Git LFS / Github build issue with Unity. UPDATE: This task was just removed from our log.
- [ ] - Integrate Unity Cloud builder for RougeJester.

---
# June: 06

> June 6th. League MiniMap.

Source: https://kbve.com/journal/06-06/

import {
  Adsense
} from '@/components/astropad';

## 2026

### Grass

-   04:10AM

    Grass blades should get updated in chuck rpg.
    Each blade should be 3 floats for position, 2 floats for facing.
    Maybe hashing with its type and group, a cluster of it could be useful when pooling.
    That cluster could be a clump of grass, color too.
    We need to account for tilt, curve and bend, definitely when it comes to the wind.

```cpp

struct FChuckGrassBladePacked
{
    FVector3f Position;    // 12 bytes
    FVector2f Facing;      // 8 bytes, sin/cos yaw or normalized XY facing

    uint16 TypeId;         // blade type
    uint16 GroupId;        // clump/cluster group

    uint8 Tilt;            // normalized 0-255
    uint8 Curve;           // normalized 0-255
    uint8 BendStrength;    // normalized wind response
    uint8 ColorVariant;    // palette/random tint index
};

```

## 2025

### Unity Toast Canvas

-   06:13PM

    The toast seems to be automatically getting injected into the wrong canvas.
    After searching for the VContainer object like a lost sub in the ocean, I finally found it inside one of the zombie prefabs.
    This Means we need to restructure the way that the toast spawns or gets utilized in the scene.
    Since we are already in the UI stage, we might as well just work from there.

### ItemDB

-   08:43PM

    The next item that we will be adding to the database was the spicy nacho dish and I think the quantum coffee, but we can keep expanding it out.
    Ideally we still want to reach that 100 item mark but also make sure that after the UI issue gets resolved, we can loop back around and make sure that the R3 + OC works for each of the item.
    The more practice that I get with the reactive programming, the better it make sense and honestly it should be how every game goes moving forward.
    Starting to split the actual game logic into its own background functions, while the main ui thread focuses on just the reactivity.

## 2024

**League Minimap**

The current tool that I want to finish building out would be to quickly make possible "battleplans" or "battle layouts" using the minimap.
Ideally I would want to include possible placements of wards and even find a unique way to save them and display them to others.

Okay! I was able to get the waypoints to display within the minimap but it seems that they are a bit offset, which might be because of the size of the waypoint itself.
Going to see if I can get ChatGPT to fix it!

Perfect, I had a feeling that it was a CSS issue and it was able to resolve it.

```css

  .image-container {
    position: relative;
    display: inline-block;
  }
  .waypoint {
    position: absolute;
    width: 20px; /* Adjust width and height as necessary */
    height: 20px; /* Adjust width and height as necessary */
    color: white;
    display: flex;
    align-items: center;
    justify-content: center;
    font-size: 10px;
    border-radius: 50%;
    margin-left: -10px; /* Half of the width */
    margin-top: -10px; /* Half of the height */
  }

```

That additional css change resolved the offset, which makes sense considering the w and h are 20, we need to then move it by half that to get the center.

Okay! The next step would be to save the coordinates and then figure out a way to render the waypoint pathing.


**Music**

Training Groq to help me expand the music collection is also another side mission that I need to focus on. 

```bash

./kbve.sh -nx kbve.com:music --args="--file=lofihiphop --title='Post Malone - Money Made Me Do It (Lofi Remix)' --ytid=RltR_yNdZ-8"

```

It still needs help with just returning the shell command, I wonder if I need to be more exact with my prompt.

The next step would be to establish a quick groq api inside of rust that will be able to communicate with the Github actions.
I got this mapped out in my head but building it out, test casing and making sure all the pieces work without any issues will be a bit of a pain.

First we will create the base `ai` folder within the `jedi` package and then afterwards, we can start the `groq.rs` file.
Also, just so we do not forget, we will need to make sure that the `mod.rs` files are editted to make sure everything links up.

We will avoid using the blocking part of the reqwest because we can just take advantage of tokio, at this point it would make sense to focus on building out the basic module.
The initial lego piece will just focus on a basic or barebone restful api communication. 

The file would under `/packages/jedi/src/entity/ai/groq.rs` and we should focus on making sure that the `kbve` package would create a pool of clients that would interact with the Groq API.

To test our package, we can use this command below:

```shell

cargo publish -p jedi --dry-run --allow-dirty

```

It seems there were some issues with this ubuntu container that I was ssh into, maybe I should extend the rust application install / tutorial to include a sub-section to help address the missing libraries.
Yet it does say what libraries were missing, anyhow, I think it would make sense to add the dry run command into the nx, so we can call it almost anywhere.

This will be easy, just take the command that we made for the `kbve.com:music` and instead of calling the `music.sh`, we would just call the command above.

Here is the JSON for Nx to perform the dry run test for us.

```json

		"dry": {
			"executor": "nx:run-commands",
			"options": {
				"commands": [
					"cargo publish -p jedi --dry-run --allow-dirty"
				],
				"parallel": false
			}
		}

```

Afterwards, we will go into the `ci-beta.yml` and have it perform the dry run before adding the branch into the main.

I figured I would do the same with the `kbve` package and making sure that the package can dry run.
It might require some libraries that Github action might not provide, so I will have to double check it.
Based upon my quick search, it seems that the Github actions default runner has the `libmysqlclient-dev` client ready to be linked.

## 2023

- 9:00pm - I messed up the formatting for my notes on 06-06 in the year of 2023. 
- 10:00pm - A general summary for today would be that we were able to finish up / wrap up the cloud build! It looks like Unity was able to build the game, however we still have a couple things that we need to finish up before we could release a working steam demo. One of the core concepts that I was looking into was how we could start the wishlist before throwing together the demo. I should use the word `playbale` lightly, I would say that it does run but most of the crashes are actually just minor bugs and unexpected events, per say.
- 11:00pm - The new login system has to be setup and we need to get that going within the next couple days, so that players could load into the game without having any major issues. 

## Quote

> A single rose can be my garden... a single friend, my world.
> — <cite>Leo Buscaglia</cite>

---

## Tasks

- [x] Complete a windows build.

---
# June: 07

> June 7th. Groqin Lockin.

Source: https://kbve.com/journal/06-07/

import {
  Adsense
} from '@/components/astropad';


## 2025

### Codex

-   02:06AM

    Okay, I am actually positive that we are slowly reaching the end game here with AI.
    I need to focus more on generic prompts and and item idea, then just have it spit it out.
    Maybe a tool to help me quickly build the prompts, or even better we are almost in an infinite loop.

    Here is one of the prompts that I just ran, but there are a couple more that I been using!

```

Inside of the /apps/kbve/astro-kbve/src/pages , look at the other .astro files and can you write me a new support.astro using the tailwindcss v4, I want it all inside of just 1 file aka this new "support.astro" 
Look at the other parts of this app /apps/kbve/astro-kbve/ to get references and maybe you can draw inspiration for this support page? 
make sure to match the color schemes.

```

    The future is going to be crazy.

### Unity HUD Service

-   05:26PM

    The HUD should provide a quick bar for mana, stamina and any other bonuses that the items would give.
    After we finish the HUD, I am thinking we could do the a panel for the character or maybe start doing the crafting?
    We still need to finish the bonus applying and also making suring that items get deployed.


## 2024

**Music**

I am thinking of making it a bit easier to submit music to the jukebox by using the music issue ticket.

The idea would be that the person makes an issue ticket with the youtube link , title and genre.
Afterwards we have the github actions parse that information, change the files within the repo and then make a pull request with the changes.

The actual core of this is to then later expand it into a system of self improving code but we will take small steps towards it.

**Groq**

When calling groq we have three main areas to focus on, the first is easy because it is just the model, which will probably be either the llama70b or mis7x8.
However the other two will be interesting, one is the system, which is basically the prompt engineer and the other is the prompt.

Now I am trying to work out the best way to use these, including how we should handle the prompts.

The next problem that we were facing was the double JSON encoding, which was causing the json to have escapes within it.
Thankfully, this is a common issue and the patch was easy to fix!

The next step would be to go back into the github actions for the music process and update it to use `jq` to process the returned output.

A quick reminder to myself, we still have to add in the middleware for the groq endpoint!
We already have a generic endpoint setup, we can just extend it out to cover all the endpoints, I am thinking of migrating them over to `/ai/`.

**Promot**

Lets take a step back and maybe the issue is not the json that is being returned but rather the promopt that we are asking it do.

```json
{
  "message": "Please read the provided text, extract the required information, sanitize the title, and fill it into the specified command format. The title should only contain numbers, letters, and the characters () . and -.\n\n**Input:**\n```\n\n**Fill out the Form**\n\nYouTube Link: https://www.youtube.com/watch?v=ODXq4FtS-ys\nTitle: Hippie Sabotage - The Best of Chill Music (Mix)\nGenre: lofihiphop\n\n## Human\n\nFor supported genres, please visit [Music](https://kbve.com/music/)\nPick only one of the different genres!\ndnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock\n\n\n```\n\n**Output:**\n\n```bash\n./kbve.sh -nx kbve.com:music --args=\"--file=lofihiphop --title='Hippie Sabotage - The Best of Chill Music (Mix)' --ytid=ODXq4FtS-ys\"```\n\nHere is the template for the command:\n```\n./kbve.sh -nx kbve.com:music --args=\"--file=[insert file/genre here] --title='[insert sanitized title here]' --ytid=[insert YouTube ID here]\"```\n\nEnsure to:\n1. Extract the `File/Genre`, `Title`, and `YouTube ID` from the text.\n2. Sanitize the `Title` to only include numbers, letters, and the characters () . and -.\n3. Only acceptable genres/file are dnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock\n4. Fill in the command template with the extracted and sanitized values.\n\n**Example Input:**\n```text\nFile/Genre: jazz\nTitle: Louis Armstrong - What a Wonderful World (Jazz Remix)\nYouTube ID: abc12345```\n\n**Example Output:**\n```bash\n./kbve.sh -nx kbve.com:music --args=\"--file=jazz --title='Louis Armstrong - What a Wonderful World (Jazz Remix)' --ytid=abc12345\"```\n\n**Your Task:**\nPlease parse the provided text below and generate the command.\n\n**Input:**\n```text\n${{ github.event.issue.body }}\n```\n\n**Output:**\n```bash\n```\nTry to give the output in valid JSON.",
  "model": "llama3-8b-8192"
}

```

## 2023

- 8:00am - The blueberries are slowly coming out! I currently have a couple plants but I am excited to see them survive through the winter and can not wait to have even more in the future. My plan might be to turn all the edges into blueberry and blackberry bushes but getting the right plant genetics is still a bit out of my scope. Maybe I could ask GPT?
- 11:00am - Before getting back into the deep end of programming, I need to do my monthly budgeting and balance sheet. By staying with India for almost two months, I was able to save over a couple thousand dollars! Furthermore, the general market value for all my portfolios have increased across the board, it seems some have made intense gains after recovering. I am looking at those $NVDA shares and I think it might be a good time to exit my position for a while.
- 2:00pm - I am almost ready to pull the trigger on replacing the lottie files on the website with rive! There were a couple of areas that I wanted to read further into but having that cute bear animation for my login form is a definite must! I am not too sure how I feel about going from an open source animation library to something that feels a bit closed off. I might actually just keep both and refine them into a larger library. `Library/Animation/` and then add `Lottie.astro` and `Rive.astro` as the core astro files that I should call.
- 11:00pm - Currently extending out my grandpa's visa for India. I have not yet uploaded a couple days worth of Journals, I will make sure to update them tonight before I go to sleep. The documents searching has taken already a hour or more, I am a bit stressed out in data fetching, going deep into the depths of my storage.
- 11:30pm - The information that India requires for extending out the visa is a bit intense, I can not wait for my grandpa to get his OCI finished, because this is definitely a huge waste of time and resources.
- 11:45pm - I should sync all the notes on my macbook as the battery is slowly dying off, its been on for over 30 hours!
- 11:55pm - Future information regarding the extension of the VISA in India, you will need the proof of visa, passport-size photo, scan documents of passport, proof of residence and the reason for extending the stay. In this situation, I am extending my grandpa's visa because he recently got some medical work done and is not really suited for travel yet. In my request for the extension, I included the most recent medical report and a couple professional-style letters requesting for an extension, including one from a doctor here in the US and a doctor that is from a popular local hospital in India. I figured if I could reference enough people and have a surplus of documents, they would have a bit harder time declining his extension. The goal would be to do this while getting his OCI resolved, so that we will never have to do this visa meme stuff again.

## Quote

> In all chaos there is a cosmos, in all disorder a secret order.
> — <cite>Carl Jung</cite>

---

## Tasks

- [x] Finish Balance Sheet for June and July 2023.
- [x] Finish Grandpa's VISA extension.

---
# June: 08

> June 8th. GHA Time.

Source: https://kbve.com/journal/06-08/

import {
  Adsense
} from '@/components/astropad';


## 2025

### Github Actions Codex

-   03:30PM

    Since codex already places the specific tag on their pull requests, we could just update the label system to read any new tickets that have that tag.
    Then we just place it into the kanban automatically!
    Later on we could have some custom build checkers and linters via the github actions to help double check the code that it writes.

### Clone Hackathon

-   05:10PM

    T3 Clone aka hackathon has started and we got about 9 days to meet the deadline.
    I wonder if Fudster can help us get there!
    I have a couple ideas on how we could approach this problem, maybe we could include a couple helper libraries and build their chat app but have it use unity webgl?
    We could even go a step further and have it use a rust egui build?
    Now I need to figure out what domain that I want to use for this, maybe we could utilize discord ac for it?
    Linking the t3 chat to the discord chat, probably throw in that new embed system too.

### Unity

-   05:12PM

    The unity webgl build is failing and its because its referencing steamworks.
    That means somewhere in the code, I forgot to throw the labels up?
    This is another side quest of debugging that I will have to do to resolve that.



## 2024

**Github Actions**

Spending a decent time on refreshing my mind when it comes to github actions.

Here is where we left off yesterday!

```yaml
    - name: Check if issue title contains [MUSIC]
      id: check_title
      env:
        ISSUE_TITLE: ${{ github.event.issue.title }}
      run: |
        echo "Issue Title: $ISSUE_TITLE"
        if echo "$ISSUE_TITLE" | grep -q "\[MUSIC\]"; then
          echo "is_music_issue=true" >> $GITHUB_ENV
        else
          echo "is_music_issue=false" >> $GITHUB_ENV
        fi

    - name: Stop if not a music issue
      if: env.is_music_issue == 'false'
      run: echo "Not a music issue. Skipping further steps."

    - name: Check for YouTube link in issue body
      if: env.is_music_issue == 'true'
      id: check_youtube
      env:
        ISSUE_BODY: ${{ github.event.issue.body }}
      run: |
        echo "Issue Body: $ISSUE_BODY"
        if echo "$ISSUE_BODY" | grep -q "https://www.youtube.com/watch?v="; then
          YOUTUBE_ID=$(echo "$ISSUE_BODY" | grep -oP 'https://www.youtube.com/watch\?v=\K[\w-]+')
          echo "has_youtube_link=true" >> $GITHUB_ENV
          echo "youtube_id=$YOUTUBE_ID" >> $GITHUB_ENV
        else
          echo "has_youtube_link=false" >> $GITHUB_ENV
        fi

```

Now I am thinking that it would make sense to turn these into smaller composite actions but that might take too long.

The plan is to try and make it as modular as possible, so that we can extend it out in the future.
I am thinking that the user will go to the discussion page for each genre, and then post a comment with a youtube link with the song that they would like.
This will then triggger an event for discussion creation, which will check if the discussion has the title of `/music` inside of title, after it does, it would parse the comment that is created and look for a youtube link.
After it finds the youtube link, it will go to the page and extract the title and then create a github issue ticket for it?
Once that issue ticket is created, which will be set with a priority of 0 and as we progress through these actions, we can raise the issue up!
So in this case, if the ML stage one is processed, we can add another label to this, as label 1.

The current problem is that the prompt is not the best to give us accurate results.
I might have to look up different guides on the best way to generate a prompt that they will finish without having any issues, maybe extending it out a bit more? Hmm.

The prompt technique that I will be using is a ToT aka Tree of Throught but I believe I will have to make some adjustments if I need this to create a zero execution.

Before I forget, let me adjust the `music.md` to make sure that it is up-to-date, afterwards, I did place a note on creating the `japrock.mdx` for my future azn music collection.

With the prompt, I might just go back and keep it simple because it seems that the ToT approach is causing some errors.

```text
Imagine three different data experts are answering this task. All experts will write down their steps of their thinking, then share it with the group. Then all experts will go on to the next step, etc. If any expert realizes they're wrong at any point then they leave. Remember the goal is to complete all of the steps provided.
```

I will keep looking up more prompt techinques on the side.
Maybe we can switch up the model to use mixtral-8x7b-32768 for this situation.

Here is the new prompt:

```js
    const system = `Imagine three different data experts are answering this task. All experts will write down their steps of their thinking, then share it with the group. Then all experts will go on to the next step, etc. If any expert realizes they're wrong at any point then they leave. Remember the goal is to complete all of the steps provided and generate the final command. \n\n Please read the provided text, extract the required information, sanitize the title, and fill it into the specified command format. The title should only contain numbers, letters, spaces, hyphens, and characters (, ), ., and -. Your task is to complete a finalized kbve.sh shell command with the extracted information. If you can not complete the command, go back and process the input data again. \n\n Hint: Titles may contain multiple words separated by quotes and hyphens. These words are often the band name and followed by the song. **Example:**\n\`\`\`\n\n**Fill out the Form**\n\nYouTube Link: https://www.youtube.com/watch?v=<yt_id>\nTitle:  <title> \nGenre:  <genre>\n\nPick only one of the different genres!\ndnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock, japrock\n\n\n\`\`\`\n\n**Output:**\n\n\`\`\`bash\n./kbve.sh -nx kbve.com:music --args=\\\"--file=<genre>--title='<title>' --ytid=<yt_id>\\\"\"\n\nHere is the template for the command:\n\`\`\`\n./kbve.sh -nx kbve.com:music --args=\\\"--file=[insert file/genre here] --title='[insert sanitized title here]' --ytid=[insert YouTube ID here]\\\"\n\nEnsure to:\n1. Extract the \`File/Genre\`, \`Title\`, and \`YouTube ID\` from the text.\n2. Sanitize the \`Title\` to only include numbers, letters, spaces, hyphens, quotes, periods, the characters () . and -. Please do not replace spaces with any other characters and keep the spaces in the sanitized title.\n3. Only acceptable genres/file are dnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock, japrock\n4. Fill in the command template with the extracted and sanitized values.\n\n**Your Task:**\nPlease parse the provided text below and generate the command. You must follow all the steps that are stated and make sure to wrap the kbve.sh command in bash code block. \n\n`; 
```

This was the older prompt:

```js
    const system = `Please read the provided text, extract the required information, sanitize the title, and fill it into the specified command format. The title should only contain numbers, letters, spaces, hyphens, and the characters () . and -. Your task and goal should be to complete a finalized kbve.sh shell command\n\n**Example:**\n\`\`\`\n\n**Fill out the Form**\n\nYouTube Link: https://www.youtube.com/watch?v=<yt_id>\nTitle:  <title> \nGenre:  <genre>\n\nPick only one of the different genres!\ndnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock, japrock\n\n\n\`\`\`\n\n**Output:**\n\n\`\`\`bash\n./kbve.sh -nx kbve.com:music --args=\\\"--file=<genre>--title='<title>' --ytid=<yt_id>\\\"\"\n\nHere is the template for the command:\n\`\`\`\n./kbve.sh -nx kbve.com:music --args=\\\"--file=[insert file/genre here] --title='[insert sanitized title here]' --ytid=[insert YouTube ID here]\\\"\n\nEnsure to:\n1. Extract the \`File/Genre\`, \`Title\`, and \`YouTube ID\` from the text.\n2. Sanitize the \`Title\` to only include numbers, letters, spaces, hyphens, quotes, periods, the characters () . and -. Please do not replace spaces with any other characters and keep the spaces in the sanitized title.\n3. Only acceptable genres/file are dnb, chillstep, lofihiphop, nujazz, electroswing, edm, rock, japrock\n4. Fill in the command template with the extracted and sanitized values.\n\n**Your Task:**\nPlease parse the provided text below and generate the command. You must follow all the steps that are stated and make sure to wrap the kbve.sh command in bash code block. \n\n`;
```

<Adsense />

## 2023

- 8:00am - No morning work out today, I feel a bit tired and burnt out from the vast amount of smoke coming from the wild fire. I made the terrible mistake of leaving my windows open with a cross breeze and slowly my room has the faint smell of BBQ! The whole situation with their wildfire seems to be intense, these type of situations remind me to be grateful for what we have and have to understand that we could loose it all within a blink of an eye.
- 11:00am - Coffee and mocha whey are the best combination. The combination of the protein and the caffeine make holy a proud boy. WAIT! That might have came out wrong....  
- 12:30pm - Going to clean up my room and re-organize some of the electronics. I think its time to take a break from software development and go deep into some hardware development. I am going to spend a couple hours looking into setting up a dev board and a small raspberry p, with the hopes to setup a fast enough cloud function to invoke it. I could rebuild a small car with camera and then let the cloud functions control the application? The only downside that I could see with the car would be the charging, as I would run into issues with the battery draining too fast. 
- 4:00pm - Hope that TSLA does not stay above $230 a share or I will have to perform some spicy memes magic to get over that bump. The price point per share seems to be a bit too much for my type of budget but we shall see as the markets have been eating up all the good news. War? Inflation? Memes? We shall see tomorrow how far the rally will go!
- 4:15pm - Going to grab some more coffee, caffeine and switch over to some programming!
- 5:20pm - Okay we got some feedback on the conch shell, there are a couple things we could do to improve it, including adding a button that is an action to `ask` the shell, incase they can not click the shell itself. 
- 5:39pm - Watching Ziggy play shadow of the colossus gave me some old school flash backs! This was such an amazing game back in the day, definitely up there with Zelda, at least for my childhood memories.
- 6:00pm - Okay I really need to play some music and the fact that I can not find a solid music bot that plays YouTube videos is getting a bit annoying. So it might be time for me to build one really quick to get the job done!
- 6:30pm - Updated Appwrite to the latest version 1.3.7 and did a basic migration to make sure that everything is okay.
- 8:00pm - Time to fork over this music bot written in Go and quickly spin up a YT ready bot for Discord. 
- 11:59pm - EoD - Will push some tasks out for tomorrow, learning the different Go aspects was cool but will just end up using Python.
## Quote

> Imagination is more important than knowledge. For while knowledge defines all we currently know and understand, imagination points to all we might yet discover and create.
> — <cite>Albert Einstein</cite>

---

## Tasks

- [x] Assemble Mock IoT.
- [x] Clean up the electrical components.
- [x] Music Bot to Play YT videos through Discord.
- [x] Unity Async Loader. Pushed for tomorrow.
- [x] React Form Update. Pushed for tomorrow.
- [x] Unity Login Migration. Pushed for tomorrow.

---
# June: 09

> June 9th. New Musical Process.

Source: https://kbve.com/journal/06-09/

import {
  Adsense
} from '@/components/astropad';

## 2025

### Daily Markets

-   09:35AM

    Still selling them covered calls for NVDIA, still need to get rid of around 1000 shares.
    I am thinking this time it will just break past that $145, letting me exit that pre trade war meme.

### Unity Stats Data

-   06:00PM

    Currently the stats are not as reactive as I would have liked.
    So I am going to restructure them to hold a couple reactive properties.

-   10:12PM

    Okay moving forward, we went in a weird loop of going from the struct for stats being raw to all reactive back to raw.
    Turns out that we will have to keep two allocations for the stats, the actual value and a soft current value that has a bit of a delayed frame reference.
    hard value is the actual source of truth, similar to a true armor but a soft value would be one that gets displayed to the user.
    This will help soften shifts in the regeneration and not the UI go through a crazy loop of shifting up and down during the damanage phase, furthermore gives us a buffer room for actions and if the user opts to cancel.

## 2024

**Cafe**

Before I start any adventures within the binary land, I think I will take a quick adventure and collect my daily quests!
Coffee, Breakfast, Red bulls, ah the usual works.

**Music**

I am thinking that I might switch up the way that I was thinking of processing the music issue ticket.
Instead of directly having the ml build the command, I will instead use it to help parse the data in the first prompt.
Afterwards, I will just use regex to pull the parsed data and then move forward from there?

New prompt:

```js

const _system_data_experts = `Imagine three different data experts are answering this task. All experts will write down their steps of their thinking, then share it with the group. Then all the experts will go on to the next step, etc. If any expert realizes they're wrong at any point, then they leave.`;


```


**RSPS**

The next function that i would like to add into Atlas would be for the ability to log into RS using the data from the database.
I still would have to build out the vault but for the time being, I could just use global variables to help handle it.

Building the `Atlas` / `RSPS` container and then running it with FastAPI, test casing its ability to communicate with the Rust backend.

Example command for building the docker image.

```shell
docker build . -t myapp && docker stop myapp_container && docker rm myapp_container && docker run --name myapp_container -d -p 3000:3000 -p 8086:8086 --shm-size=2g myapp
```

For the communication, we will use the groq as a base api, which means that I will have to build a quick api that will interact with it.
We can extend it out in the future to use Ollama but for now this should be fine.

**Python**

While I am building out the groq client, I am thinking that there might be a way to handle the prompt engineering but it seems that we would have to migrate it out of the groq library?
A whole new library to handle the prompting would make sense, but we could roll that in slowly.

Updated Atlas with the new groq features added in, next up is to utilize the parallel tooling to help with the prompt engineering.

<Adsense />

## 2023

- 3:30am - Finally got music playing through Discord, so I guess it might almost be time to launch the Discord.sh bot service. I am thinking that it will most likely be a private bot service, offering very specific and hybrid source bots for the servers. I will do a couple more test cases before launching it out in the future, it is also a bit late in the night for me.
- 3:50am - The Discord Red bot in python seems to be good enough for what we are doing, it is running under python 3.11, which is good for the long term. I will most likely keep the bot as the core and then extend out private cogs that run inside of the bot, which would be one of the reasons that people would use our service, per say.
- 4:30am - I was reading up on the recent changes on the Reddit API, it is a shame to see one of my favorite websites slowly fade into the depths of destruction. However there might be a silver lining in this, as more alternatives become popular, the resurgence of older forums, unique communities, decentralized projects, ect.. It will be interesting to see how this comes around when I read this passage a couple years into the future.
- EOD - I did not keep too many notes for the day, as the lack of sleep threw me into a bit of a slow turtle mode. I am a bit sad that I will have to sell a couple hundred shares of $TSLA at $230 mark because of an of assigned weekly cover call. However it is not too bad of a deal, as I will most likely just write covered cash puts to generate capital from that point of view.

## Quote

> Your sacred space is where you can find yourself again and again.
> — <cite>Joseph Campbell</cite>

---

## Tasks

- [ ] Make sure not all $TSLA stock get sold at $230! xD.
- [ ] Unity Async Loader.
- [ ] React Form Update.
- [ ] Unity Login Migration.

---
# June: 10

> June 10th. Prompt Pathways.

Source: https://kbve.com/journal/06-10/

import {
  Adsense
} from '@/components/astropad';



## 2024

**Prompt**

One of the last issues that we are facing is how we would organize and store the different prompts that we intend to use.
I am thinking maybe placing them all inside of the frontmatter within the `ml.mdx` and then turning them into a json?
This would be the best move for now, so let me start working that out.

What we could do is include a `prompts` inside of each of the mdx document that would hold the prompts that we would be using for that subject.
This way when we reference the `docker.mdx` document, we also have the prompt examples right there within the document.

As for the different parts within the `prompts`, we would aim to include `name`, `description`, `items` and `task`.
Putting it together, it would look like this:

```md

---
prompts:
    - name: Role Examples
      description: Common role examples for text transformers.
      items:
        - Act as a javascript console
        - Act as an excel sheet
        - Act as a HR interviewer
        - Act as an advertiser
        - Act as a publisher
        - Act as a music teacher
        - Act as a relationship coach
        - Act as a World of Warcraft player and limit the response to 50 characters
      task: |
        Define the role for the AI model and prompt it to perform actions specific to that role. For example, you can ask it to act as a JavaScript console and provide code snippets, or act as a music teacher and give lessons.
---

```

Now the question would be if we need to expand it out? Maybe include pathways?

The way that I was thinking of structuring the pathways was like this:

```python

pathways = {
    "initial": {
        "prompt": "Initial prompt",
        "next": [
            {"condition": r"regex1", "action": "pathway1"},
            {"condition": r"regex2", "action": "pathway2"}
        ]
    },
    "pathway1": {
        "prompt": "Prompt for pathway 1",
        "next": [
            {"condition": r"regex3", "action": "pathway3"},
            {"condition": r"regex4", "action": "pathway4"}
        ]
    },
    "pathway2": {
        "prompt": "Prompt for pathway 2",
        "next": [
            {"condition": r"regex5", "action": "pathway5"},
            {"condition": r"regex6", "action": "pathway6"}
        ]
    },
    # Add more pathways as needed
}

```

Yet that might not be the best way to handle it, let me think what we could do for pathways that would help resolve the issues.
Maybe we try out this method for now and then come back to it later on. The chaining might introduce more API calls then it would require, yet it might help us resolve edge cases.

After adding pathways, we will add tools as a reference too.

Example of the tools block is here below:

```python

tools = [
        {
            "type": "function",
            "function": {
                "name": "get_game_score",
                "description": "Get the score for a given NBA game",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "team_name": {
                            "type": "string",
                            "description": "The name of the NBA team (e.g. 'Golden State Warriors')",
                        }
                    },
                    "required": ["team_name"],
                },
            },
        }
]

```

This should be included within the prompt? I am thinking that it should not be help within the prompt but rather be something that the user would define within their codebase.
We can add the tools aspect for the demo purpose.
Oh! I forgot that we would include the output as well, okay to recap the prompt engine, we would have:

- name
- description
- items
- task
- tools
- output
- pathways


Here is an example of this prompt engine:

```md

---

prompts:
    - name: Role Examples
      description: Common role examples for text transformers.
      items:
        - Act as a javascript console
        - Act as an excel sheet
        - Act as a HR interviewer
        - Act as an advertiser
        - Act as a publisher
        - Act as a music teacher
        - Act as a relationship coach
        - Act as a World of Warcraft player and limit the response to 50 characters
      task: |
        Define the role for the AI model and prompt it to perform actions specific to that role. For example, you can ask it to act as a JavaScript console and provide code snippets, or act as a music teacher and give lessons.
      tools: |
        [
            {
                "type": "function",
                "function": {
                    "name": "get_role_specific_info",
                    "description": "Get specific information for a given role",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "role_name": {
                                "type": "string",
                                "description": "The name of the role (e.g. 'JavaScript console')",
                            }
                        },
                        "required": ["role_name"],
                    },
                },
            }
        ]
      output: text
      pathways: |
        {
            "initial": {
                "prompt": "Choose a role for the AI to act as:",
                "next": [
                    {"condition": "javascript console", "action": "pathway1"},
                    {"condition": "excel sheet", "action": "pathway2"}
                ]
            },
            "pathway1": {
                "prompt": "You chose JavaScript console. Provide a JavaScript code snippet:",
                "next": [
                    {"condition": "valid js code", "action": "pathway3"},
                    {"condition": "invalid js code", "action": "pathway4"}
                ]
            },
            "pathway2": {
                "prompt": "You chose Excel sheet. What operation would you like to perform?",
                "next": [
                    {"condition": "create sheet", "action": "pathway5"},
                    {"condition": "edit sheet", "action": "pathway6"}
                ]
            }
        }

---


```

I think this is a solid start to our prompt engine needs, we can then turn this into a `json` and call it from the custom action that we are building.
Okay, I will go ahead and add the prompts to the `ml.mdx`, and then begin to assemble them into a specific json file for each instance?
Should we have it build it after each run, that might be a waste of resources, hmm but for now I will just do it that way.

**Zod**

With the base prompt data out of the way, we will have to update the zod with this information, so that it will be easy to reference throughout our website and external applications.
The base zod that we have right now looks like this:

```ts

	docs: defineCollection({
		schema: docsSchema({
			extend: z.object({
				// Make a built-in field required instead of optional.
				tags: z.array(z.string()).optional(),
				"yt-tracks" : z.array(z.string()).optional(),
				"yt-sets": z.array(z.string()).optional(),
				
			}),
		}),
	}),

```

There are a couple ways we could extend this out, I am thinking of creating a couple `z.objects` that would hold the information.
So let us extend out the `z.object` within the `docsSchema` to hold the prompt schema data set, defining it like this: `prompts: z.array(PromptSchema).optional(),`.

After extending out the schema, we can move forward with setting up the json file with the prompts.
We can split the prompts up into two areas, one being public prompts that anyone can use and the second would be private prompts that would be stored in our database.

There could be additional options in the future to extend it out and let people setup their own shop or service through the usage of those prompts, hmm, for now we will just focus on the public prompt engine.

To get started, we will go ahead and head into the `/apps/kbve.com/pages/api/` directory and take a look at the other two `.json.js` files that we made.
Based upon the way we handled those two files, we could easily extend that core concept out to the prompt engine.
Now the question would be if we want to have one central file with all the prompts or if we should isolate them, hmm, since we have not yet expanded too far, I think it would be safe to just have a `prompt.json.js` that will hold all our public prompts.
We could create a nested json, where it uses the title of the mdx to help build out the prompts but I am not yet sure the best way to go about that.

While I am thinking this through, I should go back and update my notes within `ml.mdx`, since I have yet to do a reform with a transform to starlight components.

To make things easier to reference, we can extend the `z.objects` within the frontmatter `docsSchema` with a `prompt_index: z.string().optional(),` and this would be the key that we would use to help us build out the nested json.

Going to run `./kbve.sh -nx kbve.com:build` to make sure that everything builds before adding in the new json file.

The file that we created that holds the prompt will be accessible via `https://kbve.com/api/prompt.json`, now we need a way to filter it out.


**Groq Pooling**

After building out the base pool, we would need to extend it out with a temporary chat storage, so that it could reference when doing the prompt chaining.
The question would be how we would go about storing the chat, I suppose the type of vector database that we would use or should we write our own tiny vector database?
Having a custom vector database that would work with different vector databases like pgvector and chromadb?


<Adsense />

## 2023

- 12:30pm - Going over the login screen for KBVE, it looks like I am almost done! This was something that should have been really quick but I had to sit through and understand the whole OAuth situation, as we switched APIs. Now the whole setup is cleaner and easier to use! We can add and remove the components with just a couple quick lines and for the most part, everything seems to be on point! 
- 1:40pm - The login with Github looks like it is working fine! I think we can move forward with the Login with Discord next. Afterwards I will double check what we need to finish up the Google and Twitch. Moving past the basic authentication, then its the Profile page. We will keep the objective for the profile page to a narrow scope before extending it out further. The key components that we could focus on would be the general information and vibe the profile page should produce, something unique and creative but not over loading the browser.
- 2:30pm - Time for a quick coffee break! One of the other aspects that I was looking into was extending out the different page layouts, including starting the `blog.astro` and adding a couple unique blog articles onto our website. I also did postpone the webmaster tool for a bit too long, so I should look over that and get it going too! 
- 2:45pm - It is interesting to see how Google OAuth2 does its integration, they seem to be very protective of it, which makes sense to me because they have a large scope and can be a target for various malpractice. We started with a test application and now are moving towards production, in this situation we would have to provider a lot of extra information that I did not expect. I am wondering if Google really needs me to create a YouTube video that shows why we need their login support?
- 3:34pm - Yes! It looks like we are finally done with the basic production ready login screen. There are a couple CSS issues that I see, like the buttons not being exactly in the center? But I can address the style sheet problems later on, near the end. We got Github, Discord, Google and Twitch to be functional and operational! Now we can move straight forward with the next step, which is the profile.
- 4:20pm - Currently looking around for some unique profile templates to base our KBVE one off of. While I was doing some generic research into the topic, I came across the million.js library, maybe we could add this into the KBVE repo? I am going to do a bit more research into how to integrate this library into Astro.
- 6:30pm - Upgraded Astro.js to the latest version of 2.6.3 and decided to add Million.js into the project! This might help with improving the load time for complex react scripts. I will keep the integration of `Million.js` to a limit because it is a younger library and there might be issues down the line. This reminds me of the Preact < - > React situation, where certain components failed to render because of the dependencies. 
- 9:45pm - Having a nice salad for dinner, about to hit 40 range on the pure and the profile page is coming out pretty cute! Its going to be a long night of programming and test casing, but I am thinking that it will be amazing!

## Quote

> Love demands infinitely less than friendship.
> — <cite>George Jean Nathan</cite>

---

## Tasks

- [x] Add Discord Login
- [x] Add Google Login
- [x] Add Github Login
- [ ] Add Twitch Login
- [ ] Prepare for Nephews Birthday Party

---
# June: 11

> June 11th. Prompt Pathways.

Source: https://kbve.com/journal/06-11/

import {
  Adsense
} from '@/components/astropad';

## 2025

### CoPilot Flow

-   12:30PM

    The agent mode for the co-pilot has been interesting for the most part, I spent a decent amount of time looking through it and its been okay.
    There is room for improvements, but for the most part the software has been great.
    I am not too sure if it will operate well within the mono repo but we will find out.

## 2024

**Github Actions**

I finally understand what would make github actions easier, that you can just directly call the javascript functions as a file within your custom actions.
This will make building a bunch of different actions so much easier.
This is something we have done in the past but in this case we will try to build a whole collection of possible actions that we would like to use in the future.
My goal will be to shift towards getting around 10-15 actions built this month, hopefully making it easier for us to call basic mL operations without any major pain points.

The first function that we are creating will be the `kbve-api-groq`, which is located under the `.github/actions/kbve-api-groq/` and has three total files, well four once the lock is set.
Part of me is thinking that we should create a new npm package that would be like `@kbve/gha` which would be a library for the github actions, making it easier to mass produce them without having issues.
However for the first couple, we will avoid doing that until we get a full understanding of how it will operate within the pipeline.

The core packages that we will be adding are these three:

- `@actions/core`
- `@actions/github`
- `axios`

I might include a couple more but later on, we will just use our custom library to help us with that.
A wrapper around axios to make it easier for us to call, hmm, that might be interesting to look into.

The other function we should make would be one that can process issue ticket titles, this should start off at a base level and we can expand it out as we build it out.
My thought process around setting this up would be to focus on the basic parsing and the build upon it later on.

The folder for this will be located here `.github/actions/github-issue-ticket-title-parse` and we will follow the same layout as before!
I should keep track of the different actions that we are building too.

Okay! Forgot to include a top-level function for the index.js, going to add that into the script right now.
Let me go ahead and push this through for now and maybe bring the process of updating the branch to main.

I will review through the release branch and the 22 file changes, while I am doing that, I should prepare to rename the `kbve-api-groq` to `kbve-api-atlas` and extend out the functions within that action.
The two parts that I want to extend out is defaulting the routes to `groq` but keeping future options open for `ollama` and `atlas`.
The other part is to include a couple different sanitization options, hopefully providing some level of hardening against future threats.

We would extend out the `action.yml` within the `kbve-api-atlas` to include other options besides `groq` and a quick index to pull prompts from the `prompt.json`.

Currently the nested prompts are under an array of 0 to n, this might become a problem as we scale the prompts in the future. I am thinking that it might make sense to assign them an ulid as a reference point. The ulid will act like a key and a reference point between the public facing prompts and any private ones that we decide to release in the future.

Next, let us update the config.ts and zod for the vault and so we can store a better key to reference and search the prompts through. We know that it will be `ulid` as a field and we can save it as a `z.string`. Afterwards, we will have to go back and add the ulid variable to each of the prompts, so that zod does not fail the build.

Went ahead and decided to create a folder to hold the prompts, and then renamed the original `prompts.json.js` to `collection.json.js` and created a new `engine.json.js`, this will hold an optimized json table of the data. This way we can have a bit of both and work through what we already have within the pipeline. I kept the original as a collection endpoint, so that the exisiting tools do not break and we will use the new engine endpoint in the newer toolings and github actions.

Let me go ahead and sync those changes and create a new branch to work off of.

Okay we can now grab the prompt engine from this [link](https://kbve.com/api/prompt/engine.json) and we move forward.

Given its the next day, I suppose a new entry would make sense.

<Adsense />

## 2023

- 11:00am - Just got ready! Going to spend some time cleaning up the backyard and doing some general cleaning. Damn my room got a bit messy, not too much trash but my clean clothes are are not organized the way that I would want. I like to take small 5-15 min. blocks where I just tackle a specific area of my room, then rotate around. I do need to do inventory of my electronics again this weekend.
- 2:30pm - Spent some time reading up on Aaron Swartz, thought I might include his open source manifesto and maybe take a couple jabs at improving it here and there. I found it to be interesting that it has been over 15 years since he released the document.
- 4:30pm - Getting ready to go to the park! I need to enjoy some of this fresh air and weather before it becomes too hot. After the park, I will take a look at the resume issue and also see if I can get started on the next stage of development within the resume tool.

## Quote

> You yourself must strive. The Buddhas only point the way.
> — <cite>The Buddha</cite>

---

## Tasks

- [ ] Park Trip!
- [ ] Start Development Stage of Resume

---
# June: 12

> June 12th. The Sun! It Burns! A reference for my fallout homies.

Source: https://kbve.com/journal/06-12/

import { Adsense } from '@/components/astropad';

## 2025

### EGui - Da Waffle

-   03:09AM

    Made some great progress with egui, getting a better understanding of the interop but damn, I am really not a big fan of these race conditions.
    With that being said, the next thing that I want to finish up is the droid library.


### Droid NPM Release

-   05:30AM

    It is a big day for the npm side of things, we should launch the `@kbve/droid` and have it be as operational friendly as possible.
    There will be some issues with this release, but I am willing to take that gamble and test it through.
    Since we have astro builds back in order and two agents working now on the repo, it gives me time to move things forward.

-   07:46PM

    Pushing up the next update for the package release, this will be the second or third time that I had to rebuild this.
    The more that I keep doing this, the better I am getting at it, so there is a decent perk to this practice.
    Also the logo looks great, I am excited to get that pushed out too.
    We will finish up all the supabase integrations within this library, so that it can be used in all the other websites, thus linking everything together.

-   08:13PM

    Updating the droid npm package, looks like not everything was exported, including the readme!
    We can go ahead and update that, I forgot to change the exports since this is a private library.

### Plane Crash India

-   07:25PM

    The crash was terrible to hear about in the news, I been to the airport before and I thought it was ran pretty well.
    Yet I can see Air India not providing the best service and not doing the best maintenance.
    It is still too early to know what exactly happen, but its crazy to see it on the news and recongizing the parts of the city.

## 2024

**GitHub Actions Musical**

As the lack of sleep has been catching up to me, I think a musical called GitHub Actions would be amazing. It would be a bunch of robots making music, all controlled through github actions. Think about an animatronic character band that people can control via live stream and having it play to an audience that is all virtual? This is the next big thing, if KBVE ever has tech conferences, this is what we will do.

**Cookin Show**

A crazy cooking show idea would be where a couple funny guys have to make recipes that were generated by different AIs and some submitted by people. We would have to make the whacky food it suggests but also figure out if its AI or human, maybe a couple more twist and turns. This would be a weekly style show, kinda a cool way to show the advancements in ai but also a great live stream meme.

**Actions**

Okay, enough of these nutty ideas, let us go ahead and update the music process ticket to use our new actions. We are going to have some failures and a couple waves of main branch releases, ugh, I am not yet really ready for this.

I will go ahead and save myself some future typing and rename the action for issue ticket parsing to a short hand, making it easier for us to reference. I really hope these actions do not fail on us in the future, but I already get that spiderman sense running through my mind that there will be a bunch of failures.

While building out more of the github actions, I think it might be wise to do something creative and see if we can get Atlas up and running through github actions. This is just part of the test casing, hopefully jagspx launch goes as planned, but already had a couple failures in that area. We tried to grab the public ip address of the runner, yet that failed to certain extent but its good to know that we can grab that without any major problems. So the next idea is to throw up a ngrok and see if we can utilize that in our adventures, the first round of using it, uh, failed because I forgot to include the auth token. I believe in the future we should be able to just turn this into a new action, which I believe will be super useful!

While building that out, I am currently fixing up the comment action but its going to suck if all these new actions fail because we are missing some sort of logical library or a weird step.

**Python**

One of the other cool aspects of what we are building is that we should be able to even go as far as skipping a bulk of these current javascript issues and just run atlas directly inside of the github actions. I feel like having the javascript is really just a waste of resources and time but for this proof of concept, we will stick with javascript. However on my next rewrite, I will just run all of atlas, actually I might just run the whole damn docker image inside of an action and just have github handle it all for me, as if it was its own computer. Have it provide screenshots and everything! This first run is just to get the confidence to do some really whacky and crazy things later on. I am writing this all done so that I can reference it a year later and be like, damn I was right, these are some crazy times to be a programmer.

**SV**

Honestly watching Silicon Valley really puts me in the mood to grind out all night. Like I am not a huge motivation guy, but something about this tv show hits all those nerves and puts me into overdrive.

**RSPS**

We were able to get the base of the RSPS to launch through github actions! I decided to make this a different ticket.

It seems that ngrok decided to limit our transfer out, so we will have to replace that.

```yaml
# - name: Install ngrok
#   run: |
#     curl -s https://ngrok-agent.s3.amazonaws.com/ngrok.asc | sudo tee /etc/apt/trusted.gpg.d/ngrok.asc >/dev/null
#     echo "deb https://ngrok-agent.s3.amazonaws.com buster main" | sudo tee /etc/apt/sources.list.d/ngrok.list
#     sudo apt-get update
#     sudo apt-get install ngrok

# - name: Authenticate ngrok
#   run: |
#     ngrok config add-authtoken ${{ secrets.NGROK_AUTH_TOKEN }}

# - name: Expose Docker container with ngrok
#   run: |
#     ngrok http 3000 &
#     sleep 5 # Give ngrok a few seconds to start

# - name: Get ngrok URL
#   run: |
#     curl -s http://localhost:4040/api/tunnels | jq -r .tunnels[0].public_url
```

That was our older ngrok, but I will make my own custom action using localtunnel and hopefully that will let us keep the rocket up until the moon!

It turns that localtunnel was also not good enough for this project, hmm, maybe I need to think a bit outside the box.
We could create our own ingress and then integrate that directly into our Rust API, or maybe we could spin it up as a different container that communicates with our API.

Next 

<Adsense />

## 2023

- 11:00am - Waiting to transfer out a couple hundred grand from the recent sale of tesla stocks. I ended up exiting 600 shares and plan to transfer the move to another brokerage.

- 5:00pm - It seems that my grandpa's visa for India has some issues, so I shall try and resolve the issue as fast as I can. The documents requested are as following:

  - Medical Certificate
  - Request Letter
  - Undertaking Letter
  - Travel Document
  - Certificate
  - Minor Document
  - Visa
  - Others

- 5:45pm - I should further breakdown the different components but there are some additional steps that need to be done.

  - `Photo and Document(s) upload are mandatory`.
    - There are a couple file formats that they support, it seems to be mainly PDF and JPEG.
  - `Applicant must upload the photo before proceeding for appointment. `
    - We will schedule the appoint within the city of Vadodara
  - `Size of PDF document must be less than 200KB`
  - `Photo Requirements:` which extends into `Format - JPEG, Size: Minimum 10 KB and Maximum 1 MB.` They go further into detail about how the photo should be a passport photo with a `white background` with no cropping / shadows.

- 5:55pm - Quickly made a salad before I start to dive deeper into the full requirements. I will start with the `Medical Certificate`, which we already have, its in PDF format and is a total collection of all my grandpa's recent hospital checkups and doctor feedback. I think this collection should be enough under this requirement.

- 6:00pm - Next, I will tackle both of the letters, `Request` and `Undertaking`, by quickly looking up examples from the Internet. It is a shame that the Reddit blackouts are making it a bit more painful to search through, I had to resort to looking at the cache / older screenshots, but I suppose that means their protest method is definitely working. I was able to find this amazing website, [Indian E Visa](https://indiaevisas.org/indian-visa-extension-online-application/) that provides the perfect set of examples and samples to help navigate through this process.

- 6:15pm - Example of the Undertaking letter that I written:

  - `**I, Mr. Holy Byte, grandson of, Mr. Grandpa Byte, want to inform you about my grandfather holding passport No: 420696969. I am taking full responsibility for my father while he is recovering in India because of his current medical status. Thus, I am requesting immigration of India to approve his Indian entry tourist visa for 6 months.**`
  - I kept it straight forward and simple for now, as I do not think this will require much information/detail.

- 6:30pm - Next requirement was the `Travel Document`, which might be a bit confusing for me. I am under the impression that it is the Passport and/or plane ticket. I will email one of the tourist companies that I know and see what they say. Maybe it might be under the Form C? I guess I will have to look further into that area as well, I filled out this form earlier last week but I will do it again just to be safe.

- 6:40pm - Following that requirement is the Certificate, which I am going to assume falls under the Medical request / documents, in our situation, thus I will skip this as well as the minor document request. Finally the last remaining seems to be Visa and Others, thus it might be best to include any additional documents that I have within that relation. The specific office that we would be reporting to is the FRRO Ahmedabad, which is located `- Barrack No. 2, First Floor, Govt. Polytechnic Campus, Ambawadi, Ahmedabad,Gujarat-380015`. I never thought I would have to tell someone to visit a barrack within the polytechnic campus in real life but here we are.

- 9:50pm - Added an additional undertaking letter from my uncle. Hopefully these are enough documents to get this process going. I already emailed the Embassy and reached out to a local tourism agency for further support.

- 10:00pm - I forgot that someone, _cough_, made a script that automatically enters into class action lawsuits. Anyhow, that script is still running and someone may have gotten a recent check from that script. that person should make it into a weird side project / script for the future reference. Regardless there was a check from the `Celsius Class Action Settlement` and it was for an amazing total of $0.94! WoW!

- 10:25pm - The new windows server is up and running but there are a couple issues that I am already running into. The first being that docker is extremely slow and I am not too sure why! I really do not want to spend the time to figure out, it might be something to do with the drivers but the amount of time that I would have to spend is starting to look a bit tiring. Damn I am getting old.

## Quote

> In the end we retain from our studies only that which we practically apply.
> — <cite>Johann Wolfgang von Goethe</cite>

---

## Tasks

- [ ]

---
# June: 13

> June 13th. MeFourGPT. Cleaning up the pipes, everyone has to do it.

Source: https://kbve.com/journal/06-13/

import { Adsense } from '@/components/astropad';


## 2025

### Unity DevLog

-   09:45PM

    Ended up not taking too many notes because I was stuck working on the web workers for most of the day, then had to loop back around to finish up the unity stuff.
    So the notes are lacking for the day, honestly, the vite web worker bugs were driving me crazy.
    I never felt like wanting to go on vacation until I finished up fixing that vite issue.
    V is vite, vengence and vacation.

## 2024

**Cafe**

As for the general rule of thumb, the mornings should always start with a fresh trip to the cafe.
An overloaded ice coffee is perfect for the start of the morning and I got another protein-mixed coffee blend in the kitchen that is almost ready for lunch time.
AFter getting all wired up, it would be wise to start making some moves.

**Cleaning Pipes**

Just to be safe from a quick repo revamp, we need a quick function to help us migrate out some of the core code base, but maybe that can be done at a later time.
We want to make sure that none of our older games get effected by any random changes that we make moving forward.
Let me update the title for this entry, I should call it updating and cleaning up the pipelines.
I removed the actions to call the itch for deployment, this is just because we will shift gears and have the monorepo focus on steam deployment.
The next part of the pipeline cleaning will be to move some of the notes and documentation into the `git.mdx` so that it can be referenced easily without directly going to the file.
In the future, we want to basically move all the code comments and documentation out of the file itself and place it directly into the mdx docs.
Granted, we would have to also offer the translations but that is so far in the year, 2026 probably xD

It would be wise to sync the changes first with the initial branchs, like `dev` and `alpha`, maybe even include the `beta`.
I will loop back around to the main branch next week, just to make sure that I do not break the whole CI/CD flow in a day.

The new actions that we added are still broken, so let me push this through and then start fixing the broken actions.
We can focus on getting the container up and running, which we have already, but we can at least do some of the basic functions within the container.
The first step would be to add a screenshot function and also make sure that both port 3000 and 8086 are open.

Before we can even get to that point, we still have to make sure our modular actions actual run.

**Action Repair**

It seems that the `pre` command within the `action.yml` is not supported for local-based actions!
The solution would be to switch back to composite, let me sync up these current changes and push up to main.

The way that we would want to launch `atlas` would be through the issue tickets, with the purpose of making sure that the container will run within the github actions.
There might be concerns with how much this could scale but I do not think that there would be more than a couple issue tickets here and there, yet we can always improve upon this workflow!
Now the way we would handle this would be to make sure that it works. 

Ugh, there are so many weird and random bugs that it seems to be driving me a bit insane.

**Sync**

While we wait for the branches to move up into the `main`, I am thinking that there might be a better and more well rounded solution to our sync issue.
The first thing is to make sure that each of my branches that I start to commit include a reference to an issue that it is related to?
This could be an interesting concept that we can build around, given that our actions need to be updated.

**NxCloud**

The monorepo cloud environment does its well!
Finally having some level of reporting in the PR comment section is dope, now we could also look back into the `codeseemap` integration!
That will be on my list of tasks that I need to add back, 
Oh nevermind, I forgot that codesee was acquired and that means I will have to find another solution to that graphing problem.



<Adsense />

## 2023

- 9:00am - Today's market is going to be interesting, I really hope to see a dip but it could go any direction based off of what the feds say!
- 10:00am - I started to watch the apple tv show, Silo and damn it is giving me some interesting game development vibes and concepts. The show is really well written so far and I am enjoying all the characters so far! I blew through the first couple episodes without even realizing it.
- 11:00am - Going to take a nap for a while, I been up all night programming.
- 2:00pm - Decided to take a quick break and visit a car dealership for my mom's new car. We are looking at a 2021 or newer model of an Acura MDX. The current price point is around $48,000 for their `Tech` package. Personally I would want them to switch over to electric but they are still on the fence with it. The 2024 models that we want have a mild waiting period of about 4 months and pre-owned that are certified are around $41,000. I am going to continue to search through different offers, I might just offer around $35,000 and see if they have anything within their system that fits the price point. I will take a model with a couple thousand miles on it, if I can get it at a decent rate. 
- 4:30pm - Looks like my SPY put has expired and my TSLA puts are going to expire as well. I am thinking of rolling them into next week and collect that $1000~ premium. I might also sell another couple cover calls on TSLA going into next week, if this run continues.
- 5:00pm - Going to get a bit deeper into the development cycle of RogueJester, but I am definitely feeling a bit of project overload already. I might have to switch up my work station and maybe migrate over to a coffee shop or café. A part of me is thinking of just driving to the beach and working from a boardwalk for a couple hours. 
- 5:30pm - Appwrite Integration has replaced the Strapi Integration! Now I am going to test case some basic examples and see if I can play. One of the issues that I am currently facing is the Coroutine / Asynchronous problem but there are enough reference points to resolve it. 

## Quote

> Truth is powerful and it prevails.
> — <cite>Sojourner Truth</cite>

---

## Tasks

- [ ]

---
# June: 14

> June 14th. More Github Actions.

Source: https://kbve.com/journal/06-14/

import { Adsense } from '@/components/astropad';

## 2025

### Waffle

-   07:39PM

    Waffle can now load the droid library from the CDN but the additional workers are still not getting built.
    I believe 2 of the 3 init workers are failing and its because of a relative pathing issue.

### Droid Library

-   08:28PM

    The droid library is going through another update, we got it working on the astro side without any major issues but it still fails when doing the ESM/Skypack deployment.
    I have a couple ways that we could resolve that issue, I just hate having to go through the looping process of having to test each possible fix.
    We will have about 3-5 more attempts, so I expect us to hit around 0.0.20 before reaching 0.1.0, ugh.
    So much time will be spent on such a silly issue, oh well, it will be part of the learning process.

-   09:50PM

    Library still has some issues that need to be resolved, but I might just move along and focus on other issues.
    Getting the whole register and login working again, still have not yet resolved it within the past couple months, should be the focus.
    Furthermore, we have to rewrite again the whole table structure for the profiles, thus making it another painful point that needs to be addresses.

## 2024

**Action Rant**

The worst feeling about this whole github actions integration is that it does not make any sense to do all this extra work in 2024.
The whole concept of making modular actions should be so much easier than this level of abstract bs. 
I can not wait to go back to doing anything else than sitting here and going through multiple loops of annoying steps to get something so generic to work.
This now makes sense why there are all these startups that offer github based issue ticket services, if github spent a decent amount of time improving this horseload, it would be great.
Enough ranting.

**JSON**

The json format for the github actions seems to be giving me some abstraction errors, so instead of passing the keywords as an array object, I will have it pass a URL.
The URL will be the JSON location for the keyword / action combination, maybe later on, we can utilize that for some more interesting concepts.
Okay, updated the github action to accept the keyword as a JSON location.

**Deprecated**

We will go ahead and `deprecate` the `i-music-process.yml`, merging it all into a single workflow that will handle everything related to mix-usage of `atlas` and issue tickets.
When I was building this out earlier, I was thinking of having it be a bit more modular and yet I found it to overcomplicate the situation.

Ugh, it seems that I will have to rethink the way that I am building out these actions, I am going to move all the recent ones that I made back into the `deprecated` and start again fresh.
This sucks but the amount of random bugs and issues that I am running into is way too high, almost nearly pointless in making any of the actions modular.


**Jukebox**

The next update that I want to do for this weekend is for the jukebox's ability to play in background mode on the phones.
This way I can listen to the music while my phone screen is closed off, there might still be some tweaks that will prevent this from happening.


**NPM**

The best solution that I can come up with would be to release a `npm` package under the `@kbve/gha` and then we will just call that for all our actions.
I will make a bunch of custom functions within this library and then use action scripts to call it directly.

After updating the nx to do independent releases and adding the npm token, we can start adding in the npm release via the ci-main.
Goal for this weekend will be to get `@kbve/khashvault` released and get the base of the `@kbve/gha` built out, I believe I should get bonus points if I can get both released without any issues.
I should also look up the requirements for releasing the NPM package at an organization level, but there should not be any major problems in doing so.
As for the documentation for each of the libraries, I believe we could link the `@kbve/gha` directly to our github actions section within git, even though it is javascript.
Khashvault will go directly into the javascript mdx within application, with an id link in any specific areas.

<Adsense />

## 2023

- 6:00am - Rise and Shine! Today will be an amazing day! I did not get as much sleep as I had hoped but I am feeling empowered and ready to tackle the world! 
- 8:00am - Going to take a break from the internet for a while, time to touch some grass.
- 2:00pm - Back from my break, time to get to work. I believe today's goal will be to get OneJS operational within the main branch of RogueJester and then start to fix up the UI/UX of the game, with something that will be a bit smoother on the eyes. 
- 3:00pm - Had to put the development stuff on hold because I need to call the Medicare office for my family friend. I need to figure out what type of insurance she has through Medicare? I am taking on this task as a test case / edge case for future problems that I might have to deal with. The queue is way too long, the hold music is painful and it feels like torture when calling Medicare aka the `1-800-633-4227`. 
- 3:30pm - Turns out that we need to find her comprehensive supplemental insurance through the private market. This type of insurance would cover the 20% of the medical bill that Medicare does not cover, but there is a monthly cost for this type of private insurance. I will have to go through the existing providers and see which one would be the best for her.
- 6:40pm - Updated the OneJS and Heathen SteamWorks into the dev-holy branch, now I am going to chill out and play some sessions of League.
- 9:30pm - Did a bit of cleaning, removed a decent amount of bulk waste from the shed, basement and the guest room. Now I back to the basic of Unity while I train up my OSRS account!

## Quote

> I cannot make my days longer, so I strive to make them better.
> — <cite>Henry David Thoreau</cite>

---

## Tasks

- [ ]

---
# June: 15

> June 15th. NPM.

Source: https://kbve.com/journal/06-15/

import { Adsense } from '@/components/astropad';

## 2025

### Worker Vite Issue

-   01:15PM

    After a late night of beer infused thinking, I was able to resolve the web workers.
    Had to use a vite configuration from the astro side to build the three worker files, which were then built and passed through as a workerRef.
    Now the supabase sdk will run on the `window.supabase` for now, before we setup a worker instance, which will be under `window.kbve.supabase`.
    Having both the main thread instance and the web worker instance will be an interesting test case because we would have two active connections per user?
    That might have some performance issues, so I will have to think through exactly how I want to go about handling that.
    Next, we need to restructure the user profile and the ability for users to create profiles and balances for their credits / khash.
    I am a bit afraid to use supabase edge functions to handle this, I would rather have a better solution for it, so I am going to think about it over some time.
  
### Not A Fathers Day

-   05:30PM

    Quick shoutout to an old beer brand that just died off, not your fathers root beer and ginger ale was actually a great product.
    Back in the day, the way to keep soda safe was to include a bit of alcohol. 

### Unity Session

-   05:53PM

    Preparing for the unity session, just looking over the note sand making sure that I am ready for the next part of the session.
    There are a couple of things that we need to resolve within the gameplay loop but I think that it should be easy.



## 2024

**NPM**

The joys of NPM!
We want to publish two packages by the end of this month, one being the `khashvault` and the other is `gha`.
Both of these are important in their own eco-system, just the small little errors here and there are taking a bit to process.

**Chess**

While we were talking on the Discord, a custom chess style game, where we can do 1v1 or 2v2 would be really fun to make!
A similar concept of autochess or autocombat blended into it the gameplay, taking a bit of that advance wars style gameplay too.
I can not wait to get back into game development, that itch needs to be scratched.

**KhashVault**

Yay! We were able to get the main khashvault released as a NPM package.
Yet there are still some errors that we need to fix, including the peer dependency.
Now the question is how would we go about doing it within Nx development cycle, and then we also need to get the `gha` library out there.

**GHA**

Okay! It seems we will have to go back around and update our external libraries, so that will be easier to build and deploy them.

In our case, we want to add the `gha` aka `github actions` library, so let us build out the basics of this lib.

```shell

pnpm nx g @nx/js:lib gha --bundler=vite --importPath="@kbve/gha" --publishable=true

```

This is the package json that we created for this library.

```json

{
  "name": "@kbve/gha",
  "version": "0.0.1",
  "description": "A GHA helper library, providing better functions.",
  "keywords": ["github", "actions", "helper"], 
  "homepage": "https://kbve.com/application/javascript#gha",
  "bugs": {
    "url": "https://github.com/KBVE/kbve/issues"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/KBVE/kbve.git"
  },
  "author": "KBVE <hello@kbve.com>",
  "license": "MIT",
  "dependencies": {},
  "peerDependencies": {
  },
  "main": "./index.js",
  "module": "./index.mjs",
  "typings": "./index.d.ts",
  "publishConfig": {
    "access": "public"
  }
}

```

It seems that the bundler being `vite` is throwing some errors that I do not think we need to debug.
Since this is the case, we could setup back and remove this library.


## 2023
- 9:00am - Will SPY keep going up? Damn I am printing money from these covered cash puts. I was hoping to grab an assignment yesterday when I was selling the $434/435 but it closed at $437.
- 10:0am - Going to take a quick break from the Internet and spend some time in the real world.
- 7:25pm - Stream Darts , the Always Sunny in Discord Edition. The concept is a high thought that we are test casing right now. The first duelist were @ziggy and @mrock, they did a rock paper scissors to determine who would go first.
- 7:57pm - The match is getting hot and heavy! As we cross intermission, @Ziggy is at 318 and @Mrock is at 225. Its been a close match but @Ziggy has been slowly gaining a massive lead over @Mrock. The crowd has been going `wild!`, almost as if they were infused with Alex Jones' special water.
- 7:58pm - Going to start the Webmaster react form from scratch again, hopefully I can get it out and ready by tonight. @Ziggy is now at 415 and @Mrock is 303! So close, and damn @Ziggy hits a 2, now at 417! @Mrock is closing in at 345!. OH NO! @Ziggy scores a double one, sitting at 419! @Ziggy wins with a 424! @mrock finishes with a 348! Great game boys!

## Quote

> A man cannot be said to succeed in this life who does not satisfy one friend.
> — <cite>Henry David Thoreau</cite>

---

## Tasks

- [ ] Building out WebMaster Tools [Issue](https://github.com/KBVE/kbve.com/issues/601)
- [ ] Updating BizOps Document [Issue](https://github.com/KBVE/kbve.com/issues/600)
- [ ] Cloud Functions Printful Scope. [Issue](https://github.com/KBVE/kbve.com/issues/602)
- [ ] Created Mermaid React JSX [Issue](https://github.com/KBVE/kbve.com/issues/599)

---
# June: 16

> June 16th. Vite.

Source: https://kbve.com/journal/06-16/

import { Adsense } from '@/components/astropad';

## 2026

### ValKey Timeouts

-   01:29PM

    Looks like our wallet balance route that we added into the Axum KBVE has been timing out because of a valkey rbac issue.
    So I will have to implement two ways to solve for this, the first is getting it shortcut out of the valkey and use the read only connection from the postgres pool.
    While I write that out, I need to check the valkey configuration, since we did drop redis from the cluster.

### CryptoThrone NPC

-   01:56PM

    We need to hook up the NPCs for the different parts of cryptothrone.
    I will have to find a way to render the way that they look, hmm that will be an adventure itself.
    The NPCDB is definitely lack luster and needs work.


## 2025

### Supabase Message System

-   06:40PM
    
    One of the things that I wanted to do was setup an internal classic pm style.
    There are still some issues that I will have to resolve but I think this should be a good way to go about handling it.
    While it makes sense that we are sending the messages back and fourth, there are a couple things that I will have to address, like making sure that the API endpoints can be hit without any major costs.
    We also have to do the stock pages, ugh, so many things to still to finish building out.

-   08:28PM

    The new message inbox looks great, I believe we can loop back around once we get a better idea.
    Instead of going directly with the idb saving, I will opt for this more traditional method until we get a bit more data and feedback.
  

### Credit Coupons and Rewards

-   08:50PM

    A reward system is next on our block, but the way that I want to build it out will have to contain multiple moving parts.
    We can focus on getting the base credits rolling through maybe social media style rewards but ehh, there might be some other ways we can do it.
    I might have to sleep through it and maybe it will come to me later on.


## 2024

**Arena**

Since Shaco keeps getting ban in Arena, I decided to pickup Sej and she is becoming more of my favorite new champ to play.
Just played a quick game of Naut and Sej, it was possibly the most broken arena session that I played in a long time.

**GHA**

There seems to be an issue with how the GHA library is building the publishable `NPM` package, but I think I was able to resolve it.
The [bug](https://github.com/nrwl/nx/issues/21855) seems to stem from where it places the published files.
Also during the unit test, the less than 26 characters test fails, but I will get back to3 that once I get this pipeline to publish the workflow.
In order to trigger the build, I will have to do a quick minor bump of the `gha` library!

It seems that the exact issue that we are facing is under `#21758` but that means we will have to migrate our nx to v19.
So in order for us to resolve this vite build bug, we might have to break a bunch of other tooling.

We changed the output to :

```json

        "packageRoot": "dist/packages/{projectName}"
```

However, I believe that was not the issue, so I am going to revert that change to this:

```json
        "packageRoot": "dist/{projectRoot}"
```

and then we will go ahead and add the `rollup-plugin-copy` package into the monorep.
This plugin will help us patch the missing package.json? I am not too sure but we will give this a shot.
To trigger another update, I will do a minor bump to the `GHA` library.
We know that there are two or three more errors that we need to resolve, but getting past the NPM issues would be the best move right now.

The error might have been in the way that I am doing the `release` overwrite?
I went ahead and removed them for the time being, maybe it might help resolve some of the issues:

This was my `khashvault` release information:

```json

"projectsRelationship": "independent",
    "version": {
      "preVersionCommand": "pnpm dlx nx run-many -t build"
    }

```

yet, in this case, I will revert to having nothing inside of the brackets and see if that can help.
Hmm, logically this does not make sense but we can give it a shot for now.
I really might just move onto to another project and give this a bit of a break, I learned a decent amount from spending a couple hundred hours within this area but the errors are just a huge pain.

The major issue that is holding us back is that for some reason the nx release process is not including a copy of the `package.json` within in the distribution.

**Apps**

We will probably want to migrate a decent chunk of the apps out of the monorepo.
I will compile a list of applications and make an issue ticket revolving around the ones that we want to consolidate and migrate into just a couple applications.

**Nx v19**

It looks like there were way too many errors when migrating over to nx v19.
The additional community plugins that were added into this monorepo are causing some additional errors with v19, a decent amount of the functions are broken too.

During the migration, we had two plugins give some rough errors, that is our rust plugin, which is still extremely outdated and the astro plugin but that has a fix in the pipeline.

<Adsense />

## 2023

- 8:00am - Need to change my sheets again, damn weather is wild. In the summer heat, I am thinking every week the sheets might have to be changed.
- 10:00am - I might be assigned on a couple call options for TSLA again this week! I will have to be very careful and maybe roll them out for another week, the premium of a couple hundred will be helpful to offset the RogueJester costs.
- 1:30pm - Watching episode 8 of the Silo and doing some quick updates to the webmaster tool. I am currently thinking to just get a basic tool out there and then over time expand it to include various services.
- 5:00pm - Grabbed a quick burger with @Mrock and we went over the GoPro equipment for a future session / podcast? This is still something that is in the works, but I am thinking we could some random events / stream some meme-style content and see where it goes from there? For the burger, we went to a local joint known as 30 Burgers! I went with my usual 12, which is a bacon & egg burger and he had gotten the 7. We would say they were a solid 7 out of 10, there could have been some improvements, the burger size was just a bit too small from my point of view.
- 11:00pm - The basics of the webmaster tool is ready for a quick test casing, however I was unable to get the storage (`nanostores`) to work as intended. One of the concepts that I was thinking was to store the domains inside of the local storage and then call it via tasks.

## Quote

> The first step to getting the things you want out of life is this: decide what you want.
> — <cite>Ben Stein</cite>

---

## Tasks

- [x] Launch initial webmaster tool onto the main KBVE website.
- [x] Begin migration towards the vCluster within the production-2 dedicated server.
- [x] Grab food with @MRock and do a quick podcast session.

---
# June: 17

> June 17th. DevOps.

Source: https://kbve.com/journal/06-17/

import { Adsense } from '@/components/astropad';

## 2026

### BlackJack Cryptothrone

-   09:15PM

    The goal will be to have a small casino inside of cryptothrone, so my players can enjoy some poker.
    I am thinking the two major games will be poker and blackjack, afterwards I might try to integrate some other games.

## 2025

### Dark Mode KBVE

-   04:00AM

    The website looks terrible in light mode, so I am going to try and just strip all that out and keep it dark mode only.
    This should make things easier on the browser and avoid that terrible flashing that occurs when the site is loading.

### Unity Build failure

-   08:30AM

    Looks like the build failed but I am not too sure why it did, maybe it was because we had those extra files.
    Maybe it was because I included the assembly files by accident, hmm but that does not make sense.
    Let me think what else could have been the problem?

-   10:18PM

    Ended up taking a nap, which turned into a whole sleep but damn these two build failures are going to drive me insane.
    I have officially found the next level of hate in software development.
    It works in developement but breaks in production, yet the errors do not make sense.
    One could argue that unit tests would solve this, but this be like higher level testing maybe?
    When building the game in the unity editor, there is no error that 

### StrudelCC

-   09:17AM

    While I am working on the game, I been just messing with this site, creating some crazy music on the side.
    Honestly, this is going to become way too much fun if I dont stop soon, but this would be perfect for chips website.
    Hell, I might even import it into the music player that I was building, so that I could play music ontop of the youtube music that we already have.
    A jukebox that not only plays music but gives the option to add custom soundtracks.

## 2024

**DevOps**

Okay so for the current v18, there seems to be a build error in `gha` and I think we will just migrate this concept library over to the `devops` library.
Let us start with the base command to create the library.

```shell

pnpm nx g @nx/js:lib devops --importPath="@kbve/devops" --publishable=true

```

We will keep track of this on [this issue](https://github.com/KBVE/kbve/issues/1955).
After creating the base of the library, we can go ahead and commit the changes we are planning for this `gha` to `devops` migration.

Finally we got the base of the devops library in operation, just need to finish making sure all the information within the `package.json` is up to date and we will go ahead and trigger a minor bump.
We can have this move up in the pipeline and while we wait for that to build and process, we can start to expand the library with the various functions.
For the test case, I went ahead and added the `axios` library, but I noticed that we would have to update the dependencies manually, which is a future painpoint that must be adjusted for.

Looks like the library was built and was published into the NPM registry, now we can move forward with expanding that said library with different functions that we will call within the workflow.

Going to look through the different github actions that we were planning to add and slowly migrate all the custom functions into the `@kbve/devops` library, then go back and activate each one as we see fit.
Added two more libraries into the monorepo, `marked` and `dompurify`, both of which will be used within the sanitization.ts to help clean up the inputs from the different variables, like the issue ticket's body.

We added the `api.ts` and `sanitization.ts`, with the basic unit testing, and we can now rebuild the issue ticket processing.

There was an error doing the release of the package, maybe it might have been the same version or a version bump error?
Here is the error:

```

  npm dist-tag add error:
  Something unexpected went wrong when processing the npm dist-tag add output
   TypeError: Cannot read properties of undefined (reading 'summary')

```

Let us try going to version `0.0.4` and then seeing if we still get this error.

**Nx**

I made an issue ticket to keep track of the [Nx v19 migration](https://github.com/KBVE/kbve/issues/1954)
Making sure the `nx.json` was updated to make sure that they dry run does not generate files.
Before moving forward, we will go ahead and sync these changes and make sure that there will not be any major issues during this process.

## 2023

- 10:00am - Garden time! The blueberries are almost ripe and ready to be eat, that is if the birds do not take them apart. Once that blue hue starts to come out, the crows start to feast.
- 11:00am - Going to have a nice and relax Saturday, a couple quick H sessions and some general chill vibes until later tonight. The main focus will be to prepare the NodeJS / Python cloud function, which I could turn it into a custom cloud function, with automatic build and deployment? 
- 3:00pm - I started a great book from Julian Baggini called `The Duck That Won The Lottery`, I will try to include some cute notes and feedback while I am writing these random journal entries. The preface is legendary, I am already loving the starting quote, `Doing things right is simple: just elimin ate all your mistakes and then you'll be perfect.`! I went to highlight the sentence and ended up over highlighting it? To infuse more grace to the fire, the lofi remix vibe added a layer of poetic justice. I am not even looking to backtrack.
- 8:00pm - Settling down after a couple league sessions, the first concept will be to migrate out the cloud function from being just a python script into the NodePy setup. The main objective will be to migrate certain key components out of the basic setup, hmm this might be a bit tough to write out. The docker image that I will use is from `nikolaik` , under `nikolaik/python-nodejs:latest` and I believe that it is a Debian-based operating system. Based off the Github, it looks like Node 20 and Python 3.11, which I should not as the target for this image? Or should I keep it to the latest? Hmm... That might have to be a future problem for my future self.


## Quote

> Be faithful in small things because it is in them that your strength lies.
> — <cite>Mother Teresa</cite>

---

## Tasks

- [ ] Deploy a basic hybrid cloud function with a load balancer.

---
# June: 18

> June 18th. DevOps.

Source: https://kbve.com/journal/06-18/

import { Adsense } from '@/components/astropad';

## 2026

### KBVE Gate

-   07:39PM

    The kbve gate will be a way to control access to certain endpoints by double checking their JWT.
    We can consider this as a cloudflare trust access style gateway but we control it via our supabase is staff bitmask.
    The issue with the gate is that we are not able to keep track of the cookies that get assigned.
    I might have to create a rbac policy to make this easier, maybe even a JWT-based valkey to help quickly verify certain actions?
    There is room for us to expand the gate, going to look into it now.

## 2025

### Naruto

-   01:50AM

    Rewatching naruto is like traveling back in time, when things were just easier xD.
    I forgot how bad the animation was back then but its okay because the story is great, plus skipping all the filler episodes only makes it easier.

### Unity WebGL RareIcon

-   03:47AM

    Still having more build errors from unity and its getting me a bit upset.
    I am not too sure where the issue is but I am going to do another full scope build, this time with no cache and maybe that might help resolve the issue.

-   04:01PM

    Going to disable the WebGL build for Rareicon until I figure out a way to resolve that build error.
    I might have to move all of steam into its own extension and then focus on using that as a way to resolve the build errors.
    This should be a focus right now but I also do want to get a steam demo out of the way faster.

### RareIcon Card Game

-   02:43PM

    While building the unity game, I am thinking that we should not leave the WebGL users in the shadow and since we have a GoDot background, maybe we could have that build into the game?
    A simple card game should not be too hard for us, given that we have a bunch of things already in place!
    We could re-utilize the itemdb that we made for the rareicon unity game as turn that into this rpg style card game.


## 2024

- 6:41am

**Lift**

I need to hit my bench more often, maybe aim for about 3 sets of 100 reps today, I will space them out in the morning, noon and sunset.

**DevOps**

We got the library to publish, it seems that the pre-patch and patch style publishing did trigger a failed build yesterday.
This means we will focus on doing small patches throughout this month and maybe even extend it out to different libraries down the line.

We can start to expand out some of the utility class of the devops library through the `/client/` folder.
I believe I will keep the structure similar to the way that I did atlas for now, without having to over think it.

Added a quick little image for the library while I updated the readme, now we can go ahead and prepare a npm publish.

Lets run this shell command to bump it up:

```shell

pnpm nx release --projects=devops

```

**YT**

Spent most of the day going through my notes, cleaning up and preparing the `yt.ts` file within the devops npm package.
I added some decent bare functions, which I plan on extending out into the github actions once they get published and released!
To be safe, I went ahead and added some generic test casing, which I am doing locally but have not yet integrated those unit tests within the CI/CD pipeline.

The way to execute our unit tests, we just run this shell command:

```shell

./kbve.sh -nx devops:test

```

This will then run pnpm nx with arguments: devops:test and generate a cloud nx link with the test results.
However, placing this within our main ci-cd pipeline, ideally inside of the `alpha`, and/or `beta` would make sense too.
I have it in my notes to find a couple spots to do the unit tests, ugh, I just do not want to overload the actions.



## 2023
- 5:15am - Short nap but I must get back onto the grind! The first concept that I was looking into was getting the basics of the Cloud function LoL Python going and somehow I have turned it into the PyNode project that I was thinking about earlier. While I liked the general feel of flask within Python, it was a bit too slow when I was doing some general stress testing and for that, I am not willing to deal with it. 
- 5:30am - I am thinking for the YouTube functionality, I should extend out the YouTube-Dl from Python, https://github.com/ytdl-org/youtube-dl, which I will also reference inside of the Python notes. I noticed there were a couple repos floating around with a large collection of scripts too, something that I might look into in the future.
- 5:30pm - Fixing up LoLPython for a bit before getting dinner with the family. There will be a couple test casing that I will have to do because it has been a while since I used Python.

## Quote

> Anything you really want, you can attain, if you really go after it.
> — <cite>Wayne Dyer</cite>

---

## Tasks

- [ ] Add YouTube Download to PyNode
- [ ] Add League of Legends Champion Information via API

---
# June: 19

> June 19th. More Operations. More Pain.

Source: https://kbve.com/journal/06-19/

import { Adsense } from '@/components/astropad';

## 2026

### MacOS Runner

-   04:15AM

    The macbook runner is almost ready, we also want to make it have cache improvements.
    I am thinking the goal will be to make all of it first in class and give us the ability to scale them out.
    Another area that I would like to focus on is sdcard based reading and firecracker deployment.
    It would be cool to have some python scripts run from the web on my macbook runner, a bit of isolated fun per say.
    Furthermore, we could even automate some of the browser concepts we were thinking aobut in the future.

## 2025

### Starting Stocks

-   05:50PM

    Going through the S&P 500 list and going to add each of the company listed, with the goal of having about 500 companies, before adding more of the random ones.
    After we get majority of the companies listed, then it will be the ETFs, REITS, CEFs, Bonds , ect...
    Furthermore, we will have to build tools to grab data and render the charts as well.

### Admin Schema + Table

-   08:49PM

    The next move would be fix the material view refresh and that means we would have to create basically an admin schema.
    This is the sql schema that we would create for admin.

```sql

-- Create the admin schema
create schema if not exists admin;

-- Revoke default PUBLIC access
revoke all on schema admin from public;

-- Revoke access to objects in the schema from anon/authenticated
revoke all on all tables in schema admin from anon, authenticated;
revoke all on all functions in schema admin from anon, authenticated;

-- Grant access to service_role
grant usage on schema admin to service_role;
grant select, insert, update, delete on all tables in schema admin to service_role;
grant execute on all functions in schema admin to service_role;

```

## 2024

**DevOps**

The library is officially released onto the NPM registry, you can see it [here](https://www.npmjs.com/package/@kbve/devops)!
I did notice that the image was a bit too big for the page, so from 540x540, I decided to resize it to 400x400.

Now we still need to test the library out in our github action test case but there are still some functions that are missing that we need to adjust for.
The next function that I am going to add into the library is the `_title` function and that will be used to clean up the issue ticket title before calling an action.
We want to make sure that it gets trimmed down to 64 characters and avoid generic regex attacks.
I am thinking there might be still some weird strings that might get through the filter, but we shall see.

The next issue seems that the npm package does not actually build the javascript files but rather just uploads the typescript files.
While this is okay, we still need it to build the actual javascript files too, which I think is because we do have not the right path setup within the `project.json`.

The most recent package release failed but I think its because we need to manually trigger the build?
Inside of the `ci-main.yml`, I went ahead and added a commmand to build the package.

```yaml
- name: Build KBVE DevOps NPM Package
  uses: ./.github/actions/kbve-shell
  with:
    flag: '-nx devops:build'
    create_pull_request: false
    github_token: ${{ secrets.GITHUB_TOKEN }}
```

We will build the application before preparing to publish it.


**Repo**

We will have to clean up the monorepo and remove a bunch of older libraries and dead projects, I am thinking of doing it slowly and making sure to back it all up as I do so.
Each instance should be saved in multiple areas, but we also want to make sure that we are not removing anything major that is required for anything in production.

Furthermore, we have to make sure any of the apps that get removed, also do not trigger any specific build.
I already went ahead and removed some of the itch builds, so our games would not get affected but I will have to go back and fix up the docker cicd builds.

The first project we can check to remove is the `js-embed-passport` and `js-embed-passport-e2e`.

---
# June: 20

> June 20th. Monorepo Cleanup.

Source: https://kbve.com/journal/06-20/

import { Adsense } from '@/components/astropad';

## Notes

The `Atlas` project needs to process the tickets but without the monorepo.

---

## Quote

> If I know what love is, it is because of you.
> — <cite>Hermann Hesse</cite>

---

## Tasks

- [x] Update Taxes, including the Annual Forms.
- [x] Start Mother-in-Law Construction Research -> Moved Task.
- [x] Start Living Trust Research -> Moved Task.

---

## 2026

### UE5 Mac Release

-   04:56PM

    It is almost time for the mac release of chuckrpg!
    We can get this out of the way very soon!
    While that is being built out, we could look into the iOS builds.
    We want both UE5 and RN, but it would be nice to get Unity and Godot out of the way too.

-   06:15PM

    Preparing the release of v0.3.28 and hopefully we get the mac release out with this build.

-   06:20PM

    Bumped unreal-chuck-beta to v0.3.28. Created iOS build tickets (#12875 UE5 iOS, #12876 RN iOS) with new `ios` label. Same Xcode/certs for both pipelines.

### IOS Builds

-   05:14PM

    The next goal will be to get iOS hooked up, then we loop back around to android.
    This will be our last logistical pipeline, then we are fully ready to build and distribute the packages.



### Metric Improvements

-   06:05PM

    We want the ArgoCD, Clickhouse and Grafana all giving us accurate information.
    Eventually we will bundle them all into a single metrics dashboard that we will scope to help us find degraded or burst issues.
    The idea will be to first focus on the backend side, but later expand into the front end, giving us our own sentry style eco-system.

## 2025

### Sleep

-   11:15PM

    Just got up, spent most of the day just sleeping, I will have to loop back to my written notes and update todays entry.

## 2024

**Monorepo**

Cleaning up some of the older projects within the monorepo!
We will have to remove enabled three js and maybe ammo too, these projects are still a bit too early for what we were aimming for.
Next project we will be removing is the `expressdiscord` and maybe even most of the colyseus library.
While I think its fine to use nodejs for small projects like this, I feel like the networking might be a bit of a pain via this library and it would make more sense to just use rust.
We can work with the axum sockets and get better performance / stability than using the colyseus library.

Removing the `e2e` test case for the `expressdiscord` is the next step.
While I am doing that, I will tackle the Adsense missing in the older journal entries.

The best way to remove this without breaking anything is to do it in small parts.
Slowly migrating the changes into the main branch, without doing it all at once!
I am thinking of slowly removing the pieces that we do not need, but limit it to about a couple patches every week.
This gives us time to backup everything but also make sure nothing is out of bounds or cause massive failures.

**Express**

Removing the `express-colyseus-discord` application from the monorepo, well the `e2e` test case for the application.
I will swing back around after this release to remove the whole application.
We should also start to take out the libraries that are causing the npm error, which is the `enable 3d` library.
The error is because they did not update to the latest three js library and their types are a bit of a mismatch, and since we will not be using them, it just makes sense.

Now we will remove the whole application next since the main branch was updated.
This next push will be the removal of about 19 files, but for the most part, it should be safe for now.

**Disable The Enabled**

Since we are moving away from the `enabled` library, it would make sense to document the removal of the said libraries.

```shell

pnpm remove @enable3d/ammo-on-nodejs

```

The first library that we will be removing is the `@enable3d/ammo-on-nodejs`.
Next we will go back to our `03-19.mdx` notes and remove the colyseus from :

```shell

pnpm remove colyseus @colyseus/monitor @colyseus/schema @colyseus/uwebsockets-transport @colyseus/ws-transport

```

For the remaining `enabled` libraries, we will run this code:

```shell

pnpm remove @enable3d/ammo-physics @enable3d/common @enable3d/phaser-extension @enable3d/three-graphics @enable3d/three-wrapper

```

**Atlas**

Ah the issue of the peer dependency is because we did not start with an empty folder, but rather the main branch.
We could disable the repo checkout for a couple of the initial operations and then work around that?

---

<Adsense />

## 2023

- 11:00am - Woke up a bit late today! :C
- 2:50pm - Getting ready to open up my midgame office hours! I started to update some of the unity projects and just did my first plastic merge. It was a bit scary, as I hate when I accidently do a rebase or something terrible lol. There were a couple issues that I ran into when merging the main branch into my dev branch. I believe I should have went the other direction but in the future we want to make sure that the main branch is functional before we put any changes onto it. We should also limit the off branch changes to a couple days, so that we are not stuck in a huge problem where the branch forks are really offset.
- 4:20pm - Making quick plans for dinner! The craving for El Portal is real, I am dreaming about the Mexican restaurant! If you are ever in North Jersey, this is one of the best places to grab food, even if you are vegan.
- 4:30pm - Updated Gena but it looks like the Unity main branch has a couple broken files. The HealthManager seems to be causing the project to load into Safe Mode. I will take a day break from Unity and switch back over to the main website, I am opening up the Postboy and Manga side projects for the website. I also noticed that the webmaster tools needs to be updated. The best option that I am seeing right now might be to just convert the older code base into the general tailwindcss and then migrate the typewriter effect into the react library, where I can reference it from there.
- 6:30pm - El Portal with the homies, once I get back, I will make a decision on the the future of the Manga and how I should move forward with it.
- 11:30pm - After testing a couple concepts out, I think having a MDX file for each page and then letting the writer(s) pick and choose options to display might be the best bet. This would help offset any future SEO issues and also give us the flexibility to add our own custom content, including videos! The big issue that I ran into was if we wanted to do a build-your-own path for the visual novel. The complex index system would be a bit more tough to do within React.

---
# June: 21

> June 21st. Fixing Atlas Issue Process.

Source: https://kbve.com/journal/06-21/

import { Adsense } from '@/components/astropad';

## Notes

The month is almost over! The summer heat be rough.

---

## Quote

> If you would take, you must first give, this is the beginning of intelligence.
> — <cite>Laozi</cite>

---

## Tasks

- [ ] Start Mother-in-Law Construction Research
- [ ] Manga Codebase Refresh
- [ ] Start Living Trust Research

---

## 2026

### Unreal Mac

-   11:15PM

    Looks like the mac operating system pipeline is complete, so we now we have a full three build set.
    This means we can look into making improvements further down the line for iOS and android.

## 2025

### Dashboard for Project Fudster

-   10:27AM

    Finished updating the dashboard for the fudster project, now I can loop back and start the command center.
    It took just a bit longer to fully understand the secrets but its good to go now!
    We will start with the basics, making sure the login system works without any major hicups and then see if we can make changes from there.
    Setting a pending state would be wise, that will be something that I will look into, maybe a genral state management based upon the machine.

### Unity

-   9:30PM

    Session went great, got a better understanding of where I need to patch up the rest of the game.
    Moving all of the character state and orchestration into a refactored r3 will be the next goal for this week.

## 2024

**Atlas**

Going to update the `i-atlas-process.yml` by removing the initial checkout for the first couple actions, as we do not need the whole monorepo.

```yaml
- name: Checkout repository
  uses: actions/checkout@v4
```

This step within the job is not needed, so we can remove that for the time being.

Okay we were able to get the comment to be placed onto the issue ticket and resolved the npm library issue that we were facing earlier.
Now there will be a couple steps that we need to execute, it will be kind of like putting together a puzzle set.
We already know that the pieces are functional but the orchestration has be secure, ensuring that there are not leaks or mismanagement amoung the different steps.

In our first stage, the focus will be on only two actions that we want to execute, the `atlas_action` and the `music_action`.
Once we get these resolved, we can move forward with the `herbmail_action` and `rareicon_action`.
Granted we are very much behind schedule, maybe we can try to force some concepts through this weekend and get back on track.

I just spotted a quick error, inside of this action script block:

```yaml

      - name: Check title of the ticket
        id: title-parser
        uses: actions/github-script@v7
        with:
          script: |
            const { _$gha_kbve_ActionProcess } = require('@kbve/devops');
            const title = context.payload.issue.title;
            try {
              const action = _$gha_kbve_ActionProcess(title);
              core.setOutput('action', action);
            } catch (error) {
              core.setFailed(`Error processing title: ${error.message}`);
            }

```

We need to wrap the `_$gha_` action within a try-catch, because it will throw an error.

**mL**

Just a minor shift in the mL docs, there is a decent amount of information and links that are missing from the whole document, but I think I will take a couple stabs at it slowly.
We should have a jupyter notebook section and it would be really interesting to have atlas open them up and execute commands against them?
Now I am really running the gears in my mind.

**Prompt**

Need to test out the prompt engine and make sure the devops library can grab the different prompts, based upon their ULIDs.
We went ahead and added the prompt engine types into the `api.ts` and made sure the tests ran without any issues.
Now we need to prepare to extend them via the Github actions, hmm.
This might still take a bit, because I can already see some common errors that we will face as we build this out.
The converting and preparing of the prompt engine is definitely still too whacky and needs some solid refinement.
Right now, we are just passing through just the task section of the prompt engine and not including any call functions, pathways or tree chains.

**Claude**

Taking this for a spin while I am about to sleep!
So far, I am going to say that 3.5 sonnet is doing great, if anything, it might be fun to use it with groq and openai.
It provides a great level of feedback and is able to pickup on what I am trying to do via github actions without any flaws.

**Action**

Switching back around to the github action, while the recent changes are being tested and pushed into main, I think it would be wise to start our execution job.
After the music handle job is done within the `i-atlas-process.yml`, we can run a new execution job that will pull in the repo and make the pull request.
The objective would be to smoothly make a minor change to the proper mdx file that the song is suppose to be in.
Granted this will not happen right this second, but if we can lay down the foundation and make sure everything runs smoothly, than our goal of updating the jukebox via the static page itself will be near complete.
I started to add the generic handle execution job, which I will push out now.

**Sanitization**

Now that I am thinking about it, we should account for the table changes and make sure the title is escaped.
Here is a quick function that would make sure that the title of the song will be markdown safe, we will have to be careful not to break our markdown table.
```ts
/**
 * Makes a string safe for use in a markdown table row.
 * @param row - The string to sanitize.
 * @returns Markdown-safe string.
 */
export async function _md_safe_row(row: string): Promise<string> {
  // Escape special markdown characters to prevent formatting issues
  const mdSafeRow = row
    .replace(/\|/g, '\\|')   // Escape pipe characters
    .replace(/_/g, '\\_')    // Escape underscores
    .replace(/\*/g, '\\*')   // Escape asterisks
    .replace(/\\/g, '\\\\')  // Escape backslashes
    .replace(/\[/g, '\\[')   // Escape opening square brackets
    .replace(/\]/g, '\\]')   // Escape closing square brackets
    .replace(/\(/g, '\\(')   // Escape opening parentheses
    .replace(/\)/g, '\\)');  // Escape closing parentheses

  return mdSafeRow;
}
```

We also do have an escape function added into the `music.sh` that will escape, but this is just to be safe in the future.

The pull request was the last failed workflow and I also noticed it grabbed the actual song title, rather than keeping the artist / band.
In our markdown table, we are keeping both the title of the song and the artist/band because breaking it down further might not be worth it right now.


<Adsense />

## 2023

- 8:30am - It seems that I was assigned again on a SPY put, so forced to buy 100 shares of $SPY. I might also get assigned on one of my TSLA calls, but at the same time, my puts look like they expired with a decent amount of profit. Overall this week looks like another $2000 in the bag, which I will most likely allocate towards CEFs, as my REIT position is already above 10% of my portfolio. I might also look into adding a larger position of bonds too, including some meme bonds.
- 5:00pm - Decided to delete the older manga reference files, including the abstract theme. I am going to start it again but with a fresh take and maybe a more internal / core approach to resolve the issue. As for the transition effects, we could reference the older SWUP but we can also utilize the pre-fetch to help load the options before hand? There are a couple ways we could go about this.
- 11:00pm - It looks like the basic layout for the manga / visual novel looks like it can be a MVP. I am going to mess around with the settings and see if we can expand upon that.

---
# June: 22

> June 22nd. Too Many Languages.

Source: https://kbve.com/journal/06-22/

import { Adsense } from '@/components/astropad';

## 2026

### DiscordSH Github integration

-   04:47PM

    The github and discord sync is working!
    Now we just need to figure out how to get the threads to archieve and lock.
    Basically anything older that is done, we need them closed out.

### Kube Graph

-   04:50PM

    Inside of our deployments aka apps/kube, I wonder if is there a way for us to group them togethr? 
    Imagine a tag system or something at either the argo level or the kube level, so we can move forward with creating a better graph design for representing the different pods and namespaces?
    

## 2025

### AutoLogin Test

-   05:17AM

    Time to test the automatic login system, its been a while since we did anything within the java side.
    There still needs to be some level of integration amoung the java, python and js side of supabase.
    Let me get the ball rolling on this end.

## 2024

**Switch Up**
I been wondering if anyone else gets a bit bent when having to work in multiple languages, like having to switch from typescript, javascript, python, yaml, rust, all of which in a short peroid of time.
The other issue with moving in between multiple languages is that the build cache gets a bit too big, but I am thinking we can resolve it by being a bit creative with how we would handle the cache storage.
I am thinking of writing a custom `node_modules` and `python` cache system, basically holding our storage within a 3rd party location, pulling it only when doing safe builds.

**Prompt**
The prompt for the jukebox is still having some issues that we need to resolve, it seems to output a python script when we need it to output just a json.

**DevOps**
I am going to extend out the `github.ts` within the `@kbve/devops` library to have some general wrappers around the github actions.
The goal would be to make it easier to extend these actions around in future libraries and to make the workflow a bit cleaner to manager.
During the most recent pull request, it seems like the execution handler was not able to write a pull request and I am thinking that it might have been the permissions that we assigned at the time of the workflow.
What we could do is migrate the permissions down to an individual job level within the workflow and see if that can help resolve this issue.
The worst part is that I am going to make more changes in the wrapper, but for now we can test case both in the next push.

Yay! We are finally getting the base system built out and tested.
There are still some concepts that I need to improve upon, but we are getting the gist of it out of the way.
Now the next part will be the discussion integration, which has two parts to it.

**Merge**

While the pull requests seem to be fine, there seems to be a merge conflict, it might be from the fact that its pulling from `main`, instead of dev?
We should update it so that it is checking out the `dev` branch instead.

```yaml
- name: Checkout repository
  uses: actions/checkout@v4
  with:
    ref: dev
```

This should help prevent some of the merge conflicts but it wont resolve all of them.
I wonder if we could do some level of automatic management of the pull request.
We know it should only edit one file and then maybe find a way to help resolve the merge conflict, if it appears?

Okay the `dev` checkout is working as intended, but we still have to be a bit careful when it comes to the issue tickets.
I think the best move would be to limit the amount of executions and back to back genre additions.

Lets wrap back around and prepare the discussion and auto resolving.
For the automatic resolving, we could run a diff check and force it to automatically accept both merges but this might not be worth it for now.
As for the discussion based trigger, the idea would be to post a youtube link under the discussion thread and then have it automatically parse and add it into the jukebox.

<Adsense />

## 2023

- 9:00am - Time to look through the backyard and do some general upkeep. The lawn looks healthy but part of me wants to start replacing certain aspects of it. One of my dream concepts would be to expand the mint garden, to the point where there is a natural aura of mint that flows through the property.
- 10:00am - I should really think about placing a quick recipe onto KBVE for my amazing mint tea. Hmm should I go with a generic tea style and then build upon it? Maybe include various ways to show it off too.
- 6:00pm - I was a bit slacking on the note taking but there is a general flow of how I would want to improve upon that.
- 8:00pm - One of my side projects look like it is on the verge of failure. This is a point where it gets a bit tough, the letting go. Part of any project is knowing when it ends, when it stales and when it dies. Death and ending are two different concepts when I look at a project, with one being sudden and unexpected, while the other being a bit planned.

## Quote

> A failure is a man who has blundered but is not capable of cashing in on the experience.
> — <cite>Elbert Hubbard</cite>

---

## Tasks

- [x] Mock / MVP Design of the Manga.

---
# June: 23

> June 23rd. Too Many Languages.

Source: https://kbve.com/journal/06-23/

import { Adsense } from '@/components/astropad';

## 2025

### Meme Machine SH Project

-   08:30PM

    Missed updating the daily entry again, for both today and the other day.
    Nothing major to report, its been a slow day, rolling brown outs and way too much heat.

## 2024

**Actions**

The next step would be to update the github actions library with more wrapper options.
These will be basic ones, like open and close, as well as lock and unlock issue tickets and maybe also reactions.
I believe we want to also automate the assignee management for issues, which will make things easier to understand down the line.

Went ahead and updated the action to remove the debug message, since we will not need that for now.

**Music**

Okay we did a couple live test cases with the issue tickets and almost all of them went through except one of them.
It seems that songs with quotes will cause an escape to occur, which we will need to resolve and fix around that issue.
However the amount of time that I have spent trying to move this aspect of the project forward is getting a bit too long and it might be time for a break.

To be exact, when a song title has a `'` or just a general quote, it needs to be escaped.

```bash

./kbve.sh -nx kbve.com:music --args="--file=edm --title='Fred again.. - Billie (Loving Arms)' --ytid=XqUZcHBsU5I"

```

The escape has to be during the args section of the command.

```bash

./kbve.sh -nx kbve.com:music --args="--file=lofihiphop --title='Post Malone - Motley Crew (Lofi Remix)' --ytid=uBYFYhHFoW8"

```

Next update will be in the jukebox play via URL.

Noo! We had some errors in the jukebox and it seems that copyrighted songs seem to crash the player.
I am thinking that we should have a report function for removing or replacing a video? Hmm.
Also fixed direct linking to a song via the idea, so [Post Malone - Motley Crew](https://kbve.com/music/?yt=uBYFYhHFoW8) should load the song dynamically.
But given that certain songs are getting removed or banned, maybe we should also include a ULID style system for each of the songs?
This could be done later on, as we expand the collection, but it might end up making them too large, hmm.

Here is the bash ->

```bash

./kbve.sh -nx kbve.com:music --args="--file=rock --title='Rise Against - Like the Angel' --ytid=1B2N0rxp25I"
./kbve.sh -nx kbve.com:music --args="--file=rock --title='CKY - Plastic Plan' --ytid=AlDCT_1u7hU"
./kbve.sh -nx kbve.com:music --args="--file=rock --title='CKY - Escape from Hellview' --ytid=ZYk7vwdwtm8"
./kbve.sh -nx kbve.com:music --args="--file=rock --title='CKY - 96 Quite Bitter Beings' --ytid=aVdR6JeEyT8"
./kbve.sh -nx kbve.com:music --args="--file=rock --title='CKY - Disengage the Simulator' --ytid=yXrFH9agq14"


```

The part that fails is within the way we are handling the single quote. 

```bash

./kbve.sh -nx kbve.com:music --args="--file=rock --title='Dirty Heads - Life\'s Been Good ' --ytid=R70b1XYuSvQ"
pnpm nx run kbve.com:music --args=--file=rock --title="Dirty Heads - Life's Been Good" --ytid=R70b1XYuSvQ

```

So there are a couple ways we could handle this, let me sleep on it and maybe tomorrow I will have a better solution.
We could just escape it with another character and then adjust it later on.
Let me try it like this:

```bash

./kbve.sh -nx kbve.com:music --args="--file=rock --title='Dirty Heads - Life◈s Been Good ' --ytid=R70b1XYuSvQ"

```

That seems to pass without any issues for now, okay we can work with that for now.

```bash

./kbve.sh -nx kbve.com:music --args="--file=rock --title='Rise Against - Paper Wings' --ytid=ZJwy9jTiyu4"

```

Let me run another quick command against the rock.mdx and see if that would run into any errors, it seems we do not.


<Adsense />

## 2023

- 11:00am - I woke up a bit late and missing my morning meeting, which is starting to become a bad habit. I will have to make sure that I attend every meeting for the next couple months, it was a bit rough to adjust my sleep and schedule for the meetings but that is no real excuse. I can be caught into a various reasons for my procrastination. What should I do? Well I was able to re-arrange my tasks and maybe look into postponing certain non-important tasks to a later date. I might try to use another layer of numbering or just be honest within my soul, time to put some projects to stale.
- 7:30pm - I updated the repository for RogueJester and removed my older branch. One of the concepts that I was thinking of was keeping the patches to a limited amount, maybe just one or two max. This way I do not have to keep going back and forth, plus keeps me focused on what needs to be done.
- 8:00pm - When the application launches, I am thinking of having the basic manga open up and let the reader go through it. This part of the launcher could focus on the notes and latest updates? I suppose we could also sneak in this journal, a bit of offsetting but it could be an idea that we could look into later down the line.

## Quote

> Nothing diminishes anxiety faster than action.
> — <cite>Walter Inglis Anderson</cite>

---

## Tasks

- [ ] Render the Manga on the Unity Project
- [x] Cleaning up the Unity Branches

---
# June: 24

> June 24th. Conch Time.

Source: https://kbve.com/journal/06-24/

import { Adsense } from '@/components/astropad';

## 2025

### Meme Deployed

-   11:18PM

    The Meme.sh website now has basic auth, yay!
    I still need to adjust the older settings and let people create accounts without having to sign in via Discord/Github but that can wait.
    The goal will be to quickly build a meme website, with the goal of advertising and testing some theories.

## 2024

**Conch Shell**

Time to bring back a classic application! I will probably host the conch shell directly under the `/tools/` under the `conch.mdx`.
We could also throw our prompt into that mixture, since that was a pain point before in the past couple rounds.
I believe we can stick to the default of a true / false for the start of the application, and then go about adding more features later down the line.

**Mic**

New mic? Who Dis!
After searching far, wide and low, I might have found the perfect mic, its the Alpha Cloud from HyperX!
This bad boy has a battery life of over 300 hours!

**Jedi**

We will expand the jedi library so that it can call a couple different endpoints!
The next file that we will be adding into the library is the `featherless.rs` which will be a wrapper around their API service!
I am currently building around their API but I do not have access to test it, so we shall see how far we can get with it.

One of the cooler things that I want to do is to try to build around the Semaphore / SegQueue, both of these being part of a stable concurrent call system.
The final goal will be to have multiple different LLMs communicate in a real time.

**Villows**

Just stumbled upon a new artist called Villows and a decent chunk of his music has been amazing! WoW!
I will have to parse through all of his work and throw it into the jukebox.
Now there are some parts of this that I need to further automate but we are getting some solid gems out here.
Very much helping me solve my petite biscuit requirements.

```bash

./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Villows & Niicap - Dimmest Light' --ytid=jwTOq65qaWA"
./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Villows - Coast' --ytid=6vOUyl4EvL0"
./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Villows - Endless' --ytid=ygcLDN4GgkU"
./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Villows - Childhood' --ytid=wcuAXzt55LY"
./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Villows - Mountains' --ytid=1HT47cz8yVA"

```

We should also add a bunch of the rise against and adtr before we forget.

```bash 

```

Quick Porter Mashup?

```bash

./kbve.sh -nx kbve.com:music --args="--file=edm --title='Porter Robinson - Sea of Voices x Shelter x Divinity (Resaixo Mashup)' --ytid=uPBpmz1Z32w"
./kbve.sh -nx kbve.com:music --args="--file=dnb --title='Delta Heavy - Ghost' --ytid=b4taIpALfAo"
./kbve.sh -nx kbve.com:music --args="--file=dnb --title='Delta Heavy - Kaleidoscope' --ytid=DwJefiLqgM8"
./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Empire Of The Sun - We Are The People (FlicFlac Remix)' --ytid=Zwxb-bOZKTI"
```

**Phi**

Okay the phi model is running fine on my m1 and its really not killing my battery!
It does have a decent ability to help parse some basic information, but it works so much better with a regex combination.
Maybe a LLM style verification that can be added into the pipeline for adding music would make things easier.

<Adsense />

## 2023

---
# June: 25

> June 25th. Concurrent.

Source: https://kbve.com/journal/06-25/

import { Adsense } from '@/components/astropad';

## 2025

### NVDIA

-   05:50AM

    Looks like 800 shares might get sold this week, them calls for $145 have just been rolling!
    I might even roll it again to next week, but I am not too sure, I might let it push through and see if I can wheel that cash into puts.


## 2024

**Featherless**

Updating the `jedi` crate to use the featherless api, however as I am building it out, it might make sense to make a general OpenAI wrapper and then just adjust that based upon these different models.
We will be using a combination of Semaphore from Tokio and SegQueue from Crossbeams to handle our concurrent queue but this is still a bit new for me!

**Jukebox**

The UI for the Jukebox needs to be rebuilt but I will take some small steps towards that.
I am thinking of a neumorphism style within tailwindcss but getting the customization down is a bit of a pain.
This would be a great way for me to learn a bit of abstract UI design but the time it will take is something that might not be worth it right now.
The skip button will be the first attempt at a neumorphic style and then I will go from there, plus it does look tough to do in a dark style because of the way the shadows would be handled.

**Haystack**

The next part of the atlas upgrade will be with expanding the haystack integration, mainly haystack 2.0 but that might come with its own set of issues and problems.
We are currently using a custom api wrapper around groq, ollama and a couple other libraries, so maybe we would have to create a single uniformed wrapper around those that would work directly within the haystack eco-system?

<Adsense />

## 2023

- 4:30pm - Updates to the WebMaster tool. I should wrap all the URLs that we can use for the tools inside one list, then reference them using tags? There are a couple tools that I will reference in the bottom where the user will have to login to use? Maybe a small element near the tools that require a login to use? I suppose we could collect feedback and then go from there.
- 5:20pm - Going to push through some of the branches and start to split up the branches a bit. I accidentally removed my changes from yesterday, which is a shame because that does throw me back another day in development time.

## Quote

> Give whatever you are doing and whoever you are with the gift of your attention.
> — <cite>Jim Rohn</cite>

---

## Tasks

- [ ]

---
# June: 26

> June 26th. Jedi Release.

Source: https://kbve.com/journal/06-26/

import { Adsense } from '@/components/astropad';

## 2025

### React 19 Render

-   04:05PM
  
    After 11 hours of memes, research and jumping around, I think I was able to resolve the bug.
    Had to change the vite configuration for react and even then, I am not too sure if I had solved the issue.
    I am hoping that its done with, so I can actually get back to programming and building the core.

## 2024

**Jedi**

Time to upgrade the jedi library and release our featherless instance?
While I prepare do that, we also need to release the core of the conch shell application.
The best step to make right now is to push the most recent changes into production, as blank templates or shells and then slowly add to that foundation.

To test case the library against a dry run, we use this command:

```shell

./kbve.sh -nx jedi:dry --no-cloud

```

Okay, we released the latest jedi crate under `v0.1.12` , with a small update to the readme and the foundation of the [Featherless](https://docs.rs/jedi/latest/jedi/entity/ai/featherless/struct.FeatherlessClient.html).
However I did notice a couple issues at hand, the documentation that gets auto-generated on the `docs.rs` is not the greatest, so I will have to find a way to improve that.
I am sure there is a minor markdown style that I need to include within the source code or something of that nature, I will keep that in my future notes.


**Conch**

This is my second official rewrite of the conch, I will be placing the it directly into the `astropad` library so that I can call it on other websites if I need to.
We will be pushing the recent assets into the production branch, so we can hotlink them directly in the code.
The relative path is going to break during some of the test casing and we want to make sure that everything works as smoothly as possible.
The idea here would be to pitch this meme application to featherless.ai and maybe they might be willing to sponsor it.

After pushing up to the `main` branch, we have our assets loaded into the `embed/conch` path and now we can hotlink all of them within our source code.
The default background for the conch shell will be `https://kbve.com/embed/conch/bg.jpg`.
For now, we have two default song clips in OGG format, 

```js

    onMount(() => {
      yesAudio = new Audio("https://kbve.com/embed/conch/yes.ogg");
      noAudio = new Audio("https://kbve.com/embed/conch/no.ogg");
    });
```

I think we should look for a couple more song effects, like the pulling of the string and maybe some evil / shadow effects.

While I am creating the new music effects, I should also build out the prompt that will get executed during the questioning process.
Oh I forgot to add the conch, let me do that quickly too.

**Jukebox**

There seems to be an issue where the jukebox either crashes or fails to load the next song, maybe we should account that with a timer?
If nothing is playing within the past 3000ms, have it automatically load the next song?

I believe the force play would make sense to add into the production build, so we will do that for now.
Never mind the forced play did not work as expected and actually caused a bunch of bugs, so maybe we might need to find a new way to load the videos, hmm.

**Music**

The Musical studio of KBVE should launch at least one or two singles within the next couple months.
We could use the jukebox as a way to help us spread the music to fans as well!
Furthermore, we still need an official open source DAW that all of us can use without any restrictions, the current prospect is `LMMS` but there are a couple others out there that might peak our interest.
The Suna + n8n + discord integration will make generating and finding samples easier too, but there should be a bit more planning we could do.

**Discord**

Launching a discord bot that can make ai artwork is something that we been planning to do for a while!
The idea here is not to compete with midjourney or any of the other popular services out there, but rather just have our own open source version to mess around with.

## 2023

- 6:00am - Early grind for the day! Going to focus most of the day on resolving the Steam issues for Unity and looking to optimize the load scenes. I am hoping to make the shift between different scenes a bit faster and add a bit of an aesthetic to it as well. I will not be doing this all from scratch but rather looking through existing references, so that I do not get too lost in the sauce.
- 11:00am - Currently sitting through a quick RJ meeting and going through a lot of the older issue tickets. After spending some time on the Unity project, it would make sense for me to review through the issues that are currently open on KBVE.com and see what progress I can make with each one. 
- 12:30pm - Reviewing over the humble bundle, I did notice that we forgot to add the notes onto our website. We could make a section for deals? Then under the deals, we could keep a track record / log of anything worth wild that we can share in the future. The concept or idea behind a deals section would be something that we can talk about in a future casual meeting.
- 3:00pm - Watching TSLA correct itself for the short term is interesting, from almost hitting the $270 mark to slowly going back down to the $250 mark. I do have 3 puts for this week on $TSLA at @ $250.00 , which means I will most likely be assigned another 300 shares for $75K. If it does happen, I will just sell another set of weekly call options against them. I was assigned on SPY about 3 times, so I do have about 300 shares of SPY at around 440 mark that I do need to get rid, to shore up some of the cash reserves. I believe a couple loses might mean that I need to take a break from the cover puts and look into riding out a couple weeks. I might need a couple more paychecks to bring my cash reserve back up to a level that I would feel a bit more comfortable, as of right now I have only about $110K cash, with $75K set aside for the put. This is the dangerous part because in this market, you do not want to go into margin, as the interest rate will eat away at your profits. I suppose this could give me the motivation to get that extra jay jawn faster, as one of my goals for 2023 was to have a liquid cash pool of $200K. Since it is already been half the year, it would make sense that I shift focus and resolve that issue.
- 5:00pm - Need to plan a quick trip for Coffee, Red Bulls and Seltzer. These are my three core powerups and probably what keeps me going, aside for any additional matter-based intake. 
- 7:00pm - I am looking over the notes for our meeting and realized that I would need to look further into the currency concept for RJ and KBVE as a whole. This has been something that we ran in the past and an issue that would have to be resolved before anything major, such as offering a SaaS style system in the future? The current notes that I have would be more towards a 3 tier style system, where I talked about using `KHASH`, `CREDD` and `COUPON` as the terms to define them. When I was talking to a local investor, she was extremely fond of the coupon style concept but was on the fence about the khash and credd, yet from asking a couple developers, they found the khash and credd style to be a bit more forward and the coupon style to be a bit lack luster. I suppose I will have to think it through before I move forward, given that a decent amount of my side wealth may be attached to the internal cogs of this system. I am usually not a fan of placing my own capital at a large risk, as it could hurt the existing projects, thus looping back, maybe it makes sense to stock pile a larger capital reserve. This would mean that we start cutting down in expenses as soon as possible. I guess the homework for this week would be to review all my current costs and see where I can cut expenses as fast as I can, then at the same time, look at places and areas where I can generate more capital? It does sound simple when I write it down, but it can become an extremely painful and dull process within the larger scope. Yet it is always better to do it now, when we have a health budget. 

## Quote

> They can conquer who believe they can.
> — <cite>Virgil</cite>

---

## Tasks

- [x] - Clean Washing Machine
- [x] - Allocate 3 hours of R&D on the Unity Project
- [ ] - Resolve Branch Merging - I will skip this task for the day.

---
# June: 27

> June 27th. Conch Groq.

Source: https://kbve.com/journal/06-27/

import { Adsense } from '@/components/astropad';

## 2025

### React MemeSH Vite Build

-   01:01PM

    Spent the whole week trying to resolve that build issue with the React v19 and the Meme.sh website.
    Now we can resolve some of the unity issues and focus on getting the base game out of the way.
    

### Nvidia Surge

-   05:40PM

    Did not expect a Friday run up, but here we are!
    No other major notes for now.

## 2024

**Shell**

I was working on this earlier yesterday night into the middle of the morning.
We want to move all the generic commands out of the cloud, so that `-nx` flag will run the commands without invoking the cloud credits.
I added a new command, `-nxc` that will run the commands with the cloud / cache instance, moving forward we can isolate the exact cases where we want to utilize the cloud.
One of the plans would be to automatically move the errors that get generated from the `-nxc` into a Github issue ticket and then let a couple different LLMs work on resolving the said issue.

**Groq**

Since we do not have the feather integration, I am thinking we can atleast throw in the groq integration.
The bigger issue would be to control the endpoint and have it not get abused by other 3rd party users.

**Music**

The next genre that we need to add is the study beats.
The base template for the studybeats genre will be under the `/docs/music/studybeats.mdx` and I will try to expand it out to about 10-20 songs for now.
We should explore all of `DeKobe` first, just grabbing some of his best work would be right move.

```shell

./kbve.sh -nx kbve.com:music --args="--file=studybeats --title='DeKobe - Small Problems' --ytid=A0DHLDjQhaU"
./kbve.sh -nx kbve.com:music --args="--file=studybeats --title='DeKobe - Stars in the Forest' --ytid=XhhtsViFbfE"
./kbve.sh -nx kbve.com:music --args="--file=chillstep --title='Fred again.. - Roze (Tiny Desk Version)' --ytid=48R8iCN4fN4"


```

**Debate**

The debate this night was extremely sad, it would make me feel so bad if I was stil in school.
The thought that our leaders are this bad, is wild!
Both of them made me extremely sad, considering that the debate was not even funny or had any form of information or entertainment.

<Adsense />

## 2023

- 1:00am - Looking over the webmaster tools and seeing what I could to improve upon them! I am thinking of expanding the services that are provided and maybe include additional links? We know the goal for this tool is to include as much reference material as we can for all website owners, which does place us under a specific niche. The best bet would be not to over think it and slowly add more? I will keep researching and see if there could be some minor tweaks that I could do.
- 1:07am - Need to add `https://validator.w3.org/nu/?doc=https%3A%2F%2Fkbve.com%2F` into the WebMaster tool as a dev option? It would be interesting to have a small AI agent scope these out and then make suggestions! I guess another aspect would be to train the AI agent on a large amount of SEO/SEM data and then have it generate a custom report based upon the website added? Like a custom report generated for a generic amount too.
- 1:13am - I found another one that we could include in the dev report as well! `https://www.robtex.com/dns-lookup/kbve.com`, which is a decent chunk of information that a webmaster would be interested in. It does a solid job in looking through the DNS records. Speaking of looking through the records, I suppose we could also offer a free nmap search for the domain? This would be something that I could wrap all into an expansion issue / concept for the future of the webmaster tool.
- 1:29am - I completely forgot to add SEMRush as well, `https://semrush.com/info/kbve.com`, which should definitely be on the list as it is a vital SEO tool.

## Quote

> Stay committed to your decisions, but stay flexible in your approach.
> — <cite>Tony Robbins</cite>

---

## Tasks

- [ ]

---
# June: 28

> June 28th. Weekend Bash

Source: https://kbve.com/journal/06-28/

import { Adsense } from '@/components/astropad';

## 2025

### Unity Session SSDB

-   02:36PM

    The SSDB needs to migrated into its own extension, so that we can resolve that webgl build.
    Having it isolated will be the best way.



## 2024

**Weekend**

The weekend flow is always a nice change of pace, I wonder what we can build this end of the month jam session.
We should host or plan another session with a bunch of devs, maybe try to pump a product out in 48 hours?

**Windows**

I am currently on the beef machine, aka vm 400, and the whole windows migration was a great success besides the WSL backups.
It seems that the encryption or maybe the way I setup the drives caused some issues when boating it up.
However, I think running a windows in an emulation environment then having ubuntu run under that is a bit overkill.
The current solution is to just have promxox deploy another ubuntu container and we run a ssh tunnel.
With that being said, I am also connecting the ssh tunnel with the mac book too, making it easier to build x86 without burning through the battery life of the laptop.

**HerbMail**

The next stage in the herb mail will be after we get a couple more LLM examples built out and tested.
Afterwards we want to run the mailserver using stalwart, a rust based scalable all-in-one server.
While I am moving forward with the LLM models, I think it would be wise to test case the deployment of stalwart.


## 2023
- 12:30pm - Looks like the Indian office approved my grandpa's visa extension! This is great news as it means I can plan my new trip to India a bit better and not have to worry about him being in India with an expired visa. This makes me wonder how my life will be when I am nearly at his age of 80? He is a true warrior, the man has done it all. 
- 3:30pm - I need to start planning the construct and layout for RareIcon, with all these projects in the backlog, I may have to find a better way to manage my time within the scope of error handling? I should utilize more of the error / issues that we have and then target them each over time.  I will postpone anything major for RareIcon until we get RJ onto the Steam store.
- 9:00pm - Finished organizing the notes and learned a bit more on how to use Mermaid! Moving forward, I will try to use mermaid for all our note taking, as it does make things a bit easier. 
- 9:30pm - Region Save for Dwarf Fortress. I wonder if I could make a repo for the game and then have that saved for people to access and play.

## Quote

> The greatest good you can do for another is not just share your riches but reveal to them their own.
> — <cite>Benjamin Disraeli</cite>

---

## Tasks

- [ ] Finish Up Profile Page
- [ ] Organize Initial RJ Mangas

---
# June: 29

> June 29th. Weekend Bash

Source: https://kbve.com/journal/06-29/

import { Adsense } from '@/components/astropad';

## 2025

### Unity SSDB

-   05:01PM

    Preparing for the Unity SSDB session, basically I am thinking of splitting the days between the two extensions.
    Ghostly will be on the SSDB side and we have Mike to handle the MMExtensions, which means I need to finish up the kilonet.

### React Dashboard

-   11:05PM

    After spending sometime going through the React eco-system and v19, I am getting a better understanding.
    My goal will be to isolate all of react into mini applications aka components.
    I said this before but I just never went into a deep dive.


## 2024

**Cricket World Cup**

It looks like the world cup game is going to be a close call, and the cup might fall into India's hand!
I am sure a bunch of people in Edison are going to go crazy this weekend.
India grabbing the victory with just 7 runs, it was a wild game to watch, even though I am not a huge cricket fan, these close games make it worth wild to watch.

**Commission**

I am going to run a test case of the bounty system on the `login`, `register` and `services` page for KBVE.
We want them to be isolated react-based components, well they could be in svelte but I think react might be better because the dom will be dynamic.
Plus we can utilize framer motion to help create some fancy visuals.

**Hair Cut**

Going to quickly head over to the barbershop, get a clean fade and then SSS.
Afterwards, I have a quick birthday party to attend and then should be home within a couple hours.
Goal for tonight is to take the plans that we built out and start to execute them in a small modular steps.


**DevCode**

The *DevCode* snippet needs to be migrated over to `astropad` so that we can officially release it to the NPM Library and use it outside of our monorepo.
I might finally start branching out of the monorepo and try to really focus on a hybrid repo approach.
There are situations where we might not need to place all our apps directly innside of the monorepo, hopefully we can find a way to update and 


**TitanFall**

CHIP decided to bless us all with a copy of titanfall 2, which will replace my league needs for a little bit.
League has been slowing down my PC and I need a change of pace! While halo did help the migration over to a shooter, I believe titanfall will be the perfect blend.
Honestly, the way that titanfall handles the grunt system is great and this really gets me excited to make a future fps style moba, one day when I get enough resources, I will make this dream come true.


<Adsense />

## 2023
-  10:30am - Preparing for todays trip into the city! I will be taking a train with @bell into the capital of the capitalistic shadow realm, hopefully I do not encounter any trolls, goblins or dark entities.
- 4:30pm - Interesting set of events, we went through the train and part of the train tilts into the train station, which was extremely weird but I assume it was because they were doing construction / fortification. I am going to further assume that this is part of that infrastructure plan. 
- 4:00am - What a fucking trip, it was a bit more expensive then what I expected but I enjoyed all of it. The Halal Chicken Chopped Cheese Sandwich. That was the most legendary sandwich ever made in the past decade. It was the perfect balance of spice, protein, and flavor, I am going to forever remember it as the sandwich night. 

## Quote

> If one is estranged from oneself, then one is estranged from others too. If one is out of touch with oneself, then one cannot touch others.
> — <cite>Anne Lindbergh</cite>

---

## Tasks

- [ ]

---
# June: 30

> June 30th. Sunday Funday!

Source: https://kbve.com/journal/06-30/

import { Adsense } from '@/components/astropad';

## 2025

### KBVE Dashboard

-   01:55PM

    We need to update the front page so that it be easier to see and utilize.
    How I want to go about that will be interesting?
    Maybe we take what we had before and recycle it, add some more interesting content too.

### BitCraft

-   03:58PM

    So I am trying the game out, the game is definitely a mixture of runescape and memecraft.
    There is still some server lag, which is a bit interesting because I figured it be so much smoother?
    Maybe there is an issue with what the server thinks and what I am doing, I am sure they can smooth that out with some adjustments.
    Overall, it feels like an idle game and honestly would be more fun if it was a mobile first game.
    Furthermore, the combat is definitely janky and could use some improvements, but I heard there is a pet system that helps.

## 2024

**DevCode**

We finished up migrating DevCode into the AstroPad but trying to convert the Shiki helper from a javascript file into a typescript was throwing way too many errors.
I will see if I can atleast convert the jsx and js files into a typescript tsx / ts but that might be a pain.


**Services**

Going to quickly create a bento grid component that would hold all our services.
The service page will just be hotlinks to our future shop.

The shadcn library integration with a couple other framer motion / r3f libraries within the astropad is the next move today.


**Fuster**

This is going to be the ultimate python library out there!
Hopefully this operation does not get discovered, its going to be a top secret library that will have the best haystack.
Actually, part of doing this is to get a better grasp at releasing python libraries, I was forgetting how I was doing it earlier today.

Starting with the Fudster library's migration of the secret, we want to make sure that we handle all secrets without any sort of problem.
The major difference between the `atlas` project and the `fudster` project is that one will run in a GUI format aka `atlas` , while the `fudster` library will run inside of a CLI?

Actually, as I am writing this out, it might make sense to swap those two? Damn I might have made a mistake.
The current error with publishing the fudster library was that our pypi token was not scoped to the right project, but since we will be building all our libraries out of the monorepo, this should no longer be an issue down the line.


**TitanFall**

The best way to handle build steps?
Play a quick round of titanfall ;D
Okay I am trash, damn I was getting killed left and right, oh well.


**Gunsmith Cats**

We should bring back the anime section!
There are so many amazing animes that we could provide *ways* to watch.

**Black Lagoon**

The best tv show to watch right after some gundam?
It has to be the lagoon!
I miss the characters, the music and the sounds.



<Adsense />

## 2023
- 12:00pm - My legs are sore as fuck!
- 1:30pm - An interesting [docker image](https://github.com/Steam-Headless/docker-steam-headless/tree/master) for a small future side project, `Twitch Plays DF`. This docker image would run Steam within a Docker instance and let the GPU pass through, so ideally it would make it easier to manage the game instance. I am wondering if I could also automate the connection to the container, maybe using a combination of the Duck DNS and a reverse proxy.
- 3:30pm - Okay it looks like I am going to close out some of my positions and see if I can extend out my call options on TSLA, SPY and AAPL. 
- 5:30pm - Going to start migrating some of the ansible components into custom shell commands that can operate outside of Ansible, including the usage of Github Actions. This would extend out the CI/CD and it would help prevent vendor lock-in because it seems that Red Hat / IBM are doing some weird things with their open source software. 
- 7:00pm - I started to read up on the VuPlex concepts, so that I can integrate them at a basic Javascript level and then see if we can utilize them.

## Quote

> Some of the best lessons we ever learn are learned from past mistakes. The error of the past is the wisdom and success of the future.
> — <cite>Dale Turner</cite>

---

## Tasks

- [ ]

---
# July: 01

> July 1st. Update!

Source: https://kbve.com/journal/07-01/

import { Adsense } from '@/components/astropad';

## 2025

### Damn CC Payments

-   08:04PM

    Just programming and finishing up any remaining balances.
    Hopefully nothing major gets assigned over this short week.
    Calls & Puts on Nvidia.
    


## 2024

**Figma**

I have not yet used figma tooling for more than a couple instances but the recent changes that I have seen, especially the AI modules, is amazing to see in action.
We are currently in the process of using it to design our new services page but there are some really abstract concepts and ideas that come with it.

**Services**

The plan right now is to expand the services that KBVE offers directly through the `shop` and on the website.
While we are building out the services, I want to see what tweaks and adjustments I can make around them.
The core services that we will be offering are within the technologies sector but I think bizops and media will not be too far out there.
We can look into the Canva API and general AI-based image generation down the line.

**Benefit**

The `Benefit` component will be loading the different services that are being offered into the bento grid on load.

**Kill Tony**

One of the best episodes of kill tony this year!
I could not stop laughing, everything was perfect, from the jokes to the random events. Shane and James were also amazing guest hosts, I am really seeing the peak of the podcast right now.

**Quick Songs**

A classic way to end the night, load a bunch more songs!

```shell

./kbve.sh -nx kbve.com:music --args="--file=rock --title='A Day To Remember - NJ Legion Iced Tea' --ytid=WVHgME1ncz8"

```

**Fireworks**

The annual light your money on fire celebrations are around again!
Nothing more than explosions, laughs and random street dogs barking all night.
The BBQ stops are getting better too, I am almost perfecting my runs. 
Key things to do during my runs are to drop off beer, soda or chips, maybe partake a quick grilled burger and take a couple photos.
I have not yet really utilized instagram, but I think I would be an amazing photographer if I had some more time to practice.
Even with all the equipment, I should really look into getting some of my photos up into unsplash and with my programming background, I bet I could make some amazing artwork out of the photos.


<Adsense />

## 2023
- 2:00pm - I started the VuPlex basic integration on the `KBVE.com` end point, which I will repo and then test case in the launch scene. This part will be interesting because I want to see if I can get the login to work on both end points without having any issue.
- 7:00pm - Okay the way that I will go about this will be to have a login screen / page on the KBVE website and then use a postMessage between the C# within Unity and Javascript within the browser. The initial transfers will be two parts, the first will be a string variable that would contain the general messages, like warnings.

## Quote

> Iron rusts from disuse; water loses its purity from stagnation... even so does inaction sap the vigor of the mind.
> — <cite>Leonardo da Vinci</cite>

---

## Tasks

- [ ] VuPlex Javascript API Integration

---
# July: 02

> July 2nd. FireWorks

Source: https://kbve.com/journal/07-02/

import { Adsense } from '@/components/astropad';

## 2025

### React Dashboard v2

-   01:15PM

    Launching of KBVE Main Dashboard will be the main focus for the day.
    No other major notes, will have to loop back in the future for this.

## 2024

**Cough**

- 11:00am

Damn, I caught a terrible viral bug and my body is fighting this thing to the end of earth.
I have not yet taken any anti-viral medicine but if things get bad, then I might have to pop some anti-biotics.
Greek yogurt has been a life savior, my logic is that if I fill myself up with healthy bacteria, it would make it harder for the evil ones to get a hold of my immunity system.

**Issue Tickets**

- 1:45pm

I need to get into the grind of updating the issue tickets more often.
My private kanban is looking great but I think getting a public one that is opertional and synced would be a great benefit in the long term.

**Shopping**

- 6:40pm
Currently running around Edison and buying random wedding gear, as I would like to call it.
It is not for my wedding but for my cousins, which is going to be in Italy, so nothing is going to be more epic than an Indian wedding in the heart of Italy.

**FrontEnd**

- 9:45pm

Spending most of the night working out the issues within the frontend, switching between a bunch of different libraries.
We were using flowbite before but ended up going with preline instead.
I just remembered that we will have to update the preline parts within the doc section because it might not call the the script execution.

<Adsense />

## 2023

- 5:45pm - Going through all my monthly statements, just to make sure that everything will be paid off. I have to contact my insurance agent soon too, as I want to see if I can get a further discount on my car insurance. Usually I pay 6 months in advance, hopefully she can find me a better rate.
- 5:50pm - Having some minor flowbite issues, I am thinking that I will add their react library and call the javascript that I need directly within the jsx file for the time being. I have it noted and I will go back and alter it when I get some time. This would be a hot fix but I need to get the basic login working within Unity. I also noticed that this login solution will not work for WebGL games, but in that situation, I will just use the ReactUnity to handle that. I am like not too far from just rebuilding a cyperpunk neopets lmao.
- 9:00pm - I am thinking of cooking some ramen with spinach and egg! I am currently looking for recipes to work with. I am thinking of cooking the ramen and then add the layer of spinach near the end? Hmm, now there are a couple ways I could go about cooking this but I wanted to make sure I do not over cook the noodles or the eggs. I am a bit too lazy to weight out the spinach, so I am just going to throw all of it.

## Quote

> Argue for your limitations, and sure enough they're yours.
> — <cite>Richard Bach</cite>

---

## Tasks

- [ ]

---
# July: 03

> July 3rd. Americas Unofficial Bday?

Source: https://kbve.com/journal/07-03/

import { Adsense } from '@/components/astropad';

## 2025

### Supabase Edge

-   09:19PM

    New edge function deployment will be our focus for the kuber network, dropping the database hosting.
    Migrating all of the postgres back to the supabase cloud and focus on the edge compute on the kuber network.

### Godot Card Game

-   11:59PM

    Wrapping the day off with some more minor changes to the Godot card game.
    I should start moving this into the public repo so that we can push around.

## 2024

- 12:34am

I forgot to update the journal, so give me a bit of time to fix up the entries.

- 3:30pm

Time to go through and prepare the cryptothrone domain for a quick publish.
The idea should be a simple one page application / game, that will make it easy to work around with build.
For now we can launch a quick demo / pipeline and then slowly work through the kinks.

- 4:50pm

Tesla might cross over the $250 mark, this will be bad for us because then I might be forced to sell a bunch of shares.
I am thinking that it would be wise to just keep rolling the call options, even if its just for a couple hundred dollars a week.

- 6:25pm

CryptoThrone deployment, this was long over due and I think it might be a good summer hobby project.
We got adsense approval, so it might make sense to now start stream lining the process.

- 11:45pm

Before we end the night, I am thinking that it would make sense to build an engine to help handle some of the phaser situations that we will come across.

```shell

pnpm nx g @nx/js:lib laser --importPath="@kbve/laser" --publishable=true

```

This could be an engine that holds all our phaser code and also any additional utility code that we can use in future projects?

<Adsense />

## 2023

- 10:00am 

Going to quickly head over to a friends house for a 4th of July party to help setup and prepare. 
I am about to do the classic h0ly move of bringing things, setting things up and then leaving early!

- 4:00pm

I have to split up the login form into two or three different classes or maybe have different modules?
I am a bit confused on the path that I want to take for setting up the login system.
This has been an issue for a bit way too long, I am thinking that I might just stick with very basic moves and then later on, go back to write it up.


## Quote

> Your attitude, not your aptitude, will determine your altitude.
> — <cite>Zig Ziglar</cite>

---

## Tasks

- [x] Start VuPlex

---
# July: 04

> July 4th. Fireworks!

Source: https://kbve.com/journal/07-04/

import { Adsense } from '@/components/astropad';

## Notes

Happy Independence day yall scrubs. Please do not blow up your hands when engaging with fireworks. Do not mix BAC with fire.

## 2025

### Google Search Box

-   11:00PM

    The search box took the whole day and it was a complete waste of time.
    I never felt so sad, a huge waste of my time.
    Honestly, I should have known better before going down that path.

## 2024

I was not able to convert the written notes for this date, but most of them are in the binders.
I spent majority of the day working through the `CryptoThrone` and `@kbve/laser` library, slowly trying a couple different ways of handling the different problems.
There was just way too much to break down and throw into a journal entry.


<Adsense />

## 2023
- 3:30pm - Looking over some of the issues on the main website, there are a couple locations that just do not work as intended. I suppose one of the reasons we are not getting Adsense approval is because of the deadlinks that are splattered across the whole website! 
- 3:50pm - On the sidebar, I will add a media dropdown. The dropdown will be linking to manga, gaming, music and video for now. I went ahead and made it into a Git issue, which I will close out with the next pull request.
- 8:00pm - Besides the sidebar update, I went ahead and started to update the Search a bit. I am trying to use it more personally but there are a couple things that I also wanted to address and add. One of the things that I might look into would be adding a custom search range that we can save via localStorage and have it insert in every search? This would be an interesting area to explore later down the line. 

## Quote

> Miracles come in moments. Be ready and willing.
> — <cite>Wayne Dyer</cite>

---

## Tasks

- [ ] Repair Dead Links

---
# July: 05

> July 5th. Items

Source: https://kbve.com/journal/07-05/

import { Adsense } from '@/components/astropad';

## Notes

## 2025

### Mobile Menu

-   03:02AM

    The damn mobile menu within the dashboard is not working, which means more time gets burnt.
    Furthermore, the mobile login is not working either, so I will have to loop around and figure that out soon too.

## 2024

The current plan is to formulate a solid way to use items through an event and queue system, with working notifications as well.
I was going to spend a decent amount of the time working through getting the tool tip resolved but it seems that it might not be worth it, instead of having a tool tip appear over hovering, we can get a bit creative with it.

**Items**

For the item management, we should create an `itemdatabase` that would store all the static items that could be added into the game.
Furthermore, I am thinking of having those said items stored within the `cryptothrone` mdx on KBVE and utilizing the zod to manage them?
In the future, we could also extend this out to a more advance item engine that can be used in multiple games, without having to recreate the wheel.

For the item viewpoint, we can build the database within KBVE, we could go as far as having the items be used in all our various games?
This would make building and expanding the game much easier, including getting new users and adding a couple different abstractions onto our project.
The itemdb will start with a markdown collection that gets turned into a json file and then finally we would call it for storage. 
There are a couple minor things that we would have to account for, like the ability to replace descriptions and certain apsects of the item, yet that can be done through an ommit.

## 2023
- 6:00pm - Building out the basic RareIcon.com NextJS template. I am thinking that I might also build out a general template / concept for a majority of my websites as I prepare for my Resume / CV builder. I should aim for about 3-5 live projects that I can shift through and utilize! One of the core concepts that I want to test is the multi-tenant core within the Appwrite eco-system and how far I can extend out the API.
- 10:00pm - Okay! After some general test casing and going through some templating issues, I was able to get the CI/CD done for RareIcon! Now we are operating the website on NextJS, similar to the Discord.sh setup. My plan moving forward will be to get at least both of those websites to become integrated with the Appwrite. While that is going on, I wanted to start focusing on the `batchmation` of SEO/SEM/Marketing/Media through cloud functions. This part of the project will be a bit interesting to build out because there are a couple moving parts that I need to address. 
- 10:20pm - I believe one area of difference between the Discord.sh and RareIcon.com will be the CSS, I am going to keep Discord.sh with MUI and try Tailwindcss for RareIcon. As for the majority of the notes, I am thinking of writing them out here, as a collection of my thoughts and then clear them up and migrate them over to the documentation.
- 10:45pm - The Robot Unicorn Attack SWF will be located here -> `https://rareicon.com/assets/swf/arcade/robotunicornattack/robotunicornattack.swf`. I am thinking how I should do the asset structure for the website. 
- 11:50pm - Okay ended up getting it resolved! Let us try this now in production?

## Quote

> What is new in the world? Nothing. What is old in the world? Nothing. Everything has always been and will always be.
> — <cite>Sai Baba</cite>

---

## Tasks

- [x] SWF CORS Issue

---
# July: 06

> July 6th. More Items!

Source: https://kbve.com/journal/07-06/

import { Adsense } from '@/components/astropad';

## 2025 

### BitCraft

-   09:50PM

    Decided to do a deep dive into the whole bitcraft game!
    There is a bunch for me to learn, I am enjoying their sailing but it feels a bit slow.
    As for the other parts of the game, the lack of world content is definitely noticable after about 50 hours of gameplay.
    However it has a great idle loop, but needs to focus more on the community building.
    Traveling around the world is interesting, I do wish they made it a bit easier to sail, its a bit annoying to click around every few seconds.
    

## 2024

**Items**

For now, we should focus on getting the items to pull from the json and then save them on into the localdb.
We can do this quickly, as I push the static api route up into the production.

**Equipment**

The equipment aspect of the game will be a bit tricky to render right this second, but we could still handle it within the text mode?
Here is what I am thinking we would do for the interface:

```ts

export interface IEquipment extends IObject {
  type: 'head' | 'body' | 'legs' | 'feet' | 'hands' | 'weapon' | 'shield' | 'accessory';
  bonuses?: {
    armor?: number;
    intelligence?: number;
    health?: number;
    mana?: number;
    [key: string]: number | undefined;
  };
  durability?: number;
  weight?: number;
}

```

We can work with that for now and then extend it out later on.
Next we will add an action for the IObject.

```ts
export interface IObjectAction {
  itemId: string;
  itemObject: IObject;
  actionEvent: 'consume' | 'equip' | 'unequip' | 'discard' | 'view';
  actionPerformedAt: number;
  performedBy: string;
  actionDetails?: string;
}

```

The equipment test casing seems to be throwing some errors, that might have to do with the fact that we did not yet add items to be equipped.
I am going to take a break on this area and maybe come back around when we have more items to test case.


**UI**

For the game's UI/UX, we will have to maintain a submenu system that can be extended and utilized across this game and maybe even future games?
Right now, we have this seperated from the laser library, I think it would be best to keep it isolated because different games will have different UI elements.
There was a bug where the tooltip did not display exactly where the user had clicked, which seems a bit weird of a bug, but I was able to adjust the client's x and y to help with that.
In the future, we could add some extra options to help with this customization, maybe different settings for offsets and things of that nature.

**Build**

We can setup the build pipeline to push to Itch with the Electron / NWJS wrapper, I will start to write that action out on the side, while building more of the game out.

## 2023
- 9:30am - Quick coffee trip before sitting down for a meeting and programming session. My general go to breakfast is some egg-form sandwich, coffee and sugar free red bulls!
- 10:00am - Looks like a minor update came out for Astro! Going to read through that and then update the website. I am thinking I might also go back and migrate the RareIcon.com website from the general node package manager to yarn.
- 11:25am - Saving the minor updates to RareIcon.com, I need to extend out the general typescript paths and condense the components into a smaller form factor that I can reference easier. I believe that pathing / dynamic routing will be next on the update sheet!
- 11:27am - The next couple hours I will begin looking back at the Unity async loading problem and see if I can figure out a better way to load the components. The next step was to use vContainers with unitask, so that the loading would be a bit faster between the scenes.
- 2:30pm - Got the basic of the stream up and running! It has been such a long time since I had it online, I think it will be a solid edition to have within the KBVE eco-system. I will try to live stream my coding sessions more often.
- 4:45pm - Setting up the Vuplex javascript library on KBVE.com, so that we can reference it inside of Unity. The current plan is to use a JWT session between the Vuplex instance and the Unity instance, but that can change later down the line, depending on how we move forward with it. 
- 5:30pm - Going to make some issue statements regrading on-going errors, updates or concerns with the stream. This might be a good way to keep things organized, so that we can keep everything organized and not all over the place. 
- 10:00pm - Before I forget, I have to create an issue ticket regarding the notification system. We will want to extend this out to RJ and our future games, as well as the future websites that we build.
- 11:50pm / EOD - `This follow passage was from the hand written notes, doing my best to write it out and save it for future reference.` Making a large list of the functions and concepts that we could render and then call from would be useful. The idea here would be that we have to extend out each of those renders, i.e functions. I suppose that is like nested cloud functions, it could be interesting. Gelling to this point will require increasing the number issue tickets that we can generate / find including those outsides of the current main repository and migrating them all into just one? So we would have a different repository for each cloud function, but try to keep the issues within just the main repository, this way we could keep track of the functions and their issues but also keep to a hybrid-style source code management. This is because some of the cloud functions will remain behind a private wall, to avoid direct copying or abuse, while keeping some of the cloud functions public. In addition, we could create a mermaid style graph for each of the interpolation that we reference within the nested functions. 'The written notes go further into the game plan design but writing them out seems a bit pointless as of right now'

## Quote

> The greatest way to live with honor in this world is to be what we pretend to be.
> — <cite>Socrates</cite>

---

## Tasks

- [ ] Async Unity Loading

---
# July: 07

> July 7th. More Items!

Source: https://kbve.com/journal/07-07/

import { Adsense } from '@/components/astropad';

## 2025

### AstroPad

-   10:43PM

    Time to migrate all of the supabase files again into the astropad.
    Other than that, it was a slow day of note taking.

## 2024

**Items**

I adjusted the items a bit today, adding a couple from AndSam's Eve Guild Campaign!
After we add a couple more items for Eves guild, we could open up the bar and let users come into it and buy those potions, maybe we can do a barter system.

I am also trying to avoid dumping a bunch of random pixel art without making sure it has an exact usage and with credits.

**Settings**

The next update should be organizing all of the settings into a single interface, making it easier to call through out the game and any future game.
I believe we should also include another function that will wipe all the save data, just to do a clear restart during each session.

```ts

export interface UserSettings {
  tooltipItemId: string | null;
  tooltipItemPosition: {
    x: number;
    y: number;
  };
  submenuItemId: string | null;
  submenuItemPosition: {
    x: number;
    y: number;
  };
  isStatsMenuCollapsed: boolean;
}

```

Now that I am thinking about it, we could introduce the submenu for the different NPC characters too, upon clicking them and then rendering the actions for them?
This would free up the action menu and make things a bit easier for us to manage.
With that being said, let us go ahead and update the types again but this time something along these lines?

```ts

export interface UserGenericMenu {
  id: string | null;
  position: {
    x: number;
    y: number;
  };
}

export interface UserSettings {
  tooltipItem: UserGenericMenu;
  submenuItem: UserGenericMenu;
  tooltipNPC: UserGenericMenu;
  isStatsMenuCollapsed: boolean;
}

```

Inside of the `localdb.ts`, we went ahead and created the store, like this:

```ts

export const settings = createPersistentAtom<UserSettings>(
  'settings',
  defaultSettings,
);

```

And then added two helper functions, that are setup like this:

```ts

export const getUserSetting = <T extends keyof UserSettings>(key: T): UserSettings[T] => {
  return settings.get()[key];
};

export const setUserSetting = <T extends keyof UserSettings>(key: T, value: UserSettings[T]): void => {
  task(async () => {
    const currentSettings = settings.get();
    settings.set({ ...currentSettings, [key]: value });
  });
};

```

We will be wrapping the set function inside of a task, making it a bit easier in the future to extend out into event and chaining style functions.
One other suggestion was to add a class / factory for it all and then extend it out but I think that might be too much work within this first write.
I will most likely rewrite all of laser again in a couple months, as a trad meme programmer.

**Dice**

Now the next fun begins, which will be to find a way to implement the dice rolling and have it done outside of Phaser.
I am thinking we should do this whole Dice rolling using just React and Three, so that we can utilize this dice rolling in the future and across other applications, like Unity.
After drafting out the dice plans, I was going to originally do a multi-dye , with the option of swapping out different ranges to create that perfect illusion of dice rolling.
Yet for some reason, I felt the need to just use a simple 6 face set of dice, we could adjust the 

We got to this part so far:

```ts 
dice.rotation.set(Math.PI, 0, 0);  // shows 6
dice.rotation.set(0, 0, -Math.PI / 2) // Shows a 5
          dice.rotation.set(Math.PI / 2, Math.PI, Math.PI)  // shows a 4
dice.rotation.set(0, -Math.PI / 2, -Math.PI / 2) // shows a 3
dice.rotation.set(-Math.PI / 2, -Math.PI / 2, -Math.PI / 2)  // shows a 1

 ```

 Getting closer

 ```ts 

   1: new THREE.Euler(-Math.PI / 2, -Math.PI / 2, -Math.PI / 2),          // Face 1 on top
  2: new THREE.Euler(Math.PI / 2, 0, 0), // Face 2 on top
  3: new THREE.Euler(0, -Math.PI / 2, -Math.PI / 2), // Face 3 on top
  4: new THREE.Euler(Math.PI / 2, Math.PI, Math.PI),// Face 4 on top
  5: new THREE.Euler(0, 0, -Math.PI / 2),// Face 5 on top
  6: new THREE.Euler(Math.PI, 0, 0),    // Face 6 on top

  ```

  <Adsense />

  ## 2023
- 6:00am - After my early morning ritual, I figured it might make sense to do some updates across the board for various projects. I will push through some of the general updates and then sync the repo before I grab my mini-laptop.
- 6:30am - Pushing the sync command and taking a nice break from the house! Early morning touch grass sessions are so relaxing and fun, a great way to start the day.
- 8:00am - While I am in the zone, I am going to layout an effective game plan for myself to quickly do sprints in the form of post-it style issue tickets. I am thinking to compile almost every issue within KBVE, projects and sub-projects into one large kanban. The idea here should be within the scope of keeping each issue / task within the size of a post-it note, minus any technical debt, like links and resources. I should make it a habit of doing this at least once a month, with the idea of keeping certain issues open until they get downsized to smaller ones that can be referenced back to the larger ones? I am rambling a bit here while I type away, but I suppose that is the idea of the journal. Keeping written logs and then typing logs?! Ugh.
- 9:00am - As I am resting in my bed, hoping that I do not take a nap, I am thinking through all the small notes that I made and seeing how far I can push the kanban post-it game plan will be an interesting experiment. 
- 9:20am - Created an issue regarding the A to Z of FinTech. I am going to try and keep dual set of logs, a bit of double accounting style with how I approach each unit within the kanban board. 
- 10:22am - Quickly rolled a SPY $442 call for Monday , quick $50 and rolled 2 TSLA $270 put for $800. Completely forgot to do my Friday specials xD, dumped all that extra cash into O, for about 13 shares, which is another $3.30 additional monthly income. 
- 10:30am - Twitch Mockup / Builder concept notes? Maybe that could be placed into a tools -> stream concept? Where we could generate a bunch of pre-built renders / concepts for people. 
- EOD - n8n is a monster when it comes to debugging certain types of situations, but it seems that I was able to get the duplicate GitHub triggers resolved for now.

## Quote

> The teacher who is indeed wise does not bid you to enter the house of his wisdom but rather leads you to the threshold of your mind.
> — <cite>Kahlil Gibran</cite>

---

## Tasks

- [x] Resolve n8n bug.

---
# July: 08

> July 8th. The Flow!

Source: https://kbve.com/journal/07-08/

import { Adsense } from '@/components/astropad';

## Notes

## 2025

### Nvdia 160

-   03:24PM

    Will we see it this week?
    I am seeing 160, which means my 155 puts will be printing.

### AstroPad Supabase Services

-   04:55PM

    The goal for today will be to build out all the service files for the supabase auth system.
    This singleton approach should help us with a bit better memory management and make things cleaner to use.
    Our first three services will be the login, register and the oauth, which will be the 5th time we done a rewrite of it within the past three years.    

    The three services will be `ServiceLogin`, `ServiceRegister` and `ServiceOAuth` and majority of the code for these have been written out.
    We are just cleaning this up and applying some level of optimization!
    The end goal will be that we can have multiple sites that can quickly integrate into our eco-system, making future websites easier to manage and scale up.
    I am excited to see how it goes about building this out, being able to mass produce websites is going to be a great feature for us.

## 2024

**R3F**

The next library that I want to integrate into the laser package is react three fiber and three js, using both of those to help us render smaller components outside of phaser.
We want to isolate some of the minigames, so that the application, as a whole, will not fail directly.
Going with a bit more of a modular flow with the rendering but the downside is that it will make the game and library heavier.
The trade off will be worth it in the long term.

**Sleep**

I might have messed up my sleep schedule, so I will have to think through what the steps to take to get it back to normal.

**Kill Tony**

The episode of kill tony was okay, it was definitely not the best but I had a couple solid laughs.
The golden ticket winner that they had on had a terrible minute doe, was surprised he was a holder.

**Dice** 

One of the issue that I was having with the Dice roller was that it kept re-rendering and since I have not done react in a bit, I forgot to wrap it in a memo.
Next I changed the material color to a yellow-ish color, to help it match the rest of the site's theme.
I believe we will have to go through all the colors and stick to a solid combination or set of matching hexs.

<Adsense />

## 2023
- 7:00pm - Late start to the PC neety life, had to touch grass.
- 7:30pm - Caffeine check! Red bulls, yup. Coffee, was drank before I even got home. Water? A gallon of filtered water, hopefully there are no PFAS chillin in there. 
- 8:00pm - Going through all of the backlogs and then creating issue tickets for each one! The idea here would be to have about 50-100 issues that are pending, then focus on tackling as many of them as possible. A bit of a wave function style management per say.
- 11:00pm - I am cycling through almost 200 post-it notes and I am getting even more daily. I have to be very careful not to over extend myself and focus on getting the really basics out of the way.

## Quote

> Act as if what you do makes a difference. It does.
> — <cite>William James</cite>

---

## Tasks

- [x] No Tasks for Saturday! Just chill and do as the gods' will.

---
# July: 09

> July 9th. NPC Engine

Source: https://kbve.com/journal/07-09/

import { Adsense } from '@/components/astropad';

## 2025

### Nvidia 4T

-	04:36PM

	Great to see the big green machine push towards that 4 trillion cap, I wonder where it will be in 40 years from now.
	I am going to try and get around a 1000 shares before the end of this year, just to further push my nest egg.
	With that being said, I been wheeling the puts, using that capital back to invest into rareicon.

### AstroPad Supabase

-	03:44PM

	In the future, I will try and add some hook systems so that the astro pad can directly hook into vite configuration.
	This will be something that we add in the future, the goal being that we make this as modular as possible.

## 2024

**TSLA**

Looking at this tesla spike is really getting me excited!
The market might finally see some of the value within the `ai` and `energy` areas that the company could push forward.

**NPC Engine**

I am adding another couple layers of complexity to the NPC engine but I think the time invested now will pay off in the future.
The plan will be similar to how we moved the items out of the games core and now we can create new items through the MDX.

The schema looks like this right now:

```ts


const NPCPositionSchema = z.object({
	x: z.number(),
	y: z.number(),
	z: z.number().optional(),
	d: z.number().optional(),
  });

const PlayerStatsSchema = z.object({
	health: z.number(),
	mana: z.number(),
  });

const NPCDataSchema = z.object({
	id: z.string(),
	name: z.string(),
	spriteKey: z.string(),
	walkingAnimationMapping: z.number(),
	startPosition: NPCPositionSchema,
	speed: z.number(),
	scale: z.number(),
	actions: z.array(z.enum(['talk', 'quest', 'trade', 'combat', 'heal', 'steal'])),
	effects: z.array(z.string()).optional(),
	stats: PlayerStatsSchema.optional(),
	spriteImageId: z.string().optional(),
	avatarImageId: z.string().optional(),
  });

const SpriteSchema = z.object({
	id: z.string(), // Assuming the ULID is validated elsewhere
	spriteName: z.string(),
	assetLocation: z.string(),
	frameWidth: z.number(),
	frameHeight: z.number(),
	scale: z.number().optional(),
	spriteData: z.instanceof(Blob).optional(),
  });

const AvatarSchema = z.object({
	id: z.string(), // Assuming the ULID is validated elsewhere
	avatarLocation: z.string(),
	avatarData: z.instanceof(Blob).optional(),
});
  
  
```

I am thinking that we could split the three schemas into their own `z.objects` , then just having the `NPC` reference the sprite and the avatar.
This schema is not yet complete because we still have to do the dialogue system.

Okay the first NPC is Chip and after adding him in, we need to create the JSON endpoints to pull the data from.
We will follow the same structure as the itemdb but pivot the data points towards the avatar, sprite and then npcdb.


**DevOps**

The devops library should have internal git commands that are built into it, making it easier to branch off the codebase and make changes that would be scope specific.
I still need to work out the exact steps and logic that would be involved in getting it to work without having major problems.
Also we could expand groq by having it build out items for our game using the mdx layout.
The user would make an issue ticket for the item that they would want to add into the game, then have it parse through the mdx contents and add the variables/data points to the itemdb.
There is still some work that would go into it, hmm, maybe I am writing a bit too much and need to do some more coding.


**ItemsDB - Fish**

The next couple items to add into the `Fish.mdx` will be these:

- Nemo Fish
- Zebra Fish
- Ghost Lobster
- Warhammer Shark
- Blue Angular
- Rainforest Frog
- Koi
- Blood Octopus
- Bowhead Whale
- Seahorse
- Blue Seahorse
- Posion Seashorse
- Pink Shrimp
- White Squid
- Starfish De Patrick

These are the generic items that we can add into the category, I am just making this list so that I can remind myself to add them into the itemdb.

<Adsense />

### 2023
- 1:24am - Just finished finished a quick league match and I figured it would make sense to go through more of the backlog grooming stage.

## Quote

> Genuine sincerity opens people's hearts, while manipulation causes them to close.
> — <cite>Daisaku Ikeda</cite>

---

## Tasks

- [ ] Sunday Funday!

---
# July: 10

> July 10th. NPC Engine Demo

Source: https://kbve.com/journal/07-10/

import { Adsense } from '@/components/astropad';


## 2025

### Astropad

-   02:35PM

    The next update to the astropad will be ReactCallback, as its a bit too buggy for us.
    I am thinking that we should split the rendering up.

### Nvidia 4T Continued.

-   04:59PM

    The 4T continues and I think we might see Microsoft reach that goalpost soon too.
    I decided to gamble a bit and roll 5 puts on TSLA for $2k, I figured the 24 hour risk would be worth the reward.

### BitCraft FloatCity Team

-   07:10PM

    Zane, Bell, Fud and I have decided to start our journey into the first group quest, visiting the temple.


## 2024

**Chip**

We will have to add the sprite sheet and the avatar for Chip.
For his character sprite, we will try to use the bard image and see if that fits his style.
The location will be under `/assets/items/npc/sprites/bard.png` and then for the avatar, we will just place it under `/assets/items/npc/avatars/chip.webp`.

While we are waiting on the build to reach production, we can start the pulling of the NPCDB endpoints.
The three endpoints will be, `https://kbve.com/api/npcdb.json`, `https://kbve.com/api/spritedb.json` and `https://kbve.com/api/avatardb.json`.
We will still need to figure out the style methods for the different avatars, I am thinking we will stick with an anime-style because its easier to draw and looks great.
In our current example, we went with a pixel-art stytle for the avatar but that was just a placeholder.

<Adsense />

## 2023
- 5:40pm - The Astro core redesign is almost done, I plan to migrate away from the namespace concept and focus a bit more on refactoring the theme to take advantage of the named slots. Part of this update is to make sure it is easier to call important files and isolate the ones that would utilize the API. I am thinking of having two shell files, one being the generic one for guests and another for logged in users. 
- 6:30pm - Okay going to try another method to solve this and maybe approach it a bit more Lego style and let the menus have slots, then pass the components that we would need through this.

## Quote

> Every problem has a gift for you in its hands.
> — <cite>Richard Bach</cite>

---

## Tasks

- [x] - Backlog Issues

---
# July: 11

> July 11th. NPC Engine Demo

Source: https://kbve.com/journal/07-11/

import { Adsense } from '@/components/astropad';

## 2025

### Techie

-   05:59PM

    Good news! We are hitting all time highes on a couple of our tech holdings, which should open up some extra capital.
    Seeing Nvidia hit $200 is also a crazy experience.


### Bitcraft

-   11:51PM

    We should look at seeing if Claude or any of these AI tools can take an exisiting program and turn it into a react application .
    I am going to try and run a quick dry run.


## 2024

**NPC**

Still working on the NPC Engine and making it just a bit easier to load characters dynamically.
The path for loading the NPCs will shift towards the Map class or factory, not yet sure which approach we will take.
While we want to load the NPC via the Map, we also need to figure out how to handle the loot table and then we have to figure out the combat.
These are steps that we can probably handle through ulid-style relationships and just making sure each aspect works.
I am sure just like how we were able to abstract away the item creation, we are getting a step closer for doing the same with the map and NPCs.

Updated the engine to also accept an optional x and y coordinate.
As for the loot table, we can keep that as an additional table to be added into the `indexedDB` on a later date.
The goal for that loot table should be handled outside of the placement for the NPC.
We can always create multiple clones of the NPCs in the future with different loot tables based upon the map and location, rather than make the loot table too expansive.
But I could be lying because I am finding this part of the whole structure to be fun :D

After some more test casing and some key issues, we were able to get the `Chip` character to load and display the actions.
The current actions do not yet work but that is because of another key mismatch, one that I will fix later today.
The issue behind the sprite-key is a bit confusing because we a couple different ids, names and keys that represent the object within the grid engine itself, phaser, client-side database and also the static-side.
I have not even gotten to the management of the NPCs from the server-side, but these are all small steps towards building this abstracted layer.

**Map**

The map generation will be in two forms, the first will be static cities, villas and towns and the second will be a dynamic and random dungeon crawler style.
This should give the game a bit more depth and create unique play back, since the each cave will be unique.

As progress is being made with the NPC engine and after a couple more NPCs are added, we can move forward with setting up the map system.
This part of the code will start off simple, with focus on the city maps and then expand into the villas & towns.
If we can get about three to five cities out of the way within this week, then adding the base random crawler system could be achieved within a couple days.
We are not too sure what type of problems we will face with the map generation, but I am hoping that they will be small in scale. 

**jRPG**

The combat system is still a long way from being complete.
I am currently trying the multi dev environment, building a couple different javascript classes on different machines within the same time.

**Loot Table**

After finishing up the base map system, I will have to come back around and expand the NPC engine, with a loot table.
I am thinking about how I would want to handle the loot tables, if we should do isolated tables for each action?
So a different loot table for stealing, combat, trade and quest?
We could set the interface up for the loot table to be fairly generic, then expand the type / inter out for the different actions.

<Adsense />

## 2023
- 5:55am - The sunshine is definitely strong! After finishing up my quick SSS, I am going to finish up some more of the Astro core.
- 6:04am - While I am tackling some of the Astro stuff, I am going to take a look at a random issue and see if I can progress it too.
- 9:51pm - 

## Quote

> Once we accept our limits, we go beyond them.
> — <cite>Albert Einstein</cite>

---

## Tasks

- [ ]

---
# July: 12

> July 12th. NPC Engine Demo

Source: https://kbve.com/journal/07-12/

import { Adsense } from '@/components/astropad';

## 2025

### BitCraft The Drama Wall

-   11:37PM

    

## 2024

**Dice**

The yellow material over the dice shows up on the initial load but after the roll animation, it seems to revert.
I am wondering if there is an issue with the object itself or the animation is resetting the material on the dice.
The max amount of dice that we can roll would be about 4, which gives us a low range of 4 and a max of 48.
Having this be our scope of rolls would be the best move, then having the additional rigged dice to help over some of the issues.
So a crit fail will be a 4 and a perfect crit will be a 48.
However we could work out a better formula to determine the critical chance, maybe roll an additional d100 style dice to handle the critial chance.
There are still a decent amount of options, but I will try to look through each one.

**Sprites**

Thanks to the recent purchase of finalbossblue's complete asset collection, we have a decent chunk of characters, animations and tilesets to work with.
This means that the only thing left is to slowly focus on the different core mechanics of the game engine, we can tackle the map builder and the dialogue system next.

The animation engine for different characters will be an interesting test case, I am not yet ready to handle this, I might have to visit the forest of 420 and embark on a hazy trip.
For the animation system we will have a couple options but I think we could find a way to use either the threejs or a direct function to control the movement of the assets.
I am trying my best to think through the best course of action but it seems that we do not want to create a situation where every new item would require a vast shift in animation.

Replacing Fudster's in-game character from a `monk` set to the `jesus` set would be fine.

**Dialogue**

I am thinking that the dialogue system should be something along the lines of a semi-complex data structure that would link other structures together creating a nested web of nodes.
We could use the ULIDs to help us keep track of the different dialogue options and then work around that, but try to include ways to `skip`, `actions` and `effects` based upon how the dialogue is setup.

This would be the general `IDialogueObject` that we would use to store the different talks that the player would have with the NPCS.

```ts

export interface IDialogueObject {
  id: string;
  title: string;
  message: string;
  actions: string[];
  options: string[];
}

export interface IAction {
  id: string;
  description: string;
  nextDialogueId: string;
}

// Interface for Option Object
export interface IOption {
  id: string;
  description: string;
  nextDialogueId: string | null;
}

```

Actually, just to be safe, we should rename the two other interfaces with a better name, like `IDialogueAction` and `IDialogueOption`.
After thinking it through, maybe we step a bit back and do something like this:

```ts

// Interface for Dialogue Object
export interface IDialogueObject {
  id: string;
  title: string;
  message: string;
  actions: IDialogueAction[];
  options: IDialogueOption[];
}

// Interface for Dialogue Action
export interface IDialogueAction {
  id: string;
  description: string;
  nextDialogueId: string;
  actionType?: 'giveItem' | 'startQuest' | 'updateQuest' | 'completeQuest';
  itemType?: string; // Type of item to be given (if actionType is 'giveItem')
  quantity?: number; // Quantity of the item (if actionType is 'giveItem')
  questId?: string; // ID of the quest (if actionType is related to quests)
  questStatus?: 'start' | 'update' | 'complete'; // Status of the quest (if actionType is related to quests)
}

// Interface for Dialogue Option
export interface IDialogueOption {
  id: string;
  description: string;
  nextDialogueId: string | null;
}

```

This would let us keep the initial object of the conversation the same without having too many different objects.
This is what I am thinking would be the core dialogue object now, as of the end of the day:

```ts

// Interface for Dialogue Object
export interface IDialogueObject {
  id: string;
  title: string;
  message: string;
  actions: IDialogueAction[];
  options: IDialogueOption[];
  style?: string;
  backgroundImage?: string;
}

// Interface for Dialogue Action
export interface IDialogueAction {
  id: string;
  title: string;
  message: string;
  nextDialogueId: string;
  actionType?: 'giveItem' | 'startQuest' | 'updateQuest' | 'completeQuest';
  itemType?: string; // Type of item to be given (if actionType is 'giveItem')
  quantity?: number; // Quantity of the item (if actionType is 'giveItem')
  questId?: string; // ID of the quest (if actionType is related to quests)
  questStatus?: 'start' | 'update' | 'complete'; // Status of the quest (if actionType is related to quests)
  style?: string;
  backgroundImage?: string;
}

// Interface for Dialogue Option
export interface IDialogueOption {
  id: string;
  title: string;
  message: string;
  nextDialogueId?: string;
  style?: string;
  backgroundImage?: string;
}


```

Okay for the future of this system, I am thinking that it would make sense to include a `style` and a `backgroundImage` for all three of the interfaces.
This will help us with rendering out the dialogue on the client-side.

Next step would be to setup the `DialogueDatabase`, we will follow the same structure as our NPCDatabse.
My goal would be try and keep some of the logic on the client-side as similar as possible, so that it would be easier to maintain in the future.


**House of Dragons**

Season 2 is shaping up to be a great season so far!
I am enjoying episode 3 and 4, its getting solid and the dragon fights were top notch this season.



**Sprites**

Thanks to the recent purchase of finalbossblue's complete asset collection, we have a decent chunk of characters, animations and tilesets to work with.
This means that the only thing left is to slowly focus on the different core mechanics of the game engine, we can tackle the map builder and the dialogue system next.



## 2023
- 6:00pm - H to V to the A-C. HVAC was not yet done, I am still a bit afraid of getting electrocuted to death.
- 6:35pm - I am thinking of converting the whole `TypeWriter` concept into a `MangaTextHandler` which will act as the component for all the unique text styles and logos.
- 8:30pm - Adding a couple more mock examples to the stream tools. Got to top-up the Namecheap.com account as well. Furthermore, I have to prepare another couple thousand for my insurance bill that is coming up too. 
- 11:30pm - As for the 100 assets, I should at least prepare the list and get from the 5 current assets that we are tracking to around 25 before the end of this week. If I can add around 5 assets daily, we should get to the 100 we need to close out the asset expansion issue ticket. After we hit the 100 mark, we can start to organize the data sets for them a bit better, as well as improve the flow of information for each one. Adding a couple of ETFs would make this faster, hmm.
- EOD - Time to get some sleep. I need to get back to being a bit more active on my journal entries, they have been lackluster these few months.

## Quote

> A monarchy conducted with infinite wisdom and infinite benevolence is the most perfect of all possible governments.
> — <cite>Ezra Stiles</cite>

---

## Tasks

- [ ]

---
# July: 13

> July 13th. Dialogue System.

Source: https://kbve.com/journal/07-13/

import { Adsense } from '@/components/astropad';


## 2025

### Ergo IRC

-   04:54PM

    My side project will be pull to integrate the Supabase instance with the ergo irc server?
    Basically offloading the chat concept into its own irc server that people can connect to.
    As for the actual guest system, we can keep that open for anyone to join that chat but lock parts of it into its own verified channel.
    My thought process is that having the IRC hold the chat would make it easier to then relay to Discord and other concepts. 
  

### BitCraft API

-   06:57PM 

    The SpaceTimeDB has a public facing API that I want to test and see what information that I can pull from it.




## 2024

**Dialogue**

We will merge the `DialogueDatabase` into the `NPCDatabase` to make it easier to manage the state of the dialogue.
After we merge those into one, we can look at preparing the different dialogues using the zod/astro integration, moving that logic out of the game itself and into the main website.
This means in the future, they will be able to view and read the dialogue outside of the game itself too.
A new astropad component to handle the NPC, the Dialogue and the Lore should be coming wiithin the next couple weeks.

We added the zod configuration and now need to test it.

**Cosplay**

The next sprite that I wanted to add was a cosplayer but I got side tracked with so many different and new sprites!

**Horror**

A twist and turn in the game story could be around the corner.
I am thinking of adding a bit of a horror-style element into the game but there is still a decent amount of work to do.

## 2023
- 6:00am - Getting up and ready! I believe the major goal for the day is to get through about a couple of the issue tickets and organize some of the cloud functions. I should move the older set of functions into a private github repo and then test the deployment of them through there. There might be some issues with how deployment would work within the scope of hybrid repos, where the sub-modules would be from hidden repos or 3rd party locations, but I suppose that is the part where we learn and find out.
- 6:05am - The automated deployment will be a bit interesting because there are a couple different active entities that would be called, so it can create a bit of confusion, as there would be a decent chunk of vastly different moving parts. Software does not always like to work together, but with enough safety checks and cross communication, we should be able to get the majority of the concept and MVP up and running. We are soon reaching the time of a massive launch, it will feel great to come out of the shadow with massive swings into the public realm. I suspect there will be a bit of delay and bug abusing within the first couple months, but there will be a great burden that will be lifted. Seeing all the software perform and slowly coming together is amazing. 

## Quote

> Never bend your head. Always hold it high. Look the world right in the eye.
> — <cite>Helen Keller</cite>

---

## Tasks

- [ ]

---
# July: 14

> July 14th. Dialogue System.

Source: https://kbve.com/journal/07-14/

import { Adsense } from '@/components/astropad';

## 2025

### TSLA Puts

-   11:40AM

    Going to roll another 3-4 wheels on Tesla, hoping that it will not drop too quickly to under $300.
    I might also exit the position if the swings are a bit rough over the hump day.

### Rain Rain Rain

-   07:05PM

    So much rain, it is a bit insane the amount of water that is being dumped into the streets.
    I also ran out of seltzer water and I am debating if I want to take the trip to get more.

### Astro UserProfiles

-   09:26PM

    Moving the user profiles into a bento grid that will utilize the react window and a bit better caching of the modal.


## 2024

**Zod**

The dialogue zod is still a pain to create but we are getting there slowly.
Maybe we just have one structure for the dialogue node and then have it include possible actions as an optional ulid.

For this case, we can just do this:

```ts 

export interface IDialogueObject {
  id: string;
  title: string;
  message: string;
  actions?: string[];  // Array of ULIDs pointing to actions/effects
  options?: string[];  // Array of ULIDs pointing to other dialogue objects
  style?: string; 
  backgroundImage?: string;
}

```

Actually we could add in the playerResponse as a string too.

```ts

const DialogueObjectSchema = z.object({
  id: z.string(),
  title: z.string(),
  message: z.string(),
  playerResponse: z.string().optional(),
  actions: z.array(z.string()).optional(), 
  options: z.array(z.string()).optional(),
  style: z.string().optional(),
  backgroundImage: z.string().optional(),
});

```

Okay while waiting for this to move into the `production` branch, I am going to continue to improve the codebase.
I believe we can make some changes to the `NPCDatabase` that can be useful in the future!
Lets make some minor changes first to the NPCDB, making sure we got the core fundamentals down.

**Princess Mononoke**

The `Kodama ` from the movie were nearly perfect, I think we should have those hidden through a forest scene.
We will have to work out the background image for them and not try to copy exactly how they look, maybe mix them in with the unknowns and pikmen?
So a cute and easy to draw spirit that will appear throughout the background scenes for the different NPCs within the forest.

**Dialogue**
The next step for the dialogue system will be to render the visual novel style but also include a way to add some color to the text when going through the typewriter effect.
We also might want to play a sound when the character is typing out, similar to the Animal Crossing effect?




## 2023
- 6:00am - React Native time. I am going to try and build out an application as fast as I can? There will be a mixture of me learning how different template engines work and how to use the different routing styles.
- 8:00am - I need to rewrite the notes from this date back into this journal entry for reference. `FLAG`

## Quote

> Imagination rules the world.
> — <cite>Napoleon</cite>

---

## Tasks

- [x] Study React Native

---
# July: 15

> July 15th. Dialogue System.

Source: https://kbve.com/journal/07-15/

import { Adsense } from '@/components/astropad';

## 2025

### Bitcraft Fishing

-   08:19PM

    Trying to get the fishing up from 37 to 40, hoping that I can get even further by the end of this week.
    Cleaning up all the extra fish inventory and maybe from there we can find other updates.

### React User Profile

-   08:42PM

    Going to wrap up the user profile within the next couple hours and then switch focus to the main dashboard.
    The card holding all of the profile data can be updated too, it seems to be not responsive enough.


## 2024

**League**
Before getting deep into the programming grind, I am going to quickly throw up a couple quick matches.
Get that RTS/MOBA hit off really quick.

**Debug**
The debug aspect of the game should be handled right now, I think it would make sense to avoid postponing this too far along the dev cycle.
We will extend the user settings to include a debug Boolean to represent the mode and then create a new `debug.ts` to handle the generic problems.
Afterwards, I am thinking of extending it out to create a bug report that can be executed by the player, which will send the information to a github issue ticket? I suppose there are a couple ways we could work that out with the rust-based API. The different parts of my brain are wired and ready, lets go ahead and push through the changes.

**Kill Tony**
I am excited to see who the guests will be for todays kill tony, I expect at least a couple trump jokes all through the set too.
This was an amazing set! I forgot that it was taped right after the debate but the amount of laughs and jokes, definitely one of their best episode yet.

<Adsense />

## 2023
- 6:00am - Going through the react native code base once more. These mornings are starting to become very blurry, as I am just diving deeper and deeper into the react eco-system. 
- 7:00am - Mapping the pipeline for the iOS / Android.
- 4:00pm - `FLAG` - Need to process the written notes for 07-15-2023 into this journal entry.

## Quote

> When you discover your mission, you will feel its demand. It will fill you with enthusiasm and a burning desire to get to work on it.
> — <cite>W. Clement Stone</cite>

---

## Tasks

- [x] Study React Native

---
# July: 16

> July 16th. Dialogue System.

Source: https://kbve.com/journal/07-16/

import { Adsense } from '@/components/astropad';

## 2025

### Pirate 17

-   04:45PM

    The jam starts tomorrow so I need to prepare for it, I am a bit excited to see where it will go.
    Moving forward, all gamejams will be in Godot, which will make things easier to manage and keep the whole games source code out there for future projects.
    I am hoping that we get something playable out.

### Tesla Puts

-   07:49PM

    Rolling the puts into the next week, hopefully they do not get called and expire without any problems.
    I am not looking to do anything but collect that sweet sweet wheel money.

## 2024

**Settings**
The game needs a settings menu and then an option to enable and disable debug mode.
We will use the debug mode to switch between enabling and disabling the events, logs, data, ect... through-out the game.
So we extended out the `UserSettings` interface within the `types.ts` with a couple new variables.

```ts
export interface UserSettings {
  tooltipItem: UserGenericMenu;
  submenuItem: UserGenericMenu;
  tooltipNPC: UserGenericMenu;
  isStatsMenuCollapsed: boolean;
  isSettingsMenuCollapsed: boolean;
  debugMode: boolean;
}
```

Under the `Settings` , we want to toggle the debugMode on and off, after we get that setup, we can move forward with updating the different classes to pass around the debug messages?

The initial settings panel will look like this:
```ts
const SettingsPanel: React.FC = () => {
  return (
    <div className="transition transform duration-1000 ease-in-out">
      <div className="mb-4">
        <h2 className="text-lg font-semibold mb-2">Settings</h2>
        <p className="text-sm">Additional settings can go here.</p>
      </div>
    </div>
  );
};
```

After loading that new settings panel, we can add a new `debugMode` that will help us handle any of the debug messages. Now we can go back and extend out the `eventhandler.ts` within the `@kbve/laser` package to utilize the debug mode and send back any additional information based upon the events that are being triggered.

**Stats**

We want to move the stats section into its own modular function that we can extend out in the future.
The issue that we might run into is the race condition of updating the stats and making sure that they render on time, yet we also do not want to continuously render them.
The render should only occur when the stats are changed.

We could try to build a quick progress bar for the stats?

**Notification**

I was running into this weird bug for the Notification function that we had built.
It turns out that the issue was because there is another `Notification` class that already exisits, thus causing some naming conflicts.
For now, the solution was to rename our Notification to `INotification` and move forward with the dynamic imports.

**eBPF**
One of the areas that I was looking to expand the Rust API into was the `eBPF` area, maybe integrating the packet level of filtering and management. This would make the multiplayer aspect of the game easier but also allows us to look into the anti-cheat concept a bit more, since we could see all the packets that are coming in and out. Once more, this is just a proof of concept but we can work out the kinks on a later date.

The plan will be to extend out the API to include Aya and some level of eBPF integration, basically our own internal ingress and then we can place an external ingress on top of it via Traefik, all of this bundled into a [Kubernetes](https://kbve.com/application/kubernetes/) cluster. I will draw out the map and prepare the next adventure into this field near the end of the summer.

**Character**
There seems to be an issue with loading the characters that are a single sheet, I am thinking that either the image settings are wrong or my configurations for the image are wrong. The best thing that we can do for now is keep track of this frame bug and then come back to it when we finish up some of the core features for the game.

Okay it looks like this is no longer an issue and it was in fact patched. I believe we had an older cache and updating / clearing it all helped resolve the frame issue. Next we will need to start loading in new characters and making sure that we do not run into any issues with that.


**Dice**
One of the future improvements that we could make with the dice rolling is to optimize the disposal of the threejs. I am not too sure what the best course of action would be, maybe instead of removing and then bringing it back, we could find a hybrid approach where the dice can stay ready to be displayed? We could move them off canvas and then move them back in whenever we need to roll them, I believe we can get a better answer to this once we get combat into staging.


<Adsense />

## 2023
- 6:30am - Started to add state management through nanostores into the React Native application. 
- 6:41am - Removing the `react-hook-form` from the RentEarth repo because I was having some issues getting it to work with the Tamagui framework. There was a solution to use a 3rd party plugin, but I felt like it might best to step away from that for now and use write something a bit more simple. 
- 6:50am - Renaming the `/auth/` path to `/account/` to keep the same naming convention across the multiple tenets. I should note that I am thinking of renaming the RogueJester to RentEarth and pivoting the gaming to be a bit more focused on this concept. It would be an interesting shift per say, but it seems that the marketing potential is definitely higher with this name. I suppose the RJ is a codename for the project and is not the final title name. I find it interesting how even the name of a video game can help determine its future, at least to an extent that falls under the branding. 
- 8:27am - The next step within the RentEarth saga will be to build out the state / storage, I am thinking that I might use nanostores library for this, as it also has a very solid task system. 
- 10:52am - I created an issue ticket related to the storage situation, it would be called inside of various platforms from React to our mobile apps to Unity. Thinking through how we would go about setting it up, I am also thinking that while we do it, we should also build a proof of concept. I suppose we could look into making it a npm package? That way we could reference it anywhere we would want. 
- 2:30pm - Taco bell is a double edge sword and in some cases the most dangerous offering that a person can give. We know how bad it can be for the body but if anyone offers to pick you up some taco bell? Are you going to say no? But that is something that I need to learn and understand. It is okay to deny food, definitely if afterwards you know your friend next to the da pepe will suffer. 

## Quote

> Every time you smile at someone, it is an action of love, a gift to that person, a beautiful thing.
> — <cite>Mother Teresa</cite>

---

## Tasks

- [ ]

---
# July: 17

> July 17th. Dialogue System.

Source: https://kbve.com/journal/07-17/

import { Adsense } from '@/components/astropad';

## 2025

### Depot Carpet

-   01:34PM

    Buying a new carpet for the living room and stairs because our current carpet has reached its peak age, which has been almost two decades at this point.
    This journey has two paths, we will either hire another contractor to pickup the carpet and install it, OR, we will go with a full solutions from home depot.
    To avoid any headaches, I am thinking that we stick with the bundle deal, trusting that the HD will handle all the annoying aspects of it for that premium.

### AstroPad

-   09:30PM

    The starlight-style component system will be how I plan to build all my websites moving forward.
    I am getting tired of having to build around the different styles and honestly, I am really really hating the UI world.
    Everything that I try to make looks exactly the same and extremely dull.
    Even as a child, I was never into the color schemes or even enjoyed any part of painting, all my artwork was in a greyscale tone.

## 2024

**State**
I had some really bad state management with the dialogue system that set me back a day but I am moving forward with the dialogue system.
The next step would be to organize and clean up some of the messages that get sent back and forth.
Afterwards, we want to see if we can add some custom font and maybe some sound effects for the different text that is being sent.
There was a point where I was thinking we would include a more dynamic setting, allowing more emotions to be displayed in the VN art style BUT I am thinking that should be on a later date.
We get the core of the system operational and then focus on the combat and gameplay!

**Dialogue**

We go some of the minor bugs fixed, now we need to split up the NPC response and the player base response.
Afterwards, we want to offer the different paths for which way the player wants to take the conversation.
Also there is a bug with the priority messages, it seems to be doing them in reverse.
I was able to update some of the flow within the text and yet there is still a decent amount of work that still needs to be done.

**Combat**

There are a couple ways that I want to handle the combat, the three major areas would be a jRPG, card style and a bullet hell.
Depending on the monster and situation, the player will be dropped into these three types of combat, keeping the game a bit more interesting than usual.
I was hoping the card style might be more towards a grander scheme, like town or nation management with the jRPG being more towards npc vs npc.
Finally, we could introduce the bullet hell concept when it comes to bosss or major fights?
The best way to move forward with this would be to create all three possible core scenes and then slowly build and abstract away from there.

## 2023
- 6:09am - It is an amazing Monday morning! The sweet and musky smell of the rain gives off a civil war-ish style vibe.
- 6:57am - I spent a bit too much time trying to get basic powershell scripts to work for RentEarth. I created two currently as `native.ps1` and `web.ps1`, one that runs expo for the mobile emulation and the other that runs the general webserver for the nextjs. 
- 10:37am - Migrating the state from React's state to the Nanostores state. i.e `() => tasker(status$, 'submitting')` while utilizing the tasker system. The idea would be to migrate a decent chunk of the state management / notification / variable system into the nano library. This will help improve performance and move some of the complex actions out of the main workflow. There could be a couple new issues that this might introduce, but for the most part, I think we should be able to manage them.
- 11:42am - Going through the Unity build setup so that it works on the Unity Devops. One of the issues to note would be that scenes might be referenced through their index number rather than a string. To resolve that issue, in the ASync loading of the scenes, it only accepts the string of the scene, however we have not yet migrated to that setup. There are some external notes for Unitask / Vcontainers that we could reference.

## Quote

> I can't imagine a person becoming a success who doesn't give this game of life everything he's got.
> — <cite>Walter Cronkite</cite>

---

## Tasks

- [ ]

---
# July: 18

> July 18th. Dialogue System.

Source: https://kbve.com/journal/07-18/

import { Adsense } from '@/components/astropad';

## 2025

### Atoms

-   04:31PM

    No major plan for today, I am half tired and been running around in loops, trying to resolve the visual bugs.
    I think the UI libraries are going to mentally break me, I am starting to get scared of my own mental health based on how much I hate UI.
    The light mode just looks so bad, ugh, why do we need it? 
    I love the pagefind search that starlight provides but the current default light mode makes me want to visit god instead.

## 2024

**Once Human**

Spent a majority of the day getting the once human running!
I wanted to play the game using a controller and it was a bit of a pain to get it all going.
The only major downside is that there are way too many combos and buttons to press, so playing the game on the side is a bit rough.
In order to get the full controller support to work requires you to run Steam as an Admin and then enable the steam input support override.


## 2023
- 8:00am - Before I begin the pipeline for the Android build, I need to make sure that the keys are setup in the right way. The path that I will end up taking will be to utilize the Github Actions to build the APK, or I could go through with a private Gitlab instance? However I was planning to build multiple applications and I wanted to make sure some of the projects are open source for future programmers to look through.
- 2:28pm - Double checking all my positions within the market and I am a bit sad that this feels closer to a bear trap. I wonder if the feds will keep increasing the rates and how it will impact the rest of 2023.
- 3:48pm - At this current rate, even adding an additional 16 shares of WPC took around $1000 in capital. This means that I will have to start doing R&D and finding other ways to increase the amount of capital that I can generate. I might have to enter another realm of hustling, but I do miss those days lately, being behind this computer screen is slowly reaching some of its peak. I can sense the burnout coming down the line within the next couple months, hmm, I will have to figure out something short term, at least to generate another $4000 a month. 
- 5:33pm - I think I will take a break from the PC really quick and do some chores. Laundry and mowing the lawn sound like they be great tasks to do really quick! 

## Quote

> A true friend is someone who is there for you when he'd rather be anywhere else.
> — <cite>Len Wein</cite>

---

## Tasks

- [ ]

---
# July: 19

> July 19th. Dialogue System.

Source: https://kbve.com/journal/07-19/

import { Adsense } from '@/components/astropad';

## 2025

### Unity

-   05:00PM

    Time to take a break from gaming and web dev, so we can dive deep into the unity eco-system. 
    Once more, the biggest issue that I am having with the Unity is the UI, which again makes me go crazy.

## 2024

**CrowdStrike**

It might be a bit wild that a simple security firm was able to shutdown a bunch of airports, banks, stores, ect...
Remember kids, never deploy production code on a Friday or weekend, always aim to release them Monday.


**Once Human**

Got the game to stream to my phone, so I can play it almost anywhere!
There are still some small adjustments that I need to make for the inputs, but I am thinking it be cool to have a semi-automated farming macro.
The idea here would be that I send a quick command and it will eat, drink and then run around the base to collect resources.
After it collects the local resources, it will place them into a crate and repeat every 15mins or so.


## 2023
- 11:41am - I am falling behind my virtual journal entries and keeping digital logs. I need to find a faster way to keep track of these, maybe split the journal md file location OR maybe keep the mac book open to keep logs on it without causing issues on my screeen.
- 12:48pm - Trying to figure out the navigation / routing for RentEarth / React. There are a couple issues that I am running into, the biggest being the ability to change the path that the user is on. 
- 6:00pm - This is an earlier note that I missed to document, so the mini-charles , which we can refer to as Charlie has ran into some issues, the first being that the Windows instance where the container / docker would boot from has failed in multiple instances and honestly I think the hard drive is on its way out on the laptop. There is still a SSD but I took it out and have not yet placed it back in, I am thinking of just wiping the whole SSD and starting fresh with a desktop version of Ubuntu? I will have double check my notes and see what would be the best course of action for that situation. I really hate having to do edge case hardware but it is something that must be done and there really is not a ton of documentation out there on IoT laptops. 
- 9:00pm - An update on the Toyota offer that I made on a truck. The guy wanted around $30,000 for it and I said that I could do $20,000 right now but wouldn't mind taking a look and seeing if I could find a middle ground, depending on how the truck performs. The idea would be to get the truck but work it out another company, so that the insurance for the truck would be under the company policy, rather than under my name. I do not mind buying a new truck but I really do not want to increase my monthly / semi-annual insurance premium by having another object to cover. This falls into the lack of abstract income to cover increases in my expenses, definitely if I want to afford trips to places like Japan or Amsterdam, both being within less than two years. One of the worst feelings is paying the insurance premium but never driving my tesla, like paying six months and then the car never moved, it just hurts my soul. 

## Quote

> Courage is what it takes to stand up and speak; courage is also what it takes to sit down and listen.
> — <cite>Winston Churchill</cite>

---

## Tasks

- [ ]

---
# July: 20

> July 20th. Dialogue System.

Source: https://kbve.com/journal/07-20/

import { Adsense } from '@/components/astropad';

## 2025 

### Pirate 17

-   04:40PM

    This can not be.
    I am having UI issues now in Godot, I think I am legit going to go crazy with ducking user interfaces, react broke my heart, unity broke my soul and godot is about to break my will.
    Hopefully there might be a better solution out there or maybe I am just referencing the wrong things, i am not too sure, but each of these makes me want to go operate in CLI.

### UIUX

-   04:52PM

    Yeah the best solution for anything UIUX will be to hire another developer to handle the core parts of it.
    Have them do all the painful things first and then loop back around and make the adjustments.
    For example react's css issues were all about the overflows.
    The Unity issues were related to me not having Sprites.
    Godot issues are all related to how they have different structures for buttons and containers, with those containers being like div tag.

## 2024

**Once Human**

I was suppose to do some programming today but I ended up playing a bunch of Once human!


## 2023
- 8:00am - I had a feeling that TSLA would have stayed at around $280 to $300 mark, did not expect it to dip well below that mark. Even with decent earnings, I did not expect the hype train to slow down but I guess operating margins decreasing could spook some investors. 
- 3:00pm - I am thinking of migrating certain aspects of the form design into its own tsx library that I can reference in the future without any major issues. The `Form.tsx` will be the first rewrite before I do it again when migrating to the `DF.tsx` , however I did want to implement a modal / toast system for the form submission, which would make sense to do inside of the `FormForm` concept, furthermore I suppose I could also add validation down the line within the component. Extending out some of the features will be interesting too, definitely once it comes to certain cloud functions, which I will be excited to do! I do want to reuse some of these template and eco-system later down the line for another application or two. We could extend it to RareIcon, CityVote, Herbmail and several other projects within this year.  As for generating revenue and marketing, I am aiming to get that going in August, at least a decent sized pipeline towards promoting the application. We can spend a whole year or more in development hell but getting users and feedback will be very vital.
- 4:50pm - There are a couple concepts that we were thinking for FormForm, including what type of content should be passed through the form, including if there should be an id for the form, a default message and the general scope of the fields and the trigger. I still need to work on how I handle the typescript, as it is still something that I am not 100% familiar with and/or confident to an extent. I am also thinking of deleting the DF component for the time being but that might be later on the line. 
- 5:22pm - We could look at the removal of the `app` folder later down the line too. I should make an issue ticket with this down the line. As for the main issues that I am facing with Tamagui, it seems that they have resolved them but placed them under a private code base / license that would make things a bit more difficult for me to use when working on an open source project, so I will have to get a bit creative with how I want to handle this. I am going to avoid any additional purchases for now doe.
- 5:43pm - I think I should look into extending out the validation through the `FormField` within the `Form.jsx` and include a type that would be under the validation? Okay the general `FormForm` proof of concept was added into the Login screen but we would have to migrate the `useEffect` from React out of the whole flow, so I am thinking we could migrate that logic into the action or task system within the nano stores? That would resolve some of future performance issues with calling too many renders. I suppose the next step would be to look over the VE class that I was looking at before and see if I could implement a way to handle that without issues. 

## Quote

> Nothing could be worse than the fear that one had given up too soon and left one unexpended effort that might have saved the world.
> — <cite>Jane Addams</cite>

---

## Tasks

- [ ]

---
# July: 21

> July 21st.

Source: https://kbve.com/journal/07-21/

import { Adsense } from '@/components/astropad';

## 2025

### TSLA Gambas

-   09:35AM

    Wheel runs on tsla might be too risky before the earnings call, so we should leave our position.
    Holding off until after the call would be the best move and we will be gambling with around $150K.

### Ergo KBVE Docker Image

-   08:59PM

    We will have to build our own ergo/irc image and have it be our gateway or relay home.
    The data would come from discord, twitch, ect... and all over it should then get collected in our IRC, hmm.
    It kinda sounds like we would be building our own internal bot network, ugh.
    Now it makes more sense why they all operate using IRC, it really is the best option for communication.

## 2024

**Once Human**

The grind has finally hit me hard, I believe I have officially burnt out of the game.
Currently the plan is to setup a grow farm and mass produce beer and soda!
We were planning to setup fuel production but because I am a bit too low of a level, this will be postpone until I get enough power generation.
The current meta farm plan is to grow a bunch of oranges, because who does not love orange soda, and then corn and wheat.
With the corn and wheat, we can produce a bunch of beer and the oranges will help us move forward with the orange soda.
Afterwards, I would like to expand into canned goods, if I get to the level within the time period.

**Halo**

Switching it up to halo!
Okay, a CTF map where both sides get a bunch of flying options to wage war on the ground and in the air would be insane.
The idea would a simple 8v8 CTF but both sides get a bunch of jets aka Sabers and heavy equipment, with the goal of not only getting better at flying but a decent amount of mass bombing.
However this would be something that would take a while to do in forge and we do not really have the playerbase for halo.


## 2023
- 9:00am - Going to do a couple quick rounds of the `H` but honestly it seems to be getting a bit boring and out of place. I definitely need something a bit more rewarding or well obtuse, maybe it might be time to hit that cookie clicker flow per say. 
- 12:20pm - Friday! Time to roll some of the TSLA calls/puts out for another week, I have to be careful on how far out I extend them, as I only have a couple thousand dollars to work with. This is okay for the time being as my REITs monthly income has been growing really well this past few months but I want it to grow faster. I should aim for around $10,000 a month within the next 2-3 years.
- 1:14pm - Going to run a couple quick games of the new Arena game mode on League of Legends aka the `H`. As for the official plans, I believe moving forward we will be naming the game `RentEarth` as we build out the website.
- 10:54pm - Went through a decent chunk of the backlogs, addressing a couple major concerns and I will have another chunk to add into the current list. There was a Coolify issue that I needed to address, which caused an error in the way we were storing the secrets, but a quick roll back was able to handle that. This does mean that I will have to look over the backup system and maybe implement a whole new one. 
- 11:50pm / EOD - The credit structure will still remain the same as of right now. `$1.00 = 1,000,000` , `$0.10 = 100,000` and `$0.01 = 1,000`. With the creation of the database, the documentation will look like this `$1.00 = 1M , $0.10 = 100K and $0.01 = 1K` as short hand notation. We currently have a couple bulk orders that we can process once we launch the credit system, I am just being extremely careful on how I approach this, as any mistake in this area could cause a major upset / problem later down the line. I did make a promise-style note for the first bulk batches to be discounted for certain early groups, with the condition that these bulk credits would only be used for KBVE services and not re-sold. 

## Quote

> Only through our connectedness to others can we really know and enhance the self. And only through working on the self can we begin to enhance our connectedness to others.
> — <cite>Harriet Lerner</cite>

---

## Tasks

- [x] Backlog Clean Up

---
# July: 22

> July 22nd.

Source: https://kbve.com/journal/07-22/

import { Adsense } from '@/components/astropad';

## 2025

### Edge Deployment - KiloEdge?

-   04:34AM

    I am thinking about what would be the best way to deploy our new supabase edge functions.
    There are two issues that we would need to resolve, the first is getting itch users to actually log into our supabase.
    Then the second would be making sure our deployment is fast and effective, might even have to alter how the self deployment would function.

### Crazy Train

-   04:40PM

    Rest in Peace to the Shadow Wizard King, Ozzy.


## 2024

**Register**

The register form and onboarding process has to be rebuilt once more, this time we will be adding more animations and effects.
I am trying to make this look as amazing as possible but also super fast and re-usable.
We will have this added onto about 4 or 5 websites at the same time, so it might be a bit of a pain at first but I think it will be worth it in the long run.
This is part of the multi project dev environment.

**YT**

The next update to the music app aka jukebox will be the music room.
I think it would be cool to turn it all into a video game with a couple other options for the person that is listening to the music.
We could include a DDR style game and tetris as two initial options, but the cool part will be making the whole room a multiplayer experience.
I will try to reframe from add a text box because we might not want people to spam or cause problems but at the same time, I think it would be cool, hmm.
There are a decent amount of ideas that can come from this but we will get there slowly within this week.

**Loader**

With the addition of the loader, we should release the next minor patch for the laser package, this it the command that we will run.

```shell

pnpm nx release --projects=laser

```

This will give us a couple options and for this case, we will bump the package up to version `0.0.7`.

**Kill Tony**

It is not a complete monday without a quick couple hours of kill tony!
The guests were okay, a perfect blend of failure and brilliance, I actually think we found a 70 year old version of Fudster.



## 2023
- 7:35am - The goal for this weekend will be to finish up most of the basics within RentEarth and get it up to date. This includes the login, register and general profile scope for now. We want to at least get the bare components resolved and then work on expanding the rest. I am not too sure if I want to add SSO to the website for now, but it might be something that I will look into in the future. 
- 8:27am - We would look or make the minion class to be that of all encompassing? That does not feel like it would be the best, hmm. Okay as I am re-writing this out, I am thinking that it would make more sense to isolate the possible commands into different tasks, yet how would we handle the data that is being sent over? Would there have to be specific styles of input/output per say that we would have to handle? Like are we sending a `Data` map/array filled with different atoms , i.e string, number, boolean? There still has to be some level of logic and thought to this, one that makes the most sense. 
- 9:00am - While I am programming, I am listening to a couple different podcasts with some lofi-jams and it is nearly perfect, I really should just stream this as a 24/7 style session, where its just random podcasts and the lofi-beat. Granted there would be some copyright issues, so I suppose we would have to have someone break down the podcasts and provide input? Like a deep dive style where we take a single podcast episode and expand it out by going deeper into the content. 
- 11:08am - Got my coffee and moved up some of the pipelines that were in private/public. We are making progress in some areas but are still a bit held back in others, specifically the client storage. I am still working out the logical flow on how we should handle it all, but maybe isolating it all into different files might not be the best idea. I will try to keep it small and easy for now.
- 2:04pm - I have returned back to my programming zone. The next task would be to setup `v0id` and `minion`. With void being the main task handler and minion being the task wrapper. I do need to transfer over some of the written notes that I have to this journal sheet but damn sometimes I am just getting lazy, huh. Okay so minion calls `minionLogin` which will handle the client-side validation before calling the API to login? This will help put a bit less stress onto the API and it just makes sense to do. I am thinking we could pass validation through as a regex string? It is a shame that we can not call React Hook Forms directly or this would be a lot easier and I am not going to pay for their private source takeout. Ugh.
- 2:40pm - Migrating the Sheet/Toast modal from the home screen into the Form, with the purpose of utilizing it in between the submissions of each form. This way the modal opens when the form is busy? There are a couple ways that I can go about handling this. The other idea that I am thinking about right now would be to just (a) merge the sheet and toast into the FormForm class and (b) remove the `useState` and utilize the `useStore` to handle the control of modal / sheet and toast message. I noticed a couple errors with the current build that I have but this might be a better way to resolve the issue without overcomplicating the situation. 
- 2:50pm - I believe it is time to take a quick break and play a quick round of the H. But before I do, let me convert this upper left hand box for tomorrow. "&" This epic idea that I am thinking could work great would be to build/expand a couple of the Postboy foundlings (typo?) and add a couple new structures into the mix. Now on a/ai side note, I should finish the three manga's that I had planned out. The first being the fintech A-Z and then the Japanese A-Z Conch Manga. After doing those two, I can migrate one of the threads, which is for the Rogue Jester/Rent Earth. After the break, I will address this issue: Warning: Cannot update a component (`FormToast`) while rendering a different component (`FormToast`). To locate the bad setState() call inside `FormToast`, follow the stack trace as described in https://reactjs.org/link/setstate-in-render. I am aware of the reason this issue exists, it was how I handled the code migration.
- 5:49pm - Okay, it seems that I was able to resolve that render issue by migrating some of the general react states into the nano stores. The plan was to replace the Boolean for the toast and numeric value for position, however I am not too sure how I should handle the error code reset. Currently on the dismissal of the modal, I am resetting the `toast$` back to false and the `error$` back to `undefined`. Yet as I am working through the current code base... I am taking a bit of time to be reflective. Am I being the most optimized or letting myself overthink and overengineer? Besides the insecurities that come with a new project and/or new code-base, I have to make sure I find a decent balance of hackery and professionalism.
- 6:40pm - As I am watching some Trigun, I am definitely thinking of throwing in some references! It would only be fun and a fair tribute to one of the best shows out there lol. Damn the show has some of the best lines / quotes, all of them are straight bangers. I am enjoying how they are building up to the story's main antagonist / villain, I really forgot how great the writing has been for this show. Also, Wolfwood is still one of the best side characters in manga history, a perfect story arch. Okay today's important function will be `FormForm`, which currently takes 4 stores as the main state and information slot. I believe this would be a good time to look over the codebase as well, looking for specific areas to refactor. We should definitely place one of the future storages after the priest, I guess I will have to do that asap before I forget.
- 7:57pm - Test casing on line 92, `OnPress` seems to work fine when attached to the trigger and the next move would be to dismiss the keyboard when the button gets pressed, thus we know that there are two ways that we can handle the `event`. I am still figuring out what would be the best way to go about it, looking through the docs right now. 
- 10:05pm - Switching over to the cyberpunk series! It has been a while since I saw the series, but damn its epic. Going from Trigun to Edgerunner was the wave!

## Quote

> But man is not made for defeat. A man can be destroyed but not defeated.
> — <cite>Ernest Hemingway</cite>

---

## Tasks

- [x] Finish RentEarth.com Login / Register - Postpone.

---
# July: 23

> July 23rd. Renewals

Source: https://kbve.com/journal/07-23/

import { Adsense } from '@/components/astropad';

## 2025

### Godot Clicks!

-   02:15PM

    After a long loop of gamejams and a couple mock sessions, I actually understand everything we need to know about Godot.
    The final piece was the scenes, which I did not realize are just prefabs, so basically the whole game can just be those prefabs.
    Also things like quad trees and a star, well they are just inside of godot already, so I dont need to go out of my way to do them.
    wowowow! This is going to make future godot games even more enjoyable.

## 2024

**Renewals**
A bunch of domains were about to expire, had to do a mass renewal, ugh.
The costs for some of the domains are getting a bit too high and the rate of production for these projects seem to be a bit too slow.

**Llama**
Groq updated their models to support the new meta llama 3.1 models! 
I will be excited to try them out later this week, I am also getting impressed with the improvements, including a larger context window and better reasoning.
We will not have to do much on our end and just switch the model names to reference the ones that we want to use.
I do wonder if there will be different rate limits with these models compared to the older ones but I think it will be reasonable enough for what we are doing.

- Llama 3.1 405B (Preview)
- Model ID: `llama-3.1-405b-reasoning`
- Developer: [Meta](https://kbve.com/stock/meta/)
- Context Window: 131,072 tokens

- Llama 3.1 70B (Preview)
- Model ID: `llama-3.1-70b-versatile`
- Developer: [Meta](https://kbve.com/stock/meta/)
- Context Window: 131,072 tokens

- Llama 3.1 8B (Preview)
- Model ID: llama-3.1-8b-instant
- Developer: Meta
- Context Window: 131,072 tokens

The average tokens that I am getting for higher end model is about 100 tokens per second, but I will have to do more testing to get a full understanding.

**Register**
We will be adding three new components into the astropad, the first will be the register form, then there will be the login and finally the onboarding component.
Once we get these rolled into the library, we will then focus on the emailing and the general account settings for the different services that we will be offering.
I been postponing the email server because I know it will be a pain to get into production without running into a bunch of bugs and problems.


**YT**
The Youtube Zod for the next musicroom component needs to be added in this week before we can prepare the initial dev cycle for the music room application.
I am getting a bit backlogged from work and the new devs that we were going to hire at KBVE are a bit behind in understanding the next couple updates, ugh.

**TreeShaking**
Okay I made a minor mistake when it comes with using Laser package, in some situations, we might not want to import the whole library because it will make tree shaking a bit more rough.
Granted in our usage, we will be using all of Laser and each function that it provides, thus it might not be too much of an issue but in the case of the smaller aspects of this application, we will have to be careful.
I was also thinking that we could isolate some parts of the game into their own pages, maybe making it easier to bundle and abstract some of the features away from the main game loop.

```ts

// Instead of this
import * as Laser from "@kbve/laser";

// Do this
import { specificFunction1, specificFunction2 } from "@kbve/laser";
```

We will circle back around to this on another date.


<Adsense />

## 2023
- 9:00am - I need a haircut but I also need hair! The density of my hairline is getting rough, I am looking at losing it all within the next couple years, womp womp. Maybe that gym grind needs to really pump up, should I do the duel daily flow? 
- 10:39am - Looking over the sweep ai and mapping out what I should be doing this Sunday Funday. Okay mapped out what I needed and going to quickly grab some coffee and get my day started. 
- 11:58am - Going to take a look at [issue 183](https://github.com/KBVE/kbve.com/issues/183) and see if I can make any quick edits. I think throwing up a couple quick UX/UI elements would be the best course of action for the time being.
- 3:16pm - Going through the CI/CD and I am looking at adding a couple tools and rebuilding the pipeline to be a bit more friendly to bots. I am currently looking at how to add codesee maps into the patchs as well as sweep.ai into the mixture. These tools can help a lot down the line, when we get a bit more creative and flexible with our pipeline. The current area that I am looking into would be the rebase of the existing branches. 

## Quote

> If it turns out that there is a God, I don't think that he's evil. But the worst that you can say about him is that basically he's an underachiever.
> — <cite>Woody Allen</cite>

---

## Tasks

- [ ]

---
# July: 24

> July 24th. LootTable

Source: https://kbve.com/journal/07-24/

import { Adsense } from '@/components/astropad';

## 2025

### Hulk

-   07:20+PM

    Death comes in threes, did not expect to see hulk go out this fast.
    He holds a spot in my wrestling phase because I was a huge fan of his work!
    My grandpa and a bunch of his friends loved watching him perform too, so that also makes it hold a special part in my soul.

### Entity vs Entity.

-   08:29PM

    The entity vs entity system will be an important part of the Airship game because we want to create a world that exists without having to play.
    For now, I want the dragons and the navy ships to have constant battles, then I will start to introduce ground troops like goblins and navy guards afterwards. 
    These units will move from tile to tile, setting up tents and engaging in long standing wars, with the player being able to either fly over and help or if flying too close, take damage.

## 2024

**LootTable**

The next major patch for the Laser package would be to build out a `LootTable`.
I am thinking the structure the table with an array of objects that represent the item, types of loot and the rolls for it?
We could include a chance on steal, drop from combat and tradable for a certain gold value.
The best idea would be to start small and then expand from there based upon the different options.

```ts

export interface LootableObject {
  ulid?: string;
  name?: string;
  chance: number; 
}

```

We also need to factor in the roll that the user gets and compare it to the chance table.
One way to handle this would be to take the rolls value and convert it over to a 100 point scale, basically a function to help us handle this.


<Adsense />

## 2023
- 5:45am - The morning was a bit too hot for my blood, I made the mistake of not running the AC over night at a set temp, but I woke up in a pool of sodium-fused run off. The goal for today will be to keep things simple and hit a couple minor tasks.
- 7:00am - The bald spot has been increasing, I can no longer deny it, after getting out of the shower, I nearly saw my future bald self, I will have to... I am sorry, I must get stronger. The difference in self confidence will be depend on my ability to morph into the Rock or become a hermit buddha. 
- 12:00pm - Roll my weekly option contracts and then take the credits! I will have a bit of a slow week, I am only looking at around $500~ in profits, as I am slowly diminishing my cash reserves a bit too fast. Ideally I would want to slow it down, but there are only so many cuts that I can make and the generation of income has also been growing too slow. I made notes of this earlier but need to get back on the grind.
- 2:00pm - I am test casing the patch system but there are a couple things that I am already not a big fan of! The current bug that is driving me a bit nuts is why can't codesee's graph generation proc faster? I am thinking that I should experiment a bit with their action? Maybe I should merge their action with the patch pull action? It would be worth a shot to see what would happen. Furthermore, I need to start moving the needle on the backend auto-deployment and tackle some of the unique bugs that I know will come up.
- 3:20pm - Taking a bit of a programming / dev break and looking over my MTG card/deck. I am really thinking that I should build my trump and yoda deck before I play in person again. Both of the decks will be about 100 cards each and follow the EDH format, but I play with cool people, so proxy cards are always acceptable. I refuse to spend too much money on MTG cards and honestly `puttin` Trump onto the field and letting my friends destroy him, has its own unique taste to it. The coolest part about the deck is that I get to spawn Trump walls, which only make Trump stronger too lmfao. 
- 8:15pm - Mini Charles aka Charlie needs to come back online as well. I started to plug some of the base components within the older StormTrooper PC Tower, the good news is that it turns on but the neutral news is that we are not too sure how well it can run and there are way too many spider webs. If any PC gamer saw what I have done to this machine, dear lord.
- 8:32pm - Updating my daily journal and then going to push through the addition of codesee to the patch workflow action, let us see if that was worth wild. 

## Quote

> Technology is anything that wasn't around when you were born.
> — <cite>Man Ray</cite>

---

## Tasks

- [ ] R&D The Pipeline

---
# July: 25

> July 25th. Lot.

Source: https://kbve.com/journal/07-25/

import { Adsense } from '@/components/astropad';

## 2025

### Airship

-   04:14PM

    More changes to the game, hopefully we become a master at the UI before the gamejam ends.
    For my next godot game, I want to make sure the scenes , prefabs and assets are all combined into a single folder per entity.
    Even the pools and tile systems could be used for this in the future.

## 2024

**Swarm**
Played a quick couple rounds of the Swarm gamemode and I found it to be a bit interesting!

**CT Production Error**
There seems to be an issue when running the cryptothrone at the production level, the website is returning a couple errors and causing the game to not load.
I was under the impression that since the dev cycle did not have any errors and same with the build, we should be good to go with the production but something went wrong!
The best option would be to go back and trace through the changes and see if we might have made any mistakes?
I am thinking that it might be a race condition, such that it is calling the `NPCHandler` before the `Phaser` is ready?

The error we are having right now is:

```
[astro-island] Error hydrating /_astro/App.DxAk5t4Z.js ReferenceError: Phaser is not defined
```

The plan now will be to change the hydration layout, I am thinking that we place a state around the gamewindow and make sure that everything is loaded before hand?

Ended up spending a whole night trying to debug it, which turns out to be a couple issues with the current astro version and the different repo structure.
Currently parts of the repo on this WSL are running on an updated astro and the actual astro that was being executed was an older one.
For now, I am going to downgrade the astro to the older version and during the next couple weeks, update to the latest Astro.

**Island**
The plan is to make parts of the game have multiplayer, a bit of an island hydration but only if the player is able to connect to the server.
This means that certain buildings will have two instances, an offline default instance and an online instance if the server is up and running.
There are still major changes that we would have to do to get this to work without any issues but I will handle those on a later date.


<Adsense />

## 2023
- 6:00am - The birds are starting to become a pain, not only are they taking a bit of an excessive dump on my car, they seem to be multiplying a bit faster around our home. I noticed nests near the shed, by our tress, we are slowly becoming a pit stop for the birdbros. 
- 8:00am - Automatic deployment of [Portainer](https://kbve.com/application/portainer/) will come in three stages, the first will be the command and control center, the second will be for the docker swarm deployments and the third will be for all edge nodes. The current setup is through ansible and terraform but I wanted to migrate towards utilizing Github actions to execute the commands. Part of the reason was to build custom and future tools that I could bring into eco-systems, which could help with auto-scaling, security and general automation. 
- 11:00am - Going to roll some more option contracts, it seems that I no longer have any SPY within my inventory, which is a shame because getting back into the puts seem a bit too expensive for the casual return. I will wait for my TSLA/AAPL/GOOG to calm down and approach SPY again mid-August. Cash balance is around $68,000 but our position in $O has been increasing rapidly, we should approach $2000 monthly dividends by late 2024. 
- 12:00pm - Getting ready to take my mom to the dentist, she is about to get a root canal on her 13th or 14th tooth. I am sure she will be fine but I am a bit upset that she did not get dental work done when she was in India! Granted she has dental insurance but she should have taken advantage of the fact that getting teeth work done in India would be cheaper and better, oh well. 
- 2:05pm - Building out the pipeline with additional bots, including CodeSee, so that I can get visual images within the pull request. These images represent the file changes and their relationship through SVGs. I believe a future product could be in the works to help further aid in this area, including one that could summarize the changes into a brief statement? Like a GPT Agent aka a bot that would read through the code changes and present a couple paragraphs describing what those changes have done.
- 4:00pm - Market has closed with some wiggle room before tomorrow's fed meeting. I am really hoping that they pause interest rates with a decent pause until late Q4 of 2023! If they do increase the rate, I am hoping that it is a steady 25bps instead of a 50bps.
- 6:00pm - I started to clean up mini-Charles aka Charlie's work area and should note down the updates that I would need for it. I could add more information into the issue ticket and then migrate that information over to the documentation of Charlies? I suppose we would have to talk more about this later down the line. 

## Quote

> May all beings have happy minds.
> — <cite>The Buddha</cite>

---

## Tasks

- [ ]

---
# July: 26

> July 26th. DevOps.

Source: https://kbve.com/journal/07-26/

import { Adsense } from '@/components/astropad';

## 2025

### Airship Chunks & NPCs

-   02:10PM

    Fixing the chunk system and the general NPCs/UI.
    My biggest concern is the FPS for the web build, I am hoping that there could be some additional methods that I could do to make it smoother.
    

## 2024

**DevOps**

The plan for today is to work on the DevOps library, it is due for some changes.
The major patch that we want to add into the library would be the docker container management.
We will start by adding the `exec` library into the core of the `github.ts` as an import.

```ts
import { exec } from 'child_process';
```

I am thinking to avoid any `fs` / FileSystem management for the logs and have them be placed directly into the issue ticket that spawns the docker container.
In the future, I might also set it up so that it will then connect to a hybrid cluster / cloud, maybe even spin up a tiny vcluster to help us with that.

Okay, next would be the core functions, these are the base functions right now:


```ts

export async function _$gha_runDockerContainer(github: any, context: any, port: number, name: string, image: string): Promise<void> {
  return new Promise((resolve, reject) => {
    const command = `docker run -d -p ${port}:${port} --name ${name} ${image}`;
    
    exec(command, async (error, stdout, stderr) => {
      if (error) {
        console.error('Error running Docker container:', error);
        await _$gha_createIssueComment(github, context, `Error running Docker container: ${error.message}`);
        reject(error);
      } else {
        console.log('Docker container started successfully:', stdout);
        await _$gha_createIssueComment(github, context, `Docker container started successfully: ${stdout}`);
        resolve();
      }
    });
  });
}

export async function _$gha_stopDockerContainer(github: any, context: any, name: string): Promise<void> {
  return new Promise((resolve, reject) => {
    const stopCommand = `docker stop ${name}`;
    const removeCommand = `docker rm ${name}`;

    exec(stopCommand, async (error, stdout, stderr) => {
      if (error) {
        console.error('Error stopping Docker container:', error);
        await _$gha_createIssueComment(github, context, `Error stopping Docker container: ${error.message}`);
        reject(error);
      } else {
        console.log('Docker container stopped successfully:', stdout);
        await _$gha_createIssueComment(github, context, `Docker container stopped successfully: ${stdout}`);

        exec(removeCommand, async (error, stdout, stderr) => {
          if (error) {
            console.error('Error removing Docker container:', error);
            await _$gha_createIssueComment(github, context, `Error removing Docker container: ${error.message}`);
            reject(error);
          } else {
            console.log('Docker container removed successfully:', stdout);
            await _$gha_createIssueComment(github, context, `Docker container removed successfully: ${stdout}`);
            resolve();
          }
        });
      }
    });
  });
}

```

However, we want to work around them a bit! We need to make sure that port, name and image are being sanitized before we execute the commands.
For the port, we can easily do a quick range check and make sure that the ports avoid any of the default range, this should be easy, maybe limit it to the `2500` and `50000` range?
As for the name and image, we can perform a quick regex check to make sure the name will be a valid container name and the image being in a valid docker format.

We also want the ability to issue commands to the container via the issue ticket, with the final goal for this patch to visit a website and take a screenshot for us.
This will give us a solid production level testing right in our issue tickets!

An additional function for checking new comments:

```ts

export async function _$gha_checkForNewComments(
  github: any,
  context: any,
  lastChecked: Date
): Promise<void> {
  try {
    const { repo, owner } = context.repo;
    const issue_number = context.issue.number;

    const { data: comments } = await github.rest.issues.listComments({
      owner,
      repo,
      issue_number,
      since: lastChecked.toISOString(),
    });

    for (const comment of comments) {
      const runCommandMatch = comment.body.match(/run docker (.+)/);
      if (runCommandMatch) {
        const [port, name, image] = runCommandMatch[1].split(' ');
        await _$gha_runDockerContainer(parseInt(port), name, image);
      }

      const stopCommandMatch = comment.body.match(/stop docker (.+)/);
      if (stopCommandMatch) {
        const name = stopCommandMatch[1];
        await _$gha_stopDockerContainer(name);
      }
    }
  } catch (error) {
    console.error('Error checking for new comments:', error);
    throw error;
  }
}

```

I will include this in our notes for now. We still need a couple more functions to get this patch ready for a release.

**Sanitization**
To help with making sure that the inputs are a bit cleaner, we will create a couple helper functions within our `sanitization.ts`.
I am thinking that we can add about three simple functions that we can call to help us with securing the functions a bit.
Granted this will not stop all vector attacks but it would make sense to at least make sure everything flows without bugs or errors.
For example, what if a user places a port 90000? Well here is our function to make sure the ports will not be an issue.

```ts

/**
 * Sanitizes the port number ensuring it is a valid number within the valid range (1-65535).
 * @param port - The port number to sanitize.
 * @returns Sanitized port number or throws an error if the port is invalid.
 */
export function sanitizePort(port: string): number {
  const portNumber = parseInt(port, 10);
  
  if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
    throw new Error('Invalid port number. Port must be a number between 1 and 65535.');
  }
  
  return portNumber;
}

```

Next question that I had was what if the pass through a port like 22?
Well in this case, lets go ahead and update the function to account for those ports.

```ts
/**
 * Sanitizes the port number ensuring it is a valid number within the valid range (1-65535) 
 * and not one of the restricted ports.
 * @param port - The port number to sanitize.
 * @param additionalRestrictedPorts - An optional array of additional restricted ports.
 * @returns Sanitized port number or throws an error if the port is invalid.
 */
export function sanitizePort(port: string, additionalRestrictedPorts: number[] = []): number {
  const portNumber = parseInt(port, 10);
  const defaultRestrictedPorts = [443, 80, 22];
  const restrictedPorts = [...defaultRestrictedPorts, ...additionalRestrictedPorts];

  if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
    throw new Error('Invalid port number. Port must be a number between 1 and 65535.');
  }

  if (restrictedPorts.includes(portNumber)) {
    throw new Error(`Port ${portNumber} is restricted and cannot be used.`);
  }

  return portNumber;
}
```

This should give us a solid function to sanitize the ports!
Since we will be adding this function into the library, we also want to include the tests for it:

```ts

describe('sanitizePort', () => {
  it('should return a valid port number', () => {
    const port = '8080';
    const result = sanitizePort(port);
    expect(result).toEqual(8080);
  });

  it('should throw an error for a non-numeric port', () => {
    const port = 'abc';
    expect(() => sanitizePort(port)).toThrow('Invalid port number. Port must be a number between 1 and 65535.');
  });

  it('should throw an error for a port number less than 1', () => {
    const port = '0';
    expect(() => sanitizePort(port)).toThrow('Invalid port number. Port must be a number between 1 and 65535.');
  });

  it('should throw an error for a port number greater than 65535', () => {
    const port = '70000';
    expect(() => sanitizePort(port)).toThrow('Invalid port number. Port must be a number between 1 and 65535.');
  });

  it('should throw an error for restricted ports', () => {
    const port = '443';
    expect(() => sanitizePort(port)).toThrow('Port 443 is restricted and cannot be used.');
  });

  it('should throw an error for additional restricted ports', () => {
    const port = '3000';
    expect(() => sanitizePort(port, [3000])).toThrow('Port 3000 is restricted and cannot be used.');
  });
});

```

With these tests added, we can go ahead and run the test casing with this command:

```bash
./kbve.sh -nx devops:test
```

Everything looks passing, lets move on with adding the next sanitization functions.

<Adsense />

## 2023
- 7:00am - I believe it is time that I setup a new morning ritual, including one that involves a bit more time being spent outside of the home but in a way that would benefit me? I noticed that Unsplash has a limit of 10 image submissions a week, so maybe I should start to build out a collection of images to take and prepare for submissions. My aim should be just to get at least one image out there a week, going towards 10 a week seems a bit much. 
- 8:20am - Okay I need to write this out as a journal entry first, then I will make it into an issue ticket and finally migrate it over to the rareicon documentation? We take an AI generate image / concept and then add our own artistic touches to it, we could paint our own version of it or use photoshop over the image. Afterwards we would render or display the image inside a digital frame and then using my sony alpha, we take a photo of that digital display somewhere in the real world? It would be a bit of augmented reality and I think it could create some really stunning and visually pleasing photo images. I feel like that is was similar to the Opsz concept that I still need to get out there, damn these backlogs are becoming a pain.
- 11:50am - I believe we have a solid plan for the day! I am going to pickup @andsam and we are about to have a solid kbve session, it will start off with a visit to my 2nd favorite deli, Mr. Subs! I am just craving their 14c, which is a turkey, cheese and capicola cold sub with bacon inside a fresh gutted loaf of little Italy. Honestly my only concern is that they will run out of fresh bread but if they do, I have a backup plan because right next to the deli is a ramen shop, which happens to also make some of the best ramen in NJ! So there is always a win when visiting that area. After we get our meal, we shall visit the home and then take a look at the current physical state of all the hardware. This will include the charlies, drones and other robots for the time being! Wrapping up the deli and robot lab adventure will be some quick caffeine infusion and finally a visit to el Portal. 

## Quote

> We do not quit playing because we grow old, we grow old because we quit playing.
> — <cite>Oliver Wendell Holmes Jr.</cite>

---

## Tasks

- [ ] - Robo Foodie Day.

---
# July: 27

> July 27th. Virtual Joystick.

Source: https://kbve.com/journal/07-27/

import { Adsense } from '@/components/astropad';

## 2025

### AirShip Music

-   11:08AM
    
    Trying to get the audio out of the way and then going to focus on the dialogue system.
    The gamejam is coming to an end soon, thus I am hoping that I can quickly put together the smaller parts of the game.
    One bug that I noticed was that the music seemed to pause a couple times randomly, I am going to try and move some of that out into a background global.
    This way the music should continue to play throughout the game, maybe we should have an adjustment for the music in the title screen.
    A good way to avoid getting the ears blasted, so let me adjust that for now.

### Airship ULID

-   11:16AM

    The ULID generation for the GDScript is still a bit painful, a couple errors in the int / float / dec logic.
    Them damn floating point errors keep floating into random projects, gosh darn it!

### Airship Settings

-   12:28PM

    Having the game load with a default master volume of around 20%, maybe since its a new player, we could also setup a custom screen.
    These are some of the uiux things that I will have to work out before the gamejam ends, I was hoping that maybe we could setup the supabase integration but that might be on hold.

-   05:26PM

    Too many hours have been spent going in loops with the UIUX, I am not too sure how I feel about it all.
    There might be a better way to handle refactors in the future, maybe its a bit too rough as the project grows too big.
    At least now I know in the future projects, to keep folders for specific scenes and just build around the scenes.
    It was mainly my fault because I was not being to exact with my commands and the backups started to cause some issues, this time around I will try to loop around to avoid ghost files.


## 2024

**Virtual Joystick**

The next update for laser would be to add a virtual joystick to each scene.
This will make playing the games easier on mobile as well!
I was debating over either having a click to move or a virtual joystick to move the character.

**Funding**

There seems to be a bit of a mistake when it comes to funding, I think we might need to fix that up!
For now we will accept funding through Pateron and Github, but we can expand upon that in a later time.

**Sanitize Container Image**

For deploying the container image, we need to make sure that we also sanitize the image name.
This is the function that I am going to add into the `sanitization.ts`.

```ts

/**
 * Sanitizes the container image name ensuring it is alphanumeric and can include underscores, slashes, colons, and periods.
 * @param image - The container image name to sanitize.
 * @returns Sanitized container image name or throws an error if the name is invalid.
 */
export function sanitizeContainerImage(image: string): string {
  const sanitizedImage = image.replace(/[^a-zA-Z0-9_:/.]/g, '');

  if (!sanitizedImage || sanitizedImage.length === 0) {
    throw new Error('Invalid container image name. Image name must be alphanumeric and can include underscores, slashes, colons, and periods.');
  }

  return sanitizedImage;
}

```

After adding this function, we can go ahead and add the test code for it via vitest / jest.
Then we will test the library using our nx command.

```bash
./kbve.sh -nx devops:test
```

**Quest**

Came across an interesting idea for the quests, maybe we could make the first quest as a way to self improve?
We could look at different situations that a person is in and maybe give them some advice to handle it?
So let us think about the feeling of being angry and then have the player choose amoung a bunch of cards, one of them could be to "sing"?
Or if the case is that the person is feeling anxious, then we could display a couple cards with one of them being to "take deep breaths"?
I am still thinking through how I would handle the quests.

<Adsense />

## 2023
- 2:30pm - Going through the base scene on the RogueJester aka RentEarth, trying to resolve the bug issue with Vuplex. The bug is being triggered by two points of interest, it seems to be related to a CORS policy, which is the No `Access-Control-Allow-Origin` header, yet instead of it being a yellow caution, it seems be a red warning. The other issue is that the mouse is not being registered by the frame, so the mouse clicks are not passing through. I believe both of these can be resolved within a week or so, hopefully we can get it resolved sooner so we can move forward. 
- 2:57pm - As I am writing these notes down, I think it would be wise to publish this patch out and then sync the codebase? Hopefully it will not cause any major error, ah shit as I was writing this, I see that there is a merge conflict that is already appearing. Sometimes I do wish working with git would be easier. We need that AI agent to come in and do some general git cherry picking for us.
- 3:49pm - Okay there are a couple issues that we have to address with how we want to handle the scenes within RJ. I am thinking we would do a couple, maybe around 3-5 scenes within the base scene. As for the mission selection, we will try to display that through the UI/UX.
- 4:00pm - I suppose the market draw back from the increased rates, maybe we might see more 25bps rate increases throughout the year. 
- 11:06pm - Going to push the generic blog post patch and rotate over to the patch for tomorrow. On my test list, I need to research a bit more about a couple different topics, including `microwave pyrolysis` and how it can be used to recycle plastics.

## Quote

> TV and the Internet are good because they keep stupid people from spending too much time out in public.
> — <cite>Douglas Coupland</cite>

---

## Tasks

- [X] Finish loading the base scene inside of the RJ.
- [ ] Finish DevOps Library sanitization functions.

---
# July: 28

> July 28th. Virtual Joystick.

Source: https://kbve.com/journal/07-28/

import { Adsense } from '@/components/astropad';

## 2025

### Github Actions + Thread Integration

-   09:50PM

    I am thinking that the Supabase functions might be the best option but then we would have to parse through each of the json message , so I will have to think it through.
    Since we have n8n, we could move it over to that call as well, so there are a couple ways that we can go about that.
    

## 2024

**Deadpool**
Was up all night watching deadpool 3!
The movie was a perfect blend of action and comedy, I am super excited for possible Blade + Deadpool movie?!
They could just have a 10-15min scene of them killing vampires and it would be epic.
Also Dogpool, 100% perfect.

**Action Handler**
The current action handler is for `talk`, `quest`, `trade`, `combat`, `heal`, `steal` and `lore`.
Looking through the notes, we need to add `oath` after finishing these original seven.

**Map**
There are a couple maps that we need to push into the repo, yet I still need to think through the tile system.
My idea would be to make sure the tiles are still split between zones but I been also wondering if there might be a way to keep scenes between the game modes.
However, I realized that it might not be worth it, because we could have gates and buildings act like the loading zones.

**Inn**
The inn will be both single player by default and multiplayer if the websocket / ping is there.
We can have the multiplayer session if there is a valid account and ping, thus making it a bit more interesting when going into certain buildings.


**Fudster**
Updated the lore for the Fudster character and now moving forward with a couple more of the abstracted dialogue system.


<Adsense />

## 2023

- 10:00am - The VContainer and general injection seems to be too much of an issue right now within Unity 2021, so I am going to take a different approach and try to see if I can get Unity 2022 with DOTS to help resolve the issue? There are two ways we can go about this, one would be to build out the netcode and continue to use 3rd party integrations OR we could start a new project under the Unity 2022 and migrate 2021 assets over. There would be some drawbacks, as if Opsive might not work as well in 2022, but we can just let those go for the time being. I will continue to go through the C# codebase and see what I can do on that end.
- 11:15am - I am still having some issues with dependency injections, so I might take a look at the 2nd option this weekend and see where I can get with it.  The injections were plan to be done via the VContainer but DOTS really seems to be production ready.
- 4:00pm - Looks like my put insurance has done great wonders this week, but next week might seem a bit more rough. I will let them expire gracefully and look back at it Monday.
- 4:36pm - Currently updating to the latest Unity 2022.3 LTS on this laptop, but it might not have enough ram to handle everything that I want to do. For now we will run with both and see where we can get within the scope of a weekend or two. There still needs to be a couple updates that have to be done on the main website, so that it can interact with the Unity, but I could sync those updates, such that it would work on both scenes without any major issue. The scene management and naming structure would have to still remain the same, so there has to be abstract documentation that can help keep track of the different scenes. We will keep to at least 5 general scenes, which would be the Menu, Base, Island, City and Misc? I suppose there could be a bit more edits here and there but these should work fine for the time being. 
- 4:53pm - Cloning the MegaCity repo right now and going to use that as the base for the RentEarth repo. Let us see if we can get this migrated over a bit faster than what I would have hoped? This would be an interesting test case of how to move a project from an older version of Unity to a new one. I suppose the main repo push will be in relation to? Uhh... I will first have to create the project in the Unity dashboard, then clone the Megacity Multiplayer over via Github, then migrate the codebase over to RentEarth? Well let us see how fast I can do this all, while still doing other things in the background. This is a high level of multi-task that I was not expecting to do today. I might even have to upgrade the computer in the basement, so that it would be easier to build this out in. 
- 5:11pm - Damn I installed 2022.3.5 but the project seems to be on 2022.3.3, so I will have to install that editor again. I am not too sure if I want to do any updates besides what they have provided, i.e it might break things that I do not want to repair later down the line. One of the other things that I am going to do is keep this to a local play only, as I really do not want to enable their UGS, burn through $800 in idle credits, plus it would be fun to keep this game kinda like a classic, per say. The fact that the code-base could support upwards of 200+ players is interesting, 64 is what their readme says.... I want to see where I can go with pushing those limits. As the install is preparing, I am going to brush up on some of the tutorials and links, I figured reading through and consuming as much information as I can before taking on this complexity will be its own adventure. Getting the project to open and run will be the first step tonight, once I get that resolved, I will do the first test build and see how it performs on my laptop. After the test local build, I suppose I could plan out different paths to take. Two of the major ones that I would see are in the scope of the client and server builds, with the server build having some levels of complexity that I should look into. Going from an automated pipeline build of the game to a server-ready image, then having it automatically become hosted on a dedicated server would be really the bees knees.
- 8:30pm - I believe that I might not have enough resources to handle the larger version of the game. Just loading the map takes forever, but there are a couple interesting things that I like about the newer version of unity. Furthermore this Megacity build has some interesting examples of UI components that extend out of the general TextMeshPro, but I did not get enough time to dive deeper into how they work. 

## Quote

> It is not in the stars to hold our destiny but in ourselves.
> — <cite>William Shakespeare</cite>

---

## Tasks

- [ ] Tasks? Oh this might be a bit too much to say right now.

---
# July: 29

> July 29th. Lore Lore Lore.

Source: https://kbve.com/journal/07-29/

import { Adsense } from '@/components/astropad';

## 2025

### Airship

-   06:15AM

    Building two games at the same time, or maybe just a bunch of unfinished games is terrible.
    I am aware of the issues that come with having a bunch of half donkey work floating around, but sometimes getting stuck in one area is really rough.
    Taking a break from the unity aka c# and switching back to gdscript is a great way to reset the flow.

## 2024

**Options**
I need to figure out the best way to handle the different options within the dialogue system.
There has been a couple shifts and errors when trying to find the best way to map out the dialogue session but I think we can work with what we got.
Jumping between the different messages and switching from general talking to quest specific will be a bit tough to map out!
I have a couple interesting ways we could get this done, including dynamically injecting different possible dialogue based upon the different situations within the game.

**KillTony**
Monday nights are for killing of the tony!
This was an okay monday set, it could have been worse or better, both ways I got a couple laughs in too.

**WoW**
How did I get sucked into the cata realm again?
Let me go ahead and boot it up on the macbook again!
Oh wait my battery life, damn it.
While playing, I was doing some research and I think I found a couple creative ways to keep the game a bit more interesting for my mind.
We do want to quickly get to level 85 before I put this into a full test but there should be a quick way for us to generate around 1000g gold a day easily but we can hit 10000g daily.

<Adsense />

## 2023
- 7:34am - I spent a decent amount of time going through my LinkedIn profile and updated a decent chunk of what I had on there. Part of my plan will be to automate some of the LinkedIn functions, maybe have it send custom GPT-based messages to people that I would like to reach out to. The general idea would be to at least have the introduction message be a bit personal? I also made sure to claim the company page for KBVE! As for why I decided to improve my social presence? Hmm, I was a very anti-social media, in the sense that it felt like it was very manipulative and corrupt, however that does not mean I should not at least engage in some form of gray-hat! I found that there were some clients that wanted automation tools within Instagram, Twitter, etc... and having a better background in understanding how they functioned would make it a bit easier to build those tools out? There are a decent chunk of tools already out there, I will just focus on making one that is very simple to run inside of a docker container. I was thinking of extending out some of my unity knowledge and then build it out from there but the idea of running the application in a lightweight but scalable approach seems to be the best move for now. 
- 11:30am - Idea! I am thinking that I should look into building out that license system. This would allow people to sell license key through our KBVE portal, where we would then provide unique features that would help verify and protect their licensed software. Part of this feature would also be to include various ways to license and protect your software when it comes to distribution. The license system would need a decent name that would be cute but not too over the top, just a bit of `OwO` but not too much of `AwA`. Definitely will need a hint of `nani!?`.
- 1:50pm - Going to do a couple quick league matches before doing some general workflow management. I will take a couple hours to update the general website, maybe finalize the blog theme template too.
- 2:56pm - Time to synch this with the current branch and then redo the blog design theme.  I also have to remember to migrate some of the older or really old blog content from back in the day into the main collection. It will be interesting going down memory lane and grabbing those really old articles. I should also look into setting up the interview format, there has been some great moments, and as such, I should have a decent interview template and question bank ready to ask those that are special individuals that I run into. 
- 3:11pm - Going through their message system, it looks like I could use Puppeteer to help cycle through the automated messages that I am getting... ugh it does feel a bit weird that I have to automate a response to the automated messages that I am getting, but it is what it is. I guess that Internet is really turning into a cluster of bots, part of the time I am thinking that it is just a collection of bots that all just engage with everything xD.
- 3:23pm - Let me sync this journal log before opening Unity, it was the first time that I had a blue screen crash on my laptop in a while.
- 4:10pm - Pushed the patch changes and it looks like I need to make a new workflow that would prepare for release? I suppose that would be a staging workflow, we could build that out under `staging.yml` under the GitHub workflows. The idea behind this would be to mimic the movement from a developer branch to the main branch, here we could do the code reviews, version control and test case a couple deployment concepts. One of which I was thinking would be to create an automated response that would use GPT to summarize the results from the changes. A GPT powered release note? I suppose this would be an area where we could test case the SSR components of Astro too. 
- 4:17pm - Time to get some coffee and red bull while I wait for this to build out. Damn the compiler? Maybe Unity is eating up resources a bit too much. Going to switch back to the blog design.
- 8:24pm - Okay I think I got the basics of the blog design down, now I just need to figure out what type of variables we should include? 
- 9:20pm - Finished making some fresh veggie pizza via the naan method, it was so filling and powerful, honestly it could be a healthy fast food in the future. Okay so I think we got a general gist of the blog format, with a simple MDXJS widget as well, which would help stylize, if that is a word, the general notes and information. I think the worst part of GPT is that it is moving my brain closer towards the matrix, it was bad already to have to google things, but all this is doing is moving the goal post closer towards the matrix. 
- 10:13pm - Time to update AstroJS and maybe play a couple quick rounds of League. There should be a way

## Quote

> The entrepreneur always searches for change, responds to it, and exploits it as an opportunity.
> — <cite>Peter Drucker</cite>

---

## Tasks

- [ ] Blog Post Design

---
# July: 30

> July 30th. Lore Lore Lore.

Source: https://kbve.com/journal/07-30/

import { Adsense } from '@/components/astropad';

## 2025

### JamSkip Pirate 17

-   09:09PM

    After talking to a couple partners, we decided that the best move would be to just skip this gamejam submission.
    There are too many bungs and we are not too sure if AI programming was allowed for this jam, I should have asked the support over this before starting it.
    On top of all that, there is all the pirate drama, but that is just more publicity for game during the show-off.

## 2024

**Dialogue**
The dialogue flow is almost ready to be on the production branch, with some minor tweaks left in the option branch.
We would have to add the different action ULID and action system for the dialogue but I think we can do that on a later date.
The chaining of the dialogue will be important and then setting it up so that the messages do not get displayed twice.
We could keep track of the dialogue that gets read by flagging the boolean `read` to true after its done typing it out, which should remove it from the chain pool.

**HID**
At the same time I am working on the Cryptothrone project, I am also looking into the HID emulation and getting a deeper dive of hardware emulation.
My goal would be to perform these emulations in both Rust and Python, with different goals in mind for both!
The python based HID will go into Atlas, making it easier for future developers to call and utilize, we would probably wrap the ada fruit library into a custom restful api via fastapi.
As for the rust based, I am going to aim at creating a powerful emulation program written in rust for private usage.
We could place the changes to the HID library directly into the fudster library.

The next problem that we are facing with the HID is that the ability to grab the current screen and process what is going on!
Getting the program to be reactive and fast enough is tough if its all based upon pixels and sounds.

**NPCDB**
The sidebar for the KBVE Docs need to be updated to include a direct link to the NPCDatabase.

**Action System**
I started to map out the action system that will trigger when certain dialogue objects are triggered via the chaining.
My initial concept for the action system would be to keep it simple and have it be an ULID to a factory or singleton that would execute upon clicking the action.
It is still a bit tough to write it out without actually placing the concept into production.


## 2023
- 3:15pm - Currently looking at the structure for the account setup under KBVE.com repo. I believe the next move would be to just migrate the different concepts into their own MDX file. The reason we want to do this right now is because in the future, we can make it easier to add i18n into the core source. The migration of the `*.astro*` files into their own MDX file should be isolated into their own issue? This way we could maintain a structure for future developers that might want to see how I would go about it. 
- 3:37pm - The initial files would be structured so that majority of the content would be inside of the MDX file, so that when we go about doing the translations, we have a central location for all the text. This means that if there are any errors messages, we would have the default aka English ones ready and then if there are any other languages that we would want to adapt, then those would be added on as their own MDX file. 
- 4:20pm - We will start with a new layout astro, which is currently named the `account.astro` and from that standpoint, we will prepare for the astro v3 upgrade for this upcoming year. As I will state in the issue ticket, I am thinking of migrating all of the `.astro` components that are related to account management and officially moving them into the mdx file format. Afterwards, I want to then embed the different widgets that would be required for each action, a bit of a modular approach but it might be a bit over engineered for what we are doing at this current time, but it will make going into i18n a bit easier down the line in the future. I will start this test case by... hmm. Okay let me first make the `_account` folder, where I will store all the older code / astro files. After moving those, I would have to define the zod type for the account collection and then create the files that I would want to call? I will keep the types that I would want in zod to a bare minimum and then extend them out as I would like. 
- 5:00pm - After adding the zod for the account and getting the basics out of the way. This includes watching deathclaws rip apart @andsam, which would describe exactly how I am going about this programming move. Ah I am going into a terrible performance loop within the `dev` branch right now, every build is throwing a terrible crash loop, I might have to see where I went wrong because this is starting to become a bit of a pain. 
- 7:43pm - Quickly wrapping up the basic chores, now I am going to run a quick League match and review some of the updated libraries. 
- 9:02pm - My Adventures of Superman, in the 5th episode of Season 1, Superman as Clark Kent, breaks a file cabinet then it just gets magically repaired. Why did I write this? Well there is no reason.
- 9:05pm - I should start to refactor some of the really basic modules, hmm, I think the logout module aka react one, should be simplified. The next patch will be a bit bigger than I was thinking, a decent chunk to the general codebase, which I should have split into different pull requests, but for now I suppose it will be okay.
## Quote

> He has no enemies, but is intensely disliked by his friends.
> — <cite>Oscar Wilde</cite>

---

## Tasks

- [ ]

---
# July: 31

> July 31st. Action System.

Source: https://kbve.com/journal/07-31/

import { Adsense } from '@/components/astropad';

## 2025

### July Bills End of The Month. 

-   07:15PM

    The end of the month is always a pain, this is going to be rough too.
    My expenses have risen by over 10% since last year, maybe even closer to 20%.
    This means my funds and balance sheet will go into a debt-based operation within the decade.
    Thus the runway is now 3 years, maybe even less if things get worse before they get better.

### BTC Movement into RH

-   11:00PM 

    It might be time to start selling some of the crypto off, at least to build a bit of a slushy fund.
    The war chest needs to keep growing but the capital that we have access to is starting to get a bit rough.

## 2024

**Action**
Action system for the dialgoue system.
I am going to start the base interface and then extend it around to see if we can utilize it with the event handler.
The best approach would be to split the Action system into its own dexie database and then work from there?

**Credit**
It is the that time of the month and we need to pay off our credit cards!
I am making sure that everything has a payment but I am thinking of placing all the credit balances back into a negative.
So instead of having just a $0 balance on the cards, the plan is to send them all a couple thousand and have them operate such that they owe me credit.

**Optimization**
We can do a couple more unique tricks for the javascript optimization within Cryptothrone.
The first approach will be to expand and improve the movement of javascript objects, including the ability to save them into the indexeddb and manually ensure they are sent to destruction.
While working directly with the javascript `Uint8Array` and rust `Vec<u8>`, we can setup two unique instances of Spinoza style objects.
For this we could use `Deku` for `Binary` and `Serde` for `JSON`, and all of this should be placed into our `JEDI` crate.
As GPT stated, Storing objects as JSON is a straightforward and commonly used approach because it preserves the structure and data types of JavaScript objects.
However, for certain types of data, such as images, files, or large arrays of numbers, it might be more efficient to store them in a binary format.
This can reduce storage size and improve performance when handling large amounts of data.
We already place the npc images into the indexeddb already, but to avoid having our code break, we could build a new part of the package to focus on it.
This was the original optimization function:

```ts

function serializeObject(obj) {
    return new Blob([JSON.stringify(obj)], { type: 'application/json' });
}

```

However we could use this basic function:

```ts

function serializeToBinary(obj) {
    if (obj instanceof ArrayBuffer) {
        return new Blob([obj]);
    } else {
        return new Blob([JSON.stringify(obj)], { type: 'application/json' });
    }
}

```

A little bit of a cleaner function:

```ts

function serializeObject(obj) {
    try {
        if (obj instanceof ArrayBuffer) {
            return { type: 'ArrayBuffer', data: new Blob([obj]) };
        } else if (obj instanceof Blob) {
            const supportedTypes = ['image/png', 'image/jpeg', 'image/gif', 'audio/ogg', 'audio/mp3'];
            if (supportedTypes.includes(obj.type)) {
                return { type: obj.type, data: obj };
            } else {
                throw new Error('Unsupported Blob type: ' + obj.type);
            }
        } else {
            return { type: 'application/json', data: new Blob([JSON.stringify(obj)], { type: 'application/json' }) };
        }
    } catch (error) {
        console.error('Serialization error:', error);
        return null;
    }
}

```

Hmm, we should move the `supportedTypes` as an optional type, thus making this a more extendable function.
The updated serialize function that we will be using.

```ts
function serializeObject(obj, options = {}) {
    try {
        if (obj instanceof ArrayBuffer) {
            return { type: 'ArrayBuffer', data: new Blob([obj]) };
        } else if (obj instanceof Blob) {
            if (options.supportedTypes && options.supportedTypes.includes(obj.type)) {
                return { type: obj.type, data: obj };
            } else if (!options.supportedTypes) {
                return { type: obj.type, data: obj };
            } else {
                throw new Error('Unsupported Blob type: ' + obj.type);
            }
        } else {
            return { type: 'application/json', data: new Blob([JSON.stringify(obj)], { type: 'application/json' }) };
        }
    } catch (error) {
        console.error('Serialization error:', error);
        return null;
    }
}

//
const options = {
    supportedTypes: ['image/png', 'image/jpeg', 'audio/ogg', 'audio/mp3'] // Customizable supported types
};

// Additional exampls of usage!

// 1. Regular JavaScript object
const myObject = { name: 'example', data: [1, 2, 3] };
const serializedObject = serializeObject(myObject, options);
console.log('Serialized Object:', serializedObject);

// 2. ArrayBuffer
const myArrayBuffer = new Uint8Array([1, 2, 3]).buffer;
const serializedArrayBuffer = serializeObject(myArrayBuffer, options);
console.log('Serialized ArrayBuffer:', serializedArrayBuffer);

// 3. PNG file (Blob)
const pngBlob = new Blob([/* binary data */], { type: 'image/png' });
const serializedPngBlob = serializeObject(pngBlob, options);
console.log('Serialized PNG Blob:', serializedPngBlob);

// 4. JPEG file (Blob)
const jpegBlob = new Blob([/* binary data */], { type: 'image/jpeg' });
const serializedJpegBlob = serializeObject(jpegBlob, options);
console.log('Serialized JPEG Blob:', serializedJpegBlob);

// 5. MP3 file (Blob)
const mp3Blob = new Blob([/* binary data */], { type: 'audio/mp3' });
const serializedMp3Blob = serializeObject(mp3Blob, options);
console.log('Serialized MP3 Blob:', serializedMp3Blob);

```

Next, here is the updated deserialize object function.

```ts

function deserializeObject(serialized, options = {}) {
    try {
        if (!serialized || !serialized.type || !serialized.data) {
            throw new Error('Invalid serialized object format');
        }

        const { type, data } = serialized;

        if (type === 'ArrayBuffer') {
            return data.arrayBuffer().then(buffer => buffer);
        } else if (type === 'application/json') {
            return data.text().then(text => JSON.parse(text));
        } else if (options.supportedTypes && options.supportedTypes.includes(type)) {
            return data;
        } else if (!options.supportedTypes) {
            return data;
        } else {
            throw new Error('Unsupported type for deserialization: ' + type);
        }
    } catch (error) {
        console.error('Deserialization error:', error);
        return null;
    }
}

const deserializationOptions = {
    supportedTypes: ['image/png', 'image/jpeg', 'audio/ogg', 'audio/mp3'] 
};

deserializeObject(serializedObject, deserializationOptions).then(deserialized => {
    console.log('Deserialized Object:', deserialized);
});

```



## 2023
- 9:30am - Prepare legal documents for my uncle? Ugh this was a task that I hate doing because talking to lawyers has always been a pain. 
- 10:33am - I need to redo my gym schedule, I might have to do something a bit more hardcore and maybe do the duel trips? Aim for both a day and night trip, just to get out of the house and get some more data on FSD. 
- 2:30pm - The lag on league of legends is starting to get to me! It just seems to be way too much recently, the spikes are a bit draining. 
- 2:37pm - I will finish up this basic account page and get it functional enough to push to the main branch. 
- 3:06pm - I noticed that I was running out of space on my computer, so I think it might be time to do a bit of quick cleaning. I was at 72gb free and now I am at 134gb free, however I could remove some of the games on my computer but we all know that will not be happening. Cleaned up my downloads folder and now I am at around 170gb free. This should be enough for now, once I tackle my github folder, that will sum up a decent chunk.
- 9:05pm - The most recent `patch-july-30-2023` patch was a bit too much code, I am going to scale it back to smaller patches, so that there will not be massive changes inside of just one patch.

## Quote

> For it was not into my ear you whispered, but into my heart. It was not my lips you kissed, but my soul.
> — <cite>Judy Garland</cite>

---

## Tasks

- [ ]

---
# August: 1st

> August 1st. Singleton.

Source: https://kbve.com/journal/08-01/

import { Adsense } from '@/components/astropad';

## 2025

### Supabase Cluster

-   02:00PM

    The goal for this month will be to build a kubernetes cluster under talos.
    Having it fully operational is our mission and I want to get it going before the end of this month.

### Edge Nodes

-   11:50PM

    During our docker swarm era, we had a couple edge nodes that helped with processing via n8n.
    Getting this going would be a great side quest, if we get the talos networking out of the way.

## 2024

**Singleton**
Working off of yesterday, I am thinking that we could migrate the serialization and deserialization from function to a global singleton, then setup an object pool?
There might be some risk with how we handle this because of the limits that a browser window provides us, yet I think we can get pretty creative with it.
One of the goals would be to offload the objects into two different types of storage, the indexeddb and localstorage.
I am thinking if the priority of less than 10 be stored within the localStorage and anything 10 or higher be moved into indexeddb.
Then once those objects are stored within their respective areas, we can pull & push the json or binary in either WASM or JS.
There is the problem with race conditions but I think we can also handle those internally. 

We could set the structure up as these classes:

```ts

class Serializer {}

class Deserializer {}

class Pool {}

```

Afterwards, we coulkd make it so that the pool is directly referenced within both of the `Serializer` and `Deserializer` class but it might be wise to keep the pool out of them.
We want to avoid a circular dependency and also there could be a couple different pools that we could design.
Outside of the pool class, we will setup the `Juggernaut` class that will help with managing the data, in this case json and binary and the pool?
Now that I am thinking about it, hmm, there could be a better way to handle all of it through a different setup.

**Click2Move**
We can add a quick option to allow players to move via clicking as well.
For this, I am thinking we also enable touch movement too, both of these should be options within the user settings.
Okay after working through the code and performance issues, it might not be worth doing the click to move directgly from the tiles but instead keep it as an NPC action.

**Text Speed**
I was told that the text speed was too fast, I am thinking that we make it a setting for the person that is reading.
We already have the text speed value as a hardcoded number, which we can keep but we can also pull from the user settings interface the speed that we would want.
The user interface for the text speed has to be added.

```ts

const defaultSettings: UserSettings = {
  tooltipItem: { id: null, position: { x: 0, y: 0 } },
  submenuItem: { id: null, position: { x: 0, y: 0 } },
  tooltipNPC: { id: null, position: { x: 0, y: 0 } },
  isStatsMenuCollapsed: false,
  isSettingsMenuCollapsed: false,
  debugMode: false,
  textSpeed: 40,
};

```

The `UserSettings` will have the `textSpeed` as a new setting and then we can just call that key to grab the speed for the text.



**HID**
While doing some of the combat testing, I been doing some hardware emulation.
The goal here is just to test the differnt ways to emulate USB equipment, mainly setting up the base drivers.


## 2023
- 4:34am - I got up super early and started to work on the svelte migration for the react components. I also wanted to see the pre-market but I am a bit off-put with the current situation, I believe we are in the perfect mixture of events that create a decent chunk of profits for the irons condor gangs.
- 2:28pm - Doing a couple quick syncs within the public and private repos. 
- 3:29pm - Okay got my mother back from the dentist, it has been like three trips so far but everything is good to go. She feels better and that is one less stress point that I have to deal with.
- 3:34pm - I should look into setting up certain changes via github actions, going to map out two or three to build in the future.

## Quote

> In friendship as well as love, ignorance very often contributes more to our happiness than knowledge.
> — <cite>François de La Rochefoucauld</cite>

---

## Tasks

- [ ]

---
# August: 2nd

> August 2nd. Macos.

Source: https://kbve.com/journal/08-02/

import { Adsense } from '@/components/astropad';

## 2025

### Saturday Cleaner Days

-   04:15PM

    A bit whacked out and went through the whole house to do some quick spring cleaning.
    I think it might be time to start building that IOT cleaning system that I was talking about in the past.

### Kilobase

-   11:15PM

    Spent a decent amount of time trying to get kilobase to be operational enough from both the monorepo and the postgres fork.
    Our plan is to use this to build out the supabase cluster before launching the steam game.

### Intel NUCs

-   11:59PM

    Before end of the day, it would be dope if we could get chip to run some of the worker nodes via his intel NUCs.
    Getting them to be deployed and joining our cluster would make things so much cooler and easier to use in the future.

## 2024

**Macros**
To help improve my warriors rotation, I decided to grab the `GSE: Advance Macros` addon and then started to build around a basic macro script.
The first test would be to generate a random number between 1 and 10 and then send it via chat message.

```lua

/run local num = math.random(1, 10); SendChatMessage("The number is " .. num, "SAY")

```

**Arms**

Switching from Fury over to Arms, going to give that a shot next.
There is a bit of an issue with how the macro system is working, I am thinking that the solution might be to make the macro in python.

## 2023
- 10:00am - My lunch is going to be epic, I am looking at 12 wings and a Philly cheese steak pizza!
- 3:00pm - I am enjoying this pull back within the market! I am hoping we see tesla go back down to the low $200s, which would give me some time to grab a couple more cheaper LEAPs.  
- 5:35pm - The tag system and generating the relationships with those files are next on my task list. We could make the tag system built around the same MDX structure? We could automate the tags by looking through all the files? I am not too sure I want the tag system to rebuild each time we compile the website, maybe we could have the tag system run as its own yarn function. 
- 6:34pm - The Supabase and Pocketbase integrations with Appwrite might be a bit too much for what we are doing right this second but we are test casing a couple multi-api communication vectors. We are running pocketbase on the NodePy image but we have not yet setup the supabase. 
- 9:00pm - Okay I was able to get a local version of the supabase to run under Postgress, I am wondering if I could extend it out with some micro controllers without running into I/O locks. I suppose we could at least test case a read-only style replication but these options will be for later this month. 

## Quote

> Remember always that you not only have the right to be an individual, you have an obligation to be one.
> — <cite>Eleanor Roosevelt</cite>

---

## Tasks

- [ ]

---
# August: 3rd

> August 3rd. MapDB.

Source: https://kbve.com/journal/08-03/

import { Adsense } from '@/components/astropad';

## 2025

### Kilobase + NIX

-   11:00PM

    Spent most of the day learning more about nix and getting the kilobase aka supabase fork to be as operational as we can get it.
    This means not only getting it to deploy but also to get it to cluster and backup without throwing too many issues.
    A part of me does not like nix because I am very much used to just writing docker files the classic way, but honestly, it is growing on me.
    I am understanding why it exists and the purpose that it serves, because going back to an older project makes it a breeze.

## 2024

**MapDB**
Todays plan will be create the final `MapData` interface and the `MapDB` class within `Phaser`.
We could call this the `Environmental` handler? I will think about the name while I work this out.
First we need to move the types from the `quadtree.ts` into the `types.ts`:

```ts

interface Bounds {
    xMin: number;
    xMax: number;
    yMin: number;
    yMax: number;
  }
  
  interface Point {
    x: number;
    y: number;
  }
  
  interface Range {
    name: string;
    bounds: Bounds;
    action: () => void;
  }

```

With the types moved, we slap the export onto them and I am thinking we could fix up some of the references in the future.
For example, `INPCPosition` can be updated to extend the `Point`.

```ts

export interface INPCPosition {
  x: number;
  y: number;
}

// To this

export interface INPCPosition extends Point {
  id?: string;
}

``` 

The current mapdb / mapdata interface will be this:

```ts

export interface INPCObjectGPS {
  ulid: string;
  position: INPCPosition;
}

export interface IMapData {
  bounds: Bounds;
  tilemapKey: string;
  tilesetName: string;
  tilesetLayer: string;
  scale: number;
  npcs: INPCObjectGPS[];
}

```

The new `INPCObjectGPS` interface will help us with keeping track of the NPC from the client-side, but the absolute truth will be on the server side.
Given that this game plays in both single player and multiplayer with an island approach, we need to make sure that the client-side GPS can be corrected within reason.
Next we can setup the zod for the map data , so that it would be easier to manage!
While building this out, I realized that I need to preload the json and tileset png per map, so we need to update the IMapData to hold those two additional variables.

**Tracking**

While we can extend out the `INPCObjectGPS` , we also need to attach a quick ID to the object, that would be referenced by the server.
Keeping track of the NPCs should be easy for now because we did not yet add death or any complex systems, like combat.
However, if we are planning to do that, then we should plan ahead for these said actions and states!
The pool of objects could be saved into the SQL database and also kept within the RAM or a redis-structure?
I am not yet 100% sure how we would want to handle it.

<Adsense />



## 2023
- 1:00pm - I am a bit excited to see how AAPL does during their earnings call. I am hoping that it at least breaks past the $195 mark, so I can offload the shares, but if it does not, then I will keep covering 200 shares until they get sold. My small goal would be to just get in and out for around $200 a week, which I will dump into my $O pool. 
- 2:26pm - Going to install the r3f into the KBVE.com repo, however I feel like it might make the repo a bit too heavy. I shall see what we can do moving forward, there could be a bit better way to handle it. 
- 2:32pm - I will go ahead and install all the libraries that I would want to use for the Three.js integration onto the website and extend out the Canvas via a couple different elements, including a portal and some unique examples. I would like to see how they look under the Unity video game as well.
- 2:51pm - We should place the models that we want to use for the R3F inside of the `public/assets/model` and there I will build out some of the general models that we will be using for the test casing. For the time being I will place some of the generic content that I find on the internet there but try my best to keep the licensing within those folders. This will be to help avoid any major issues. 
- 3:20pm - Coffee break and then when I come back, I will begin to install the R3F, I noticed that there might be some issues with how I would want to go about it, so I might have to think a bit about how I would want to handle it. Maybe having an isolated repo for each instance could be better? The Widget style setup would be interesting doe. 
- 6:49pm - Installed the basic libraries for r3f and looking at how they will perform on various browsers. It seems that general mainstream browsers that are are chromium based have a decent ability to render and run the r3f examples. However, it seems that OperaGX was not able to render the portal example at a functional level. I am not too sure if its because I have something disabled OR if OperaGX does not support this type of library. I will have to do a couple more browser test casing, including Safari!
- 10:33pm - Test casing some of the general r3f libraries. Going to push through a general save state as patch `patch-r3f-install` and then going to continue to work from this branch until tomorrow.

## Quote

> The conditions of conquest are always easy. We have but to toil awhile, endure awhile, believe always, and never turn back.
> — <cite>Seneca the Younger</cite>

---

## Tasks

- [x] Install r3f libraries.

---
# August: 4th

> August 4th. Sunday Funday.

Source: https://kbve.com/journal/08-04/

import { Adsense } from '@/components/astropad';

## 2025

### PG Sodium Kilobase

-   09:15PM

    One of the final bosses when it comes to deploying the Supabase instance!
    We need to make sure that the pg sodium key does not get lost or corrupted, if either of those two things happen then we lost our vault data.
    However another part of me wants to see if we could just replace the secret storage to a 3rd party, like hashi vault or something similar.


## 2024

**Sunday**
The amount of WoWKrack has been hitting too hard and now I am losing some braincells.

**House of Dragons**
The ending was not that amazing, I was really hoping for a better way to finish off the story but it is what it is.
I will not go too much into the spoilers but GoT really knows how to hype up a story and then just fall flat!
This is even worse because the source material was already done, but damn.

**Family**
Had some family members come over from Canada!
I remember first meeting them in India, which was almost a decade ago but how far they have grown and matured.
They just recently bought a house out there and were talking to me about how crazy the prices were.

**MacBook**
There might be some screen damage on my macbook, I see a dark black line that is running down the side. Ugh its already super late at the night, I think its time to call it quits.

<Adsense />

## 2023
- 3:07pm - Going to look over the `account` mdx files and see if there are any additional templates, widgets and/or tooling needed before adding the r3f.
- 4:15pm - I was going through the `application` content folder to prepare for the tag folder and I am thinking that I might switch it up and try a complex structure. The first step would be to being the folder for the tags, which I will place under the `tags` and then under the `pages`, I will make a folder that is `t` which will be a slug-based id system? That could be one option, damn I just realized that I am tackling two different issues insides of the same patch. This would be a foul play in the management of the patch style of development, because I am jumping from one issue to another without having it referenced. 
- 5:54pm - The tag system is coming out a bit better than I was expecting, I am debating if I want to use the `Canvas.astro` as the base layout for the tag system OR if I should create a new layout for them? I think the best step would be to start with the base of `Canvas.astro` and then go back and refactor the tag system to use a custom `Tag.astro`. 
- 8:04pm - A minor update on the RSPS project, it seems that prices are still falling, the value of effort and reward is also diminishing a bit faster than I was expecting. This is a common problem that I feel like all MMORPGs will have, where the inflation will get more and more rampant, such that, the overall value of the effort diminishes. I think it is always interesting to see how a virtual world handles their economic activity and compare it to our physical realm. 

## Quote

> One of the most beautiful qualities of true friendship is to understand and to be understood.
> — <cite>Seneca the Younger</cite>

---

## Tasks

- [ ]

---
# August: 5th

> August 5th. MunsDay.

Source: https://kbve.com/journal/08-05/

import { Adsense } from '@/components/astropad';

## 2025

### Kong API Gateway

-   09:15PM

    Spent the whole day working on the kong api gateway, dealing with CORS issues and general flow.
    There will be three API gateways that we plan to build out, one will be for the Supabase instance itself and the second will be for KBVE.
    Third API gateway will be for meme.sh, but that is still a while from now, I do need to start moving faster.

-   11:05PM

    I did start the process of hooking up the logflare but there are still some issues around it that we have not yet fully resolved.
    The logs are not being handled to our best of ability, it will be something that I have to sit down and walk through each step.


## 2024

**Market**
The market was brutal this morning, but I see it as a quick sale!
I am going to load up my 2024 Roth today, quickly grabbing what I can for around $7K but I might also be above the income to contribute.
If I end up going too high for this year, then I will just sell out and readjust or pay the fees, it is what it is.

**Margin**
The margin on one of my accounts is starting to creep up a bit and after a couple CDs clear up within the next couple months, I should plan to wipe that out.
That would mean that I am now really debt free within my personal name.
I was hoping to keep that margin afloat until the end of the year but there just isnt anything worth trading that makes enough to cover the interest on the capital.

**MemoryLeak**
When pulling back the data points, I noticed that the KBVE API was at around 35MB and not the 14MB that a fresh API would have.
I am trying to figure out the 20MB+ increase in the usage of the API running for over 2 months was from caching, maybe a static hash map increasing in size or the worse case, a memory leak.
While the memory leak would not be the end of the world, I believe it would be wise to look over the code and keep track of the changes.
The most recent parts that we added were Groq / mL / ai helper routes, but I do not think that they would cause that issue.
I am thinking that it is an Arc pointer issue or the way that I am handling the application state.
When I put my rusty hat back on, it will require a decent deep dive.

**Zod**
Here is the MapData as a Zod:

```ts

const PointSchema = z.object({
  x: z.number(),
  y: z.number(),
});

const INPCPositionSchema = PointSchema.extend({
  id: z.string().optional(),
});

const INPCObjectGPSSchema = z.object({
  ulid: z.string(),
  position: INPCPositionSchema,
});

const BoundsSchema = z.object({
  xMin: z.number(),
  xMax: z.number(),
  yMin: z.number(),
  yMax: z.number(),
});

const IMapDataSchema = z.object({
  bounds: BoundsSchema,
  tilemapKey: z.string(),
  tilesetName: z.string(),
  tilesetLayer: z.string(),
  tilesetImageUrl: z.string(),
  tilesetKey: z.string(),
  scale: z.number(),
  npcs: z.array(INPCObjectGPSSchema),
  jsonDataUrl: z.string(),
});


```

I am going add these zod configurations into the `types.ts` and I will then call it via the `mapdb` option.
Thus we will call the mapdb in the frontmatter like this : `mapdb: z.array(IMapDataSchema).optional(),`

**Login**
The new login page seems a bit okay but I think the modal was not too bad.
The register page makes sense for us to focus on but the login might feel like it is a step back?

**Register**
The next part of the `register` page update should include a link to the privacy and terms of service.
We want the future user to agree to all our legal terms, including the EULA and any additional future requests that we plan to place on the website.
I will come back around and look over it again tomorrow morning, I suppose a quick check box that links to all those documents for approval?
Hmm will we need to check if the checkbox is pressed on the backend as well?

## 2023
- 4:40pm - The first couple of Ubuntu GitLab actions had worked fine but a couple of the latter
- 6:45pm - All my chores are done and I believe it might be time for a couple quick league matches. I did some off the record journal entries because I wanted to take a bit of a break from the screen, so I will have to migrate them back to this md document. I feel like this is one of the only major drawbacks with doing a daily journal, it is trying to remember to take your physical notes and then convert them over to a digital format. I suppose the other side of it is realizing some of the notes are a bit stupid, but then again, even if they are a bit out of the norm, it might still make sense to document them. 
- 6:49pm - Should I go AP shaco or another round of tank shaco? Hmm, I also think the two new skins are okay, they could have done a bit more with the effects, I feel like the animation game was a bit weak but that might be just on my end. About to hit that 2 million mastery, which is a bit scary to think about. 
- 6:59pm - After I finish up the tag system, I should go back and refactor some of the media content, maybe that might give me a really good static API base to work with. One of the random ideas that I was thinking to add into the Discord music bot was to pull the json data for the YouTube content and basically play music from those tags? I could do a `musicbot` specific tag and extend it out? Hmm, I suppose how would I go about a duel tag search, so if object is on tag A and tag B? I guess this goes into the relationship style of tagging, such that, multiple entities could be linked via cross-tag. These are some questions that I have to think through as I build it out.
- 9:51pm - Seeing Futurama come back after being canceled over and over, I am surprised and somewhat glad the show is back... ugh again after being canceled? So far it is exactly the perfect balance of science and meme.  
- 10:36pm  - Going to sync the patch and preparing the next patch for tomorrow..
- 11:30pm - I should look into libraries that help the movement of the mouse, the two that I was looking at where pyHM and WindMouse, both could be combined into just one unique package? I suppose this would be something that we would operate under NodePy later down the line, in terms of automation as well.

## Quote

> Even if you're on the right track, you'll get run over if you just sit there.
> — <cite>Will Rogers</cite>

---

## Tasks

- [ ]

---
# August: 6th

> August 6th. .

Source: https://kbve.com/journal/08-06/

import { Adsense } from '@/components/astropad';

## 2025

### Disoxide

-   10:35PM

    Another day in the dev world, this time we took a quick break from the general kubernetes and focused on the discord project.
    The template is almost done, added a new infinite scrolling library and improved the footer of the site!
    Next we need to add the actual server database and setup the voting and bumping for the site, both we have already written the code for.
    So the plan is just to link them together moving forward.

    The tables for the server could be done via the rust application deployment or having the schemas be split.
    We could have it in both areas too, just to be safe and of course the schemas have to be double checked regardless.

## 2024

**RockHaus**
Nothing says we have entered the deep parts of the wowcraft than a bunch of us streaming ourselves playing all day.

**Gaming**
The gaming docs section of the KBVE collection needs to be updated, I will try to fix that up right now.
One of the things we can do is make sure to import everything from starlight that we might need for the document.
Here is the generic imports that we commonly use:

```js
import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
  LinkCard,
  Tabs,
  TabItem,
} from '@astrojs/starlight/components';
```

We will try to inclue a couple different sections to describe the general gaming document.
The next update will be in the configuration for the website and place `gaming` inside of the `astro.config.mjs`

```js

				{
					label: 'Gaming',
					collapsed: true,
					autogenerate: { directory: 'gaming' },
				},

```

The menu for the gaming section will remain collapsed as a default setting.


**WoW Movie**
A great way to end the night!
Granted, with the south park episode and the movie, we been down this rabbit hole twice already and it feels a bit too much for me.
However, getting a chance to see Preacher again is always worth it.

**MapDB**


<Adsense />

## 2023
- 12:05pm - I should find a way to combine the weekly reports that I get into one? I suppose we could do that via Postboy? Have it shift through the reports that get generated? Maybe make it a bit more modular and then work from there. I suppose we could utilize a bit of creativity to handle this. I believe the best way to approach this would to be a module that would initially scope out the data and then place it into a Google sheet based, this way we could organize and refine the data we would want to display onto our 
- 3:01pm - Getting ready for another night shift of programming and running around with the meme gang. 
- 4:07pm - The first report that could parse through would be the Google webmaster / search results data. This would be a bit easier to do from the current standpoint,  I believe the hardest part of this would be to manage the sessions, including the login data. I suppose setting up a chrome session with pre-defined instances might make this easier but there would be a security risk that I would have to account for. The tools we would use for this automation process might just be n8n, as it would make replication and migration a bit easier too incase someone else wanted to use them. 
- 4:34pm - Time to grab some coffee and prepare for general rounds. The bigger issue for me to tackle and shift this block towards will be to resolve the tags AND also make some minor updates to the visual novel.
- 4:40pm - The `Cover` widget is ready to move into this daily patch, with the purpose of providing a generic cover for the VN aka Mangas. The first demo of this will be used for the FinTech and the Conch series, both I should wrap up today! They are minor issues that could be resolved without too many pain points, at least getting the basics out of the way.
- 7:17pm - Let me sync these notes for now and I will start with the cover widget afterwards. 

## Quote

> Value your friendship. Value your relationships.
> — <cite>Barbara Bush</cite>

---

## Tasks

- [ ]

---
# August: 7th

> August 7th. Memory Allocation.

Source: https://kbve.com/journal/08-07/

import { Adsense } from '@/components/astropad';

## 2025

### Disoxide EventBus

-   05:13PM

    The event bus system will be used with the worker system.
    Granted we did take the worker system down for a bit, so I do plan on throwing it all back up as an unified library.
    The purpose of the event bus is to just handle all the possible events that could occur via the UI/Realtime and different workers.
    Also the menu still needs a bit of work, even though its off canvas, we can definitely improve the original dom and virtual dom.

## 2024

**Nvidia**
Making an educated bet that Nvidia will rise above $109 before the end of this year.
I am going to bet almost a yearly salary towards this and making it the goal of swinging in and out for around mid five figure profit.
With the capital that I gain from this trade, I will move it directly into another pool of monthly dividend stocks and aiming to reach another net goal of $1000 a month in dividends.
One of my yearly goals is to generate pools of capital that will generate around $1000 a month or 10 blocks a month and with Q4 around the corner, I want to see if I can accomplish this within two months.

**Heap**
Time to do some big boy programming and by this, I mean some lower level programming!
I am going to see if I can change up the heap allocation within the `rust_api_profile` image to help debug this memory usage bug that I am having with the application.
The solution to this problem might be a change the default allocator over to jemallocator but we will have to make sure that the docker image and the chisel container will not have any issues.
A huge shout out to Tom Hacohen from Svix.com for explaining the heap allocation issue that I am running into.
Updating the Dockerfile so that Ubuntu will have `libjemalloc-dev` installed ahead of time.
Then under the chisel image, we will move over the `libjemalloc.so.2` as well after the base build.
Now with the `jemalloc` library that we are using, we might want to also make sure that the `LD_PRELOAD` is setup and we can set that with this line:
`ENV LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2`.
After updating all the docker files, we can go ahead and start the test casing of the libjemalloc.
The shell command that we are going to use to run this application is this:

```shell
./kbve.sh -nx rust_api_profile:run
```

The local test cases have passed and now we can look at the docker build next.

```shell
docker build -t rust_api_profile .
```

After the build, we can go ahead and run the docker image locally and make sure that it works without any issues.
Then move the changes up to the `dev` branch.

The curl command that we will be using to hit the `rust_api_profile` docker image: `for i in {1..100000}; do curl -s -o /dev/null http://localhost:3000/api/v1/speed & done wait`.

Next test case will be a quick 1000 on the main API, here is the code that we will run for this:
`for i in {1..100}; do curl -s -o /dev/null https://rust.kbve.com/api/v1/speed & done`.

Actually, now that I am thinking about this, we could probably add this into the KBVE shell file or maybe a custom script to help us handle these requests / test cases.


**Chisel**
The next update will be to the docker container that would be in charge of chisel.
I am debating if it would be worth increasing the size of the binary but that performance gain might be offset by an extremely large binary, which may impact the spin up time.

**RAM**
I did a couple test cases with the ram profile on the new heap allocation and we are sitting at around 6MB start and then hitting 25MB at base usage, then leveling off to around 15MB average and finally, near idle of 11MB.

**Cargo**
There was a cargo mismatch with the dependencies, so we will have to quickly update that with this patch.
After cleaning up some of the rust code and updating `time-rs` crate to the `0.3.36` version, ugh this should fix the build failure.
Let us go ahead and test this with:

```shell
./kbve.sh -nx rust_api_profile:build
./kbve.sh -nx rust_api_profile:dev
```

A quick build and dev command, let me push this all up and maybe it will trigger the build of the image.

**Cache**
The cache within all the workflows have to be updated from `actions/cache@v3` to `actions/cache@v4`.
We are operating with a node version that is not v20 and its throwing some errors around.

<Adsense />

## 2023
- 4:20pm - Time for some of the classics League memes! 
- 4:51pm - After a couple quick sessions of the H, going to switch back to general programming and chilling. It will be a slow week this month, but I am a bit glad that it is because sometimes the extra stress is just not worth it. I been trying to find creative ways to break through those complacent loops, that might also be an interesting app concept for the future. Oh going to clean up some of the branches on the repo as well, now let us think about the general task for the day.
- 5:02pm - We could migrate the structure for the `{content}` folder so that there is a bit of isolation among the different documentation, which would make it easier to implement future tools to help build out the eco-system. One of the concepts I was thinking of was to expand the folder options and letting n8n create new md files without alternating the main `mdx` files. I am writing this idea out as it has been in my head for a bit , yet it would make sense to include it as it could expand the library a bit more and also make it easier to introduce unique tooling examples. The test case that I wanted to introduce was having an `ai` model that would gather information and then store it as its own entity file, then have someone review and parse through it before migrating it over to the documentation. This would mean that the future `ai` tools would not directly produce the content but rather help with the research and data mining. This would mean that the final documentation still has a researcher or human entity element to it and avoid some of the hallucinations that we would run into.  
- 5:22pm - Took a quick break and decided to make a protein smoothie! Now the current issue that I am facing is a bit slower development cycle because of 404 errors that are crashing astro a bit. I wonder if there is a better way to handle that but also those 404 errors are also an issue on the production branch too. I suppose I really should focus to address those 404 errors that keep appearing.
- 5:43pm - I believe I will use a `@l\Shell.astro` for the layout and then wrap each of the md files inside their own notes document. I believe that might be the best course of action in this situation but I could be wrong to an extent? Let me think it through while I drink my smoothie and ponder a bit of life. Hmm, would I want to add each note as its own entity or should I just import them as a bulk metric? I suppose that will be the next step in this adventure.
- 6:16pm - The `@l/Shell.astro` was created and it has the barebone templating system for now, however I am thinking about how I would want to include the glob concept moving forward. There are a couple ways that I could go about it. The current error is `Error: Invalid glob import syntax: Could only use literals`.
- 7:30pm - Need to double check my current credit card balances and make sure that all my money is on point for this month, it feels so weird that we are already a week past the month. 
- 12:00am - Okay it might be the 8th, so I will move these notes over to the next day. But I was able to figure out what would be the best way to handle this situation with the glob and make sure that it would work moving forward. Part of this example will be to keep the `Shell.astro` but add a new `MDX.astro` file to work with! I believe that it should resolve that problem that I was having with Astro globs earlier. 

## Quote

> Let the beauty of what you love be what you do.
> — <cite>Rumi</cite>

---

## Tasks

- [ ] Cover Widget + Astro Concept

---
# August: 8th

> August 8th. Portainer.

Source: https://kbve.com/journal/08-08/

import { Adsense } from '@/components/astropad';

## 2025

### Ingress Disoxide

-   11:50PM

    End of the night notes!
    Most of the day was just updating the nginx and ingress, getting back into that flow since we moved away from traefik again.
    The cluster finally got the external secrets operator, which was something that we needed in our previous RKE2 instance!
    There are two or three more operators that I want to add int our cluster, but that will come at a later date.    

## 2024

**Portainer**
The traefik stack needs to be updated because of a pathing issue.
I will be restarting n8n as well afterwards and then come back around to profiling.
Under the labels section of the docker compose, we need to update the host rule to include a path, so here is the updated version:

```yaml 

        - traefik.http.routers.rust_api_http.entrypoints=web
        - traefik.http.routers.rust_api_http.rule=Host(`rust.kbve.com`) && PathPrefix(`/`)
        - traefik.http.routers.rust_api_http.service=rust_api

```

This will have to be applied to our chisel container as well, and then we can stress test both to see the performance of them in a more real world condition.
I will also split the chisel docker compose into its own file as a reference for future updating.
One of the more interesting aspects would be to build out CI/CD pipeline that can update the portainer based upon the docker compose changes without directly portainer.
Now let us handle the scaling ability of each container, we will start with setting up the `sysctls` within the chisel container!
Side note, we can also set it up so that we have a cluster of possible containers spread out of just the OVH dedicated server.
Once we get the profiling out of the way, we can use fly to deploy a couple of our containers in more remote areas.

- 7:38am - We tried to deploy the `sysctls` within the docker container and the deployment failed, so it might be either on the Portainer side or our docker enigne binarys are a bit out of date.

**loadtest.sh**
For testing out the loads, I am thinking that we could make a quick shell script to help us handle this.
Furthermore, we could extend out the `devops` library to include a quick method to perform the load test against certain applications.
Having the `loadtest` be its own file within the package is ideal, but what name should we make it?

**n8n**
Time to update the n8n instance and the compose for it.
We will try to operate it under the `automation.kbve.com` subdomain.
Updated to the version of `1.52.2` and everything seems to be operational, tested one of the workflows and did not have any major issues.

**Git**
Updated the `git.mdx` with a quick cheatsheet for Conventional Commits.
There might be some that are missing, I will wrap back around and update those.

**Cafe**
Time to take a quick break and grab some food and caffine.

**Memory Fragmentation**
Lets see if we can update the memory fragmentation aspect of the jemalloc and hope to get better performance.
For this issue, I went ahead and set the `ENV MALLOC_CONF="background_thread:true,dirty_decay_ms:1000,muzzy_decay_ms:1000"` to help with the faster fragmentation.
This should then allow us to run multiple replicas that can eat and release hits without any major issues.
Next we will try to expand the configurations for the malloc, here is the next updated environment: `ENV MALLOC_CONF="background_thread:true,dirty_decay_ms:1000,muzzy_decay_ms:1000,lg_tcache_max:16,narenas:4,oversize_threshold:8388608"`

**Tile Map**
Downloading and setting up the editor for the tilemap system.

<Adsense />

## 2023

- 7:30am - There are a couple issues that the RSPS project is facing, one of them would be the general management, which I know could be resolved with creating a custom docker image with NodePy as the base. We know that the python scripts can perform fairly well for general tasks but the deployment and overall management still has to be worked out. Ideally I should look into isolating the modules, such that, they are not specific to any project. I.e NodePy should have its own control panel and the custom python scripts that we use would be just drop in replacements. 
- 8:44am - Going through my emails and I am content with the automated labeling and migration. My total inbox is currently sitting at 68 emails, a couple of the emails did not get filtered through or labeled but one of my n8n workflows was able to unsubscribe from a couple random newsletters.
- 10:42am - I have to map out my call options for this week and it seems that I might have to roll them again for next week. The credit and return is starting to diminish down to less than $500 a week, which would make sense because some of the puts that I am rolling are already a bit deep in the red. I could extend them out until next month and migrate the strike down a bit too but that is something that I would have to over look.
- 12:21pm - I have a major meeting to attend to later today, hopefully it will go well and will not require a huge chunk of my brain cells. To prepare for the meeting, I decided to skip lunch and keep my diet fairly relaxed, so that meant being light on water too. Why would I want to prepare so much for a meeting? I just did not want to randomly have a bathroom break.
- 4:39pm - Okay my total inbox is at around 46 emails, I will see how this performs within the next month! My goal will be to get almost near less than 10 emails, with a majority of them being filtered! The signal base automation seems to be working fine, but I need to prepare for the next staging route, where the automation tools can make issue tickets and even pull requests based upon the emails! 
- 5:05pm - This meeting is still going on! I feel so fucking bored, listening to people talk, throw shade and loop around topics. This is slowly breaking my faith in humanity, the levels of abstract conversation but limited actions have a profound 
- 7:47pm - Watching `Corner Office` right now while doing some general programming! Besides using the new glob Astro layout for tags and applications, I am thinking that I could use for legal too! I should migrate the disclaimer message into a mdx file? I will hold off on it for now, because I want to make sure that it all works in those two scopes before putting legal into the mixture. 
- 8:41pm - I decided to let go of my current padfolio and replace it with two new ones, a specific one for a new laptop and another for storing my journal sheets! The objective will be to make it even easier to look over those notes later down the line. The padfolio that I ended up getting has a small three ring binder inside of it too, but I will hold off on the review until I get the item. 
- 11:07pm - It seems that my method of using glob within a namespace would not work currently, thus I will be closing out the [issue](https://github.com/KBVE/kbve.com/issues/753).
- 11:15pm - Going to push this out and then prepare a new patch for tomorrow.

---

## Quote

> He who angers you conquers you.
> — <cite>Elizabeth Kenny</cite>

---

## Tasks

- [x] - Review the Email Automation Software.

---
# August: 9th

> August 9th. Map Map Map.

Source: https://kbve.com/journal/08-09/

import { Adsense } from '@/components/astropad';

## 2025

### Operator of Secrets

-   10:59PM

    End of the night notes, most of it was just around the secrets operator from the other day.
    Most of today was just relaxing, so this entry will be short.

## 2024

**MapDB**
The first map that we will be building for the initial main city will be around `1000x1000` large and it will be used as the main city of operations.
Let me save the map with the expanded tileset and then I will try to fill it up with as much content as I can.
Okay, we were able to get the base grid and map done, I was able to figure out that `ge_collide` was the variable that was being used to determine if a certain tile has collision.
However, I was not able to test out the different height or elevations when it comes to the tile mapping, but for now I can skip it.

**MadMax**
Decided to spend some time watching all of the mad max series!
The world building for it is great and we should definitely look at making one or two maps based upon the series, grabbing a bit of the lore too.

**Notes**
I am thinking that we could move the notes into the frontmatter for the future reference and then have a script handle the editing of the notes?
This means we would be moving the `notes` and `tasks` into the top part of the frontmatter.

**Proxmox Migration**
Moving the last instance of a local proxmox into the next v8.
These are changes that we need to make within this next couple weeks, then I will have to make sure its moved up faster.

<Adsense />

## 2023

- 12:15am - I should get ready to sleep! Going to spend the early morning setting up Supabase and migrating the tri-force to near perfection.
- 6:24am - SSS Completed. It took some time for my system to boot up because of a Windows update B0UT I am all cylinders ready to go! The first couple course of actions would be to setup the Redis cache system, so that we are not hitting the database too hard with our queries. 
- 7:35am - The n8n and Supabase integration will start with the general profile, I should expand it out slowly as I get more information and time to work with it.

## Notes


## Quote

> Everyone in the world ought to do the things for which he is specially adapted. It is the part of wisdom to recognize what each one of us is best fitted for, and it is the part of education to perfect and utilize such predispositions. Because education can direct and aid nature but can never transform her.
> — <cite>Maria Montessori</cite>

---

## Tasks

- [ ]

---
# August: 10th

> August 10th. MapDB Zod

Source: https://kbve.com/journal/08-10/

import { Adsense } from '@/components/astropad';

## 2025

### Unity Session

-   10:00PM

    Wrapping up another unity session, this time the focus is on the supabase integration!
    The goal for this month will be to link the supabase with the unity client, giving us a better connection between the players and our server.
    Granted we are making an offline / single player game, I just wanted to make sure that we had the multiplayer connection ready so that as we build around the single player, we can extend it.
    

## 2024

**Capital Cloud City**
The name might be better as Cloud Capital City? or Capital City of Clouds?
Within the different parts of the dialogue, we can reference it in latin or maybe our own style of languague.
For `ccc.mdx`, I added all the most recent mapdata that I built in the past couple days, but I am wondering how much of a performance drop we will have with a 1000 by 1000 grid, since we were operating within a small 20x20 grid.

**Zod**
While making the new mdx document for the capital city of clouds, I am going to see if I can make updates to the zod configuration to move the notes and quotes into the frontmatter.
I might roll these three out as an optional frontmatter and then have the `Notes`, `Quotes` and `Tasks` under the astropad as a component.
This would be a similar way to handle the `ItemDB` and this would make it easier for ai / ml functions to actively edit the changes without causing the document to break.

**Rust API**
We are going to be testing the api out with two different sets:

```shell

cd /tools/scripts/public/
./loadtest.sh -u https://rust.kbve.com/ -n 1000
./loadtest.sh -u https://rust.kbve.com/api/v1/speed -n 1000

```

The two routes are important because the first is just testing the `API` as a bare application without having to connect to a remote database, while the second connects directly to planetscale and runs a basic query.
We can expand this loadtest shell file to test a large json query on a production application.
After running the test, we see the performance of the application directly through `Portainer` and we can see that the memory usage after the burst is calming down.
I am also limiting the hits to around `1000` because I do not plan on having more than that hit the specific container at once.
On `Idle-Boot` would sit at around 19MB, after the first hit, it hits around `26.3MB` and then after the second hit, it hits `21.6MB`.

**Laser**
Releasing the next laser patch with the updates for mapdb.
The command for setting up the patch release is:

```shell
pnpm nx release --projects=laser
```

Then we go through the cli and select the minor patch update.
Version bump was successful, we can loop back around and make sure that the new mapdb data works as intended.

**MapDB**
Updated

<Adsense />

## 2023
- 4:30am - The premarket is looking rough but I am going to get ready this early morning to do some general checks around the house .
- 5:15am - I need to look over my current workout, my body is not getting sore and I think that is because my workouts are too isolated and are not yet pushing it to the limits. I should add on more reps and maybe go till failure more often.
- 6:05am - Morning trip to get some breakfast! Today will be a great day, the air is filled with peaceful vibes.
- 9:00am - I am doing a bit of whiteboard style mapping for the Supabase migration, I call this part of my tri-force structure, with that being said, I still need to update the public Strapi docker image and maybe migrate the name to something along the lines of a Logging API or something within that nature? Our holy trinity stack is Strapi, Appwrite and Supabase for now! This feels like a bit overkill within certain scopes but I have isolated each of the elements to be more specific to their purpose. We will be using Supabase as the core authentication for the user management, Strapi to handle the log system and general moderation and finally Appwrite to handle all our edge functions and their abstractions. While Supabase does provide some unique instances of edge functions, definitely within the AI eco-system, I found that having complete control over that eco-system to be a bit more impactful and allows a bit more freedom when building out those micro-services.
- 3:00pm - Lunch time! Break time. I am going to make myself some quick and dirty ramen. I definitely should add more veggies into my diet doe. 
- 6:15pm - I should migrate over the next patch for development, as well as avoid any larger pushes that might hurt the base. 
- 7:00pm - To stay on schedule, I will push through this daily patch and wrap up some of the storage mechanisms that I wanted to deploy. 
- 8:19pm - Started the Login setup for Supabase! I decided that I would try to build it out in Svelte instead of React, just to see how it would work out!

---

## Quote

> You have to believe in yourself.
> — <cite>Sun Tzu</cite>

---

## Tasks

- [ ]

---
# August: 11th

> August 11th. Map DB Integration.

Source: https://kbve.com/journal/08-11/

import { Adsense } from '@/components/astropad';

## 2025

### AC Project

-   05:15AM

    The A Core project is a wow private server that we wanted to build for our local community!
    I been thinking about this for a while, the goal would be to get a near bot based server where the NPCs and PlayerBots would be super active within the world.
    There have been some hic-ups related to this project but with our cluster now being operational, it would make sense that we look into launching this.

## 2024

**Atlas CT**
Next bug to handle is the loading of the `https://cryptothrone.com` within the atlas project.
The error that we are getting is `Error code: SIGTRAP`

Here is the compose that we are using right now:

```yaml

version: '3.8'

services:
  atlas:
    image: kbve/atlas:latest
    networks:
      - public
      - atlas
    shm_size: '2gb'

    deploy:
      mode: replicated
      replicas: 1
      resources:
        limits:
          memory: 4g

```

However we are still getting a bunch of the `SIGTRAP` errors when going through the different test cases.
Still ends up having the application crash, so maybe it needs even more ram, but if that is the case then it be best not to use it.

**NavBar**
We might want to move the navigation bar up within the z-index?
There are a couple graphical bugs that seem to be caused by an overloading the `z-index`.

**Laser**
Updated the `index.ts` to have the exported MapDatabase.ts , `export * from './lib/phaser/map/mapdatabase';`.
I am thinking that we would have to also build out an initilize function that would load the map data.

**MapDB**
Next update will be for using the new tilemap setup!
The bigger issue will be the loading of the `1000x1000` within the browser memory, but this is part of the test casing.
After looking through the possible refactors of the `MapDB`, the next step would be to move the ability to load a specific map as a function from the database?
I am thinking that it would make more sense to do it using a web worker but since this a core part of the game, it would make sense to have it on the main thread.
The function of `loadMap` should be in the `mapdatabase.ts` to help us quickly load the json-based map data.

**DevOps**
The next update to the `devops` package should be ready to be released and deployed within the next couple of hours.
I am going to finish up the base of the map loading and then work around the map issue.


## 2023
- 4:50am - FRIDAY! FRIDAY! It is ducking Friday. This will be an interesting morning as I have to test case the migration of `Supabase`, but honestly it has not been too rough. Svelte has been an interesting route to take because it will be another new framework for me to test out. 
- 6:00am - My sleep schedule has been a bit offsetting lately, I am getting these random urges of just getting to the AI area of the project! I know that I need to catch up to the rest of the team, but at the same time, I have a rather interesting way of approaching the problem. I call it the hackers take, where I need to break the software down and guess and check until I get what I want. The downside of this method means that I have to go through a couple rounds of getting beat up and silly mistakes, BUT it will be worth it in the long run, I know of it. 
- 8:30am - I forgot that I was assigned on one of my TSLA puts, I am glad to have those shares added into my account but the cost basis was a bit too high for my taste. I will roll these shares at the same price point that I was assigned, hopefully I can get rid of them at a decent price.
- 11:07am - We reviewed the migration plan for the Docker eco-system at work and I feel overly confident that it will be able to scale and auto-repair without any major hic-ups. During the development cycle, I was able to spawn a couple quorums of docker swarm, each with around 5 nodes each. We were able to loop, backup and stress test them , achieving a solid network consistency of under 200ms. There are improves that we could do to get it even further down but at this point it is not worth it because the end-users and businesses can not really tell the difference in the speeds, as if you account for the JavaScript rendering on the browser, it alone takes around 900ms, so this is more than optimal speeds. I have to be careful on how I go about this, because I know that I can not share too much information as it would be under the realm of trade secrets but I have done all of this outside of the company's scope and majority of the tools are open source.
- 2:00pm - I am going to test case the front end for KBVE and see if I can at least get through some of the main issues that the company might face. My goal is not to just build out a better front end but one that would minimize the overall usage of Supabase and have some levels of flexibility, including the usage of react components with svelte. 
- 4:30pm - While I take a brief break from the madness, I should look into the directus integration once more for Supabase but there are some issues that I can already see happening, including the large amount of data that will be flowing in and out of the Supabase's db. This might be where I could implement Pocketbase and Surrealdb into the mixture, both of these databases will provide a way to offload the main burden that is held on Supabase, I would think of them as helpers. I suppose another way to look at this would be to implement a proxy-like data fetching component that could be utilized in other areas, similar to the redis-rust-n8n concept that I showed at a meeting earlier this week. 
- 7:42pm - Svelte hCaptcha seems to be resolved, I was able to figure out how to load external javascript files and then interact with them using svelte. I can see where Astro really shines, the fact that I can easily integrate among different javascript libraries is brilliant and make things far more interesting! We will see the true scale of how far we can push the boundaries when I start to integrate 3D modeling into the front-end base. We did this earlier with the Unity Webgl but I want to take things further, mainly to see how far I can improve my front end experience. 
- 9:00pm - I am going to wrap this day's journal up from here and start working on tomorrows journal. 

## Quote

> Nothing is softer or more flexible than water, yet nothing can resist it.
> — <cite>Laozi</cite>

---

## Tasks

- [x] Integrate Supabase into the final tri-force.

---
# August: 12th

> August 12th. MapDB.

Source: https://kbve.com/journal/08-12/

import { Adsense } from '@/components/astropad';

## 2025

### SupaJob

-   03:00AM

    Late night but worth the submission!
    I am hoping to get a job as a growth engineer or maybe in their AI field.

## 2024

**Rust Async**
During the test casing for the memory usage, we were able to solve a decent amount of the bugs and get better performance!
Yet, we still need to go back around and look at how we are handling the async code && functions, furthermore there is the whole issue with the delay with planetscale.
I trying to figure out what would be the best way to lower the speed that it would take for establishing a connection to the remote database but also we should offload some of the resources to a cache-style service.

**Bounds**
The next update to the `mapdatabase.ts` will be the `getBounds` function, which would look something like this:

```ts
async getBounds(tilemapKey: string): Promise<Bounds | undefined> {
  const mapData = await this.maps.get(tilemapKey);
  return mapData?.bounds;
}
```

Afterwards, we will update the bounds of the map and then move towards loading up the NPCs, and to do that, we will need a function to help us pull the NPC data from the map database.

```ts

async getNpcsForTilesetKey(
    tilesetKey: string,
  ): Promise<INPCObjectGPS[] | undefined> {}

```

It seems that putting the full function into this document, causes MDX to bug out xD.
Anyhow, moving forward, after grabbing the NPC details and their position on the map, we can then load the NPCs.
There are two options that we could use, one is having the NPCDatabase aka the `npcdatabase.ts` load the NPCs or we could try to use the Scene itself to handle the loading, hmm.
The next issue we are having is that it is taking a bit too long to load the player into the game and load up the NPCs, maybe we need to see if there might be a better way to load them into the game?

**Player**
Within the player controller, we could also add a function setup the player controller and the player sprite?
I was thinking that it could be its own library but for this situation, it might make more sense to continue using the playercontroller, eventually this class will evolve into the whole player class.
One of the things that I wanted to avoid was building out too many files, trying to keep it isolated but also easier to understand without having to jump all around amoung different classes and files.
Next we need to update the camera to help with the async loading, I am thinking that we could setup a couple effects / event systems to help with the camera panning.
This means we would have to build a future library class known as `camerahandler` and have it perform some calculations on our behalf.

```ts
    const playerSprite = this.add.sprite(0, 0, 'player');
    playerSprite.scale = 1.5;

    const playerBounds = playerSprite.getBounds();

    const targetX = playerBounds.centerX + (playerSprite.width * 3);
    const targetY = playerBounds.centerY + (playerSprite.height * 3);

    this.cameras.main.pan(targetX, targetY, 1000, 'Power2');

    this.cameras.main.once('camerapancomplete', () => {
      this.cameras.main.startFollow(playerSprite, true);
      this.cameras.main.setFollowOffset(
        -playerSprite.width,
        -playerSprite.height,
      );
    });

```

For now, we will keep this simple function and move forward with the next part of the code base that needs to be updated.

**Kill Tony**
Oh I am excited for todays kill tony and still have to watch the NYC series.

**Worker**
The next library that we will be adding to the monorepo will be for a dedicated worker library that all our javascript applications, websites and all, will be using for handling data, storage and communication.

<Adsense />


## 2023
- 12:31am - I spent most of the day setting up and understanding the core concepts of Supabase! The holy trinity is almost ready to be pushed out to the masses, I suppose the next step will be to test case a couple different instances, including the mobile platform. 
- 1:27am - Played a quick match as Shaco support before he gets that long awaited nerf. Okay we know that the session does not preflight, thus we might not need the cache at the general `getProfile`, I suppose we could rename that function to `getUser` and rename `pullProfile` to the `getProfile`. I was under the impression that the session would query against the Supabase but it does not and utilizes the JWT to get the information, which is what we want it to do anyway. 
- 7:56am - Going through some of the current active tickets and trying to tackle a couple minor problems here and there. I want to reduce the amount of tickets that we have active from the `40` to a mid `20` range by the end of this month!
- 8:49am - I think I need some early morning caffeine pumped into my blood flow! Before I head over to get some much needed cafe, I am going to take a look at the structure of mdx -> astro, with the hopes of just making it even more stupid simple. Basically going to migrate all of the website into its own internal content style structure and then have it all render through the contents folder? Maybe not all of the content but at least some of the main structures. This might seem a bit too much of a hassle but I think it might be worth it in the long run because then I could isolate each of the components within their own documentation too. All of this is to prepare for the i18n, which will be another beast in its own realm. 
- 11:14pm - I believe I might have to create a general flow chart or guide on the tri-force approach to the API! There are a couple areas where I am running into issues, including the general authentication flow, but there might be a couple ways around it that we could implement, but we would have to be very careful upon how we approach it. 
- 12:19pm - Finished double checking the backup system and general updates! It seems that one of the instances failed to update but that might have been because it needed to update twice? Maybe after running updates, I should have it double check and make sure that no additional updates are required, but it was a bit strange. It could have been also that the VM was not restarted in a while? Hmm, I placed the information as a note under the vault warden but in the future I want to make sure that it does not happen again... actually I am pretty sure it will happen again.
- 12:21pm - I am typing these notes currently as, err my brain is processing them, so think of these notes as a form of my mind. I am streaming my mind via my heads onto this digital screen, it is for the matrix. Okay so I am thinking that as I am about to deploy this Tri-force API, I would need to make sure that never finish updating the theme on KBVE, as with any crazy person. The new , errr, new new theme would be hmm uhh, Ghost! Yeah I think going with a shadow money wizard gang style theme would be perfect. I suppose I could call the theme Mage instead of Ghost.
- 1:34pm - Time to figure out my first new character for the Gate 3, I am definitely going to go Rogue and most likely have to make a shaco-style character. This would be a great side tool in the future, one that would help people make DnD character names or even a collection of DnD style tools, this was mention before by a couple other people too! These tools should definitely be on my list of things that we must have on KBVE!
- 11:00pm - Wrapping up the whole Gate 3 session, I definitely enjoyed and it was exactly like the meme session that I wanted to play.

## Quote

> All our dreams can come true, if we have the courage to pursue them.
> — <cite>Walt Disney</cite>

---

## Tasks

- [ ]

---
# August: 13th

> August 13th. M3.

Source: https://kbve.com/journal/08-13/

import { Adsense } from '@/components/astropad';

## 2025

### Thunder Thunder , Where Art Thou?

-   11:00PM

    The terrible storms caused massive brown outs that then ended up becoming a black out.
    Without any power, internet and purpose, I wrote most of these entries in the candle light.
    There will no be leaks about it yet, all of the content will go directly into the RareIcon.

## 2024

**M3**
Going to pick up a quicky M3 laptop today and then later on going to order a larger one for when I get back from Italy.
I ended up grabbing the 16gb model for about $1300, which was basically a small percentage of my Nvidia gains xD.

**Italy**
I am going to keep my m1 at home and take my m3 on my trip, this way I have a small laptop that I can travel around with that is extremely light weight and will be a bit more secure.
Not only will I use the iCloud lock service but I wanted to use my rust based one that would operate within the active system.
The rust based storage system is written to use AES encrpytion but is shared and nested with a couple different algos and loops, I also made it a bit of a pain to recover for myself, so if another person steals it, they will have a ton of a fun figuring out what each byte does.
One of the keys that I used for decryption is based upon the location of the file and then there is the git crypt that I have to still plan around.

**Journal**
The schema for the journal configs have to be updated for the `task` and `quotes`, but before we add those, we need to create the schema to store them as well.
For the quotes schema it could just be the quote itself, footnote and the author.
As for the task, that would be a collection of tasks that can be stored as an array, with a completed boolean?
I will think through the best options tonight or tomorrow.


<Adsense />

## 2023
- 10:30am - I am trying to sign up with the Oracle's cloud plan but been running into various issues. It was a bit messy but I am thinking that I might just reach out to their support and get it resolved from their end. 
- 3:27pm - Changing the main background color of the KBVE's homepage to a nice black color. I did not change the template's bg-default to the black because I still want to use that blue but keep it a bit higher in the layer, so that it would utilized for certain actions in the future, like the dropdowns. 
- 3:58pm - I am currently looking at this Ai Hackathon and thinking that I might either form a team or look for team mates that might be interested in forming an alliance where we could work on the said projects together! I will reach out to those that might be interested and see if I can find enough people that might be down.
- 4:05pm - Let me finish up the recovery page for KBVE and then I will shift back to the pocketbase setup. I will create a couple new tickets in reference to the current issues that I want to tackle, so that we can stay organized and make it a bit easier to handle. 
- 4:27pm - It seems that SendGrid is rewriting the URL's with the brandable URL? I am not too sure what this feature is exactly but it is causing some pain points in terms of the usability. I also know that I have only 100 emails per day to send, it would be a shame if I burn through all of those just trying to figure out this mess. 
- 5:49pm - I started to work on the md and mdx structure for different applications and their issues. I will isolate the notes, journals and errors into three basic folders. This will help in the future as we expand the library of information.

## Quote

> If one does not know to which port is sailing, no wind is favorable.
> — <cite>Seneca the Younger</cite>

---

## Tasks

- [ ] LabLab Teams
- [ ] Pocketbase Notes
- [ ] KBVE Recovery
- [ ] KBVE Template Updates

---
# August: 14th

> August 14th. Loot and Work.

Source: https://kbve.com/journal/08-14/

import { Adsense } from '@/components/astropad';

## 2025

### Deranged Realtime

-   07:00AM

    The plan is to just go crazy heads deep into this realtime configuration!
    I am not a person that you want to talk to when dealing with this complete mess of a system.

### FF MTG

-   09:35PM

    Taking a late break from from the regular programming session and working on the MTG deck.
    I think I have an interesting idea for a cloud deck, one that will be extremely broken to use in a game.

## 2024

**Lootables**
The lootables or loot-table is the first game mechanic within our CT and I been thinking through exactly how I want to handle it.
Majority of it will come from the rolling of dice and the results of the roll will determine if you steal something.
The table should include the amount of dice that we would need to roll for the table but then there is an issue of how we would keep that stored, hmm.

**Journal**
Here is the current `config.ts` zod that we are using for the journal:

```ts
const journal = defineCollection({
  schema: z.object({
    title: z.string(),
    description: z.string(),
    tags: z.array(z.string()),
    footnote: z.string().optional(),
    author: z.string().default('KBVE Team'),
    role: z.string().default('KBVE Member'),
    unsplash: z.string().default(''),
    img: z.string().default(''),
    date: z.date().optional(),
    url: z.string().optional(),
  }),
});

```

We can extend out `quotes` and `tasks` as arrays.
Lets start with the first zod for quotes and then we can look into the `tasks` and `archived`.
The quotes schema could look like this:

```ts

const QuotesSchema = z.object({
  quote: z.string(),
  author: z.string().optional(),
  date: z.date().optional(),
});

```

but we could extend it out to include a footnote, as well, which will be a `z.string().optional()`.
I asked GPT to create a base schema and this is what it came up with:

```ts
const QuotesSchema = z.object({
  quote: z.string(),
  author: z.string().optional(),
  date: z.date().optional(),
  footnote: z.string().optional(),
  source: z.string().optional(),
  context: z.string().optional(),
  tags: z.array(z.string()).optional(),
  id: z.string().optional(),
  importance: z.enum(['high', 'medium', 'low']).optional(),
  language: z.string().optional(),
  page: z.number().optional(),
});

```

These are the breakdowns for teach of the schema suggestions, I will this noted for now.

Source: If you need to track where the quote was taken from (e.g., a book, speech, article), you could add a source field.
Example: source: z.string().optional()

Context: A field to provide additional context or background information for the quote.
Example: context: z.string().optional()

Tags: To categorize or label quotes, a tags array could be useful.
Example: tags: z.array(z.string()).optional()


ID: If you plan to reference quotes elsewhere or need a unique identifier, you could add an id field.
Example: id: z.string().optional()


Importance/Priority: A field to denote the significance of the quote (e.g., primary, secondary).
Example: importance: z.enum(['high', 'medium', 'low']).optional()


Language: If the project is multilingual, specifying the language of the quote might be useful.
Example: language: z.string().optional()


Page Number:For quotes from books or documents, a page field could track the page number.
Example: page: z.number().optional()


<Adsense />

## 2023
- 5:00am - SSS. Honestly, I might 
- 6:30am - Going to prepare my notes for a quick meeting for work and I really need to make sure that I get some of the Appwrite functions ready for the hackathon later this weekend.
- 8:00am - A bit of a brutal start for the pre-market, I am surprised that TSLA has slipped so low, it will make for an interesting end of the year, will it hold the $230+ line or will it slip all the way down to the lower bounds of $200? Only time will tell, but there has been a ton of random memes and conspiracy theories floating around. My favorite so far is the one that Elon will buy $X , because he wants the ticker symbol! However, that could really be market manipulation.
- 2:00pm - Spaces time! Going to listen to the X Spaces for the AI hackathon.
- 2:42pm - It was definitely not the best talk to attend, I felt like it was a bit all over the place, honestly it did give me a couple cool concepts/ideas for a future concept. 
- 3:45pm - Spending most of the day going over the flowchart and outlining a complete CI/CD deployment of Appwrite functions from a Github repo. 
- 10:20pm - Finished a quick league session! Oh earlier in the day, I had a 1v1 match with Fudster, the record is 0-1, with me losing! However I know that I did not pick the best runes for the 1v1 and my itemization was not really the best, if I can make wave clearing a bit easier for me then I could easily win the next round. 
## Quote

> Absence makes the heart grow fonder.
> — <cite>Thomas Haynes Bayly</cite>

---

## Tasks

- [ ]

---
# August: 15th

> August 15th. Quote & Task.

Source: https://kbve.com/journal/08-15/

import { Adsense } from '@/components/astropad';

## 2025

### Nginx Kong

-   10:05AM

    Going to end up spending the whole day trying to get the kong and nginx reverse proxy fixed.
    There are no plans to give up, just going to wild out into the eco-system until I get it operational.
    The biggest issue that we are facing is getting the CORS to be operational, without breaking the security of the whole pod/eco-system.
    I plan on also making sure that any front facing application has CORS built into it too, so that we can handle it at the rust level.


### ARURF

-   11:05PM

    The best gamemode that can ever come out for league, its just so much fun to burn through it.
    My plan was to play some BF this weekend but I just do not have the time to deal with shooters.


## 2024

**Quotes**
The quotes plugin for the journal entries should be similar to how we are doing `itemdb.astro`, where it grabs the front matter quote data and then displays.

**PasteBin**
We should place the a KBVE pastebin as a test case, maybe even include the ability to have it cross post onto the Discord?
There could be additional requirements like password protection via AES?
Ideally this would be a test on our ability to utilize the SQL database and also we do need to test out the transactions against the planetscale model.

**FlyIO**
It seems thast the FlyIO service also seemed to remove their free service, according to them it was because of abuse.
For now they have a `pay-as-you-go` plan and will cover about $5 worth of expenses each month.
Now that I am thinking it would still make sense to at least deploy 3 VMs that would act like cache end points to help offset any heavy load.
The 256mb should be enough for us to handle around 10000 active connections each, so the cache pool would be around 30,000 active connections. 
I will try to formulate a way to call those cache endpoints without having it affect the main script, we could setup a simple client side algo to help with that.
As for the flyio deployments, it should still be all done via the github actions?
We could also make it so that it gets deployed as dev branches, this way we can test case our dev APIs.

## 2023
- 6:00am - Still need to clean a bit of my room up, the only mess that is getting me annoyed is around by work bench. 
- 7:27am - Time to clear up the Layout issue with the MDX files. Oh man, the joys :/
- 8:24am - I should make another patch with the `layout:` killer.
- 7:23pm - I been at this for almost 12 hours and I am still running into random errors, ugh! This day is extremely lame.

## Quote

> Nothing diminishes anxiety faster than action.
> — <cite>Walter Inglis Anderson</cite>

---

## Tasks

- [ ]

---
# August: 16th

> August 16th. Configs.

Source: https://kbve.com/journal/08-16/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Kong

-   09:05AM

    The realtimme and keyauth issue between our custom deployment of realtime and what the documentation has is just too much.
    It feels like they are giving us a lack of documentation because they either are moving way too fast and not keeping track, or rather not have enough people working there.

-   02:00PM

    I am so tired today, I am going to a quick nap before the end of the day.



## 2024

**Task**
The task module will be similar to the quote and itemdb, I will throw it into the `Astropad` and then import it directly into this journal entry.
The current task schema would look like this:

```ts
const TaskSchema = z.object({
  id: z.string(),
  title: z.string(),
  description: z.string().optional(),
  dueDate: z.date().optional(),
  completed: z.boolean().default(false),
  priority: z.number().int().min(0).max(6).default(0),
  tags: z.array(z.string()).optional(),
  assignee: z.string().optional(),
});
```

We could write an additional helper function for the `id` to make sure that they are a valid ulid.
Also the priority can be changed to a max of 6 or 7, but I do not think we need that level of an extreme.
I am going to copyleft the `ItemDBTable.astro` and turn it into the `Tasks.astro`, then going to updated the `astropad` package.
We can now call it via `export { default as Tasks } from './src/tasks/Tasks.astro';` and thus import it via `Tasks`.
The tasks look a bit better now and moving them into the frontmatter will help us in the long term!
Next we need to setup the archive but before I get to that point, let me see if I can adjust the looks for the tasks.

As for the tasks that are completed, we want to automatically move those into a different array within the schema.
The new array would be archive or archived, which will still be the array of taskschemas but we will keep them compact and slightly hidden.

**Regards**
Ended up driving close to south jersey to an Indian wholesaler that gets custom clothes manufactured in bulk from India!
Each piece of clothing is unique and close to a one of one, with slight changes released through out the year.
I thought it was a really cool concept to the way that we were planning to design and distribute our merch.

**Wg-Easy**
While I am updating the task schema system, I need to finish test casing the wireguard system.
We want to make sure that all our applications are connected at the wireguard level and that our abstracted mesh system can communicate without having major problems.
There was a wireguard mesh that was setup almost two years ago but its a bit outdated and needs to be improved.
I should get into the habit of updated the daily journals a bit faster and making sure everything stays into a proper sync.

<Adsense />

## 2023

- 5:00am - I am up and ready! I do need to prepare my mornings a bit better, so I am thinking of adding a couple quick ToDos into the mix.

- 6:01am - After SSS, I am going to quickly grab some coffee and slowly shift my mind over to the minor development issues that we are running into on the main `kbve.com` repo.

- 8:18am - Damn it took a bit too long to finally resolve the dev hang!

- 12:25pm - Going to shift over to the `n8n` and also look over some of the documentation for the hackathon this weekend! I definitely want to make sure that everything is good to go by Thursday night, I am currently taking a bit of a hybrid mixture of notes, some digital and some analog.

- 1:10pm - I might have to put some constraints on how I will work on the main repo, I believe that while using the mdx files for i18n integration might not be worth it right now. I may have to go back to it later on, in a different date? This part of the project planning and pathway is a bit tough on a developer's standpoint. I see the benefit of using the mdx files for structuring some of the static content but I can also see where the issues can arise, definitely in the scope of certain projects and their styles.


<Tasks tasks={frontmatter.tasks}  />

---
# August: 17th

> August 17th. Tasks.

Source: https://kbve.com/journal/08-17/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Session - Supabase

-   04:15PM

    The goal for the day will be to get the Supabase integration to at least compile and not break the whole game.
    Ghost has been a great person to work with and I am looking forward to getting it all operational before the end of this month.

## 2024

**Monkey Pox**
Just as we are preparing to go to Italy, there has been a rise in monkey pox cases and it would make sense to be a bit more prepared for it.
I think I will bring gloves and a bit of extra protection to make sure that we are safe during our travels.

**Flight**
Making a unique document with all the travel information and a smart checklist would be useful.
I will add it into another part of this site, maybe extend this out to a future travel collection?
I am still thinking if it would be worth expanding it out into its own folder or series of information, I guess I can write a bit and see the traffic stats over the course of the year.
Speaking of random parts of the website, I should continue to update the recipe section and add more unique styles!
While I am in Italy, I think it would make sense to go on a couple quests to find more interesting foods xD.

**DryCleaners**
Preparing everything with the dry cleaners was a bit of a pain because they did not have experience with cleaning and preparing indian outfits.
I had to plan around this issue and find a cleaner that was way too far from my house that could handle all eight outfits.

**Worker**
The next library that we want to release would be the worker library, which will take the place of `khashvault` and `db`.
We will be moving all the indexeddb actions into this library, but also extend it out to do websockets, sse and a couple more advance techniques.
The worker library will be deployed using this command: 

```shell 
pnpm nx g @nx/js:lib worker --importPath="@kbve/worker" --publishable=true
```

I was thinking maybe calling the library orc or ork for short? A bit of play on words for an Orc and Worker but I think we can move forward without it.

**Warcraft**
A great way to end a Saturday!
I might not be able to get my warrior up to lvl 60 before we have to go to another nation but I will gladly get it to lvl 85 once I get back.
A part of me can not wait for us to get really up there on the levels.





## 2023
- 5:45am - I had to get up early to fix up some of the issues with my roof's sun window? I am not too sure what they are called but there is a leak and honestly, the moment there is a roof leak, you know its going to be a problem down the line.

- 10:11pm - I will have to come back and update today's journal entry after the hackathon because it seems to be causing Astro to crash a bit.

## Quote

> It requires wisdom to understand wisdom: the music is nothing if the audience is deaf.
> — <cite>Walter Lippmann</cite>

---

<Tasks tasks={frontmatter.tasks}  />

---
# August: 18th

> August 18th. SupaBase.

Source: https://kbve.com/journal/08-18/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Late Entries

-   11:07AM

    Journal entry backlog time!
    I was so busy with the kubernetes and talos integration, that I had to take a bit of a step back from the journals.
    I still have them all written down but I will update them when I get a chance.
    Its crazy because it was last year when doing this level of migration again.

### OSRS

-   11:09AM

    OSRS price tracking will be the first major part of the site that I want to add.
    Migrating KBVE.com back from GH Pages to Talos is going to be a huge win.
    Auth is basically set in stone, its just the realtime that has been hitting us hard.

### Disoxide v1.4.7

-   12:14PM

    Realtime Broadcast is working, but how shall we go about handling the next couple parts of the test casing.
    I suppose the broadcasting will be another interesting part to handle thism test casing.
    Before we can do that, we need the realtime demo up and running, so let me get that going.

### Superman 2025

-   08:00PM

    Going to end the night watching this banger of a movie!
    I plan to just pass out while watching it, I been super tired.

## 2024

**Supabase**
One of the most boring aspects of development is going through the point of a rewrite and we might be doing it again.
Migrating from the current planetscale and very minimal image setup to something a bit more advance with postgres.
I did some intense test casing and found that my own version has a better performance but its so small at scale, that it does not seem to matter.
We will go ahead and grab the base docker compose and then look into setting up our own internal supabase for us to use and mess around with.
I am going to move these parts of the note into the `08-19.mdx` because I started to work on them again at around 1:00am.


**Worker**
The command that we want to execute for the worker library will be in the next patch, as I want to get this super base up and running before I have to fly.
I can make it a task to start the execution of the workers after I get some clothes and my haircut later tonight.

```shell 
pnpm nx g @nx/js:lib worker --importPath="@kbve/worker" --publishable=true
```

**Vault**
While I am traveling around the EU, I should make sure that I can still access the vault without having any major issues.
I will double check the access point later tonight before I go to sleep.

**Rustrewrite**
Nothing will be more fun than starting a zero-copy postgres rewrite of the kbve api.
This will make the air flight so much more interesting and I am a excited for the challenge, hopefully I can get the application running before we have to leave.

**Clothes**
I spent way too much time trying to figure out the best clothes to grab, my phat is getting a bit too much.
I need to speed up my WoW grind setup.


## 2023

- 4:00pm - The race is on! Another 2 hours before we start to hand out tasks and individual goals for people! Hackathon mode activated.


## Quote

> Judge nothing, you will be happy. Forgive everything, you will be happier. Love everything, you will be happiest.
> — <cite>Sri Chinmoy</cite>

---

## Tasks

- [ ]

---
# August: 19th

> August 19th. Worker.

Source: https://kbve.com/journal/08-19/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Elixir Day

-   05:04AM

    Today is the day that I finally step into the world of elixir!
    I saw that there is a rustler crate, which is a ffi between rust and elixir.

-   08:39AM

    Moved the `seed.exs` from out of the config file, now it will be called via the kustomization yaml.
    Next, the plan will be to test if it deploys without any issues, then we can focus on improving the seed file, including handling migrations.

### Arcane Rewatch

-   06:26AM

    Arcane is a TV show that really has a great rewatch ability, the two seasons were done perfectly.
    As I have said before, Riot is better at media than balancing their own game.
    You can say they are a media company, with shows and music being their best work, while using crack to fuel their ventures.

## 2024

**Worker**
Time to execute the worker library, I been holding the command off for a bit.

```shell 
pnpm nx g @nx/js:lib worker --importPath="@kbve/worker" --publishable=true
```

Let us start with the base library, I am thinking a singleton to handle the workers?
We would create a singleton worker manager class and then have that manage the different pool of workers.
I am thinking that we split the worker library into two unique classes, the `minion` and the `warden`.
Each browser will only have a single warden that is running but can have a pool of these minions?
The initial load will be a single warden and two minions, but if the user has the resources, we can increase the pool size.
The warden would be the first class that our future main scripts would initialize and that would provide a pool of minion instances for us to reference.

Okay mapping out the different aspects of the task system and warden system, we are getting closer to a functional setup.
For now, let me throw up a bunch of these base files for the general concept.
Afterwards, I will try to test case and see where we can establish a working proof of concept.
Besides adding in the comlink, we also need to make sure that the tanstack query core is also included in this setup!

**Vault**
The vault seems operational, I am going to double check it again right before I leave!
It does scare me a little bit because it is important for me to make sure that I can grab the important details anywhere from the world.
I can not come back to my pc magically when I am floating around.


**Supabase**
The version of `supabase/postgres` needs to be updated on the docker compose to be around `15.6` rather than the `15.1` that was stated within the default compose.
Hmm, let me go through all the generic break downs of the services:

- `studio` - the iamge that was being set from the start was `supabase/studio` but we might want to update that to the `20240729-ce42139` version.
- `auth` - The `gotrue` version that we the docker compose has is set to `v2.151.0` and could be upgrated to `v2.158.1` ? We can look further into this.
- `rest` - The stack version is `v12.0.1` but the latest compose example image has it set to `v12.2.0`, so we will have to see what is getting upgraded.
- `realtime` - Once more the current version is `v2.28.32` and latest version seems to be `v2.30.23`.
- `meta` - The outdated compose has it set to `v0.80.0` and the latest version from the example stack is `v0.83.2`.
- `functions` - Seems to be the same situation for the `edge`, i.e needs to be bumped up to `supabase/edge-runtime:v1.56.0`
- `db` - The big one, it seems that the version they are recommending for the self hosted is `15.1.1.78` and the one that is under the compose is `15.1.1.61`.


- `kong` - `kong:2.8.1` that seems like it will be okay for the current version, so we can keep that the way it is. Could be a good reference to keep track of.
- `storage` - This seems fine at `v1.0.6`.
- `imgproxy` - The darthsim/imgproxy at `v3.8.0` seems fine currently.
- `analytics` - This seems fine at around `logflare:1.4.0`
- `vector` - This seems fine - `0.28.1-alpine`.

Even though I can see some of the pain points that Supabase will bring to our eco-system, the tradeoffs will be worth it in the long term.

**ZeroCopy**
While preparing to launch the internal supabase, I need to start preparing the rewrite of the rust api and the zero-copy reference fun!
I would be a bit concerned with how I will handle the supabase interaction within the api but during my test casing, we were able to get a small api up and running that was under 20MB!
The size of the image was also smaller and the jemalloc made it so much easier to scale out, oohhh the next month will be so much fun.

**Realtime**
The realtime configuration will be fun to build out within Cryptothrone and having each of the NPCs have their own edge functions.
This would make each NPC have unique abilities that could be written in different languages without having major drawbacks.
Granted a python or nodejs process would be slow to run, even at edge, there are a couple cute and cool tricks that we can use!
Having cloudflare deploy wrangler-style functions will be a dope prize for us to obtain this year.

**Flight**
Preparing to venture to Zurich and then eventually to Italy!
I will try to take a bunch of photos and maybe keep a written travel log that I can convert over.

**KiloBase**
The idea of setting up a postgres / supabase image that has additional plugins already setup and ready.
I am thinking that we could call this the kilobase for the time being.

**Airport**
Family got through the airport terminal and the new systems that they have in place makes going through TSA painless.
Furthermore, having some decent internet speeds too, this might be the first time that my airport journey has been amazing.
Well this time and of course the airports in Amsterdam!

**Warden**
The major focus for the worker package will be the warden system and how it will handle the minion scaling system.
I am still a bit on the fence for the amount of resources and power that it will be using, yet I think it will be worth it in the long term.
Next, we have the new types.ts to add into the Worker library, which will start with the very basics and then update it again later on.
I am not too sure if we need to use enums for the TaskStatus but for now it would be fine.
Actually we could use a better way to handle it by having an integer value but we can loop back.

**WriteOnFlight**
Since I will be in the air for a couple hours, I wonder how I will balance out the mini jail.
My usual plan would be to get wasted and pass out, but since the flight is not really that long, the second best option would be to just write away.
I am thinking about how much I will be able to write without having internet?

About to board the flight in about another 20mins.

**PostGres**

I am trying to run postgres from my laptop but I made a big mistake.
I forgot to download all of the extensions, so now I am stuck without being able to run pgvector on the 8 hour flight.
Its okay but I was really hoping to have this resolved in this flight but damn, we have not even taken off.


<Adsense />

## 2023

- 3:37PM - Fixing up the Login system so that it works across multiple domains. I will have to delay any major notes for today because of the current project.


## Quote

> Neatness begets order; but from order to taste there is the same difference as from taste to genius, or from love to friendship.
> — <cite>Johann Kaspar Lavater</cite>

---

## Tasks

- [ ]

---
# August: 20th

> August 20th. Flight.

Source: https://kbve.com/journal/08-20/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Nvidia Puts 

-   04:15AM

    I am a bit scared about the $180 puts, going to roll them again into next week and see if I can capture that premium.

### Realtime

-   07:15PM

    Realtime needs to be adjusted further, I been running a couple experiments regarding the clustering.
    We might not need cluster support for a while, but I do want to make sure that we can do it without breaking the current setup.

### Robots

-   11:50PM

    Just finished this animated movie and going to end the night!
    Robin williams is great when it comes to anything animation, you can see his voice flow into the animated characters.

## 2024

**Flight**
The whole travel time feels like forever, I really hate the shift in time and the amount of delays were wild.
However we are safe in Swiss alps for now, making my way out of Zunich.
Yo, side note, the swiss chocolate is always worth its rep, so damn good.


**Archive**
CopyLeft of the `Task.astro` and then just quickly shift around the tasks.
This is the best approach to the quotes and a couple other concepts we want to add in, better to copyleft and make small changes over time.
I would like to shift the layout for the archived tasks so that they are a bit more hidden and out of the ui/ux.
We could place the archived tasks right in the footer, maybe above the footnotes or just under it?
Ideally the archived section of the data is mainly pointless and could just be deleted, which we should also setup.
After a task has been added into the MDX, it will remain with a reference back to a global database with our private tasks and objectives as well.
The overall goal would be to make sure that all of this is linked but we do not need to keep too much data in the monorepo because it will cause it to bulk up.
Yet having our journal entries be just here, we know that there would never be more than 365 files and it allows us to keep some kind of track of daily movement.

<Adsense />

## 2023

- 11:00am - I am falling a bit behind in sleep and on my notes are a bit off for a while. I will get back onto the flow, it is just my current hackathon is taking up a large chunk of my time. So no major notes for today.

- 4:00am - Ghosts. That is how I am feeling like right now.

## Quote

> Friendship is a strong and habitual inclination in two persons to promote the good and happiness of one another.
> — <cite>Eustace Budgell</cite>

---

## Tasks

- [x] Hack.

---
# August: 21st

> August 21st. This is going to go fast.

Source: https://kbve.com/journal/08-21/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Seeds for Realtime

-   12:10PM
    
    The seeds file works great for a single instance, which is what we want but later on we might need to make adjustments to replica sets.
    By that, I mean we will need a way to make sure that the locks do not run into race condition.

-   03:32PM

    The seeds now have a lock on them

### MariaDB Operator

-   07:45PM

    We were able to get the MariaDB operator running but still need to begin the ac namespace and core deployment.
    Turns out that we az core does not support the MariaDB anymore and that we would need to use MySQL instead.

### Zero Day TV Show

-   08:04PM

    Great mini series that is a mixture of house of cards and mr robot, feels like a 6-7-8 rated tv show so far!



## 2024

**Morning**
The morning flow in Italy is crazy!
So much caffine that is floating in the air, I am like excited to go hang out with the old guys at a local cafe.
The only thing that they dislike is my crappy spanglish, which I understand and the craze of American politics.

**Florance**
The last day in this vibrant city before we head out to the rest of the nation.
I am going to try and see more of the main downtown area and maybe hit up a museum or two.

**Supabase**
For us to move forward with the supabase, we need to make sure that our instance of supabase can not only run but not crash.
One of the parts that I would like to focus on is also making an adjacent version that would not use supabase but indirectly talk with the postgres.
The zerocopy api that would work directly with postgres would be amazing and I would be all for it.

**MovieLibrary**
The greatest invention is the refurbished movie theater turned library.
I am shocked there is not any more of this!
Plus the best coffee is all around you, I think I could write a perfect paper here.

<Adsense />

## 2023

- 12:25am - The ending hours of a hackathon! We got a couple hours to throw the whole application online, I can feel the stress going through my veins. We were having a ton of trouble with docker and appwrite functions, rough.

- 9:59pm - The hackathon is over! I am still stressed out over all the different adventures. I ended up spending most of the day sleeping, had to catch up on the `zzz`.

## Quote

> The Universal Zulu Nation stands to acknowledge wisdom, understanding, freedom, justice, and equality, peace, unity, love, and having fun, work, overcoming the negative through the positive, science, mathematics, faith, facts, and the wonders of God, whether we call him Allah, Jehovah, Yahweh, or Jah.
> — <cite>Afrika Bambaataa</cite>

---

## Tasks

- [ ]

---
# August: 22nd

> August 22nd.

Source: https://kbve.com/journal/08-22/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Nvidia Put Rolls

-   01:10PM

    Before the weekend starts, it would make sense to roll my puts again into the following week.
    If everything goes as planned, we should get a couple more credits for the roll.

### MySQL Operator

-   03:24PM

    The MySQL operator is still not yet functional, we are running into some image issues.

## 2024

**Supabase**
Starting our trip through out deeper part of Tuscanny.
The next couple updates for today will be focused on making sure that the self hosted supabase will work without having any major problems.
The core of the concept is simple enough, building ontop of postgres and keeping the stack open source and focused on maintaining data integrity.
Those areas of the stack can be updated as we build it out.

**CarRide**
The car ride there will be great, we ended up renting out a van and its filled with space.
Gives our legs a bit of room to breathe and I can focus on just the core aspects of the momnorepo.

**Projects**
The next couple cycles within our core project will be to launch a series of core projects.
These can range from some past projects or brand new complex ones , but with the supabase integration, it will be easy for us to scale those out.
Since we will be running a self-hosted instance, we can focus on growing as fast as possible without having to worry about the MAU.
Yet we will try to maintain a level of data integrity, making sure the user that joins has a valid email and has signed in within the past 180 days or x months.
While it would make sense to keep track of the different forms of user data, we also want to make sure we give the ability for users to delete or remove themselves from our platform.

**CityVote**
The idea behind CityVote.com would be to just create a quick and small satire-style website that would be fun to work on!
As for the backend tech, we are thinking that it would make sense to use either AstroJS or Next via Expo?
I am aimming towards an expo style release. 
I wonder if we can launch that tonight without having even the internet?
The monorepo should have everything in place for us to build the core of the site without having issues.

The expo application was added but I am not too sure if we will be able to deploy the whole application right this second because the laptop does not have xcode.
Right when I get to the resort, I will put the xcode onto the laptop.


**DiscordSH**
The next move after getting the core of cityvote up and running would be to get the discord sh service going as fast as possible.
After the self hosted postgres and supabase are added and we have the completed test case, we can easily launch it ontop of it.
That would mean our future discord bots would have direct access to the supabase infra, as well as edge functions, would could be great for an AiO Discord bot. 

**Expo**
I was having a weird bug with expo , so I will keep this in my journal as a note!
Here was the command that I ran to update it so that I could access the developer console faster.
```sudo xcode-select -s /Applications/Xcode.app/Contents/Developer```

<Adsense />

## 2023

- 6:34am - My sleep schedule might be a bit off for right now but I will be working on getting it back together within this week. 

- 7:43am - Going to sync the repo with the dev branch and then start to make notes on the mL and Nodepy. To grab the appwrite key, I did a test case to see if I could read the variable.

```javascript
  router.get("/app/app/", (ctx, next) => {
  try {
    _v(`{r} -> app -? ${process.env.KBVE_API}`);
  }
  catch (error) {
    _v(error);
    ctx.body = {
      status: 500,
      message: error,
    };
  }
});

```

- 7:44am - Let me sync the repo.

- 7:50am - There were a couple errors with the sync going to fix them up after work.

- 9:30am - The market looks like a bull trap, honestly I am hoping that the feds do another pause on the rates and keep the slow increase going. 

- 9:33am - Going to clean up some more of my notes and maybe use a bit more of the GPT.

- 5:32pm - Off of work and now I am going to see if I can push these notes through.

- 9:25pm - Added charts to the stocks but need to do some more updating and configurations! There are a couple of interesting test cases that we could pivot around and make a bit better for `meme.sh`.

- 11:16pm - I went through the RentEarth and was able to clone and repo through everything, I should make it into a template in the future but for now this seems to be more than good enough.

---
# August: 23rd

> August 23rd.

Source: https://kbve.com/journal/08-23/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Branch Rework

-   06:03PM

    Decided to let go of the multi branch and decided to stick with just forks from main.
    This is because I think it might have been overkill, like our quad branch system earlier, and now we only pull from main.
    I was against this for a while but since I am the only one that does 90+ percent of all commits, this might be the best move going forward.
    We will have to update the unity libraries around this as well.

### No Nested Branches

-   07:14PM

    This deserves its own note, because its a big point in the future moving forward.
    We no longer have a dev branch, just like dropping our alpha and beta branch!
    Now its just main + off-branches, a bit of a stepback but it is what it is.

## 2024

**Wedding**

Today is the end of the most important aspect of our trip to Italy!
My cuzin getting married inside the heart of Tuscanny is super dope and definitely romantic.
This trip is making me think twice about my life goals, makes me do that double check swing.


**Expo**

In between the events, I am taking a small breather and doing some general test casing.
Expo always feels like a pain to setup and build on, but I need to get an application up and running before the end of the month.
We want to make sure that there is a fully functional application for us to manage in the fall of this year.
Hold up, Nx can automatically update the code for my expo applications to the latest version that I would need?
This is actually super useful, saves me a bunch of headaches and indirectly a bunch of time as well.

In the future we could extend the shell script to create a new branch off the dev, run the update and then make a pull request with that update?
I suppose in that situation, we could also have it run a bunch of tests and handle some of the dev cycles for us as well?

For future reference, the command is:

```shell
pnpm nx install expo-cityvote --check
```

But I am thinking we could extend it out into:

```shell
./kbve.sh -autodate
```

This could then be done via github actions too, that would be an interesting avenue to take?
We are getting a step closer to self learning and self building code!

**Build Failure**
While going through the latest journal entry, I forgot that certain original markdown might cause issues.
In this case, it was looking for a `notBetween` function , uh basically I have to becareful with mdx, because I could inject random javascript code without thinking it through.




## 2023

- 8:10am - I believe I got the general flow of the docker container! Yay!

- 6:51pm - Going to sync the notes in between the sessions. Okay, now I need to add github actions to the `NodePy`. so that it can build the images without having any major issues. As for the key storage, I am thinking that it would be an AES style encryption, so that there would not be any major issues. 

- 7:40pm - I added the docker image creation test casing, under the workflow. Going to add the Clarifai Python and then maybe cargo too.

---
# August: 24th

> August 24th.

Source: https://kbve.com/journal/08-24/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Session

-   10:50AM

    The unity session for today will be to hook up the realtime via guest mode!
    Afterwards we can work out the kinks related the realtime, broadcast and presence.

-   09:50PM

    Spent the whole day getting the realtime and auth setup!
    We were able to get the auth to be operational and we were able to make a change to the postgres database!
    The only issues are now in two areas, the broadcasting and presence.

## 2024

**Expo**

I forget how much I hate and also enjoy the world of expo!
Making a couple quick updates and check-ins before going straight to sleep, I am tired and had a long day.
The wedding is over and now I am about to rest, calling it a good night.

**WoW**

Trying to install WoW on my m3, but I am not too sure if I will be able to run the whole game tonight!
I do have get some rest, but knowing that it can be installed and runs on native m3 is a huge win in my book.

**Lucca**

Traveling around some more remote parts of Italy and I can not wait to ride the trains around.
There was a point where I want to train hop and free float like a homeless bum throughout Italy.
However I do enjoy my sleep and a warm shower, but If I could get away with it, I would.

**New Fabric**

The core of RN is going under a new framework with the release of react 18 around the corner.
This new framework for react native should be easy to integrate and add into our eco-system, but there will be some minor changes that we will have to do ahead of time.
We need to pass through all the variables to enable the new framework but also make sure that it will not break anything else.

**Legal**

Under the current legal framework, there might be adjustments that have to be made!
The next update to the legal docs will have to come around mid Sept or late Oct because we will have to find a new team to work with.


**SupaBase**

I delayed the setup and deployment of the supabase because the compose was not yet ready.
We shall try the first deployment this week and with the goal of getting it running before end of Q4.
For this, we will have to make adjustments to the compose


<Adsense />


## 2023

- 8:40am - Nvdia's bubble is insane but also the fact that they have a margin of around almost 70% is mind blowing. 

- 9:45am - Okay we are seeing some pull back from the markets but I need to focus on some of the stuff for work, so I will keep this journal a bit small in that sense.

- 6:00pm - Finally finished up with the general work related tasks, the backup recovery is still having some issues that I need to migrate and fix but I will test case that on my own time. 

- 7:20pm - Currently making sure all my accounts are ready for the hackathon tomorrow and that includes making sure we have the basics out of the way. 

- 8:08pm - There was an issue with the Business operations aka BizOps document not rendering the graphs, so I will fix that right now.

---
# August: 25th

> August 25th.

Source: https://kbve.com/journal/08-25/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### TurtleWoW

-   09:07PM

    Started an orc shaman and a goblin warrior, both on the horde side to see what is up with the turtle.
    I am liking what they have done with the starter zones, expanding the map a bit was a great idea.
    This could be considered as a form of research, one day I will launch that private server and see what we can learn from this.
    The tent system that they have is a bit whack, I get the idea of boosting up the rested exp gain but its just not worth it, feels a bit OP.

## 2024

**Roma**
Taking the two hour train from florence to rome but it means that I also know that this is an option in the future.
I was surprised with cost but its been pretty nice because we did take a small train around to get to here, so it could be seen as our reward!


**Drizzle**
There will be a couple changes that we will be doing with the `kilobase` project, the first will be the utilization of a couple different applications.
The first application will require a drizzle style integration, similar to that of planet scale but more focused on.
Ugh, we will have to setup the project folder for kilobase and work around it.

**KeyValue**
The more I was thinking about a key value system that would operate like redis/mysql but open to the whole world, kinda like a tracker but with the goal of offering small size key + value storage?
It could be so that the day is in JSON when being stored and grabbed, or we could work around making it a bucket friendly approach? 
The real goal would be to find a way to keep the sessions short enought that the data gets deleted within a reasonable time period.
We can also make this global key-vaule system utilize some of the cooler aspects of rust and planetscale, it would let us push the storage really in and out there.
The next question would be how large would we want to keep the key and value?
Wait, we could just make all the keys be the `ULID` and then have the data object attached to them?
This would help solve our time issue because we can check the date of the ulid ahead of time and we could work from there and try to establish other types of ulids.
That means the key is a binary 16? We could also just offer a straight bigInt as well, eviction based upon the large number object.
Okay the final part of the three key would be a hash? but I feel like that might be a bit of overkill, so we can try to be a bit creative with how we want to handle this.


<Adsense />

## 2023

- 8:00am - Getting ready for general roll call. We got another hackathon later tonight and this whole weekend, I am excited about it!
- 1:30pm - Started the backup test casing, defining the terraform for the recovery test case. For the backup plan, I believe I should aim for about once a quarter? Maybe we should do it a bit earlier. Hmmm... this Friday feels a bit slow for me, maybe because its about to be the memorial weekend? 
- 2:20pm - Finished the Claifai stream and now I am going to start working on the PAT / Personal Access Token for their service. 
- 4:45pm - One of the bigger issues with the 

## Quote

> The industrial landscape is already littered with remains of once successful companies that could not adapt their strategic vision to altered conditions of competition.
> — <cite>Ralph Abernathy</cite>

---

## Tasks

- [ ]

---
# August: 26th

> August 26th.

Source: https://kbve.com/journal/08-26/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Turtle WoW

-   06:15PM

    Running around the whole realm of Durotar to see all the new additions to the map, its a decent amount of changes but nothing too crazy.
    I understand the classic plus vibes that they are going for but I would have hoped they would make some adjustments to the pvp side of the talents and spells.
    Seems that I am having a tough time running the WSL on my laptop, might have to either upgrade the RAM or look for a new model to replace this laptop.


## 2024

**Roma**
The city of rome is way too crazy, I can not keep track of time or myself haha.
I forgot to update the daily journal, so let me throw some entries around.

**Postgres**
We will have to prepare for the postgres migration and setup.

**k8s**
We will have to prepare for the kubes.
The migration will require someone to help with the flow.
We have a couple different kubes to run and mess around with, hopefully we wont run into issues.

<Adsense />

## 2023
- 8:31am - Mid day during the Clarifai hackathon! Let us see where we can get within the day!
- 7:13pm - Fixing up the front end template and then going to add a couple different functions to call.
- 10:19pm - Damn lost my first flex ranked match on league, but its been a long time since I played. 
- 10:56pm - Cleaned up some of the house and now for some Baldur's Gate with the Zs.

## Quote

> The hours of folly are measured by the clock; but of wisdom, no clock can measure.
> — <cite>William Blake</cite>

---

## Tasks

- [ ]

---
# August: 27th

> August 27th.

Source: https://kbve.com/journal/08-27/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Laptop Replacement

-   08:16PM

    Might be time to replace my older laptop because the WSL instance is just hanging way too much.
    Yeah I am going to start shopping around, waiting for over 80 seconds to confirm that a file has been saved is way too much.
  
### IronJedi on TurtleWoW

-   11:00PM

    The plan is add a bunch of easy macros to use and get the shaman all the way up to 60!
    I might also look back around and try to make a lvl 19 twink, as part of the research.
    Furthermore, I should loop back around and see why the AzerothCore seems to fail at starting up.

## 2024

**Roma**
I will update this entry when I get back to the cafe.


**Expo**
Let us go ahead and setup the hqplan deployment.
The plan here would be to run a couple series of developments.

## 2023
- 3:10pm - I need to wrap up building this `backup` plan for work, I am going to extend it out to around 50 pages and then add a ton of graphs and visual aids! I know that it will have way too much information and no one will really read it but that will be on me to tell them over and over. I want them to memorize it once its completed! Then in a couple years, I will release it under this repo.
- 5:04pm - Daily chores are out of the way, now I am going to fix up the Docker. 
- 8:56pm - Added loadash to the docker image, I should push that out for now and fix up some of the notes that I would reference.

## Quote

> Where there is love there is life.
> — <cite>Mahatma Gandhi</cite>

---

## Tasks

- [ ]

---
# August: 28th

> August 28th.

Source: https://kbve.com/journal/08-28/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Nvida Post Earnings

-   5:00PM

    Those $180 puts might expire without being called, which would be great for the next following week.
    It would mean that we are back at around $130K cash that we have sitting around to play with.

### KBVE Update

-   08:14PM

    Planning to migrate the KBVE website out of the Github pages and into a custom axum deployment, with an API gateway that sits in-front of it.
    So we will have to configure another instance of kong to help us handle that, while also preparing the axum deployment of KBVE.


-   11:38PM

    The new app/project will be codename hyperlane!
    I am going to start the basic build off tonight and then look into expanding it later this weekend.
    We should not have any major issues with the deployment but the general route configuration will be the main focus.
    

## 2024

**Roma**
Running around the city again today and just looking at all the sights.
I found out that office 21 was closed and its a shame because I really wanted to work out from there.
Now I need to find a place in rome that has an epic view , amazing wifi and is not too expensive.

**Villa Doria Pamphili**
Decided to make a quick date with a lady that I befriended!
We did a couple sandwiches and a general walk around the park, it was actually super fun and we had this amazing connection.
Rome is truely a magical city, the moments you can just build those connections, its actually wild.

**Expo**
The other update that I have to do for the repo is to make sure that all of expo will build without having to download anything.
I believe we need to create a prebuild folder for ios and android, then setup the files for it.
We will have to do this off of wifi because I do not want to burn through my data.
Lets go ahead and have groq update the app.json, and slowly perform the changes to prepare the general build.

O M G! 
I forgot to setup metro to use the tamagui configuration, which would explain part of that bug I was having earlier.
This is the first time that an AI really got a problem resolved that was way out of bounds for it to understand.
I am amazed with this setup!

The animations need to be replaced, but what type of library will we use to help with that?
I am thinking we could expand out the `expo-bbq` package and include a bunch of animation integrations that we can then call in our apps.
We could try to get the animations on the main ui thread too, since we can move all the complex logic off to a worker thread?
Let me zeta this journal entry and switch back to a proof of concept.

Cleaned up some of the metro configurations and made it a bit easier to read.
I am going to swing back around and make some open source documentation that will be in our javascript application mdx.


**KiloBase**
The idea behind deployment of `kilobase` is that we take the exisiting supabase image and then wrap around our custom changes.
Since we want this postgres database to be large and powerful, we can make changes at this core level, thus making it easier to maintain.
Furthermore, we could also create another image called `cachebase` that would be focused on providing a read only instance of supabase / postgres, that has further tweaks to focus on providing a cache of the data.
For setting up the core kilobase, we should make the .ts file that would be similar to our planetscale file.
My idea would be to have all the base postgres configuration inside of this file, including the model design and initial migrations.

As I am writing it out, it feels like we might be going backwards.
The usage of drizzle is making the supabase / postgres interaction a bit too rough, maybe we can find a better way to handle this?
We could setup the postgres to operate with the raw variables and then work around that.

**Nx**

Trying to migrate the repo over to v19 but I am have a bit trouble finidng a strong internet connection to do it with.
Sadly the wifi is too slow to perform these migration tests.
However we are still waiting on a couple packages to either update or move to a later version of v19.

**Warden**

<Adsense />




## 2023

- 8:30am - Getting ready for the day, I been slacking on the daily journal entries because I been so backlogged with learning a bunch of random new things! We had to skip a hackathon recently because it felt very unrated and I just did not have the time for it. I suppose doing a couple hackathons back to back is not yet in my timeline, plus my sleep schedule has been taking a hit.  

- 9:45am - Besides doing my morning trade setup, which includes selling weekly call options, I been thinking that I really need to start expanding out my time table and switch over to a more specific block time. 

- 11:00am - Updating Astro to the latest version! Let us see if we are able to run the `v2.10.14`!

- 9:35pm - Going to update the repository and make sure that we are able to run Astro at the latest version.

- 11:17pm - Okay everything was pushed through for this repo.

## Quote

> If you are out to describe the truth, leave elegance to the tailor.
> — <cite>Albert Einstein</cite>

---

## Tasks

- [ ]

---
# August: 29th

> August 29th.

Source: https://kbve.com/journal/08-29/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Headers

-   05:14PM
    
    Looks like under the the Supabase options, we will heave to add a custom header.
    So maybe we need to refactor the realtime for supabase to basically become a supabase manager, having that instance handle the setup and data.
    That will be our goal for today and also the hyper-lane deployment.

## 2024

**Train**

Leaving Rome once more, its been almost a decade since I was last here.
Next time I am going to come here with a bunch of helper notes.
A world wide scavengar hunt is also a cool idea for promoting Rent Earth.

**Postgres**

We could split the global key value storage but I think it might be fine to just use it within the postgres database.
Having it stored and saved at a core level within the postgres but then being pulled out and into redis would just save us time in the long term.

**Florence**
We are about to arrive in my favorite city in the world!
Well, Rome is not bad at all, I do believe it holds a great place in my heart, there is just something about Flora.
Maybe a trip to Siena next? 
Hmm, that is making me wonder if its worth the time investment to plan around a quick day trip.
Actually this would mean that working remotely and traveling around Italy for short bursts is possible without any major pain points.
Now I just need to find a girlfriend that can the same with me, ideally another software engineer and we would be set.


**Minions**

Going to focus on the minions folder for the worker script.
While I am working on that, I am also preparing the next batch of updates for the postgres and hqplan revamp.
Ugh there are a ton of moving parts that need to be cleaned up and updated but there is never enough time.
I am going to split the minions concept into a folder with about three to five files that will be the core of the whole system.
This is the current breakdown for these files within the Minions folder:

- minion.ts handles the creation and setup of Web Workers.

- minionWorker.ts is responsible for the worker's entry point and exposing the MinionImpl.

- minionImplementation.ts contains the actual business logic for the MinionImpl class.

The new `minion.ts` will look like this:

```ts

import * as Comlink from 'comlink';
import { MinionImpl } from './minionImplementation';

export function createMinion(id: string) {
  const workerUrl = new URL('./minionWorker.ts', import.meta.url);
  const minionWorker = new Worker(workerUrl, { type: 'module' });
  return Comlink.wrap<Comlink.Remote<MinionImpl>>(minionWorker);
}

```

**Food**

Took a break from programming and decided to venture around the city.
I am actually enjoying this vibe so much better than I was expecting, the amazing combination of being able to do all my work in the morning and then roam around the city.


**Church**

Did a loop around and looked at all the churchs again, and its a shame they stop making these masterpieces.
They really hold the community together and give the whole landscape a majestic vibe, in terms of lighting, shade and atompshere.
The churchs provides a metaphysical shelter for all, while you walk around it, a deep feeling of peace and safety.

<Adsense />

## 2023

- 9:13am - Getting ready for the markets to open up, but before I do that, I should make sure everything is in sync. I will publish out this branch really quick before going a bit deeper into the deployments.

- 12:40pm - It seems that everyone at work was pleased with the backup plan and writeup that I did, I played deeper into the "Trump" style presentation, keeping to simple and short words that got the point across. I r regarded.

- 5:15pm - I am currently doing a bit of R&D on the different paths we could take for the file system management, which would also include the backup storage and the restoration. While my documentation can provide a decent roadmap for where we want to go, I think sometimes the time spent mapping out should not be overloaded because there will always be interesting and unique edge cases that will take a large chunk of time out of the implementation. This is just really a note to my future self on how to tackle those issues. 

## Quote

> There is no greater harm than that of time wasted.
> — <cite>Michelangelo</cite>

---

## Tasks

- [ ] Research File Management

---
# August: 30th

> August 30th.

Source: https://kbve.com/journal/08-30/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### KBVE Hyperlane

-   11:05PM

    The next major update to the kbve website is almost ready, we are still stuck on a couple deployments, like the studio, realtime and edge functions.
    The hyperlane has already been tested with the disoxide build, so that will not be an issue that we should be worried about.
    Goal will be to help make it easier for us to control the KBVE website, rather than it be just a static website!
    Axum should be great for us to build and scale, while having all the perks of astro to our benefit.

## 2024

**Firenze**
I am so used to calling this place florance that I forgot how fire the original name sounds.
We will be here for the last of our trip, flying out tomorrow and I am going to miss parts of this city.
The only way that I can think of ending this perfect trip is to do some work in my favorite movie theather.
Followed by the best espresso right next door, I can not think of a better place in the world to do work. 
The amount of style here could also compete with japan.
Now with any good time, we have to take it with a fair and balance approach, I would not want to live here doe.


**Portainer**
I am currently mapping out the portainer changes that we will need to deploy for the rancher / kube stack.
The best suggestion would be to get all the main proxmox instances up and then work from there.
I believe we also need to get a couple more of the expo applications built out and deployed when entering the dev and main branch.
There might be a weird feeling of having to do multiple apps at the same time but it makes it easier to test case different parts of the build and to see how they affect performance.

**NotAllWeb**
The otherside of this build process would be to remove the core focus on mobile + app , and just have an amazing astro application that runs near native on the phone.
The Worker library will be in charge of making that happen.

**Worker**
Going to grab a quick expresso, enjoy a bit of the outside before coming back into the Odeon.
The goal today will be to finish up the warden class, whom will be in charge of the minions!
Part of the test casing will be to have the warden issue off-thread commands and processing to the minions and return back the results.
Then we can move forward with setting up the edge functions and supabase integration.
The edge functions will be split into a various collection of global and local servers, the goal would be to pull in and out as much information as we can for now.
Having the focus on speed is something that we can overlook for now because we will not have enough data to perform the changes that we will require.
Once the supabase is ready, we can start to expand out and collect users, aiming for around 10,000 users before the end of the year is a bit of a strech but I think we can do it.
To test case the worker library, we will be using this command to help us:

```shell

pnpm exec nx run worker:test 

```

or in the case of the kbve shell, it would be:

```shell

./kbve.sh -nx worker:test

```

The next issue with setting up our test casing is that we are have debug the `indexedDB` and it seems that our current testing environment does not support it.
After doing some quick research, it seems that the best approach would be to use `fake-indexeddb` to help fill in the gaps.
This makes me a bit worried about the concept of testing this library if we need to need use more third party tooling but we should go on this adventure regardless.
The goal would be make sure that our 30 example tests are all functional and we can move forward with publishing the package that we will be using in the future.

To install the `indexedDB` for test casing, we will be running this command:

```shell

pnpm install -D fake-indexeddb

```

which will be providing us with the fake database to play with.
It will be a bit painful to keep adding more extensions and as this project grows, but I can see each package that is being added and I understand its premise.

**Warden**

I will move the notes for warden over to an official documentation once its built out.


**New Items**

Taking a break from the design and building of warden, we can look at adding new NPCs and items to our tiled map but this goes back to another issue where we need to fix the map.
Loading the map tiles into png and then having them merge into a final map is a bit annoying, so I am going to give Unity a huge plus one for making it so much easier to optimize the maps.
I can not believe the biggest hurdle ends up pushing us back to doing code inside of Unity 6, but I will wait for that, maybe do a whole new game for that engine.
We want to finish at least one game before the year ends, then once its published and gets its weekly updates, we can focus on adding a new 2nd game.
Actually, I take back the weekly updates and think that it would make more sense to do a full monthly update but roll in the updates in small minor changes without breaking the game.
Common monthly updates should include new NPCs, Quests, Items and nomial changes to the game play before we get deeper into the combat.
After getting combat resolved, we will have a working demo within a couple weeks, since a good portion of the game loop is done.

<Adsense />

## 2023

- 7:32am - Going over some work emails and getting a general vibe going to today's hackathon! It is a 24-hour Audiocraft hackathon with no major prizes but I always wanted to generate music, so I figured this would be fun regardless.

- 7:51am - Migrate the notes and general flow of the hackathon into just one area that we can look over and use to communicate / reference.

- 9:30am - Updated the main repo to Astro v3.0.0 and now I am going back to the general updating of the music hackathon. We might not use Astro for the time being until I can make sure that I am comfortable with the v3.0 series from them, but they definitely handled it really well! The breaking changes were really easy to resolve and their approach of granular tweaks is amazing, definitely one of the best examples of version control on the market to this date. 

- 11:00am - The realm of browser extensions seems to be hurt by the different levels of version control within the manifest. It seems to me that Google is making it way too complicated with their version 3 and as they scope into the different permissions vectors, they are adding a bit too much complexity to the whole structure. I suppose there are concerns with privacy and the levels of which extensions can undermine? Why surf the web with a VPN but have insecure browser extensions?



## Quote

> A noble one produces an abundance of merit by having a compassionate mind towards all living beings.
> — <cite>The Buddha</cite>

---
# August: 31st

> August 31st.

Source: https://kbve.com/journal/08-31/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Supabase Studio

The studio seems to be an issue, I am thinking that it might be another problem that I need to fix.
All my WSL instance has been crashing, so I think I will have to either replace this laptop or find another solution, maybe just drop all of the windows operating system.
I need to also update my homelab, proxmox v9 is looking pretty solid.

## 2024

**Firenze**
The last couple hours of florence!
The river is amazing to look at during the sunrise but that red sunset was wild.
Also the hot air balloons that are cool to look at floating around the sky.

**NiceHash**

Before the end of the year, double check the nice hash session and see what changes can be made.
We are only making a couple dollars a day from nicehash, which need to be automatically sold off and invested into reits.
The graphical mining market is very much dead and we are really close to reaching the general end of crypto mining.
Our best bet right now would be to consolidate the capital and focus on a new blue ocean.

**Airplane**s

The whole programming while flying is not an easy skill to master but a combination of saving constantly and rotating to paper is very helpful.
Sometimes, its a bit tough to collect all your thoughts while your mind is floating and zoning in and out of space.
The sky is so bright, there is just an abundance of different light.

**Vintage**

The idea of being able to find vintage clothes through image process and color matching does make sense.
However the cost bases to run those operations at scale and the general returns would be terrible.
Unless you could get the consumer to buy into a more premium market, yet with fast fashion eatting up the lower end of the market, hmm.
There could be a new market where its just focused on extreme durability and long lasting, you are no longer selling just a jacket, you are selling the story of the jacket.
From where the jacket is being created, by whom it was created by, their life and their art work goes into your hands, hmm it could work.
This goes into the whole limited edition sets of work and unique trends that I am seeing in the techie clothing industry so far. 
Focus on a limited collection and maintain the hobby and unique collaberation amoung the various artists, designers, merchants and consumers.
If the margin can be kept at around 1500 basis points but with some extremely rare items thrown into the mix, we could easily reach around 2 million in just sales volumne and a healthy margin of 400,000 usd.
That would take some time to plan out but the core plan could be done within a couple months.

**Worker**

While flying in the air and lack of internet does make it a bit tough to finish up the worker library.
I did end up getting the readme updated and the package json, but I would still have to finish the ci-cd pipeline for the release of the package.

**Internet**

I am debating if it would be worth paying the 30 and getting the internet, but it just seems a bit overkill for now.
However, it would have been dope it tmobile just started to offer roaming on the airplane, like giving all the tmobile flyers a bulk amount of data when they renew.
Just like how airliners have a miles program, it is really a shame that tmobile does not push a datas program before any one else gets onboard!
I think cornering the market on the data points would be great, giving people bonus points for being a commited tmobile member.
Actually, thank god for net neutrality or we would have seen some wild monoploies from, like a "Free Netflix In Flight" and ... well actually that could be a good case against net neutrality.


**Items**

When we plan around releasing new tiems, I think that it be fine if we focus on adding new items and adjusting the item values. 
However, we should do our best to limit the removal items, as we should find more creative ways of using each of items within our eco-system.
We eventually want to grow our own internal in-game economics but that will also require a vast amount of thinking and planning.
Nothing makes it more fun than having to play the federal reserve simulator.

Here is an example of the frontmatter of the magic nemo:


```yaml

    - id: "01J269PK47V1DWX2S1251DEASD"
      name: "Magic Nemo"
      type: "food"
      category: "consumable"
      description: "A magical fish that will fuel your wizard powers. You are now a harry wizard, becarful of pots."
      img: "/assets/items/food/fish/magic_nemo.png"
      bonuses:
        health: 10
        mana: 100
      durability: 1
      weight: 1
      consumable: true
      effects: "Heals 10 health and 100 mp, but be warn, there are dangerous to be had."
      stackable: false
      rarity: "common"
      levelRequirement: 0
      price: 500
      cooldown: 120
      credits: |
        Magic nemo asset was made by Roku6 - https://roku6.itch.io/pixelfishes    

```


The item goes by the ulid of `01J269PK47V1DWX2S1251DEASD` aka the `Magic Nemo`, however the item should include another ulid as a reference for any action or effects.
This then goes back to structuring the itemdb and making it easier to process in the future, also adaptable enough to shift the requirements without breaking the whole game.
I am going to keep working on this part of the code base until I get it nearly perfect, but even then I know that will not happen.

We will have to come back around again in the future and update the itemdb again because we have to account for item equipment , durability and rarity abit more.

**Atlantic Blue Marlin**

```yaml
    - id: "-generate-new-one"
      name: "Atlantic Blue Marlin"
      type: "food"
      category: "consumable"
      description: "A marlin from the East Blue Sea, once home to the greatest chefs of the old era. A fish that should be shared with everyone, even those in need."
      img: "/assets/items/food/fish/atlantic_blue_marlin.png"
      bonuses:
        health: 100
        mana: 100
      durability: 1
      weight: 1
      consumable: true
      effects: "Heals 100hp and 100 mp, for you and another 50 hp and 50mp for everyone around you!ß"
      stackable: false
      rarity: "common"
      levelRequirement: 0
      price: 500
      cooldown: 120
      credits: |
        The blue marlin asset was made by Roku6 - https://roku6.itch.io/pixelfishes    
```

This fish will have a special mana effect that will happen when eaten, which will give everyone near the person that eats it a bonus amount of mana.
I am thinking that these could be carried by a mage / support in the future to provide mana for everyone in the party.


**Dora**

```yaml
    - id: "-generate-new-one"
      name: "Dora"
      type: "food"
      category: "consumable"
      description: "A fish that might cause confusion."
      img: "/assets/items/food/fish/dora.png"
      bonuses:
        health: 10
        mana: 100
      durability: 1
      weight: 1
      consumable: true
      effects: "Heals 10 health and 100 mp, but be warn, there are dangerous to be had."
      stackable: false
      rarity: "common"
      levelRequirement: 0
      price: 500
      cooldown: 120
      credits: |
        The dora fish asset was made by Roku6 - https://roku6.itch.io/pixelfishes    
```

There were a couple more fish that will be added into the game this month of September!
We want to make sure that we can have these two get added into the game without having any hicups.


**Fish Stats**

The initial stats will be off when we add them into the game but that should be fine because we can use that is part of the rolling patch concept.
Introduce the item into the game with the base stats and then nerf / rework as we test it out.

**Coffee**

Coming back from Italy again got me all caffinated to the max OR that is what I thought would happen.
It seems to me that I need a decent amount of expressos and cappos to even remotely feel the energy level from my morning cafe combo.

**Japan**

I was talking it over with some friends and a trip to Japan is overrated and would be so much fun!
The plan would be to go from NJ to California, stay in LA for a weeken or two, just to get the vibes into the flow, then take plane ride directly to tokyo.
Maybe I can be super clutch and get it done this year?
I really should improve my camera skills and be able to capture these moments.

**CICD**

Quickly update the core of the hq plan deployment and the deployment of the cityvote.
Both of these will be the same application and website, since they are expo related and will share the same core codebase, we can publish them together.
My goal would be to have a decent amount of code sync among these projects, allowing us to deploy them all and launch them at once.
If we can throw 5-10 apps onto the board and see which one would stick around?
I think if we can get cityvote up and running before the electon season then it could be poised from the traffic boost related to that drama.
Since we will be launching the worker package as well, I will include that in there for now:

```yaml

  alter:
    needs: ['globals']
    runs-on: ubuntu-latest
    name: File Alterations
    if: github.repository == 'kbve/kbve'
    outputs:
      worker: ${{ steps.delta.outputs.worker_any_changed }}
      expo-hqplan: ${{ steps.delta.outputs.expo-hqplan }}
      expo-cityvote:  ${{ steps.delta.outputs.expo-cityvote }}

```

Next define the regex for changes.

```yaml

      - name: File Changes
        id: delta
        uses: tj-actions/changed-files@v39
        with:
          files_yaml: |
            herbmail:
                - 'apps/herbmail.com/**'
            kbve:
                - 'apps/kbve.com/**'
            rareicon:
                - 'apps/rareicon.com/**'
            discordsh:
                - 'apps/discord.sh/**'
            atlas:
                - 'apps/atlas/kbve_atlas/**'
            worker:
                - 'packages/worker/package.json'
            expo-hqplan:
                - 'apps/expo-hqplan/src/**'
            expo-cityvote:
                - 'apps/expo-cityvote/src/**'
```

I wonder if we could migrate the alter operations to our npm package but I feel like that might be too much inner loop / god repo complex.
We want to isolate some of the projects and concepts or we will never get anything done.


These are the three checks that we want to implement before we start to build out their cicd pipeline, we want to have these ready right now so that we can easily plug them into our pipeline and see what it is able to produce.

The run on sentences are mainly because I am shifting my thought process and the plane is just not making it easier.
Maybe I will drink something nice and cold to snap me back into the flow.


**Expo Actions**

```yaml


  expo-hqplan-web-build-and-deploy:
    needs: ['alter', 'globals']
    name: HQPlan.com Web Deployment
    runs-on: ubuntu-latest
    if: needs.alter.outputs.expo-hqplan == 'true'
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup NodeJS
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Setup PNPM
        uses: pnpm/action-setup@v3
        with:
          version: 9
          run_install: false

      # Not too sure if we will need the react-native-cli globally? I need to double check this.
      - name: Install react-native-cli globally
        run: pnpm add -g react-native-cli

      - name: Install dependencies
        run: pnpm install

      # Not sure if we need watchman but is fine.
      - name: Setup Watchman (if applicable)
        run: |
          sudo apt-get update
          sudo apt-get install -y watchman
          watchman --version

      - name: NX Command
        shell: bash
        continue-on-error: true
        run: |
          pnpm nx run expo-hqplan:export --verbose

      - name: NX Command - 2
        shell: bash
        continue-on-error: true
        run: |
          pnpm nx run expo-hqplan:export --verbose

      - name: HQPlan Build
        uses: ./.github/actions/kbve-shell
        with:
          flag: '-nx expo-hqplan:export'
          create_pull_request: false
          github_token: ${{ secrets.GITHUB_TOKEN }}

      # We should migrate the .nojekyll creation into the build process, as well as the CNAME.
      - name: Create .nojekyll file
        run: |
          mkdir -p dist/apps/expo-hqplan/
          touch dist/apps/expo-hqplan/.nojekyll

      - name: Create CNAME file
        run: |
          mkdir -p dist/apps/expo-hqplan/
          echo "hqplan.com" > dist/apps/expo-hqplan/CNAME

      - name: HQPlan.com -> Deployment
        uses: dobbelina/copy_file_to_another_repo_action@main
        env:
          API_TOKEN_GITHUB: ${{ secrets.UNITY_PAT }}
        with:
          source_file: 'dist/apps/expo-hqplan/'
          destination_repo: 'kbve/hqplan.com'
          destination_folder: '/docs'
          destination_branch: 'main'
          destination_branch_create: 'patch-kbve-hqplan-deploy-${{ needs.globals.outputs.sha256head }}'
          user_email: '5599058+h0lybyte@users.noreply.github.com'
          user_name: 'h0lybyte'
          commit_message: ${{ github.event.head_commit.message }}
          rsync_option: '-avrh --delete'

```

I am going to take this part of the lc agents and see if I can turn it something more meaningful for we are trying to build.
We could just trim down the steps and focus on getting a future action called `expo-hqplan-web-build` that will handle everything we need for deploying our changes directly to the main repo.
Fixed up the command to export the hqplan generic website, but we will not know exactly how it will perform until we get more of the codebase up and running.
Tonight I am going to focus on the supabase deployment and then will switch back around to the hq plan. 


**UnityWorker**

While I am going through the `cicd` pipeline, we can take a look back at the unity flow we were using ... oh the sleep juju is hitting hard.
and once unity 6 comes around and we get this worker published, we could look at integrating the unity wasm into the minion thread.
Actually, I believe that be an interesting way to get that dual level of multi-connection that some game companies are after for mobile first video games.
However we will have some issues when trying to get the game load from cdns, so we will have to be extremely careful on how we handle it.

The way that we were calling the unity wasm was through the react unity webgl library, but there might be another way to do it with unity 6 exports.
Unity should have resolved it by now but the worry that they have not yet is always a possibility.

**SD&ME**

Both of those projects will continue to be on hold until we can get the backend up and running with around 100 memebers?
The frontend would have to be 3-5 projects as well, so that when we go ahead and add more projects, they all have their place in the eco-system.
Getting it moving faster and faster will be our key, we should have a whole podcast in the future where we just work on the monorepo.
The newer guys that come into the podcast, the objective is to help them get into the full devops flow and maybe even look into it as bizops?
We push the BizOps to the max and have it pump out profit generating websites? 
I am going to focus on a couple core ones but the skills and this corebase would make it easier for anyone to do it.
The part where this will help us a lot will be in the i18n aspect of the build process, since we will have to look through a bunch of different languages.

**References**
I am starting to become a reference floor, I am just using them in almost everything!
Proof of concepts, complex tasks, everything could just be a reference to another reference, one cell to another.
Two more hours left in this flight and I am doing everything that I can to keep the flow going before I eventually go home and passout.

**Landed**
Back in the chemical state and I already miss the vibes of Italy.

**PNPM**
The global `pnpm` has to be updated to v9.9.0 but I want to make sure that there are no breaking changes with that upgrade.


<Adsense />

## 2023

- 8:00am - I been a bit behind this week at work so I should start to redo my schedule of actions and maybe block more time for work. I am also a bit behind on some of Amazon's newer cloud tech, they keep releasing new stacks and its a bit over kill at this point.

- 4:00pm - Getting EFS / Elastic File Search to work outside of the Amazon VPC is definitely better now than what it was like in 2016. But know I am looking into the RDS structure once more and it makes more sense that this might just be over engineered. I might just step back and look at a different approach to handling the file system. 

- 7:15pm - Our team did amazing for the Ai Agent hackathon! I am glad that we placed 3rd and I am really excited to see where we go from here, as this might open so many interesting doors that I am not yet ready to expect. On one hand, I do not want to over run myself with any form of ego, but I really think we have an amazing group of developers and the pressure that hackathons bring has a nice touch of anti-procrastination forced into it. Sometimes the competition brings a different level of human nature into the mixture, it creates a sort of excitement and the publicity that comes with it is also a great cherry on top.

## Quote

> When a thing is done, it's done. Don't look back. Look forward to your next objective.
> — <cite>George Marshall</cite>

---

## Tasks

- [ ]

---
# September: 1st

> September 1st.

Source: https://kbve.com/journal/09-01/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Supabase Realtime

-   11:59PM

    End of the day notes, we spent a bunch of time on the realtime, to the point where we found out the issues were not just us but at the supabase level.
    I understand that they are also working on it actively, but the rate that they are moving is really slow.
    The biggest issue that we faced was that `realtime` was the name of our deployment and that caused a naming conflict, switching it to over to `realtime-prod` helped solve a disconnect bug.
    Fudster really showing his tech powers.

## 2024

**Supabase**

The self hosted swarm is up and running, ish.
Now we need to mess around with it!
The biggest issue that was a stupid docker mistake on my end, I accidentally replaced a bunch of the migration and init scripts when setting it up.

**Edges**

The edge functions need to be fixed as well.
I realized that this was also a mistake on my end, we should have this part of the code running without any major problems.
The way that that supabase handles the edge functions is interesting, by having a main function that then acts like a wrapper around all the other edge functions.
This setup makes it easier to avoid having to call redudant code and keeps each of the unique functions in a sandbox.

**Hybrid**

After thinking through with the plans, it would make sense to hybrid cloud out the whole supabase!
We can run a bunch of instances throughout our eco-system, even try to get some really cool concepts in the lower levels, like a k2d instance.
The plan will end up being setting up k3d on the local dedicated server and linking the 4090 to it!

## 2023
- 9:40am - Looks like I got assigned again on $DIS, never thought I would have a collection of Walt stocks this early, I suppose I will just keep rolling them until I get a chance to offload them. I had to close a couple of the puts at a lose because it might over allocate my capital into just one basket. There are some weights and parameters that I need to tweak because the wash sales implementation is too rough and needs to be improved. \
- 11:00am - I am starving and I really need to get something to eat, my stomach is crying in pain for some of those calories. Should I get a classic taylor ham, egg and cheese bagel or should I mix it up with an egg and bacon wrap? These are the real questions that I want Ai to help resolve. 
- 1:15pm - The Appwrite function fix for now seems to be fine! As long as we can deploy our functions, then we should not see any huge issues coming up for the next hackathon. I should try not burn myself out, but I am getting a bit excited to see the future of their functions and how they will evolve.
- 3:30pm - I will spend a decent amount of time helping `Erni` onboard to our team, so that we have another solid developer join our ranks! He was a great addition for the Music hackthon by coming in clutch and resolving the browser extension build issue. 
- 4:40pm - The real solution here would be to just move away from him using Debian and give him a VPS to mess around with and get a better feel for the project. We have some spare resources and it would make sense for him to use the same unix operating system as the rest of us, granted Debby is not too far off from Ubuntu, as they are in the same family but there are some minor tweaks that we do not want to spend too much time working out. 
- 5:30pm - Gave him a slot in the OVH dedicated server with his own little VPS, but I do not plan to keep that around, after a couple weeks, I will remove that and we will implement a new system for it. I suppose adding a test case and a more standardization for VPS allocation will always be an issue that I want to resolve. 
- 8:15pm - After setting up NodePy and going over the different test casing, we noticed that the performance of the nested emulation was definitely a lot slower than what we were expecting. It might make sense to maybe find another path to take with the emulation and security.
- 9:00pm - I am going to get some sleep a bit early today because I want to get up super early and get back to my normal schedule. Its going to be a bit rough but I have some tips and tricks that help me get back into the early bird flow.

## Quote

> Sometimes your joy is the source of your smile, but sometimes your smile can be the source of your joy.
> — <cite>Thích Nhất Hạnh</cite>

---

## Tasks

- [x] - Prepare the funds for Charles.

---
# September: 2nd

> September 2nd.

Source: https://kbve.com/journal/09-02/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### KBVE Forked Supabase Realtime

-   11:59PM

    End of the day notes, we ended up forking our own version of the Supabase realtime and Fudster built a dope sync system between them!
    There is a ton of information that we need to outline but its been a crazy ride!
    I will update the Supabase MDX with all that information when I get a chance.

## 2024

**BIOS**

Turning Charles back online after all the crazy intel situations and my Italy trip.
Our board was the ROG STRIX Z790-A motherboard and it already has a nice usb slot for bios reset and updating!
Grabbed the new bios for the motherboard, loaded it onto a usb2.0 and threw it in for the update.
Its going terrible, the first round we got to the bios setting and then it just froze up!
Afterwards, its been a battle between my sanity and patience.
Its been a nightmare so far today, nothing feels great like watching a bunch of money spent on a machine just die on you.

**k3s**

We will go ahead and setup the k3s using ansible on a local proxmox setup.
This way we can continue to run our portainer on the main dedicated server and make sure that the transition a full k3s eco-system as easy as possible.
For the k3s, we will be using axivo/k3s-cluster as our guiding path, but we also need to setup ansible and proxmox to build out our VM eco-system.
Eventually the goal will be to manage the whole devops eco-system through github actions.

**Supabase**

Preparing the profile and ledger accounts within the kbve postgres database!
For realtime, we can go back around and reference this [discussion](https://github.com/orgs/supabase/discussions/22484)


## 2023
- 5:30am - Spinned up an instance of Weaviate sandbox! Lets goo! We will use this instance to test case any of the issues that we might have with batching on weaviate and then migrate over to any additional concepts that we could use. 
- 6:38am - I need to send out a couple text messages and plan out my morning the best way possible. I sure want to grab some breakfast but I also want to make sure that I get all the parts for Charles and have it operational by the end of the day. We could split up the hard drives for the project ahead of time, maybe place the operating system on a completely different mount / drive and then use another SSD for machine learning operations?
- 7:11am - Let me sync the repo and this patch with the main website! This way I am all caught up on my different laptops and phones.
- 10:15am - Getting ready to pickup the parts for Charles! I believe I have some spare parts that I can integrated into this special PC!
- 2:15pm - Okay this pc structure was a bit more than what I was expecting to build, there are a couple parts that I was not too sure that I would understand, even putting together the heatsink was a bit extra.
- 5:45pm - Taking a bit of break from setting up the PC and chilling out.
- 10:15pm - Going to get some sleep and prepare for tomorrow morning, tonight was interesting, definitely the multiple trips to the electronic store, definitely was not what I was expecting. 

## Quote

> Sometimes your joy is the source of your smile, but sometimes your smile can be the source of your joy.
> — <cite>Thích Nhất Hạnh</cite>

---

## Tasks

- [x] - Gather parts for Charles.
- [x] - Research the assembly of Charles.

---
# September: 3rd

> September 3rd.

Source: https://kbve.com/journal/09-03/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Notification Bot

-   11:00PM

    Getting the python docker build and everything streamlined was the days goal.
    We are almost near perfect with a streamline of a code change and to production kubernetes deployment, feels pretty solid at the rate that we can move.
    I noticed that the container does use around 70MB at idle, we can resolve that with jemalloc, maybe get it down to 40-60MB idle ram by the end of the week.
    Another cool thing could be that we swap out to a tokio based handler, which could put just above axum but with faster deployment.

## 2024

**Supabase**

Today I am going to test case the postbin concept using supabase, part of that will be to setup the datatome table and making sure we can post json to it.
I think there can be some performance upgrades that we can do on it as well, including switching the json serialization to a rust-based extension or a wasm wrapper.

**Proxmox V8**
Upgrade complete, will update the notes for this later on!
Everything from 7 to 8 went great and I am actually surprised how easy it was.
The key command that I recommend is `pve7to8 --full` and making sure that everything else, vm wise, is offline.
Then go through the general steps that they recommend for upgrading from 7 to 8, making sure to keep track of the files that need to be changes.

**Deckhouse**

The whole deckhouse was a cluster kubber phuck!
We ran into so many issues, ended up staying up until 4am trying to debug them.
The documentation for deckhouse was trash and we spent so much time going through the operations that I feel the need to take a break from it.

## 2023

- 5:05am - On the PC this early? I woke up way tooo early, the sun is not even out yet and this screen is way too bright for my eyes. 

- 10:24am - Need to quickly catch up on the 3rd episode of Ahsoka, I am super excited for this mini-series and so far it has been great! It definitely has a bit of a slower vibe but I am enjoying the way they are looping the timeline and handling the world building. I should be careful not to put too much information out there as well. 

- 11:36am - A couple hours of just chilling and now I am getting ready to mount the CPU heatsink onto the tower. 

## Quote

> Give a man a fish and you feed him for a day. Teach him how to fish and you feed him for a lifetime.
> — <cite>Laozi</cite>

---

## Tasks

- [ ]

---
# September: 4th

> September 4th.

Source: https://kbve.com/journal/09-04/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Nvidia $180

-   9:25AM

    I am trying to move out a bulk of shares at $180 but it seems that the post earnings dip has yet to recover.
    If it can get just above $181 before the end of this month, it would be great news for my future framework laptop.

### Notification Bot v1.3

-   1:25PM

    This version of the notification bot will be using the embed system, but I noticed that will need two tokens, one for the active production and another for development.
    That means I will have to create a whole new bot, get the damn linking out of the way and then deploy it as a dev bot.
    `Notify PyBot` will be the production name.
    `Notify PyBot-Dev` will be the development name.
    Maybe a quick way to move between having either be operational without breaking the other, hmm, I will try and think the best way to handle that.
    I wonder if there is a way to shared them. 
    After looking at the docs, it seems that we can use `AutoSharedClient`, okay this is great news, we could start to build around that!
    This will make scaling very easy for us moving forward.
  

## 2024

**rke2**

Todays goal will be to switch the k cluster over from deckhouse setup to rancher.
The initial plan is to setup a master node with two worker nodes, thus a simple 3-node cluster and then expand it out with a 3 master and 2 worker node setup.
This is before we go ahead and build out a more advance structure.
I lied, we ended up with a 5 node cluster, 3 of them being master and 2 of them being worker.
After we got those five setup, we still need to go back and fix up the backup system.

**Helm** 

On my mac, we needed to setup the kube config and helm, so that we can control the cluster from our local machine.
The best solution was to replace the kube config from my macbook's local instance of orb with the remote instance!
For that and helm, both were installed using brew but I am positive it will be a pain to do using windows.
Now that everything is working locally and remotely, we can start deploying applications.


**Rancher**

Once we got the cluster deployed and everything was smooth sailing, the next part was setting up the rancher dashboard.
Using our local machines, we were able to deploy and configure Rancher.
It has been a couple years since I last saw the rancher dashboard, but damn is it amazing!
A huge shoutout to suse and the devs that worked on it, I am amazed at how it looks and performs.

**shell**

We can also expand the `/tools/scripts/public` to hold more automated shell scripts?
I am also thinking we can add a folder for playbooks and other iaac code.
The first script that we will create is the `ubuntu_install_master.sh` and that will be for quickly deploying a master node in rke2.
Next shell that we could make is for the worker node and have that handle each of our slave nodes, hmm, we will call this the `ubuntu_install_worker.sh`.

**Nvdia**

With nvidia dropping in value, I am going to pick those 10 option contracts back up and see if I can leverage them for another quick couple thousand.
The goal with this swing is to make a bit of side cash.
The strike will be 109c 2025 Jan again, but I am going to sell those out really quick on the next pop, maybe walk away with a 2000.

**Keyboard**
There was an issue with my keyboard earlier and I updated my drivers and there is still this delay that appears when I type-in the words.
We tried to update the graphics driver, keyboard driver and a bunch of other things, but still no luck.
I am thinking that it might just be my CPU and its inability to handle all of this computation!
The CPU spikes are getting bad and I might also need to clean out the PC.


## 2023
- 5:26am - Monday Meme Day!
- 7:07am - Cleaning up the KBVE.com repo a bit, took out the astro-compress library as Astro v3 now default compresses the data that is being outputted. I believe we could remove a couple of the react libraries and lottie, then migrate it over to a custom widget package.
- 8:02am - Weaviate + Unstructured Data integration time! We were able to establish the weaviate connection using the appwrite database, so the next step will be to see if we can add data into the database cluster. 

## Quote

> Happiness is not in the mere possession of money; it lies in the joy of achievement, in the thrill of creative effort.
> — <cite>Franklin D. Roosevelt</cite>

---

---
# September: 5th

> September 5th.

Source: https://kbve.com/journal/09-05/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Discord Notification Bot

-   05:00PM

    Shard deployment and trying to see if I can manage it myself seems that is not working out.
    Furthermore, I need to update my tracker table that has the user tracking and identity can just be all replaced.
    Seems that I missed the auth indent table, so later this week I will have to just remove it.

-   11:00PM

    Spent most of the day trying to get the damn shard deployment resolved and fixed, but running into too many issues.

## 2024

**Longhorn**

We were able to get longhorn installed or deployed into our cluster but we have not yet setup a use case for it.
My goal might be to use it for a three cluster postgres and see how it performs.

**Grafana**

Initially we were going to deploy our own grafana isntance and then have it be the core location of the metrics, but decided to backtrack and use the exisiting one that rancher provides.
This way it already has a pre-configured data source and we can just extend out from there.

**VaultWarden**

I am going to aim at trying to do two different deployments, the first is the vault warden.
The goal would then be to migrate the secerts out of the instance that is running under the portianer and into this vault warden.
After that migration, I will shutdown the portainer and begin the process of shutting down the docker swarm, giving us around 150GB space back and a decent chunk of ram.

**Supabase**

Besides preparing to run the vault warden, I will need to start the supabase helm deployment on the stack.
The first step would be to look over the supabase chart and our previous docker swarm compose, then see if we can formulate a solid chart that can help us deploy the instance.
I am going to download the current supabase helm chart and then start to move it over to our stack, hopefully giving us a better understadning of what is happening under the hood.
The first two will be `Chart.yaml` and `values.yml` and then we can work from that point.

---

## 2023
- 7:40am - I need to make sure the camera is ready for maybe morning trips? I am thinking of building a creative way to express artwork through a combination of digital frames and a decent camera. This was a shower thought but I just wanted to get it written down before I forget.

## Quote

> The young man knows the rules, but the old man knows the exceptions.
> — <cite>Oliver Wendell Holmes Jr.</cite>

---

---
# September: 6th

> September 6th.

Source: https://kbve.com/journal/09-06/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### v1.7.1 Notification Bot

-   12:26AM

    The plan is to just get the basics out of the way and maybe include a way to have it automatically clear up the embed for the bot.
    There should be a way to keep track of that message that gets created in the thread, but hmm.
    I am doing everything I can to avoid having to keep creating and destroying damn tables, its just seems like that its too much.

### Unity Session

-   10:06PM

    Unity session ended perfectly and it gave me some cool concepts that I could play around with!
    I am thinking that it would be interesting to see if we could have the notification bot hook into the irc and twitch chat, then relay that information between them.
    Furthermore we could have it be relayed all into the discords irc chat, so a tri-level integration of chat.
    This also gives me a chance to setup the Twitch login for the Supabase Auth system!
    A really cool concept would be to allow the people in the chat to spawn themselves as zombies into whatever scene we are in, just to test the logical movement between the chat and game dev side.
    I suppose it be pretty simple if we look at from the command, `!zombie` and then we have the virtual container find the prefab , then add it into the play scene, maybe even do something cool like have their twitch name above the zombie.
    This would not be that hard given that we have most of the tools in place to do this.

### CICD Pipelines Improved v4

-   06:54AM

    Finally got around improving the CICD pipelines, making it easier to move from atomic, dev and main.
    Just need to clear through some of the orphan branches and test case it without running into code review problems.
    Oh no, I think I created an infinite loop of cicd pipes.

-   08:57AM

    Time to take a quick nap, I was able to resolve some of the issues.
    We will have to figure out a way to handle them in the future, with a bit more skill and hmm it seems that it might not be the best right now.

## 2024

**Longhorn**

There might be an issue with longhorn and the `multipath.conf` for our nodes, thus we will have to update the configuration on all the nodes to handle it.

**Ansible**

To prepare for the github actions to execute the ansible playbook, we would have to create a new key and place that inside of each of the containers.

**MicroOS**

The homework for this weekend will be to read into the usage of [MicroOS](https://github.com/KBVE/kbve/issues/2674).
As the issue ticket states, we want to utilize the `MicroOS` for our next worker deployment.
Ideally, we should deploy it via ansible through github actions but that iaac is not yet setup on our framework.
For this deployment, we can use terraform to help us set it up and execute it!
The terraform script will be placed inside of the `/tools/scripts/public/proxmox`

**Postgres**

Spent the night trying to get the core of postgres and the namespace of `supabase` setup!
After doing a bunch of different test deployments, I think we have a better understanding of what needs to be built and a clear goal in mind with the helm chart and deployment.
One of the areas that I was thinking of looking into was utilizing github actions for the deployment but that might be in the near future for now.

---

## 2023
- 10:21am - Using ChatGPT to just quickly write out some content is becoming an addiction and I believe it might be the real mindwoke virus xD. 
- 11:00am - Okay! For my unsplash project, I was able to secure the camera but now the issue is getting a digital frame that can render the images with a bit more pixel density. Currently the frame that I have right now has a terrible resolution and under the intense light from the sun, most of the artwork looks like pretty bad. Furthermore, I do need to test my photo skills, including how well I am at for figuring out the different lighting.
- 5:58pm - Updated some of the minor components on the main page of KBVE! I am not too big of a fan of the current layout, I might have to find another way to handle it.

## Quote

> Technology presumes there's just one right way to do things and there never is.
> — <cite>Robert M. Pirsig</cite>

---

## Tasks

- [ ]

---
# September: 7th

> September 7th.

Source: https://kbve.com/journal/09-07/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Session - Supabase Metrics

-   09:15PM

    Removing the older AC deployment because its was just a test case and seems to be throwing a ton of errors in the grafana.
    I was really excited to launch it but after spending all that time setting up the MariaDB cluster and only finding out that I need to use MySQL was a huge let down.
    It really killed my motivation to finish this test case deployment and honestly, it feels a bit too grey for me to continue.
    I do not want to get into any future trouble because of it, thus it would be wise to just shut it down.

-   11:05PM

    Spent the day building out the basics of the supabase metrics that will use the realtime.
    We might have to step a bit back from the metrics because we still need to get the core gameplay out of the way.
    Once we have the core gameplay done, I will loop back to the metrics. 
    

## 2024

**Brew**

I am going to quickly re-install brew onto my linux setup, then utilize brew as a common manager amoung my debian, wsl and mac instances.
Just for my future self, I added a quick install script for brew into the repo, which we can use incase brew is missing.
Maybe we could add these barebone scripts in a future devops release, so that it be easier to manage new instances, hmm, I will table that one for now.

**CitySkyLine**

Made a quick city through the game, its actually pretty fun and interesting but there is a lack of content for mid or late game.
I think its because the game is still new and we will have to wait for the expansions and mods.

**CloudNative**

There are some plugins that we still need to test case for deployment of the HA clusters.
The main issue is testing the recovery and the backup, but the s3 configuration still needs to be done before hand.

## 2023
- 7:07am - Watching Ziggy's amazing stream, its perfect!
- 7:57am - Getting ready to write different types of test casing across the board for work and my personal websites.
- 1:03pm - Decided to go with a basic three tab setup as an Index card. I am thinking of isolating it towards three areas, the first being the blog, second being services and finally the third being an about section. I might have some additional widgets built into it. As for after the index card, I might look at adding custom tailwindcss animation, which I need a bit more practice with.
- 1:51pm - Let me commit this current checkpoint and then check back with the team on their k3s instance, maybe sneak in a quick league match too.
- 2:01pm -

## Quote

> Along with success comes a reputation for wisdom.
> — <cite>Euripides</cite>

---

## Tasks

- [ ]

---
# September: 8th

> September 8th.

Source: https://kbve.com/journal/09-08/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity IRC

-   07:43AM

    The goal for the day is to finish up the core proof of concept for an IRC Chat client built into the Unity client.
    I want to isolate the chat from the rest of the game server, so that its easier to monitor and maintain.
    Using the IRC will also let us easily hook into the Discord and Twitch chat too, which could open up future fourth wall concepts.
    Think about a streamer playing RareIcon and having their whole chat become zombies in the game that spawn up and start attacking you!
    We can be very creative with how we want to structure this in the future.

## 2024

**Secrets** 

The next issue that we have to handle is the `secrets` and its management!
There are a couple options that we can look through but we will start with `sealed_secrets` for now.
After we get the base deployment resolved, we can migrate the secret system to OpenBAO / Vault.
For the commands that we want to run, I am thinking of turning it into a shell file called `sealed_secrets_install.sh`.
This would be the shell script that would install and setup the sealed secrets, but we do want to migrate over to terraform!

The base terraform was created and it was able to install the sealed-secrets!
I included both the shell and the terraform file as an example.
After deploying the sealed secrets installer, we need to run the `brew install kubeseal` and this will help us create the one-way encrypted secrets.

**League**

The league burn out is starting to hit hard, I am getting really tired of the games and might need to switch the pace up a bit.

## 2023
- 6:03am - Currently going through the process of setting up the decentralized file storage but I am not too sure how I should go about handling the meta data engine. I am debating if I should just use the cloudflare egress or maybe switch over to another type of meta storage. 
- 11:15am - I am thinking that it might make sense to create a global redis instance that we could call from any point? There are a couple different ways that I wanted to approach this concept, one being a bit similar to how I was planning to handle the Rust+Redis build / layout. Okay so we could have two instances in this structure, one being the meta and the other just being a general redis? Hmm, I suppose one would be `meta.kbve.com`, the next being `engine.kbve.com` and finally `redis.kbve.com`? This would be the first move before building out the decentralized hybrid swarm. 
- 11:27am - Pushed through some minor updates to the general KBVE repo, now I am currently looking over the appwrite upgrade to v1.4.2, including setting up the clustering! There should not be any major issues that I should face as of right now, but this is going to be an interesting experiment, none the less. Let me see if I could update the existing documentation as well. 
- 11:38am - I believe the first engine that I want to deploy would be the meta, which can then be used by a meta-engine for the storage of the general key-values that will be then used by the scaling redis clusters. The meta engine will be like an index that will reference different data blobs spread across all our containers, virtual machines and emulators! The best option for this engine would be to use the Amazon Elastic Redis instance, yet I am not too sure if we would need to do that as of right now, since one of the goals would be to keep the cost bases as low as possible?  

## Quote

> Adversity causes some men to break, others to break records.
> — <cite>William Arthur Ward</cite>

---

## Tasks

- [ ]

---
# September: 9th

> September 9th.

Source: https://kbve.com/journal/09-09/

import { Adsense, Tasks } from '@/components/astropad';

## 2025 

### KBVE Hyperlane

-   09:53PM
    
    A huge moment within the KBVE website, we finally moved the website away from the Github pages and into an Astro/Rust deployment.
    I also believe that we might be one of the first to do so, the tests with Disoxide have been great and this is the perfect step towards the direction that we want.
    There are still some bugs that we need to resolve, but I will tackle them during the next refactor of the KBVE website.

## 2024

**Terraform Proxmox** 

Spent the majority of the day doing some test casing for terraform!
I am getting a bit better at handling the different edge cases and making sure the tfstate is able to execute in order.

**Shaco Skin**.
Oh boi, I finally have a reason to spend all those amazon x riot points.

**KillTony**

Excited for tonights kill tony!
We got a sam jay and greg combo, dope!

**KiloBase**
The next stage for deployment is to setup a cloudnative pg image based off of supabase, we will call this the kilobase.

**nxContainers**
Within the monorepo, we are going to add a new package into the nx eco-system that will help with building containers.
The nx containers still needs to be updated within the github actions and ci-cd pipeline.

## 2023

- 8:43am - Looking over the UI/UX components for the next game that we build, I am diving a bit deeper.

## Quote

> I cannot even imagine where I would be today were it not for that handful of friends who have given me a heart full of joy. Let's face it, friends make life a lot more fun.
> — <cite>Chuck Swindoll</cite>

---

## Tasks

- [ ]

---
# September: 10th

> September 10th.

Source: https://kbve.com/journal/09-10/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Wheel and Deal

-   05:35AM

    The war chest is still pretty solid and if we can continue to provide better growth and deployment, it could mean a huge surge in our development cycle.
    I am thinking that the next focus might be ditching the react native eco-system and migrating to unity for the app/desktop development, basically turning all our apps into games.
    This could be a great way to not only build out the user base but provide a way to grow the whole company as a whole.
    A dating app that is also a card game would be crazy!

## 2024

**Kilobase**

The goal for today is to build out the base image for kilobase and include a small custom postgres extension.
This will be my third attempt at doing ffi inside of rust!
The rust extension will ffi into C and during the docker build, we will add it into the exisiting supabase dir.

**MSG**

The first night of madison square garden and kill tony was perfect, a nice blend of the favorites and some really solid performances all around.
Now I am excited to see the next night, hopefully it comes out this Friday.

**Postgres**
The next update to the image will be barman cloud, which will help us with the automatic backups!
What an adventure, having to change the python version to 3.11 and then making sure the barman cloud works too, ugh.
The build was successful but we still have to figure out how to arrange the deployment, which means getting github action to build and publish the image onto dockerhub.
For setting up barman, we had to make sure the `requirements.txt` was included in the dockerfile, so we created a custom command for it.

```json

    "copy-requirements": {
      "executor": "nx:run-commands",
      "options": {
        "command": "cp apps/kilobase/requirements.txt dist/target/kilobase/requirements.txt"
      }
    },

```

This copies over the requirements.txt from the kilobase folder into the distribution folder.
Now we can start building out the basic pgrx extension, which will be a bit empty for now, just to make sure everything works before we add more heavy lifting into it.
Before getting started, we will need a couple of predefined libraries to help us build the rust extension, including additional libraries that will help us ffi into c.

```shell

sudo apt-get install build-essential libreadline-dev zlib1g-dev flex bison libxml2-dev libxslt-dev libssl-dev libxml2-utils xsltproc ccache pkg-config libclang-dev

```

This command should grab everything we would need within an Ubuntu 20/22/24 instance.
Side note, on my macbook, I had to do `brew install git icu4c pkg-config`.



## 2023

- 10:30am - Minor updates to the current issue tickets that are open. I definitely want to integrate some of the GPT-style concepts into the issues and then get to the point where I can have it patch, pull and merge different edits to the main repo! Think of it like Sweep but a bit more geared towards content generation and general clean up.

- 4:05pm - Coffee! I require some damn coffee.

- 9:37pm - The amount of memes that this is requiring. Ugh, I am diving deep into the caffeine binge. My basement has skyrocketed in temp, its actually super scary how hot it is getting in here.

## Quote

> The journey of a thousand miles begins with one step.
> — <cite>Laozi</cite>

---

## Tasks

- [ ]

---
# September: 11th

> September 11th.

Source: https://kbve.com/journal/09-11/

import { Adsense, Tasks } from '@/components/astropad';

## 2025 

### Post GH Pages Fixes

-   09:15PM

    Cleaning up the remaining actions and finishing up the migration of the KBVE website!
    We will have to turn the old kbve.com into a repo that is README Only, I might even move it out of the KBVE organization and into the h0lybyte profile.
    Having my personal profile be the graveyard of the older projects would be an interesting take.
    This could also be a security concern that we can address, making sure that nothing just suddenly breaks or have a risk of leaking our keys/tokens.

-   11:45PM 

    The global auth might be an issue that we need to address, ideally the global auth logout system. 
    Currently we are using the `GlobalLogout.tsx` but I did want it to be just all within the same instance, ugh.
    Having the logout be in multiple locations might be a pain, whereas, having a shared library would make things easier.
    What we could do is that instead of a shared Astro library, we go ahead and do a shared tsx library, with the core logic that is within the package.
    Then have the custom astro files within their own respective projects, thus keeping the style within the project's eco-system.


## 2024

**PGRX**

Going to spend a decent amount of the time going through the pgrx documentation and notes, doing my best to build out a simple extension and then make minor improvements upon it.
The command to start up a pgrx session is:

```shell
cd ./apps/kilobase/
cargo pgrx run
```

We want to go ahead and shift this over to a nx run command.

```json

"pgrx": {
    "executor": "nx:run-commands",
    "options": {
        "cwd": "apps/kilobase",
        "commands": [
          
          "cargo pgrx run"
        ],
        "parallel": false
    }
}

```

This happens to run postgres on port 28815 or sometimes another random port, thus I think we can update the command to pass the default port of 5432.
Actually nevermind, I like their system of having the base port be 28800 and then the final number representing the different postgres versions, so 28816 is postgres 16.
Replacing this system or making any changes would not be helpful, instead we could just run a test bouncer on 5432 and then have it route to the other instances.

Okay after setting up the dev and testing environment, we can begin the base production pipeline!
I am thinking that we focus on getting the image deployed into the docker hub and then we can go back and look for optimizations.
Furthermore, I know the supabase base image is both x86 and aarm, but for now, we will just focus on the x86 deployment.
This does mean that there might be some issues test casing on the m1 mac because we would not be supporting the aarm version of kilobase but the m1 can still help with debugging and the dev cycle.

I just realized that the default postgres that is on my WSL is v14, which means we need to make adjustments to our code, since we will be only supporting the version 15, the supabase version.
Once supabase releases a base 16 version of their aio postgres, we can come back around and update this library for that.

Under the toml, we will go ahead and remove the other versions of postgres.

```toml

[features]
default = ["pg15"]
pg12 = ["pgrx/pg12", "pgrx-tests/pg12" ]
pg13 = ["pgrx/pg13", "pgrx-tests/pg13" ]
pg14 = ["pgrx/pg14", "pgrx-tests/pg14" ]
pg15 = ["pgrx/pg15", "pgrx-tests/pg15" ]
pg16 = ["pgrx/pg16", "pgrx-tests/pg16" ]
pg17 = ["pgrx/pg17", "pgrx-tests/pg17" ]
pg_test = []

```

and now the new features toml will be just pg15.

```toml

[features]
default = ["pg15"]
pg15 = ["pgrx/pg15", "pgrx-tests/pg15" ]
pg_test = []

```

Afterwards, we will go ahead and make sure that we are running postgres 15, with the `pg_config` returning the postgres 15 headers.
To make sure your postgres15 is ready, go ahead and run this command:

```shell
/usr/lib/postgresql/15/bin/pg_config --version
```

Granted it might be located in a different location, this was the location for me.

<Adsense />

## 2023
- 6:30am - Preparing the morning minutes and general stand-in protocols, honestly I forget that I am muted way too long during them anyhow, should just ask if I am needed before I stay in the call. 
- 11:00am - Excited to see a quick surge in TSLA stock value, I am waiting to sell about 500 shares for $270/$275 each, so I can turn around and sell puts against TSLA.
- 1:00pm - Meetings went great so far, but there are ways 
- 10:37pm - Fixing up the parcel packager and it looks like the Yorha UI Widget is nearing production level, I just need to test case a couple integrations from a couple older widgets.

## Quote

> The winner ain't the one with the fastest car it's the one who refuses to lose.
> — <cite>Dale Earnhardt</cite>

---

## Tasks

- [ ]

---
# September: 12th

> September 12th.

Source: https://kbve.com/journal/09-12/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### OneJS Bridge System

-   11:51PM

    The mini boss fight before the big DOTS fight, I am going to try and resolve the OneJS/Puerts integration and afterwards , taking on the ECS/DOTS.
    This is the warmup fight before the final showdown, if I can get nearly all of the raw performance out of the quasi-ffi between the typescript and c#, then I should be ready for the harder parts of the DOTS.
    Let us pray that we get a decent amount of the work out of the way before the end of this week, so that we can spend the rest of the time focused on the DOTS.

## 2024

**Zoids**

The best way to keep the day flowing is by watching zoids, I am actually super excited to watch the rest of the show later tonight.
Granted its over two decades old at this point but I think the story and character flow still holds strong in 2024 and honestly, its unlocking those childhood memories too.
While watching the show, I had to look up the lore on how the zoids are created and it was rather interesting, they eat metal and have this cyber-spirtual connection to the environment.

**Nvdia**

Good to see $NVDA move up to the $120 mark, I am looking to dump my 10 calls once it hits around $123.00 or $125.00, but I think I am being a bit greedy.
This next swing should net me around $7K but no where near the ealier swing of almost $10K in profit.
Its basically paying for my trip to japan!

**PGRX**

Back to development work, this time its converting over the postgres extension to operate a shared library!
The idea here would be to run a background worker within the database that would handle some async functions like HTTPs requests and managing some tables.
Normally I would handle this within the API, but I think it would make more sense to migrate this over to the database side, I might even sneak in some other concepts here and there.
The part that I am currently stuck on is handling the table generation, I would like pgrx to create the SQL schema based upon what I provide it, rather than manually doing it via a SQL file.
Okay, to wrap back around the main issue that we had yesterday, the `pg_sys::Datum` is an opaque data type and that makes things a bit rough for rust and its type safety.
The solution would be to design a table within the sql database that operates as a data queue, I believe there are a couple more parts of this that can be extended out in the future.
When getting the datum via the arguments, we need a function to help us process it to a string.

```rust

fn datum_to_string(arg: pg_sys::Datum) -> String {
  unsafe {
    let cstr = pg_sys::text_to_cstring(arg as *mut pg_sys::text);
    CString::from_raw(cstr).to_string_lossy().into_owned()
  }
}

```

Yet we can also toss all of this out and pivot to the table method, putting us back into the safe rust zone.
Once the data that we want to process is inside of the table, we can safely assume the type and then move forward from there.
There might be some issues with the locks, but I think we can handle that as well.
Besides adding in `serde`, we should also include a `thiserror` as well to help with the error handling.

**Commits**

During the pull from 'patch-' into 'dev', we should make a quick change that will keep all the commits within the body of the pull request.
I believe we would have to not only grab the log but also sync the commits too for each additional commit that gets made.
Okay, I went ahead and updated the patch, so that it should collect all the commits and move it up to dev.
If this goes as planned, then it will make it easier in the long term to keep track of all the changes.
Damn this error:

```

Run echo "::set-output name=commits::$(git log --oneline origin/dev..HEAD)"
  echo "::set-output name=commits::$(git log --oneline origin/dev..HEAD)"
  shell: /usr/bin/bash -e {0}
fatal: ambiguous argument 'origin/dev..HEAD': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

```

Ran into a couple issues but I was able to figure it out!
Now that the PRs a bit cleaner, we can look some ways to improve the commit messages and isolate the changes.
I believe the sync and open should be isolated cases, we can have the gpt-style integration run but change the prompts based upon these two different events.
Now I am just updating this journal entry to test the pr and making sure it looks nice and clean!
Damn, looks like it failed to update it upon the open.
This is a new branch and this entry part of this journal is just to test case it.
Interesting enough, that did not work and it might be because of a race condition, thus I am thinking we might want to try `labeled` instead of `opened`.
Now lets trigger this ci-patch again with a new pull request.
This was so annoying, I forget how much I hate doing ci-cd sometimes, it feels like I am going backwards with my time xD.

**Dev**

Now that we got the patch branch resolved, we can look at making improves to our dev branch.
There might be some issues here and there, but I think we can resolve them if we walk through it all in small steps.
We could step up a bit further and organize all the commits that are being made into some different categories.
After updating those categories, we can pull in a quick ai magic too and give us an updated summary of all the changes too.

## 2023

- 8:49am - Backend updates should be automated but I am running into a couple different issues, including the backups and data management. The next move would be to build out self-hosted Github runners that we could call within the repo? They would handle the migration of data but outside the scope or control of Github. Furthermore, I think there should be a backup plan for the Github repos themselves, which I have noted.
- 11:30am - First time in a while where we had a solid lunch with the co-workers, I am always excited to hear the interesting hobbies that people are involved in! I did not know that you could easily build your own in-house hardware because circuit boards can be printed on demand per unit?! I knew it was a service but never realized that it is not just a B2B but a growing B2C operations.
- 1:09pm - Watching the Apple event! It makes me want to make apps for their products a bit more, its like a motivational speech for tech nerds.
- 1:36pm - Adding Scene management into virtual engine file, I am also thinking of just making the whole VE file be something that I can reference almost anywhere in the future. It feels weird to merge everything into just one file but slowly it just seems to make more sense as I am going through it. 

## Quote

> But friendship is precious, not only in the shade, but in the sunshine of life, and thanks to a benevolent arrangement the greater part of life is sunshine.
> — <cite>Thomas Jefferson</cite>

---

## Tasks

- [ ]

---
# September: 13th

> September 13th.

Source: https://kbve.com/journal/09-13/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### CSProj Unity

-   08:50PM

    After getting a better understanding of how embedded packages work within the unity eco-system, we can remove those extra CSProject files that are in our code.
    This makes our lives so much easier and streamlines the whole package management and production!
    I am glad that we have three open source extensions within our eco-system, it opens up so much more in the future, maybe I might start to advertise them later on.

## 2024

**DevOps**

Yesterday I spent some time preparing to fix the automated pull requests and one of the features that I wanted to add into the system would be the ability to automatically summarize the changes.
This means that we will have to be a bit creative with how we handle the markdown formating for each request.
My initial plan was to place these directly into the workflow, test case them and then writing new functions within the devops library that will help us move them around.
With that being said, the goal for today will be to go ahead and migrate those over!
The first thing we need to add is a helper function to grab the pull request number, we will try to follow the same naming convention.

```ts

export async function _$gha_getPullRequestNumber(
  github: any,
  context: any,
): Promise<number> {
  try {
    const { repo, owner } = context.repo;
    const branch = context.ref.replace('refs/heads/', '');

    const { data: pullRequests } = await github.rest.pulls.list({
      owner,
      repo,
      head: `${owner}:${branch}`,
      state: 'open',
    });

    if (pullRequests.length === 0) {
      throw new Error('No open pull requests found for this branch');
    }

    const prNumber = pullRequests[0].number;
    return prNumber;
  } catch (error) {
    console.error('Error fetching pull request number:', error);
    throw error;
  }
}

```

This helper function follows the `_$gha_` naming convention and will be a core part of the helper function.
The example of it grabbing the `pullRequestNumber` would look like this:

```ts

const pullRequestBody = '## DemoForHoly';
const pullRequestNumber = await _$gha_getPullRequestNumber(github, context);

await github.rest.pulls.update({
  owner: context.repo.owner,
  repo: context.repo.repo,
  pull_number: pullRequestNumber,
  body: pullRequestBody,
});

```

Next we want to create another helper function that would handle the actual git difference and organizing the different types of conventional commits.
The helper function that we are going to add next is `_$gha_updatePullRequestBody`, which will work ontop of the previous helper function that we wrote above.
It will look something like this:

```ts

export async function _$gha_updatePullRequestBody(
  github: any,
  context: any,
  prBody: string,
): Promise<void> {
  try {
    const { repo, owner } = context.repo;
    const prNumber = await _$gha_getPullRequestNumber(github, context);
    await github.rest.pulls.update({
      owner,
      repo,
      pull_number: prNumber,
      body: prBody,
    });
    console.log(`PR #${prNumber} updated successfully`);
  } catch (err) {
    console.error('Error updating PR body:', err);
    throw err;
  }
}

```

Granted, in the future, we will have to loop back around and create a whole new debug class to handle our `console.log` and `console.error`, but for now this should be fine.

**Publish**

We released two new packages today, the updated jedi crate with the zerocopy regex functions and then these minor changes to the devops library.
The next part of this will be to actually add in the npm package and see if we can get it to work the way we were planning in the past.
Updated the ci-patch and lets see how it works in the next push!

**KillTony**

The second MSG episode just dropped and it was perfect, seeing trump and biden return only made it even better.
I am a bit upset that black keys played and I could have seen them there, like damn!
I really feel bad for the people that got the first night because the second night was a whole new level of entertainment.

**Pipeline**

Pushing up the pipeline again, it looks we are getting a bit better with the quick releases.
Making sure that we keep the cycle clean and operational should be a side goal that we maintain, I might also start to splinter up some of the patches.
The next branch that I want to introduce would be either `major` style or maybe `issue` style, such that they are specific to an issue until it gets resolved, hmm.

<Adsense />

## 2023
- 8:34am - The mornings need to be a bit better, I might have to start sleeping early again or maybe finding a way to still program without having to be in-front of a screen. It could be the blue light or just the brain drain that comes with the amount of thinking that would be involved. There is something to be said about how fast things are moving in the machine learning eco-system, its moving too fast and my brain is unable to keep up with all the movement. 
- 9:45am - Good to see the markets performing well, I am going to have to push my calls further up for the week and hopefully my TSLA puts expire in the money! While I am not in debt, the current cash reserves are dropping really low, I am currently sitting with only $29,500, which has been the lowest cash balance in years and I am not too sure how I feel about it. I have made extreme budget cuts but there might be not be other options other than moving forward with increasing income. I will have to pivot a certain part of my calendar with more blocks towards generating an increased amount of profits.
- 2:05pm - Within the scope of the Appwrite's storage, I am thinking that JuicyFS would be the best move to stress test this weekend! I will have to see how it performs with I/O and net speeds between the datacenter and my local Charles. 
- 7:53pm - The whole unity engine drama seems to be getting worse! I am extremely sadden with how they are handling all of this and honestly their engine is not even worth this type of drama! The idea that they will get better revenue in the short term is not worth their long term growth because unreal is already leaps ahead in terms of rendering, ugh, even typing this out makes me sad. 

## Quote

> Give whatever you are doing and whoever you are with the gift of your attention.
> — <cite>Jim Rohn</cite>

---

## Tasks

- [ ]

---
# September: 14th

> September 14th.

Source: https://kbve.com/journal/09-14/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### SSDB - Supabase within Unity

-   10:10PM

    After our unity session, we are now clear to finish up the Supabase integration.
    Well we want a safe way to log into the game via OAuth through Supabase!
    Afterwards, the only thing that is missing is the metrics integration, which would require a bit more from the realtime side.
    I did notice that getting the auth passed through does slow down the realtime a bit, which might be something that we need to work out in the future.

## 2024

**NYC**

Started the day out with a quick day trip throughout the city!
I enjoyed the whole trip but the traffic was terrible and honestly it is rough.
The event was a friend's child's birthday party and I just did a quick 1-2-1-2.

**League**

A quick league match before diving back into a programming session.
However, everytime I login, I get that feeling that its just a huge waste of time because I am not streaming, which is because of charles being down.
Anyhow after a couple matches, I will start fixing up `github.ts`.

**Github.ts**

The function that we want to take a look at is the formating one, which can be extended a bit!
Added a `types.ts` for the devops library, which we will use to store all the different types that we might need in the future for the library.
I should have done this earlier but I was not too sure how complex I wanted to make this library, but its going to build into something major, almost a pillar for the monorepo.
A couple future concepts that I was thinking for the devops library would be to include some `IaaC` and even deeply integrate the `nx` eco-system, but these are still far into the future.
Hmm, I am thinking of dropping the `_$gha_fetchAndCategorizeCommits` function and replacing it with two more functions, splitting the actual parsing and then another function for the formating.
Currently the function does both and for test casing, it seems fine but we do need to make changes that would make sense.
?

**Kubernetes Client Node**

The next library that we want to add into the devops package would be one that can help us work within our cluster.
Thus it would make sense to start researching a bunch of different k8s api libraries and so far it seems that the `@kubernetes/client-node` fits the bill perfectly.
After doing some more research, I am now looking at the pulumi library and looking into what it offers for us to extend out into.
My goal was not to build an iaac from scratch but rather work around an exisiting one, then add a couple more new features.

<Adsense />

## 2023
- 6:45am - This might be the first time that Taco bell actually did not mess up my system! I think it might have to do with my increased intake in frozen veggies, a couple bags of peas, carrots and some other greens have been doing wonders. I feel great in the morning because of it.
- 8:40am - I need to find a way to clean the showers a bit faster, I am thinking of a micro-style solution where after you finish taking a shower, you could spray around a mixture of solution that helps? Or right before you shower, I know I like to run the water really quick for 30 seconds before it gets to the right temp, during that time period I could spray something down? This is a shower thought. Actually I used to eat oranges in the shower, maybe I could come up with an interesting blog post about it!
- 1:18pm - Sync the changes made in various websites into the central repository, this way we do not have to spent too much time migrating the notes between different repos.
- 2:07pm - The patch system needs a bit of an improvement when it comes to the automatic deployment and updating, I am thinking that it might be best to do a couple different branches and then see how it performs from that standpoint and then just do a final push to master, which would then create the new branch. 
- 2:15pm - Adding automated sync test with the Auto-GPT and making sure that the plan is updated without having any issues. Afterwards I will update some of the backend features within the AutoGPT, I might just make a Dockerfile + compose for their whole structure, then finally stress test the whole eco-system a bit. 
- 5:05pm - Still having a bit of trouble with the docker build but I am switching over to another side project while I wait on the docker notes to be pulled and updated. I am actually enjoying the dev space style that I am working in, it just needs a bit more of an improvement in terms of organizing. 
- 10:04pm - Docker build seems to be working fine locally, now I just need to finish up getting the action system work as intended and then finally the automated deployment. This way all our updates would be in sync and we could work on Auto-GPT with a solid MLOps.

## Quote

> Instead of saying that man is the creature of circumstance, it would be nearer the mark to say that man is the architect of circumstance.
> — <cite>Thomas Carlyle</cite>

---

## Taskss

- [X] - Docker Build for Auto GPT.

---
# September: 15th

> September 15th.

Source: https://kbve.com/journal/09-15/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### OneJS UIUX

-   11:15PM

    Late night notes, we were focused on the migration of all the unity ui into the one js / javascript uiux.
    Eventually all of the fancy unity ui aspects will just be part of that One Js system and we can really push the tsx integration.
    Furthermore, we have the tencent typescript/javascript to c sharp integration that I want to spend more time understanding!
    This can make the future UI side of the game easier to understand and scale, as I stated before, it would replace the whole need for react native too.
    The bridges that we want to build will be around 4-6, one for each of the core services and they will be placed inside of the database extension that we been building.
    I might have to refactor it again in the future and move all the steam parts into its own future extension, so that we can do the mobile builds without issues.

## 2024

**Deadlock**

The game is getting really fun and I am starting to fall into love with it!
However, I really should spend the time to focus more on the backlog, but once charles gets operational then I will definitely have a couple more rounds ready.
Playing the game on the laptop is a still a bit rough and it might be because it is not optimized.
Besides playing haze, I am about to try out the melee build next.

**Github.ts**

Updating the github.ts with the updated functions and making sure that they work at the local level before moving them up.
It is a bit tough to write test cases for the different parts of the github code because they are wrapped around the live github api.
The formatting of the new pull request is now all within a function, called `_$gha_formatCommits`.

```ts

export function _$gha_formatCommits(cleanedCommit: CleanedCommit): string {
  const { branch, categorizedCommits } = cleanedCommit;
  const { ci, fix, docs, feat, merge, other } = categorizedCommits;

  let commitSummary = `## PR Report for ${branch} with categorized commits: <br> <br>`;

  if (ci.length)
    commitSummary += `### CI Changes: <br> ${ci.join('<br>')} <br> <br>`;
  if (fix.length)
    commitSummary += `### Fixes: <br> ${fix.join('<br>')} <br> <br>`;
  if (docs.length)
    commitSummary += `### Documentation: <br> ${docs.join('<br>')} <br> <br>`;
  if (feat.length)
    commitSummary += `### Features: <br> ${feat.join('<br>')} <br> <br>`;
  if (merge.length)
    commitSummary += `### Merge Commits: <br> ${merge.join('<br>')} <br> <br>`;
  if (other.length)
    commitSummary += `### Other Commits: <br> ${other.join('<br>')} <br> <br>`;

  commitSummary += `<img src="https://kbve.com/assets/img/letter_logo.png" alt="KBVE Logo Image"><br>`;
  commitSummary += `For more details, visit [the docs](https://kbve.com/welcome-to-docs/).<br>`;

  return commitSummary;
}


```

We will save this function the way it is for now and move it up.
Extending it out and adding a couple helpful links, making it a bit cuter and things of that nature can be done later tonight.
Maybe we can add some helper constants, like `logo_markdown` and `footer_markdown`, which should wrap around the formatted commit.

```ts

const logo_markdown = `[![KBVE Logo](https://kbve.com/assets/img/letter_logo.png)](https://kbve.com)<br>`;
const footer_markdown = `For more details, visit [the docs](https://kbve.com/welcome-to-docs/).<br>`;

```

We can work with that for now!

- 10:05pm: Time to test out the next pull request! Yay!

**Rust Api Profile**

On the side, I wanted to get back around test casing the rust api deployment with the different jemalloc deployments.
After looking through some of the examples, there are some ways that I could rewrite the api profile to be extremely clean and limit the clones.
I am updating the Dockerfile for the chisel to include these configurations:

```dockerfile

ENV MALLOC_CONF="background_thread:true,dirty_decay_ms:1000,muzzy_decay_ms:1000,lg_tcache_max:16,narenas:4,oversize_threshold:8388608"

```

We could also lower the oversize_threshold and adjust the tcache/arenas but for now these should do more than enough.


**PlanetScale**

The HA deployment of postgres is going great and it might be time to start shutting down the database, they were a great service for testing but $40 a month is just too much.
The price point is great for the 3 deployments of 10gb space but with our current movement towards postgres, it would make sense that we slowly shutdown the mysql operations.
Now let us see how easy it will be to leave them, but I doubt there would be any major hurdles, our last bill is just around $20.

<Adsense />

## 2023
- 3:30am - The n8n message was sent to me a bit early into my sleep but I was able to get a hand of it and read it through. I do need a better understanding of Agents and chains, however some of what I been reading and seeing has really gotten me a bit ahead of the curve, per say. I am able to understand a decent more than what I had even a week ago, there are a couple things that I want to test case out. Now I must sleep.
- 10:05am - Almost missed a meeting! I made a mistake in not having my phone turned into silent and the device got me. Once that blue light from the screen hit my eyes, it was all over, the dreams had faded away and I was wired. 
- 12:50pm - I need to review all the issue tickets that I currently have and then start to resolve them within this weekend. This should help us stay in focus and build out what we need to move forward. 
- 2:02pm - Fixed up MDXJS so that the padding is not a nightmare in the mobile mode. Shifted some of the layers for the stocks/crypto and now I need to do the test casing for the widgets.  
- 4:44pm - Just got back from getting coffee with a new friend, we were only suppose to be there for 30mins but ended up being there for a bit too long, so I had to cut the conversation short and told them that I had to go. Now I will just keep it cool and move forward! 
- 7:38pm - Setting up the Appwrite Register function for KBVE, including a completely new one that we can utilize in the future.
## Quote

> Give whatever you are doing and whoever you are with the gift of your attention.
> — <cite>Jim Rohn</cite>

---

## Tasks

- [ ]

---
# September: 16th

> September 16th.

Source: https://kbve.com/journal/09-16/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### ClickHouse Operator

-   09:10AM

    After looking through the PostHog documents, it is time for our talos instance to deploy the operator.
    It might be a while since we get it all, actually as I am writing this, I noticed that I was referencing this last year!
    What are the odds that a year later we would actually have the talos running and are about to deploy.
    Actually, I am thinking that I might finish up this operator and then go back into rebuilding the kubernetes cluster with the cozy stack. 
    This would be an interesting turn of events in the future, I am actually glad that I am back down this road and kept notes.

## 2024

**12am**

Burning that midnight oil with cans of hazy IPAs.
Okay, the next couple updates for this week should be done faster, I am about to wrap up my [k8s](https://kbve.com/application/kubernetes/) deep dive. 
Going back around and updating the notes for k8s/kubernetes.

**Anime**

Oh man the ban wave and removal of all those anime streaming sites has been a huge pain.
Yet, I am thinking a closed and invite only will become more popular, maybe even making it so that it has everything but also a ton of protection and ease of use.
The question then becomes, how would we handle the traffic and demand, without having too many issues?
Hmm, maybe having a webRTC setup or a more complex seed and tree setup.

`OvJhPP/h0zTOl4nj/S097EJw6nUcekALQTxhLYaVJaD87ruvITffXfsTdIMhK97J` 

**Ubuntu**

There was an error in the rancher regarding the disk space, so we can go ahead and look into expanding that out!
Furthermore, upon inspection, I did notice that we need to go through the ubuntu image and check for updates.
I suppose this is where microOS and talos have their shine, the ability to no longer have to do any of this.

```

25 updates can be applied immediately.
To see these additional updates run: apt list --upgradable
System restart required

```

The issue we looking to resolve is the lack of space in the `master2` node but added another 18gb, moving it towards 50gb.
Next, we will go through the vm backups, making sure that master2 is up to date with the backups and then removing the older backups.
Okay the backup was good to go!
Now we need to figure out why the image deleting fails.

**Talos**

The next topic of interest was trying out talos over the current k3s instance, yet I am not too sure if we need to go down this route.
I was told we could easily setup a three node cluster and have this be operational without any major issues, however I am wondering how the storage would work.
Even though I thought I was done with my kubernetes research, there is always something that will pull me back in!

The first step would be to walk through the image factory and create a custom image for us to boot from.
From my understanding, the factory will help us build the proxmox iso that we will be using to deploy our base talos image.
I believe we would want to add some custom kernal configurations that would be passed through this instance.
Hmm, as I keep researching, I came across the `cozystack`, which feels like a coolify-like system that would focus on the kubes rather than the docker.
This should be the approach that we take for our whole stack, making it easier for us and it already has everything that we need!
Managed Postgres, managed clickhouse, okay I am definitely sold.
For some side notes, the cozystack is managed by the aenix and we will be deploying the v0.15.0.

**KillTony**

The best way to end a monday night? Oh course its a kill tony night!
Overall, I think the episode was a 5/10, some solid sets here and there but eh, it might have been closer to a 4/10.

**Elemental**

So it seems that Rancher also has its own immutable operating system, so more research to do.
I will add the docs as a reference inside of the issue ticket and will add more information on this on a later date.

<Adsense />

## 2023
- 4:45pm - Okay got some of the networking resolved with the Appwrite v1.4.3, its really just getting the general gist of the flow. Honestly looking back at some of the situations, just redeploying the stack was not enough, I had to stop the whole instance and then create a whole new instance. 
- 7:18pm - Finally got the docker swarm to work within my favor, there were a couple issues that I needed to resolve but for the most part it was pretty dope to see parts of the functions working. Now getting the command line to be operational will be the next step, but that might be something that I am willing to wait off on until things are a bit more stable within the eco-system at Appwrite. 
- 7:22pm - Now I need to convert over a couple of the cloud functions for the whole eco-system to the new repo and then do the deployment from there. I have to also test case the backup system and make sure that it works as intended, but that will be worth it before the hackathon.
- 11:05pm - Looks like the swarm is still healthy with no major breaks as of right now, going to keep test casing it and seeing where we can push the boundaries for our application stack.

## Quote

> To give oneself earnestly to the duties due to men, and, while respecting spiritual beings, to keep aloof from them, may be called wisdom.
> — <cite>Confucius</cite>

---

## Tasks

- [x] Get Appwrite Swarm up and running with additional integrations.

---
# September: 17th

> September 17th.

Source: https://kbve.com/journal/09-17/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity DOTS

-   11:59PM

    End of the night notes, I am getting closer with the DOTS integration into the RareIcon.
    There are some issues with the render pipeline, which was currently at the standard version but I was able to upgrade it to URP.
    In order to do the upgrade, I had to remove the top down engine and upgrade the version from v4.2 to v4.4, thus making it easier.

## 2024

**Deadlock**

Talking a quick break from the general meetings and rift raft of the day, need to enjoy the cool feeling of silver surfer kelvin.
Overall the game is growing on me and I hope that they expand the PvE aspect of the game further.
The ice gernade and melee combo on him is super fun, I think if I can get around 20 to 100 rounds playing it through, I should be solid enough to win some matches against players.
I been using the bot matches to get a better understanding of the map and the movement, looking for shortcuts and getting better at my dash jumps.

**dotNet8**

The saber build looks like it failed on the main branch and I am thinking it might be because we are using dotnet7?
It might be time to officially switch the package and the saber build over to dotnet8 and that also means converting the whole saber project to unity6.
The circle ci build for the unity6 has been released and with the canceled runtime fee, its a perfect combo for me to move forward on that department.
Furthermore, we had to update the artifact github actions from version 2 to version 4 because its been a while since we had them execute.
This means that we have not worked officially on the open source version of saber in a while, but that is because we had a ton of backlog to shift through and fix up.
With the recent release of the unity6 circle ci action, we can get back to making sure that the unity part of this monorepo is functional for that version, dropping the older versions of unity.
Since the public source of saber is already outdated, I believe there should a decent amount of the files that can be deleted or replaced, hmm.

My idea now might be to just delete a large portion of the folder, then create a new unity6 build from scratch and then reimport all the files and code that would be required.

Side note: if you have a version of dotnet7 and need to upgrade it to dotnet8 on WSL, I had to run this

```shell

sudo apt remove 'dotnet*'
sudo apt install dotnet-sdk-8.0

```


**Longhorn**

Updated longhorn from 1.5.5 to 1.6.x to finally 1.7.1!
There was a situation where the longhorn did fail to upgrade but I am thinking that might be because we do not have enough room in all the nodes, which means I will have to warp back around and update the specs on them.
The storage was updated on the master2 to about 50gb, I will have to do that again on all the other 4 nodes and then do a quick apt-get install & restart.
In the future, we should look into the Element setup for the k3s, I been hearing great things about it.

**GitOps**

Okay, now the next plan for the kube deployment would be to configure the gitops and making sure that they run without any issues.
The location for the deployments should be under `migration/kube/`, let me add a quick gitkeep to make sure the folder stays in sync.
In this situation, the plan will be to create the `Chart.yaml` inside of the `migration/kube/kilobase` and start with the base information for the kubernetes deployment.
This is the example `Chart.yaml` that we will be using:

```yaml

apiVersion: v2
name: kilobase
description: The open source stack built ontop of Supabase.
type: application
version: 0.0.1
icon: https://avatars.githubusercontent.com/u/5571997?s=280&v=4

```

Granted we are doing all of this before we deploy and release the application onto the dockerhub, but this is a good way to practice the parallel ops, aka ParaOps.

Next up, there should be a `.helmignore` that will make sure that some of the files are skipped when setting up the helm chart for this directory.
I also moved the all the charts further into a subfolder, so they are now located here: `migrations/kube/charts/` and the first chart that we will be releasing is: `migrations/kube/charts/kilobase`.
Added a quick readme and now I am going to start to upload each of the template pieces.

Now that I am thinking it through, it would make more sense to keep the application name as supabase because its all built around it and make sure that the custom iamge is just the kilobase.
This would resolve some of the issues that I might face down the line with updating and besides the `kilobase.so` extension, everything else is from supabase.

Each subfolder within the templates would represent a different service for the full stack!
The first one is the analytics, which should be easy for this type of situation.

Next is the big one, its the `deployment.yaml` for the db aka database, in this situation we will have to come back around and adjust it so that it uses the cnpg operator directly for the deployment.
The other option would be to just to set it to be an external database and then have it connect to that but I believe in our first instance, we want to atleast make sure all the other services can run without any major issues.

Okay now to add the function charts to the stack.



<Adsense />

## 2023
- 10:32am - Lunch with the family, I know it will make me feel old because I am watching all my younger niece and nephews grow up to almost become adults, which is wild to me.
- 2:11pm - Spent the Sunday morning hanging out with the family! Now I am back on the computer and going to start the micro function migration.
- 4:45pm - The first function will be the register, which has been somewhat of an issue for a while because I have to make it create the user, profile and the various other components within the structure.
- 8:21pm - Everything is working to a certain extent, so I am glad that it is moving along! I am getting a better understanding with how Appwrite and Docker are working, its really making things a ton easier as I am getting to understand it.
- 2:00am - Halo and One Piece?! I am all into this mixture! Best combination, because its really a throw back, I remember playing halo 2 and watching one piece at the same time a decade ago.

## Quote

> A good decision is based on knowledge and not on numbers.
> — <cite>Plato</cite>

---

## Tasks

- [ ]

---
# September: 18th

> September 18th.

Source: https://kbve.com/journal/09-18/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

**Midnight**

Burning that midnight oil again and looking through the different ways we can deploy the `db` within the supabase stack, such that we would get the database to operate under cloudnative-pg.
I noticed that some examples did not include the barman directly inside of the postgres image, so we will have to make some changes to acknowledge its purpose in our instance.
While doing that, I could also take a look at adding more concepts to the website?

**Chores**

Took a look at some of the dependencies and decided to do some quick cleaning.
Without trying to break the whole monorepo, I updated the `vitest`, `tailwindcss` and `vue` with their minor updates and patches.
Afterwards, I removed two colyseus packages from the earlier install of it, making sure we are good to go without it anymore.

**Functions**

The functions deployment will be in two stages, first we will launch the initial supabase edge function docker image but then during the second stage, we will replace it.
I believe the new function image will be `kilofunk` but that is still a bit out there because there are a couple changes we need to do and have to get through the inital deployment.
Thus for stage one, we will go ahead and upload the helm charts from the community for the functions.
Wrapping back around to the functions, I will create another topic for the kilofunk concept and see if we can work around that.

**IMGProxy**

For the image proxy, we will not be too worried about this right now and can just add it in and move forward.
This would be something that we can look through post-dev cycle and probably after backups and recovery are fully functional.

**Kong**

The kong that supabase operates with is an older instance, I believe a v2.8.x and it should be replaced with a v3.
However this should be done during the performance stage and for now it might not be worth spending too much time looking through it all.
There was some test casing we did during the swarm and the kong held up fairly well.
This will be another topic, we might call this the kilokong and build a layer ontop of the kong v3 that will help integrate some of the changes for the supabase.

**Meta**

The next set of charts are for the meta, aka postgres-meta.
This is another one of those situations where we can look at it post-production and we just let it be during our swarm deployment.
I believe the latest version is v0.84.0 but that might not be worth updating given that we will be deploying an older instance of the community postgres.

**Minio**

For the local s3 storage, the community charts provide an instance of minio, and we did not deploy this in our docker swarm stack but for now we might just skip it for this cluster deployment.
This will be something we determine during the deployment, I believe we will have to disable this.
If we were going to enable it, I would have to switch back around and make sure that it will use the longhorn storage.

**Realtime**

In addition to the post-production tables that need to be added, which is on our todo list, the realtime part of this cluster looks a bit rough around the edges.
For this smaller commit, we will start with the base realtime charts and then wrap back around to turn the carbon into a diamond.

**Rest**

The rest api will be another community helm chart that we can add next.
The postgrest/postgrest version on this community is tagged v12.0.1, but our swarm stack is using v12.2.0, thus I will have to look through that again.
Other than that, we should be fine with the settings that are in-place right now.

**Secrets**

The sodium secrets are also included in the docker swarm stack but I believe supabase is planning to replace them on a later date?
I wonder how this would work for them, considering there are a decent amount of moving parts that revolve around it.

**Storage**

The storage charts are next, once more these are something that we look at again post dev cycle because it will require another operator to handle the storage for them.
For now we will keep the community base template, similar to the other situations that we were in earlier.
The concept is similar to the s3 and have custom buckets that we can work with, hmm, this will definitely be post-post production.

**Studio**

The last three charts that we will be adding are for the studio, test and vector.
These will also have their own issues and I believe we will have to layer something ontop of them to protect the routes, hmm.
We could just make it so that the studio is only accessible via the rancher ingress and prevent it from being routed directly by the kong configuration?
Since the studio can operate without having the direct reference, but in the swarm deployment, we placed a traefik layer ontop of the route and protected it with a custom environmental username and password.
Some of these changes remind me of the planck's principle, but hey its just part of the adventure.

**Worker4**

The worker4 will go through a maintenance window and during that peroid we can test case some of the automated upgrades.
I am still on the fence on how I would like this to be done, there were a couple suggestions made but this will be in the air for exactly which route we want to take.
The worker4 storage will be bumped up, so we are increasing the size of the scsi0 by 18GB, going to a total of 50GB.
The configurations look like this: `rpool-vmdata-vm-234-disk-0,iothread=1,size=50GB` and now we will have to go into the container and bump up the size.
Okay the resize was fine and we noticed the metrics jump to adjust for the new size, but there will be some other issues that need to be resolved!
I wonder if I can just take the worker offline and do the changes without it breaking the stack, hmm, I believe the raft will help resolve that issue, thus making it easier for us to take it offline for the window.

After trip to the cafe, we will take the worker4 offline and do the updates.
Okay after applying the `apt-get update`, it seems we had to update the kernel.
It was operating under `6.8.0.41` and now with this update, it should be `6.8.0.44`.
After running the `sudo reboot`, we got the taints: `node.kubernetes.io/unreachable=:NoSchedule` and `node.kubernetes.io/unreachable=:NoExecute`
We can see the update live via the rancher, which does help when doing paraops, looks like the worker4 is operational again now.
Okay now we are going to get the next kernel update with another dist-upgrade, hopefully getting us to 6.8.0.45, but now we will have to reboot and knock the worker4 offline again.
I can see why some consider moving to an immutable operating system in some of these cases, as it can be a bit of a pain to handle.

**Cafe**

Some of the converting of the swarm to helm will require a decent amount of caffeine!
Okay before I perform the restart for the worker4, I will go ahead and grab some cafe and stock up on the bulls, then when I come back around, we can see how the upgrades will affect the cluster.

**Vault**

The issue with the vault is that it is not HA, which means that we need to reconfigure the deployment of the vault, ensuring that the HA is setup with an internal raft system.
We could use consul to help us with that but that might be too much overhead for just this, having an internal raft would make more sense.

**Longhorn**

It looks like there is a version mismatch with the longhorn, so we will have to fix that as well.
I am thinking we remove the vault and then go back around and remove the longhorn setup.
Afterwards, we could tgry and build the longhorn setup from scratch again but with the version of 1.6.x, instead of the 1.7.x.
Hmm, however we do want the 1.7.x, so maybe this is just part of the upstream and we need to wait for it to stablize.

**GitOps**

Now that we got the base templates installed, we can go ahead and begin the first failed deployment.
The goal of the first deployment is to make sure it fails at setting up the cluster from the branch, the sole objective is to see if it can pull the charts that we added.
After we can confirm the charts are loaded, we can go back and begin updating the charts.
Under the current situation, as of 6pm, I am thinking the best move would be utilize the rancher fleet and if we run into any issues with the fleet, we can step back towards the argocd.
So of the two mainstream options, Fleet and ArgoCD, we will use fleet first because its already included in our instance and then if we run into issues with fleet then we can switch back to the classic ArgoCD.
Okay, stashed the changes, switched branches and now preparing for the fleet!

The breakdown so far looks like this:

- Name: supabase
- Repo: KBVE/kbve
- Target: Advance
- Clusters: 0/0

We also added the path of `/migrations/kube/charts/supabase`.
Since there is no path within the main branch right now, we are getting this error.

`Job Failed. failed: 3/1time="2024-09-18T22:34:10Z" level=fatal msg="no resource found at the following paths to deploy: [/migrations/kube/charts/supabase]"`

Now I am thinking it might make more sense to deploy via the `dev` branch, instead of the main branch, this would help us avoid some of the issues that we might face down the line?.
But let me just try it via the main branch and then if it works, we can go back and updated the fleet to deploy from the `dev` branch.

Okay the folder structure needs to be to be nested by one more level, so it would be `/migrations/kube/charts/kilobase/supabase`, then within the `kilobase` folder, we would add the `fleet.yaml`.
This should help us with the 

<Adsense />

## 2023
- 9:34am - Backups are working great! Yes! I am surprised how easy it has become with all these new reference points and documents out there, I am actually really content with how an area that is the least serve, has so many improvements xD.
- 2:01pm - Re-organizing the KBVE.com repo so that it is a bit easier to use in the future, including the part where I would add in abstract functions. I think isolating the Appwrite functions as their own repo was a good initial idea but now I am thinking of combining them all into one and then seeing where we can go from there.
- 3:47pm - Got most of the Appwrite functions resolved and now I am going to merge the functions into the KBVE.com repo, under the /public/ folder. The plan now will be to build out a bunch of different appwrite functions, then fine-tune train against them all so that we could have our own LLM build appwrite functions? This will be a wild project but I am all for it.
- 7:32pm - There were some minor changes that I need to do with the repo but for now I am focused on getting the functions operational.

## Quote

> Meditation is the dissolution of thoughts in eternal awareness or Pure consciousness without objectification, knowing without thinking, merging finitude in infinity.
> — <cite>Voltaire</cite>

---

## Tasks

- [ ]

---
# September: 19th

> September 19th.

Source: https://kbve.com/journal/09-19/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

**beau is afraid**

Just spent the midnight watching this amazing piece of comedy & horror film!
It was 3 hours long but it was twisted, funny and wild, I would recommend going into it but with a bunch of people.
I think its a bit rough to watch alone, its definitely better with a couple other people over a discord call.
An IRL Jojo adventures.

**Fleet**

Okay we did the first phase of the fleet deployment and we were able to get the charts automatically loaded.
Granted it failed to deploy a decent amount of the services but that is fine because we did not include any of the secrets and thus, a decent amount of the services failed.
The `armada` could be another part of the deployment that can help us with the secret management, using the sealed secret concept but I am thinking that the vault might be enough for what we want to do.

**CICD**

While we are doing the fleet ops, we also need to create the custom kilobase image that we have to add into our fleet.
This part of the build process will be a bit annoying because we need to make sure that the requirements for building the custom postgres extension has to be done outside of the docker build.
On the debate of how we should handle the extension building process, I felt that it would make more sense to have it all built outside of the docker image and then just copy the extension over.
The other path was to build the extension within the docker image itself, which we can do if this outside-the-docker image build process becomes too much of a pain.

For the first part of the CICD workflow, we created a custom job called `kilobase_dev_cicd` and we know that this will fail in a couple spots.
The goal for this would be to get the base image published as a `kilobase-dev` before we go out of our way to build the main image!
I am not too sure how the tag system will work in this case because I believe we will have to update the project.json to include all three, `local`, `dev` and `production`.

The CICD failed this time around because I placed `postgresql-server-dev-15` and it should have been `postgresql-server-dev-all`, but I am wondering if I need to also include something else for this part.

**Kilobase**

The extension has three core errors within the query for the background worker.
A couple of the errors is just a type mismatch and I can adjust them as I am working through the changes in the workflow, but damn paraops is rough on the mental state.
Keeping track of all the changes in the eco-system and placing all the puzzle pieces together at the same time they are being printed out of a machine.
Spent way too many hours going through the possible ways of resolving the background worker, the only solution that I could come up with was to migrate all the code into the worker.
I would have enjoyed having some level of isolation within the fuctions but there just was way too many type issues and I rather keep things simple for now.

The adventure of getting the container running, I might just switch to tomorrows entry for this.

<Adsense />

## 2023

- 8:45am - The weather is amazing right now, its wild to see actual stable fall weather. I miss hoodie season. 
- 1:31pm - An interesting meeting over the secret storage and how we could improve upon it. I am just sitting there thinking, damn

## Quote

> For everything that lives is holy, life delights in life.
> — <cite>William Blake</cite>

---

## Tasks

- [ ]

---
# September: 20th

> September 20th.

Source: https://kbve.com/journal/09-20/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Sunday Session - Weapon Aim

-	06:30PM

	The session starting off with the focus on the weapon aim bug that we were having!
	This is still on the gameobject side and we will have to figure out the best course of action for handling this.
	I am glad that we are finally twitch streaming as well, making it easier to save the session as a youtube video.

-	07:16PM

	Psychotic updated the Character Orientation 2D to override the one that More Mountains provides.
	While he is tackling that issue, I am doing some research into the Age of Sprites and trying to resolve our ECS deployment of the units.
	We will have a hybrid setup for the game but we need to make sure that the ECS side works , giving us the freedom to move units out of the gameobject area and into the entity system.
	My plan is to have the minions be within the ECS eco-system and have the main boss be a gameobject itself.
	I believe we can achieve this through a strong centralized event system, which the MMEvents is already becoming.

## 2024

**Kilobase**

The amount of jumps that I have to go through to get this docker image to be uploaded onto dockerhub.
Honestly we got the build, just passing the push flag seems to be a pain and might just be some sort of out-dated docs that I been referencing? hmm.
While the build is going on, we can take a look back at the bgworker and maybe take a look at ways to integrate the jedi crate!
One of the areas that I was thinking was double checking the URL before we use it?

To get started, we will alter the jedi crate and create a new regex and function:

```rust 


pub static SANITIZATION_URL_REGEX: Lazy<Regex> = Lazy::new(||
	Regex::new(r"(?i)^https:\/\/[A-Z0-9._%+-]{1,63}\.[A-Z]{2,}(\/[A-Z0-9._%+-]*){0,64}$").unwrap()
);

pub fn extract_url_from_regex_zero_copy() -> Result<&str, &'static str> {
	if SANITIZATION_URL_REGEX.is_match() {
		Ok()
	} else {
		Err("invaild_url")
	}
}

```

After adding the function, we want to run `./kbve.sh -nx jedi:dry --no-cloud` to make sure that the package will run without any major issue.

**Docker**

Okay, switching back around to the dockerhub release, we got kilobase uploaded but the image that it placed was directly a reference to the sha and pr, but not the tag that we wanted.
I am going to move this part of the issue off into a side note because it has been way too long of a problem to resolve!
This might be because we are not calling nx container directly but rather a custom nx command.
I went back around to the `project.json` and took out some of the additional tags that were there.

The current settings for the json are these:

```json

"tags": [
            "type=semver,pattern=15.1",
            "kbve/kilobase:15.1"
          ]

```

We could either drop the `type=semver,pattern=15.1` or the `kbve/kilobase:15.1`.
The whole tag system feels a bit off!
I believe it might be because this is my first time doing the tags through the nx monorepo, so I am definitely thrown off a bit.
The next round we should look into pulling the tag from the environmental variable or setting up a script that would help adjust the tags for us.
For automating the tag system, we could just keep the major and minor to reflect the postgres, then use the last set of numbers to reference the version of kilobase that we are using?

We could also do a system where it is supabase version as our base N and then make changes as N+C+1, where c is the commit?
That might end up being a bit too complex, better to start off small and keep it simple.

An example of the shell script would be to pull the current cargo version for kilobase and then pull the major and minor from the base supabase image.
The shell script would be two parts, hmm, we are checking the `apps/kilobase/Cargo.toml` and `apps/kilobase/Dockerfile`, grabbing the data from those two files to then generate our actual version.


**Benching**

A quick break from the coding in about 20mins and doing some quick workouts, my brain might need some more bloodflow xD.
I spent almost the whole night trying to debug these weird and nearly pointless build problems that should have been super easy.
Setting up k3s was easier than this pepperhole.

**Armada**

We can begin setting up the armada next!
The central parts of the armada will be located here `migrations/kube/charts/armada`, with the core being under a subfolder that we will call `shipyard`.
Under the shipyard, we will deploy the operators and management tools, with the goal of having it all within one easy to deploy cluster.
Part of the Armada will be the `Elemental` deployment but that will take some time to move into, we will most likely do that after the supabase deployment.

Upon further research, we can have the shipyard access the helm charts directly, allowing us to build ontop of the bitnami charts.
There is still some of the concepts that I am not fully grasping but that might have to do with just me not being fully based.
Thus we will be deploying the armada this weekend, which should provide us with a couple additional operators that we can use to help us debug some of the supabase issues.

During deployment, we got this error:

```
level=fatal msg="open migrations/kube/charts/armada/shipyard/values.yaml: no such file or directory"
```

I am thinking that it might be because we have a file called values.yaml that is empty, so lets go ahead and remove that?

Getting no where with this fleet deployment, its even worse than the supabase one because we are going backwards! xD
To rule out if its a sealed secerts issue or a general fleet issue, I will try to deploy redis as well.

<Adsense />

## 2023
- 9:34am - The next move would be to test case the appwrite connection on multiple widgets and concepts outside of the general structure. This will be an interesting way to see if the CORS issue is specific to the `kbve.com` domain or if its Traefik or if its Cloudflare, ect.. There are a couple different areas where we might be having this CORS issue but this might be the best way to guess and check.
- 1:26pm - I am thinking of cloning out the YoRHa UI to be a bit like the Aura Idle but I am on the fence because of too many abstract libraries. I might use a 3rd party engine but at the same time, I might just stick with the basic vanilla Javascript as much as I can before I really add more weight to the components.
- 3:00pm - Taking a side break from the YoRHa UI and now adding Toasts into the KBVE repo. There are two main libraries that I am looking into, Toastify and Svelte-Toast, yet it seems that both get the job done, but I am on the fence on which one that I would use.
- 4:03pm - Was really hoping the feds would not increase the rates again but I will take a small hike on the table for the remaining year, I guess. Those calls all expired in profit!
- 5:14pm - Toast looks like its fine for now, needs to be a bit refined but I will have to figure out the best way to do so. I am thinking maybe outside the scope of the current templating system and has it operate as its own component.

## Quote

> Once you choose hope, anything's possible.
> — <cite>Christopher Reeve</cite>

---

## Tasks

- [ ]

---
# September: 21st

> September 21st.

Source: https://kbve.com/journal/09-21/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Zombie ECS - Overlay

-   08:30PM 

    Ghostly and I are about to enter the dangerous world of threads.
    The minions are running in a combination of main thread and off thread, so we need to find a way to have the mouse overlay.
    I am thinking since we have the R3 library, which already runs on the main thread, we could have it grab the cursor location and then find the entity that its moused over.
    This should not be too hard but lets see what we can do.

-   11:40PM

    Ending the night with a quick recap of the culling that we tried to add.
    I want to get it out of the way before I add R3 and mouse over on the entities that get spawned.

## 2024

**Fleet**

This will be our next attempt at deployment through ranchers fleet, again there are some random issues that might be from how we setup the fleet.yaml?
Back into the `/migrations/kube/charts/armada` we will be going into and making adjustments to help with the deployment.
I am going to go back and try a completely different approach with setting up the charts for armada, maybe having the armada be its own internal chart and then reference the bitnami charts as a dependency.
This might work out better in the long term but we still need to add the kustomize!
For that part of the requirement, I will come back around after it is deployed and replicated and make a `base`, `dev`, `prod`, ect...

Yes! We finally were able to get the redis and the sealed secrets to be deployed, so it seems that using the dependency style is the way to go.
This means that we can start to add external charts into our main armada chart.yaml and deploy them directly into our cluster.

Now the next test case would be to deploy the sealed secret for redis and then apply it directly to our redis cluster.
This is with the `secrets` folder and a yaml for each of the secret that we need to add into the cluster.

From my understanding, the first step would be communicating with the seal, passing through the secret and getting back the signature?
After we get the signature, we would then setup another yaml within the armada repo for the gitops.
I am going to save the base commands for this and see where we can go from there.

```shell

kubectl create secret generic redis-auth --from-literal=redis-password=<new-password> --namespace armada --dry-run=client -o yaml > redis-secret.yaml
kubeseal --controller-name=sealed-secrets --controller-namespace=armada < redis-secret.yaml > sealed-redis-secret.yaml

```

Okay so we added the sealed redis secret to the repo and now we will deploy it and see what happens!
Great! Looks like the secret was applied without any major issues.
Noo! I forgot to set the enable flag for the redis auth and now its failing to authenticate, damn it.

**Grafana**

Updating the armada fleet so that the redis instance can export its data into grafana.
The goal would be to test case the ability to communicate between our grafana's visual charts and our redis instance while doing everything through the fleet gitops.
If everything goes as planned, then we can extend it out later on with the supabase information as well, thus have a central chart for everything we run.

**RAW**

Watching this horror flim called RAW, which is in french and so far its been great!
I think the main actress is also super cute xD
Nevermind, I am way too afraid of her going crazy and eatting me.
My jimmy would never wake up if I saw her lmao, the flight mode would be activated 24/7 around that type.

**Brotherhood of the Wolf**

Keeping up with the french movie dive, the next movie that we would watch is about this mythical creature commiting crimes.
So far the movie is interesting and has a decent lineup of unique characters, but the racial undertones are also pretty crazy.

## 2023

- 9:00am - Looks like the feds took the whole market down a bit! Exciting to see how it will play out for the remaining week and even the rest of the year.
- 11:15am - Meeting before lunch, I think I am going to also take tomorrow off because I am tired and want to focus on Appwrite! I also have to create a whole new document for October, which I will bang out tomorrow mid-day as well.
- 3:16pm - Okay the general settings page looks good! I am going to push that out and see where I can go from there. Damn this is such a first world problem, I can not screen share at higher 4K, without it looking super buggy.

## Quote

> Friendship improves happiness and abates misery, by the doubling of our joy and the dividing of our grief.
> — <cite>Cicero</cite>

---

## Tasks

- [ ]

---
# September: 22nd

> September 22nd.

Source: https://kbve.com/journal/09-22/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Github Workflows

-   08:20PM

    Need to adjust the workflows for a couple of the github actions because they are a bit outdated and need some tweaks.
    When going to the workflows on the github repo, they do not display their name and that might be because I am missing something.
    For example, we have this issue with the workflows, where it shows "Rust DLL Tower Defense Build" as ".github/workflows/rust-dll-tower-defense-build.yml".
    I find that to be a bit annoying and really confusing, so maybe I need to wrap the name in quotes.

### Moving away from WebGL on RI

-   09:18PM

    Officially we ware no longer going to support the webgl build for the RareIcon.
    As we continue to build out the steam game, maybe once the demo is out and we have positive feedback, we could begin Android/iOS.
    For now, the focus will be just to get popular enough on Steam.

### Jobless Animu

-   11:59PM

    Time to finish up the second season of the show since its just been sitting on my todo list.
    After I can finish that up, I can cross that out of my ever growing rewatch.
    I did want to finish silicon valley and then finish up mr robot afterwards. 
    Maybe I could do some security work while watching the robot show, it would match perfectly.

## 2024

**Fleet**

4am, fleet, fleet, fleet, mental beats.
Okay, after dunkin my head deep into the water, some quick waterboarding and we can move forward.
I believe I need to add the paths to the additional folders, hopefully that should resolve some of the sealed secret issues.
Okay so we ended up just moving it into the templates folder, what a terrible waste of a night.
Anyhow, next we need to adjust the redis labels so that the data gets exported out.
The redis exporter also might need a password when its exporting out the data, so lets try to include that in this situation too.
Now that I am looking back at the issue, it might be within the realm of the configuration of the exporter, since we are using bitnami charts, it might be under the metrics label.
Let us go ahead with updating that part and see if it deploys!
A decent chunk of these errors are just because of a bit of mismatch with the type of older docker swarm stacks and the latest charts.
I believe this will start to get even more complex once we start to import more 3rd party charts.

**Redis**

Our goal for now is to make sure that the data for the redis instance will be displayed inside of the native grafana.
Changing the `name` to `name: redis-armada-monitor` so that it be eaiser to double check the logs.
After getting a nice fresh start of the day, I am back at the bench, doing more of the `redis metrics memes`.
The next update will be around `redis-service-monitor.yaml`, I believe the issue might be in the `relabel_configs`? or the `matchLabels`?.
Well the only way to find out is by continuing to mess around with the fleet, keep-on learning!

For the `redisLegendInput: 'Redis Input'` and `redisLegendOutput: 'Redis Output'`, I think it would make sense to just strip them out and move them directly into the configmap.
Next maybe we can pass through the `redis.addr: redis-master:6379` into the env variables and see if that can help with the values.yaml?

We know the metrics are running because we ran this command:

```shell

kubectl port-forward svc/redis-metrics 9121:9121 -n armada

```

**RBAC**

Maybe the issue was not the redis or prom, but rather the rbac?
Let us look at the options for adding them into the fleet stack.
These are the base YAML configurations for the RBAC that we are looking at:

```yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: armada
  name: prometheus-scrape
rules:
- apiGroups: ["monitoring.coreos.com"]
  resources: ["servicemonitors"]
  verbs: ["get", "list", "watch"]

---

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: prometheus-scrape-binding
  namespace: armada
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: prometheus-scrape
subjects:
- kind: ServiceAccount
  name: prometheus
  namespace: cattle-monitoring-system

```

All of this was overkill, it was a simple 2-3 lines and we are now good to go!

<Adsense />

## 2023

MIA.


## Quote

> People may doubt what you say, but they will believe what you do.
> — <cite>Lewis Cass</cite>

---

## Tasks

- [ ]

---
# September: 23rd

> September 23rd.

Source: https://kbve.com/journal/09-23/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Intel NUCS Talos

-   12:50PM

    One of the moves to expand our talos cluster will be to setup a bunch of intel nucs with talos configured.
    I am thinking of making them all steady worker nodes that our main cloud can call and have it perform tasks on our behalf.
    With the minor cpu power and okayish ram, I am thinking they would be great throw-away micronodes, perfect for one-off python scripts.

## 2024

**KILO**

Time to launch the big bad wolf!
I believe the Armada instance is good to go for now, with the sealed operator and the base internal redis.
We can wrap back around to usage and communication of that based redis for another project but for now, we can look at launching the kilobase instance.

Now we need to go back around and start to seal up more of the core secrets that we want to use.
For the sealed secrets, we want to start with the basic ones that we had built earlier from the docker swarm.
The first step in this process will be to deploy out the roles!
To avoid a bunch of failure and cpu usage of repeated deployment attempts, I believe it would make sense to disable all additional service.
We will focus on getting each of the core services up and running one at a time, with the kilobase fork of the database being the primary focus.
The cnpg operator is currently installed outside of this fleet and it operates within its own namespace, but will it be able to communicate with our supabase namespace?

**Fleet**

We will go ahead and delete the previous fleet deployment of `supabase` that we had and work on a new setup.
This new fleet will include the n8n integration but none of the hqplan / atlas images for now!
I believe for safety concerns, we will have those containers operate within their own closed system that we will be able to deploy through the supabase functions.


**n8n**

Adding the n8n chart will make our lives a bit easier to integrate and build around.
Now a bit of a crazier thing that we will be doing is directly having the n8n database integrate with our supabase postgres database.
The logic isnt too sound behind this decision but I have a couple cool concepts that I want to explore, including expanding the rust extension for Postgres to utilize the n8n.
Actually the errors that we are getting for this chart is starting to get a bit annoying, so we are going back off on it for now.

**Seal**

Now the fun of encrpyting all the secrets in bulk, then preparing to deploy them into the kilobase release.
We will use the command that we made earlier for armada. 

```shell

kubectl create secret generic supabase-secret-jwt --from-literal=redis-password=<new-password> --namespace supabase --dry-run=client -o yaml > temp-secret.yaml
kubeseal --controller-name=sealed-secrets --controller-namespace=supabase < temp-secret.yaml > sealed-temp-secret.yaml

```

Instead of running this command multiple times, it would be wise to throw it all into a shell file for us to use.
We should split it into functions then have a main function that runs those nested functions that we create.
The first function would be to double check if the inputs are there, the second function should make sure that the commands kubectl and kubeseal are there.
The thrid would handle the kubectl dry run client and output the temp. The fourth function would handle the kubeseal and output the sealed-temp-secret.yaml
The fifth function would cleanup the two files that get made, hmm sounds like a good plan for now.

The sealed function will be in a new file called `generate-sealed-secret.sh`, which we will place inside of the `tools/scripts/public/kube/etc/` folder.
For building out this function, I will just ask gpt to do the core of the function, then make changes to fit my needs!
Once the shell script works in the way that I like, I will extend the shell script into the nx run commands too, making it a bit easier to utilize in the future.

**Nil**

Looks like the current major failure is in our minio template, there seems to be some nil errors that are getting thrown around.
After resolving those errors, we got some more errors in the `executing "supabase/templates/cnpg-kilobase-postgres.yaml"`, going to see what this nil error is from.
I should create a new journal entry to keep track of the changes.


## 2023
- 6:35am - The mornings are getting cold, yes! No more ac and I can finally blast some of my PCs to max! Using my computers as a source of heat will always be OP.
- 7:00pm - I forgot to convert over my written notes to digital! I been trying to figure out the phaser engine for a bit and getting some luck in resolving some of the basic issues.
- 8:35pm - I am super excited for the next season of one piece, which will most definitely be a couple years from now with all the strikes and what not, but it gives me time to catch up on the general one piece series. 
- 11:40pm - The new john wick series looks amazing! I enjoyed the first episode a lot and can not wait to see the next episode, it is a bit of a shame that they did not release all of them at once.

## Quote

> A prudent question is one half of wisdom.
> — <cite>Francis Bacon</cite>

---

## Tasks

- [ ]

---
# September: 24th

> September 24th.

Source: https://kbve.com/journal/09-24/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Zombie Horde Mode

-   04:07AM

    We got the spawning down into the different horde squads, we just need to make the adjustments on how they will move around the map.
    There are a couple other things we need to include, but that will be for the map itself too, which is another phase in this ECS adventure.

## 2024

**Kilobase**

Already 2am, oh man, the time seems to fly when trouble shooting through kubernetes.
The goal will be to get the majority of the postgres operational but there are a room full of errors that we need to resolve on the side.
The kong settings need to be adjusted a bit for the wrapper.sh and the functions, which I will start while waiting for the build to move forward.

- 2:26am

The current error is that it wants to pull the `15.1` image of kilobase, but we released a specific image called `15.1.1`.
Maybe the issue might be because of cache, regardless, going to go back and switich the pull to Always for now and then see where it goes from there.
Actually, we could also update the image tag and make it publish with a `15.1` and the `15.1.1`.
In this case, we will do both and see where it goes from now, going to push out this branch and create a new branch.

- 3:19am

There seems to be a mismatch between the usermod for the postgres, so I am going back and switching it back to the way that Supabase had it, which was 101 for postgres.
We will bump it up to version `15.1.2` but still release it under `15.1`, but I wonder if that will cause problems, hmm.
Lets bump up the chart version too, maybe that will help with the current situation.

- 4:42am

Progress has been made, we were able to get the initial databases up and running, but there is still some issues with the other functions unable to connect.
Going to have go back around and updated all the `DB_HOST` values to be our kubernetes value.

- 4:57am

The function container aka edge container seems to be throwing an error because of the read-only file system, so let us go ahead and update it so that it can write the cache.
Under its `values.yaml`, we will go ahead and update the function setting, `readOnlyRootFilesystem: false`, which should now let us write.
One error after another, lets get this going, going to do it for all of them.
The other idea would be to just fork each of the images that supabase has and make the file changes we want, then publish them as our own images.
This way we can then force them to be read-only, but that will be way later on in the system.
Getting closer to the goal, with 35/41 resources running.

Updated the configmap with everything else we might need! Lets hope that it will solve our issue and get this baby closer to operational.


**Worker**

Expanded the worker5 sda3 to 50GB and now I am thinking of looping back around and expanding all the remaining VMs in the master series.
Adding another 18Gb to each of the masters would help with the images that we are pulling and should give us a bit more room to be flexible.
In the future, with our next worker6 and worker7, we can give them a decent bulk size but that will require some additional planning to pull off.
We did a quick resize to all the 5 original nodes.

**Markets**

What a rebound in the markets, good to see the post fed rates finally starting to give that much needed boost back to infinite.
We just need nvidia to come back into that $125 zone and we are officially printing bags.

**SQL**

- 12:40pm

The biggest issue that we have is in the configmap for the post install, which I am thinking we could resolve with our own SQL statements afterwards.
The current idea would be to isolate these additional sqls into their own configmap and then appy them afterward the main init.

- 4:00pm

It seems that the `$PGUSER` and the `$PGPASS` are reserved for the operator, so we have to remove those from the `env`.
Thus we can switch back around and update the `kilobase-additional-sql-postgres` with references to those two variables, now I wonder if the `$JWT_SECRET` will still pass through.
Going to delete the fleet that we just deployed and start the whole process again.

```sql


    -- migrate:up 99-jwt.sql
    ALTER DATABASE postgres SET "app.settings.jwt_secret" TO '{{ .Values.secret.jwt.secretRefKey.secret }}';
    ALTER DATABASE postgres SET "app.settings.jwt_exp" TO '{{ .Values.db.environment.JWT_EXP | default "3600" }}';

    -- migrate:down

    -- migrate:up 99-logs.sql
    CREATE SCHEMA IF NOT EXISTS _analytics;
    ALTER SCHEMA _analytics OWNER TO '{{ .Values.secret.db.secretRefKey.username }}';

    -- migrate:down

    -- migrate:up 99-realtime.sql
    CREATE SCHEMA IF NOT EXISTS _realtime;
    ALTER SCHEMA _realtime OWNER TO '{{ .Values.secret.db.secretRefKey.username }}';

    -- migrate:down

    -- migrate:up 99-roles.sql
    -- NOTE: change to your own passwords for production environments
    ALTER USER authenticator WITH PASSWORD '{{ .Values.secret.db.secretRefKey.password }}';
    ALTER USER pgbouncer WITH PASSWORD '{{ .Values.secret.db.secretRefKey.password }}';
    ALTER USER supabase_auth_admin WITH PASSWORD '{{ .Values.secret.db.secretRefKey.password }}';
    ALTER USER supabase_functions_admin WITH PASSWORD '{{ .Values.secret.db.secretRefKey.password }}';
    ALTER USER supabase_storage_admin WITH PASSWORD '{{ .Values.secret.db.secretRefKey.password }}';

```

These are the SQL statements that we will have to manually execute on the container to get the rest of the instance up and running.
Afterwards we can run barman and see if it moves the database into the s3 bucket as a backup.
If the WAL and the DB get saved to the s3, we can deploy it all again but with a recovery mode, then that should be enough to handle our generic needs for now.

**Meta**

The meta data issue that I am facing is:

Failed to create resource: admission webhook "vcluster.cnpg.io" denied the request: 
Cluster.postgresql.cnpg.io "kilobase-migrations-kube-charts-kilobase-supabase-supabase-db" is invalid:
metadata.name: Invalid value: "kilobase-migrations-kube-charts-kilobase-supabase-supabase-db": the maximum length of a cluster name is 50 characters

We could try to scale some of the names back to help with the deployment.

## 2023
- 9:35am - I woke up a bit late today and I think I am going to go back to sleep a bit more, I need to catch up on my ZZZs.
- 5:03pm - Okay there are a couple things that I need to overlook when it comes to handling the YoRHa UI, but the issues are still a bit of a pain.

## Quote

> No party has a monopoly on wisdom. No democracy works without compromise.
> — <cite>Barack Obama</cite>

---

## Tasks

- [ ]

---
# September: 25th

> September 25th.

Source: https://kbve.com/journal/09-25/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Nvdia Clawback - circle of memes.

-   04:50PM

    The stock had a crazy swing up and down, I been waiting for it to cross that $185 line so many times and no luck.
    I am hoping that it happens sooner or later.

### ELin

-   06:11PM

    Finally found a rpg that I would enjoy playing and building the rareicon around, this is a great example of that stardew valley mixture that I was looking for.
    The massive class and skill system is great to build off of as well.
    It took me some time to get the game to run on the mac, but the saving is terrible and honestly not worth it.

## 2024

**Fleet**

The 2am grindset is real!
We got the ghost stories playing in the background, which describes exactly how I feel when operating in kubernetes!
After we execute the manual SQL queries, we need to wrap back around and update the shared extensions.
There is another point of error that I have to look into, which is the pgnet because I believe the cURL that it requires is only in ubuntu 24 and not ubuntu 20.
Hopefully the 15.6.x postgres image that Supabase plans to release or 16.x postgres image hopefully is built using nix and ubuntu 24.

**Shared**

2:28am - Preload Error

Looks like that the `shared_preload_libraries` did not infact load the pg_net, so we will have to go back around and fix that.
Furthermore, we can also use this part to load the `kilobase` extension too, okay made some changes to the chart to include the extensions.

**Kilobase Extension**

Our custom extension did not seem to load and thus we need to go back and change the build.
I believe this should be an easy issue to resolve because we need to remove the OpenSSL part of the reqwest client.
Okay there was a small step that we skipped, which would be to bump the version control up, making sure that we are using the latest version.

When doing the version bump, we need to edit a couple files and in the future we should have a shell script that would make these changes for us during a pull request.
Maybe after an official image is published, have it go through and make changes to all the files.

- "Cargo.toml" under /apps/kilobase/
- "project.json" under /apps/kilobase/
- "values.yaml" under the /migrations/kube/charts/kilobase/supabase/

Keeping the kilobase version consistent across all three files will be important.

Okay the shell script `version_bump.sh` handles this.

Next error is in the misisng libc6, which I am assuming the linking was broken?
Let us go ahead and add it into the Dockerfile and see if it helps solve that problem.
Damn it, the error was not because of a linking problem but rather a mis-match in the operating system for building the extension on ubuntu-24 and running that so file in ubuntu-20.
I been moving around different ubuntu versions and forgot that ubuntu-24 is definitely the wave. Ugh, here are the rest of the notes related to this.


Okay there are two ways we can fix this issue, we can fix the action that runs the extension builder using `ubuntu-20.04` instead of `ubuntu-latest`?
Or we can move the extension building back into the Dockerfile as we had it from the start, ugh, that means we need to make a couple adjustments to our overall build process.
The first step in setting up the docker build would be to directly reference the `jedi` package via the crates rather than a local path.
That would split the updating for the jedi package up a bit but for now it should be okay, I can sense the future problems that this might cause with our locks but all of this is part of the learning experience.

We will shift the `Cargo.toml` from :

```toml 

jedi = { path = "../../packages/jedi" }
# TO
jedi = "0.1.14"

```

Actually decoupling the direct reference to `jedi` and maintaining the `jedi` workflow will be a better way for our future development cycles.

Now this also means that we need to adjust the `Dockerfile` next, preparing the `STAGE 1` again for building out the kilobase extension.


**Docker**

Dear lord building docker images on Windows WSL is terrible, I am honestly waiting forever for docker builds and some of the errors are just being skipped.
I guess I been spoiled with orbstack and some of the newer tech, that going back to Docker desktop feels like entering dev cycle hell all over again.
Going to version bump the whole container and see what the errors are within the dev branch, then go back around and compare the errors from my end?
That would mean we have to comment out some of the dev ci workflow as well because we moved all of pgrx into the Dockerfile, but it might make sense to test it before going into the Docker buildx.
Both of these options would make sense in this situation, testing the extension building before doing the full docker build, maybe within the dev cycle we will keep the extension tests.
Then inside of the alpha branch, we will do a pgrx build and then a docker build test, this way we can keep both of the tests but split them up a bit between the two branches.




**GLIBC**

- 7:00pm

Error log from the `kubectl logs supabase-release-supabase-db-1-initdb-flnzv -n supabase`

```json

{
  "level":"info",
  "ts":"2024-09-25T22:16:10Z",
  "logger":"pg_ctl",
  "msg":"waiting for server to start....2024-09-25 22:16:10.661 UTC [29] FATAL:  could not load library \"/usr/lib/postgresql/15/lib/kilobase.so\": /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.33' not found (required by /usr/lib/postgresql/15/lib/kilobase.so)",
  "pipe":"stdout",
  "logging_pod":"supabase-release-supabase-db-1-initdb"
}

```

Keeping this error in the notes as a reference as I know we will have this issue in the future again when we have to rebuild the supabase image using the ubuntu 24 / postgres 16.

**NVDA**

Ending up selling all the Nvidia call options and preparing to move some of the cash into CDs before the rates start to drop!
This will be a good way to save some extra cash that I will have to pay the IRS anyhow, might as well have it sit and collect some interest before the start of 2025.
So profits, about 50%, will be moved into a CD that should end right before April 2025, then we pay the IRS with that large sum, overpaying them and having them deposit back the excess cash into a T bill account.
One of my goals would be to get around six figures in T Bill funds before the age of 40, this would be then used as an extra extra extra emergency fund for the future, granted the rate of return on the t bills are pretty trash but all of this is just part of that experience.


<Adsense />

## 2023

- 10:05am - I completely forgot about the work backlog, so I need to focus on catching up on that end. I will dedicate a couple hours to just getting myself ahead of the backlog? I could mix it in with the other backlogs, so that I do not get too bored of handling issue tickets. 
- 11:17am - The storage of the meta engine should really be done on Amazon or some sort of external cloud provider, I found that the metadata being on AWS was the best option in this hybrid cluster setup. The future really seems to be a combination of a hybrid cloud, where a decent amount of the important meta-data would be stored in the cloud while the heavy functions and files are held within your own instance.  
- 4:22pm - Scaling the YoRHa UI down to just around 400px~ and keeping it there for now. This way its mobile focused at first before I migrate it be desktop / landscape friendly. I might shift out of the UX/UI area of the widget and focus more on the backend and Appwrite integration for the time being. I suppose these notes are just for getting a better understanding from my end. 
- 6:36pm - Okay I was able to swap out the general characters for the Game! I am thinking of keeping it simple for now and only three playable characters before migrating over to a bit more advance style features. There are a couple other aspects that I wanted to overview. 

## Quote

> Love is the only force capable of transforming an enemy into a friend.
> — <cite>Martin Luther King Jr.</cite>

---

## Tasks

- [ ]

---
# September: 26th

> September 26th.

Source: https://kbve.com/journal/09-26/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Elin on Windows

-   06:20PM

    Doing a run as a warmage right now, maybe it could make things easier to understand. 

## 2024

**RimWorld**
Today was a rough day, ended up playing a bit too much of rim world again.
But it is a Friday Jr night, so we are good to go in that situation!
Oh, I also got the pokemon world mod added and its been a super thrilling ride, hmm so far with the mechanoids too.
We got ourselves a poke-robo army and slowly adding more numbers to our stack, I bet we could easiy hit around 100 units with this play through.


**PGRX**
The other issue is still open with the pgrx bindings, I am thinking that we can go two ways with this now?
Actually there are three ways we can go with this!
The first would be to just drop the custom extension, this is the easy route because then we can move forward without any major issues.
Taking a look at the way that supabase handles the pgrx, it seems that they are on version 0.11.3 with the shim, maybe we can downgrade and see if that might be able to help?
From my understanding the current ubuntu 20 LTS is where our build is failing but it should not be, hmm.
The exact issue we are facing is listed [here](https://github.com/pgcentralfoundation/pgrx/issues/1822) and it is in relation to the pgrx bindgen for C.

I am not trying to give up, maybe we can try to build the extension using the pgx

**Backup**

While I am looking through trying to resolve this bindgen situation with the extension, I did make some progress within the backup and recovery.
My idea would be to set it up so that not only can our github actions deploy the latest stacks but we can even go a step further and setup a semi-automatic backup through the actions.
The idea would be to have a custom github action that would do something along these lines:

1. Create an issue ticket for the backup job
2. Prepare a couple sha256 reference shas for the job, backup postgres data with logical and physical and then use the barman to handle the backup.
3. Once the backup is done, it will go back to the issue ticket and state that the backup was done and it will then pare the next stage.
4. After it confirms that the backup is done, it can keep a hot-swap of the backup in another cloud provider, giving us a backup in both AWS and another party.
5. Furthermore, we can have the action place the WAL and logical backup into our local cluster and then have it prepare a recovery test.
6. At this point the issue ticket would still be open but it would move down the priority list from a 6 to a 3 or 4 and then begin the recovery deployment at the local cluster.
7. The recovery cluster should be able to deploy in the local cluster and provide the information to verify that it was successful, ie update the issue ticket and place it as a matrix of 1.
8. The final step before closing the issue ticket would then be to give a full report of everything it did today.

This would be the barebones focus for now, during this issue ticket creation, we can also include a NX Report and any other information that we would like to include.

**Weekly Meeting**

Finally the other goal that I had before the end of the month, 
 

<Adsense />

## 2023

- 6:23pm  - Over the night I was able to finish up the Helmet integration with the YoRHa UI widget and now I am going to add the footer buttons for the template. I am thinking that the footer should have about just two buttons, one that would be for the version / game data and another for the external services? I do not want to spend too much time trying to figure that out per say and just move forward with the next issue.
- 9:00pm - The current size of the widget is at around 280kb and I am thinking that I might be able to reduce the size by wrapping the modal into its own internal function and then calling it with children props. This way the size is standard across the board or I could have an action display the modal, which would be also interesting as an approach. 
- 10:51pm - The bundle size has increased to around 290kb, this might become a problem because there are some issues that I am seeing already. 

## Quote

> Things do not happen. Things are made to happen.
> — <cite>John F. Kennedy</cite>

---

## Tasks

- [ ]

---
# September: 27th

> September 27th.

Source: https://kbve.com/journal/09-27/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Session - NodeJS

-   06:43PM

    Setting up nodejs on Jigsaws PC!
    We finally getting him caught up with the unity nodejs.
    Turns out the popos is using an older glibc version and we really can not do much until he updates the operating system.

## 2024

**PGSodium**

After getting a couple of the postgres instances operating and a decent sized cluster, we need to go back in and add some extensions.
I decided to go the route of just loading all of them in and seeing which ones fail, the first one will be the `pgsodium`.

Error Log:

```json

[
{"level":"info","ts":"2024-09-27T16:06:07Z","logger":"pg_ctl","msg":"2024-09-27 16:06:07.972 UTC [29] FATAL:  The getkey script \"/usr/share/postgresql/15/extension/pgsodium_getkey\" does not exists.","pipe":"stdout","logging_pod":"supabase-release-supabase-db-1-initdb"},
{"level":"info","ts":"2024-09-27T16:06:07Z","logger":"pg_ctl","msg":"2024-09-27 16:06:07.972 UTC [29] DETAIL:  The getkey script fetches the primary server secret key.","pipe":"stdout","logging_pod":"supabase-release-supabase-db-1-initdb"},
{"level":"info","ts":"2024-09-27T16:06:07Z","logger":"pg_ctl","msg":"2024-09-27 16:06:07.972 UTC [29] HINT:  You might want to create it and/or set \"pgsodium.getkey_script\" to the correct path.","pipe":"stdout","logging_pod":"supabase-release-supabase-db-1-initdb"},
{"level":"info","ts":"2024-09-27T16:06:07Z","logger":"pg_ctl","msg":"2024-09-27 16:06:07.972 UTC [29] LOG:  database system is shut down","pipe":"stdout","logging_pod":"supabase-release-supabase-db-1-initdb"},
{"level":"info","ts":"2024-09-27T16:06:08Z","logger":"pg_ctl","msg":"pg_ctl: could not start server","pipe":"stderr","logging_pod":"supabase-release-supabase-db-1-initdb"},
{"level":"info","ts":"2024-09-27T16:06:08Z","logger":"pg_ctl","msg":" stopped waiting","pipe":"stdout","logging_pod":"supabase-release-supabase-db-1-initdb"},
]

```

The move would be to to figure out how to load the secret through sealed secret but we can not add the key directly into a file on the drive?
From my understanding the pgsodium key has to remain in the memory, so it would make sense that we are not storing it directly in the database.

To solve this issue, we would have to come up with about three different steps, starting with sealing a pgsodium key away and then another step with setting up a shell script and finally injecting the key.
Hmm, I am still thinking through exactly the way that I would approach this problem.
Sidecar or Init container, hmm, I am thinking we will go with an init container for now and then look at the sidecar as an additional option for future deployments.

The seal command has been integrated into the nx system, so we can go ahead and start the key generation and sealing processing.
To make sure we can generate a random key, lets do a quick debug.

```shell

PGSODIUM_KEY=$(openssl rand -hex 32)
echo "Generated pgsodium key: $PGSODIUM_KEY"


```


**Supabase**

The current commands that are we are using to debug the supabase instance is as follows:

```shell

kubectl get pods -n supabase

```

This will display all the running pods in the namespace of `Supabase` which is under the deployment of `kilobase` via `fleet`.
The result would look like this:

```

 kubectl get pods -n supabase
NAME                                                   READY   STATUS             RESTARTS         AGE
supabase-release-supabase-auth-c96889665-vtg5m         0/1     Init:0/1           0                3h5m
supabase-release-supabase-db-1-initdb-2wwtr            0/1     Error              0                173m
supabase-release-supabase-db-1-initdb-6kxpb            0/1     Error              0                3h1m
supabase-release-supabase-db-1-initdb-6rdwk            0/1     Error              0                3h5m
supabase-release-supabase-db-1-initdb-7djvz            0/1     Error              0                3h5m
supabase-release-supabase-db-1-initdb-ggkmn            0/1     Error              0                3h3m
supabase-release-supabase-db-1-initdb-m4z4q            0/1     Error              0                178m
supabase-release-supabase-db-1-initdb-wjqcv            0/1     Error              0                3h4m
supabase-release-supabase-functions-7f9f54d684-gn86g   0/1     CrashLoopBackOff   41 (52s ago)     3h5m
supabase-release-supabase-imgproxy-7649cb49ff-8xg4r    1/1     Running            0                3h5m
supabase-release-supabase-kong-5bc5b754dd-g5d6q        0/1     CrashLoopBackOff   38 (4m15s ago)   3h5m
supabase-release-supabase-meta-ccbf87b48-nmkvf         1/1     Running            0                3h5m
supabase-release-supabase-realtime-6c866974bf-xxv6m    0/1     Init:0/1           0                3h5m
supabase-release-supabase-rest-76bd699f95-9hgmm        1/1     Running            0                3h5m
supabase-release-supabase-storage-5bfb49b6f5-nvv78     0/1     Init:0/1           0                3h5m
supabase-release-supabase-studio-b6bdf46-cfp75         1/1     Running            0                3h5m

```

Now to check the error, we run:

```shell

kubectl logs supabase-release-supabase-db-1-initdb-7djvz -n supabase

```

This gets us the error logs and there we can see the issue with the pgsodium.

**Sealed**

Okay going to switch gears and look back at our `generate-sealed-secret.sh` and make some changes to make it easier for us to use.
We want the script to run in memory only and not create any files that might accidentally get pushed.
To make it easier for others to read and use:

```bash

usage() {
  echo "Usage: $0 -n <namespace> -k <keyName> -s <secrets>"
  echo "  -n  The namespace for the secret (e.g., 'default' or 'my-namespace')"
  echo "  -k  The name of the secret (e.g., 'pgsodium-secret')"
  echo "  -s  The secrets in 'key=value&key2=value2' format (e.g., 'key1=value1&key2=value2')"
  exit 1
}

```

The `usage()` part of the script will be called again through a future nx command that we can write to help us handle the secret creation and mangement.
For safety, we can add an additional function to check the namespace but that would defeat the purpose for any namespace that does not exist yet.

```bash

check_namespace() {
  if ! kubectl get namespace "$NAMESPACE" &> /dev/null; then
    echo "Error: Namespace '$NAMESPACE' does not exist."
    exit 1
  fi
}

```
So instead of the `check_namespace()` function being a general purpose one, I will wrap back around and make it so that the function checks if `armada` is there.
The sealed secret operator ships through the `armada` namespace, thus without that namespace, we can not utilize the kubeseal.
Thus the function in our bash script will be: `check_armada_namespace`. 

```bash

# Function to check the Armada Fleet
check_armada_namespace() {

  if ! kubectl get namespace "armada" &> /dev/null; then
    echo "Error: The namespace 'armada' does not exist. Please ensure the Sealed Secrets operator is running in the 'armada' namespace."
    exit 1
  else
    echo "Namespace 'armada' is present."
  fi

}

```

Side note: there are only 25 resources running in the armada fleet, so a future function that we can make would be focused on the redis-based secert manager.
This would hold the temporary secrets in the redis memory, I also believe there are some cute tricks that can be done to make sure that the temporary secrets can only be accessed through an aes-style rotation.
The redis would pull the temporary sealed secrets and hold them in small malloc that would expire once read or within a certain timeframe.
Furthermore that timeframe can be determined through the ulid, since it is a lex-based key.

The `generate-sealed-secret.sh` has been updated to create the `encryptedData:` string for the keys, here is the example command. 

```shell

./generate-sealed-secret.sh -n supabase -k testcase -s "key1=value&key2=value"

```

This command now has to be placed inside of the nx monorepo, so we will create a new nx-run-command for the shell script that can execute this for us at the `root` folder level.

Now we can call this directly with the nx via:

```shell

pnpm nx run kilobase:seal --namespace=supabase --keyName=nxtest --secrets="key1=value1&key2=value2"
# or
./kbve.sh -nx kilobase:seal --namespace=supabase --keyName=nxtest --secrets="key1=value1&key2=value2"

```

Perfect! This will make it easier for us to build future rotating keys from the github actions directly into the kubectl.

**KubeCtl**

```shell

kubectl describe pod supabase-release-supabase-db-1-initdb-2wwtr -n supabase

```

Okay this is a great command for us to use and help debug some of the container issues that.
Adding some of the pgsodium key access roles for the cluster and this should help us move forward with the key problem.

<Adsense />

## 2023
- 3:45pm - I am surprised that Tesla and Apple have back traced this fast, I was really expecting them to coast through this mild recession. Granted I do believe they are a bit over valued, but at my age and the direction that computation is moving, both of those companies seem like a safe harbor for the next couple decades.
- 6:30pm - Looks like my tesla has a flat tire, womp! The leak is pretty bad and honestly I feel like crap trying to get it fixed because it will be a pain to just find the right tire shop to do the job. I also have to get my rims fixed a bit, hmm this is just one of those things.
- 8:17pm - YoRHa UI's object placement and general modal updates need to be addressed. There are a couple ways that I could go about handling this, I am thinking to do my classic build, break and repeat until I get a bit of what I want. I have already written the state management for the modals about five times and counting! Ugh.


## Quote

> By oneself is evil done; by oneself is one defiled. By oneself is evil left undone; by oneself is one made pure.
> — <cite>The Buddha</cite>

---

## Tasks

- [ ]

---
# September: 28th

> September 28th.

Source: https://kbve.com/journal/09-28/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Astro Cleanup

-   08:45AM

    Cleaning up the KBVE Astro deployment, so that we can fix up the pipeline for the item.
    Actually since I was already in the process of cleaning up, I was able to backup the previous refactor and finally got a clean version to work with.

-   02:03PM

    Astro has been upgraded to the latest version!
    We got the build up and running locally, now just getting ready to release v1.2.2 and there is even more great news.
    Our most current build can idle out at around 10MB of ram usage, this marks great progress towards and extremely hyper web server.

## 2024

**File**

The issue that we are currently facing is the installation of a custom file into the container.

Quick commands to help debug this situation:

```shell

# Get Supabase Pods
kubectl get pods -n supabase

# Get Logs 
kubectl logs supabase-release-supabase-db-1-initdb-7djvz -n supabase

# Describe
kubectl describe pod supabase-release-supabase-db-1-initdb-2wwtr -n supabase

```

Okay to load the pgsodium key / shell, we can try to setup a sidecar with the information.
Actually since its the initDB, we can get away with using the environment because the whole container would get destroyed once its done with the init?
We would load the sidecar then through another deployment which would be the recovery? Hmm, there are ways to make this work.

Here is the pod template that we used to init the container:

```yaml 

  podTemplate:
    spec:
      initContainers:
        - name: pgsodium-getkey-init
          image: busybox
          command: ["/bin/sh", "-c", "kubectl get secret secret-pgsodium-key -n supabase -o jsonpath='{.data.pgsodium_key}' | base64 --decode > /pgsodium/keyfile"]
          volumeMounts:
            - name: pgsodium-keyfile-volume
              mountPath: /pgsodium
      containers:
        - name: main-container
          image: {{ .Values.db.image.repository }}:{{ .Values.db.image.tag }}
          volumeMounts:
            - name: pgsodium-keyfile-volume
              mountPath: /pgsodium
      volumes:
        - name: pgsodium-keyfile-volume
          emptyDir: {}

```

However, for now, we will just load the key in via the environmental variable.

**SegFault**

Looks like after disabling the pgsodium, we had to wrap back around and disable the kilobase extension as well because I believe I might have made an error with how I went to set up the extension.
I will look into the extension at another time, as there are just too many things on the plate and if worse comes to worse, we can just move the extension out of the postgres and into our own structure.
This is a tough moment but its okay, I know when to move on and there are a decent amount of other things that are on our plate to deal with.

- repo : `https://github.com/KBVE/kbve.git`
- path: `/migrations/kube/charts/kilobase`

There are 4 more core SQL files that we need to add into the configuration.
Well there were 5 total, but we got the websockets to execute without any issues.

Just to recap the 5 total:

- jwt. - done using parameters.
- logs. - giving it to the `supabase_admin`
- realtime.
- roles.
- webhooks. - works fine for now.

We got the webhooks out of the way and we can just pass in the jwt directly through the parameters.

Now there is another error that we need to look through, which was the `supabase-secret-db`, but I was under the impression that we already did this through the sealed secrets, hmm.
Okay the other three core SQLs files that we need are these:


```sql

    -- 99-jwt.sql |
    \set jwt_secret `echo "$JWT_SECRET"`
    \set jwt_exp `echo "$JWT_EXP"`

    ALTER DATABASE postgres SET "app.settings.jwt_secret" TO :'jwt_secret';
    ALTER DATABASE postgres SET "app.settings.jwt_exp" TO :'jwt_exp';

    -- 99-logs.sql: |
    \set pguser `echo "$POSTGRES_USER"`

    create schema if not exists _analytics;
    alter schema _analytics owner to :pguser;
    -- 99-realtime.sql: |
    \set pguser `echo "$POSTGRES_USER"`

    create schema if not exists _realtime;
    alter schema _realtime owner to :pguser;
    -- 99-roles.sql: |
    -- NOTE: change to your own passwords for production environments
    \set pgpass `echo "$POSTGRES_PASSWORD"`

    ALTER USER authenticator WITH PASSWORD :'pgpass';
    ALTER USER pgbouncer WITH PASSWORD :'pgpass';
    ALTER USER supabase_auth_admin WITH PASSWORD :'pgpass';
    ALTER USER supabase_functions_admin WITH PASSWORD :'pgpass';
    ALTER USER supabase_storage_admin WITH PASSWORD :'pgpass';

```

Source: https://github.com/supabase/supabase/tree/master/docker/volumes/db

Now of these three core files, we can start with the small.
For the log, we looked back at the supabase docker swarm and it looks like we set it to the `supabase_admin`, so lets go ahead and add that into the configmap.

The best move we can make right now would be to shut the whole thing down and restart the cluster.

Damn the JWT did not set via the `parameters` and we will have to go back to the SQL method.
We will try to alter it directly within the `cnpg-kilobase-postgres.yaml`.

Okay next applying the password for the role changes.

```sql

ALTER USER authenticator WITH PASSWORD 'your_password_here';
ALTER USER pgbouncer WITH PASSWORD 'your_password_here';
ALTER USER supabase_auth_admin WITH PASSWORD 'your_password_here';
ALTER USER supabase_functions_admin WITH PASSWORD 'your_password_here';
ALTER USER supabase_storage_admin WITH PASSWORD 'your_password_here';

```

Now lets go ahead and fix up the functions part of the supabase.
It looks like the error is in the permissions, specifically the cache?

```yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: deno-cache-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data/deno_cache"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: deno-cache-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

```

Okay the temporary fix for the functions seems fine and now we can move on towards temporary fixing the kong.
We can always replace the kong with our own kilokong in the future or a better service down the line, but for now, we just want to run it.

What a wild ride, we were able to shift through all the docs and finally getting to the full cluster.
The only thing left is the final parts of the backing up and restoring.

For this section, we will need to double check the cluster.

```shell

kubectl describe clusters.postgresql.cnpg.io supabase-release-supabase-db -n supabase

```

<Adsense />

## 2023

- 6:40am - So the plan for the mornings should be a sunrise photoshoot? This would be a great excuse to get outside early and improve upon my photography skills! I already have a decent collection of equipment and a ton of abstract software background, I think its just finding that niche that I want to explore within. 
- 8:30am - All I am craving is a mocha whey protein shake with an extremely spice Taylor ham and egg bagel! The combination of the heat that it generates and sweetness from the coffee, make it an amazing blend! It hits around 1000 calories but that is definitely more than enough to breeze through until mid-day. 
- 4:35pm - Almost have my Appwrite / Square hackathon project outlined, now I just need to execute it as fast as possible before the event ends. There are a couple things that I wanted to make sure that would work before I commit a ton of time into them.
- 11:15pm - Pushing through some of the work projects, I also just got another job offer and damn I am already backed up for this weekend!

## Quote

> Tragedy is a tool for the living to gain wisdom, not a guide by which to live.
> — <cite>Robert F. Kennedy</cite>

---

## Tasks

- [ ]

---
# September: 29th

> September 29th.

Source: https://kbve.com/journal/09-29/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Pathfinding in ECS

-   11:35AM

    I did not expect to have the pathfinding to be such a pain point!
    Besides the collisions, just getting the movement down with 100,000 units is the hardest thing that I have dealt with.
    We are getting closer towards something that is balanced around 60FPS, maybe I will drop the units back down to less than a couple hundred and move on.

-   03:45PM

    Wrapping up the daily pathfinding and making sure that everything works as intended.
    Sadly that was all a pipedream because the pathfinding is still very much broken.

## 2024

**Cluster**

```

kubectl get pods -n supabase
NAME                                                   READY   STATUS    RESTARTS   AGE
supabase-release-supabase-auth-5b7fdcd9b7-9qlgk        1/1     Running   0          10h
supabase-release-supabase-db-1                         1/1     Running   0          9h
supabase-release-supabase-db-2                         1/1     Running   0          9h
supabase-release-supabase-functions-64c9b5c6c7-72s62   1/1     Running   0          11h
supabase-release-supabase-imgproxy-65c697f6b8-2f9m7    1/1     Running   0          11h
supabase-release-supabase-kong-597b99965b-xhxnt        1/1     Running   0          11h
supabase-release-supabase-meta-74dcdf58dc-jtt8t        1/1     Running   0          11h
supabase-release-supabase-realtime-7f6846b545-t7sq4    1/1     Running   0          10h
supabase-release-supabase-rest-7ccb7f5954-z9862        1/1     Running   0          11h
supabase-release-supabase-storage-857d655cd7-zr96b     1/1     Running   0          10h
supabase-release-supabase-studio-b6bdf46-lqk8h         1/1     Running   0          11h

```

We finally got a state that is stable and running!
This took us a while to get going but it was under a month, so for our first round that is not bad at all.
Now to make sure that everything is working, we need to test the barman and the backup and recovery process.
Furthermore, we will need to plan for scaling out the cluster, past the base of 1/1 units.

Note: `supabase-release-supabase-db-1` is our `readwrite` and `supabase-release-supabase-db-2` is our `readonly` instance.


**Kilobase**

The bug with the `String` that is causing a segfault might have a couple solutions, the first was upgrading pgrx back to `v0.12.4` but that is not an option for us because the clang version for postgres v15 is `10` and the latest pgrx recommends clang 11 or higher.
The other possible error could come from us installing `15.8` rather than `15.1`.

**Barman**

The best move here would be to start the `postgres.mdx` and update it with more information related to `Supabase`, `Barman`, `Cloudnative-PG` and more!
Ended up staying up all night but I was able to get the barman running and it turned out to be a lot easier than what I was doing earlier.
Furthermore, there is a go plugin coming out soon, so it might become even easier in the future!

**Redis**

While I am updating the `postgres.mdx`, I should wrap back around and update our `redis.mdx` too because it would make things easier for us in the long term.
The will be to link the redis from armada into the supabase, then switch the background worker to communicate with that redis instance!


**Applications**

I need to get back into the habit of keeping better notes and information through our `/application` docs!
There has been a lack of new updates and content for that section this whole year, but I will try to get better at updating it all and getting back into the flow.

## 2023
- 5:53am - Freaky Friday! Today this going to be a heavy hitter type of day, I want to bang out a ton of my backlogs and maybe try to create about 50-60 more issue tickets, bringing my total far past the 100 mark. 
- 6:37am - The first object that I want to place into the YoRHa UI will be the `Drill` item object, located [here](https://i.imgur.com/ddKIcQu.png) and it will serve as the `tool` to repair the ship, robots and will have an energy requirement. I am not too sure how I will go about handling it all, but I am thinking of just placing the object onto the map and then seeing where I can go from there. The other task would be making sure that the player can register and login? All three of these missions will help me towards the backend migration. I am thinking of creating just one function for the game and then assigning paths for the different actions? It would be a bit rough to just make a function for EACH event, as that might be a bit too much isolation and a bit reparative. So placing the tool , then shifting towards a bit of the backend for the game, that will be the main focus for the day! We also have the autoGPT to look into, but that should be later on the day.
- 4:40pm - There are a couple interesting things going on with the AutoGPT hackathon but I shall see how I feel about it later through out the day.
- 1:01am - It seems that the best course of action will be to delete the existing AutoGPT repo and then make a new one for the event. The older one that I had some issues and was flooding my grafana with useless logs, skyrocketing the size of my logs from a couple hundred megabytes to almost several gigs. The errors were just a bit too much for my cup of tea.

## Quote

> Happiness is a perfume you cannot pour on others without getting a few drops on yourself.
> — <cite>Ralph Waldo Emerson</cite>

---

## Tasks

- [ ]

---
# September: 30th

> September 30th.

Source: https://kbve.com/journal/09-30/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### ECS Pathfinding

-   09:17AM

    Made some progress with the pathfinding but still have to convert it from a SystemBase to an ISystem.
    Furthermore there are a ton of float3s in the code, I will have to clean all of that up too.
    Finally, we need to make sure that the new state management system does not become a pain point, as we need to remove a decent amount of the booleans.

## 2024

**Redis**

The next plan for the Redis instance under the `armada` is to bridge the service between the itself and the `supabase`!
From my understanding it will be just two yaml configurations, one for the network policy and another for the external service.

So the two kinds that we will be making are `Service` and `NetworkPolicy`, I will be placing both of those into the a single file called `redis-armada-bridge.yaml`.
We want to utilize our redis master instance for the postgres instance first and then later on it will be extended out to the rust for processing and finally the n8n for additional abstract support.
The n8n integration will give us the no-code style of flow for building out and mapping theories.


**Recovery**

Nothing is more fun than setting up recovery and the joys and huge pain points that come with it!
The recovery will be be from the same `GitRepo` / `GitOps`, starting with: 

Repo: `https://github.com/KBVE/kbve.git`
Paths: `/migrations/kube/charts/kilobase`

We got all three instances running, so it looks like the issue with recovering a postgres is to double check the base and WALs before doing a recovery.

```

supabase-release-supabase-db-1                         1/1     Running   0          3m25s
supabase-release-supabase-db-2                         1/1     Running   0          2m14s
supabase-release-supabase-db-3                         1/1     Running   0          78s

```

**Kilobase**

The tokio runtime seems to create a segfault in the cluster and thus, I am thinking that we would keep the function of the background worker to maybe store the URL into a redis cluster.
We can then throw together an isolated container that would read from the redis, process the URL and then store back the data via a transaction.

From my understanding, at this point, this function causing the segfault in the postgres when enabling the extension:

```rust

fn process_url(url: &str) -> Result<String, String> {
  let rt = Runtime::new().unwrap();
  rt.block_on(process_url_async(url))
}

```

Thus the best solution would be to move that all out into its own isolated container, which I will build using axum.
We can even migrate the older function into this isolated application.

```rust


fn process_url(url: &str) -> Result<String, String> {
  let client = Client::new();

  // Make a blocking HTTP GET request
  let response = client
    .get(url)
    .send()
    .map_err(|e| format!("HTTP request failed: {}", e))?;

  if response.status().is_success() {
    let body = response.text().map_err(|e| format!("Failed to read response body: {}", e))?;
    Ok(body)
  } else {
    Err(format!("HTTP request returned non-200 status: {}", response.status()))
  }
}

```

**LongHorn**

During our disaster recovery, I noticed that while everything else came back online, the PVC management still needs to be adjusted.
For this situation, we would need to setup a replica of the storage on another S3-type bucket and make the automatic sync a bit easier.
Upon init container, we should hold off the storage deployment until the postgres database is operational, a possible point that we can adjust across all of the supabase concepts.


## 2023

NULL


## Quote

> He who conquers others is strong; He who conquers himself is mighty.
> — <cite>Laozi</cite>

---

## Tasks

- [ ]

---
# October: 1st

> October 1st.

Source: https://kbve.com/journal/10-01/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### OCT CC Payments

-   12:51PM

    Need to make sure that all the bills got paid and then prepare to build around that.
    The flow for payments are like this: Discord -> Capital One -> Paypal -> Amazon.
    Yet before those payments get automatically posted, it has to pull the capital out of the TD account, so first run gathers the total CC cost, then it runs a zelle between the two accounts.
    Once that zelle is done, it loops back and should make the payments for each of the cards.
    However this is still an issue for me to automate, so I will look further into that either next month or try a bit of a different approach.
    I should look more into the linuxserver image deployments, with how they are handling the VNC through the kubernetes.


## 2024

**Redis**

Back at it again with the redis extension for the Docker image!
The plan is still a continuation from yesterday, right now I am just testing the role bindings and making sure that the main container can connect to the redis.

**Recovery**

For the Postgres cluster, the hardest part of the whole thing is to maintain a level of security.
In the current state of resources, we are unable to setup and run two clusters, aka the `main` and `dev` or `production` and `development`.
As of right now, we are only running the `dev` cluster.

```

 kubectl get pods -n supabase
NAME                                                   READY   STATUS                       RESTARTS   AGE
supabase-release-supabase-analytics-76f4b968cf-4tcfq   1/1     Running                      0          16h
supabase-release-supabase-auth-6955f59486-cj5vc        1/1     Running                      0          16h
supabase-release-supabase-db-1                         1/1     Running                      0          16h
supabase-release-supabase-db-2                         1/1     Running                      0          16h
supabase-release-supabase-db-3                         0/1     CreateContainerConfigError   0          11h
supabase-release-supabase-functions-64c9b5c6c7-vvsrj   1/1     Running                      0          16h
supabase-release-supabase-imgproxy-65c697f6b8-zjr82    1/1     Running                      0          16h
supabase-release-supabase-kong-8568c4bccf-2tx2n        1/1     Running                      0          16h
supabase-release-supabase-meta-74dcdf58dc-psgnk        1/1     Running                      0          16h
supabase-release-supabase-realtime-7f6846b545-nbmjx    1/1     Running                      0          16h
supabase-release-supabase-rest-7ccb7f5954-8qhvj        1/1     Running                      0          16h
supabase-release-supabase-storage-857d655cd7-fx4bz     1/1     Running                      0          16h
supabase-release-supabase-studio-798b47644b-5fd5r      1/1     Running                      0          16h
supabase-release-supabase-vector-7bc47494f-swb9r       1/1     Running                      0          16h

```

6:40pm - The current error is:

```

ErrApplied(1) [Bundle kilobase-migrations-kube-charts-kilobase: cannot patch "supabase-release-supabase-db" with kind Cluster: admission webhook "vcluster.cnpg.io" denied the request:
Cluster.cluster.cnpg.io "supabase-release-supabase-db" is invalid: spec.bootstrap: Invalid value: "": 
Too many bootstrap types specified]; cluster.postgresql.cnpg.io supabase/supabase-release-supabase-db [progressing] Cluster Is Not Ready

```

To move things forward, we will go ahead and run this shell command:

```shell

kubectl delete pod supabase-release-supabase-db-3 -n supabase

```

Looks like the `CreateContainerConfigError` popped back up again, so we will go ahead and run a new command to describe the error.

```shell

kubectl describe pod supabase-release-supabase-db-3 -n supabase

```

The error that we are facing now is that:

```
  Warning  Failed                  92s (x7 over 2m34s)  kubelet                  Error: secret "redis-auth" not found
```

The postgres db was unable to find the `redis-auth`.
My theory is that we might need to adjust the `Role` kind for the secert and make it a `ClusterRole` instead, thus updating the `redis-armada-bridge.yaml` to reflect the role change.
Hmm, we ran into the same problem again and I am thinking that we need to tell the ClusteRole to grab the secret from the `armada` namespace?

```yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
    name: redis-secret-reader
rules:
    - apiGroups: ['']
      resources: ['secrets']
      verbs: ['get', 'list']
      resourceNames:
          - redis-auth
      namespaces: ['armada']

```

To be safe, we will double check the `redis-auth` secret and make sure that it exists in the `armada` namespace.

```shell

kubectl get secret redis-auth -n armada

```

Now , we still have that issue with grabbing the secret, when running this command:

```shell

kubectl get secret redis-auth -n supabase

```

This next update, we will be adjusting the `ServiceAccount` under the `ClusterRoleBinding`.

Maybe we are doing too many changes and it is causing this backlog of updates, thus we will comment out the `REDIS_AUTH` env for now and move forward with the recovery of the cluster again.
Once we can confirm that the `redis-auth` secret can be accessed, we will revert the recovery process again.

The other issue that I see in the namespace is that the `redis-secret-reader` and `redis-secret-reader-binding` are both running under the `Role` and `RoleBinding`, thus I am thinking we delete those.
So we would run these commands:

```shell

kubectl delete role redis-secret-reader -n supabase
kubectl delete rolebinding redis-secret-reader-binding -n supabase
kubectl get clusterrole redis-secret-reader -o yaml
kubectl get clusterrolebinding redis-secret-reader-binding -o yaml

```

The issue ended up being that the namespace for the sealed secret was scoped to just the `armada` and thus we will have to seal the secret for the redis again for the supabase namespace.
The other option was to open the secret up to other namespaces but I feel like that might be too much of a security issue for us in the future.

We can move this up to the Alpha branch and then start looking into the n8n deployment as the next chart / container for our supabase instance.
However, I am thinking that we could also split the n8n out into its own namespace, but that might also be not worth it, hmm. 

**Schema**

We got the hcaptcha schema added and the user profile!
Both of these are still a bit of work in progress type of schemas because we need to make sure that users can even register and make accounts.

From my understanding both of the two schemas are part of the auth system, where the hcaptcha gets triggered before the creation of the user and the profile gets triggered after the user is created.
However we need to add a couple things for the username unique check before the person is able to register, I was thinking of placing an automatic string for the username based upon their email and then let them change the username later on.

We also need to make sure that these changes are saved and then apply a recovery test against them tomorrow.
Overall, if everything goes as planned, then we should be close to having our self hosted postgres nearing a production level.


**Credit**

While I am doing the postgres schemas, I had to double check all our accounts because we need to make sure that everything has been cleaned up.
I want to make sure that there are no open credits.

## 2023

NULL

## Quote

> Habit, if not resisted, soon becomes necessity.
> — <cite>Augustine of Hippo</cite>

---

## Tasks

- [ ]

---
# October: 2nd

> October 2nd.

Source: https://kbve.com/journal/10-02/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity ECS Resources

-   07:15AM

    Completed the basic migration of the map resources into the ECS, but still need to finish up the map schema.
    Our goal will be to have the vault and map database be our single source of truth for all the objects that would appear on the map, then build around that.
    This means we want the basic resources to first load without any major drawbacks, then we can slowly scale it out.
    Now the other issue was making it so that item drops could remain being game objects or if we should also move those into the ECS?
    I am thinking we spend most of the time focused on getting the static resources rendered onto the map, specifically the tree and stones.
    Then once they are fully rendered on the map, we could add the R3 + Sync, so that when the player hovers over the entities, they can easily see what is being displayed.
    For a cluster of around 1,000,000 units, we could create a kd tree that would then be chunked for each of the regions on the map, then have that be the cache that holds the data.
    Afterwards we could handle a combination of an off thread look up and a main thread aka UI render of the different objects that are being moused over.
    Mouse does a ray cast over the position that it is near and then the UI does a label over the different objects that are within the screen?
    I suppose another move would be to move the character closer to the said object, allowing them to maybe extract the said object.
    The question would be if we want those resources have to have collision boxes or not.

-   09:00PM

    Ending the night off with the basic map object schema done and two trees were added on the astro side.
    We did a simple oak tree and redwood tree, both of those should be a good start under the map database's resources, yet we still need to do the structures.
    For the structures, I am thinking we could do the crypt and maybe orc barracks, both of those can then start to summon different entities onto the map for us to fight.
    I also do need to look more into the map, maybe figure out the best way to handle the general bullet hell / star dew flow before getting a demo of the game released.
    Now that I am thinking about it, we could get the demo out before the end of the month.



## 2024

**Dashboard**

To grab the dashboard password for quick development work!
This is just a note for myself in the future.

```shell

kubectl get secret supabase-secret-dashboard -n supabase -o jsonpath="{.data.password}" | base64 --decode

```

Yesterday, I added two base schemas and now I want to test them out!
We still need to update the dashboard's logging connections, as it is unable to see the auth logs and a couple other areas.


**Extensions**

While testing out the schemas for Supabase, I need to wrap back around and finish up the Redis extension for KBVE.
Part of the reason that I hate working on it is because if it fails then I have to go through a multi-stage recovery process, ugh.
The big issue we had last time was passing of the sealed secret but I believe that was just a mistake on my end with the permissions and nothing related to the code.

**CNPG**

Updated the `sql.mdx` notes with the CNPG Backup.
The rolling recovery still needs to be tested but I think we can find a creative way to help us handle that.

**MDX**

To help with the build of `kbve.com`, I had to go through all our `MDX` references and remove them.
Furthermore, I had to remove some of the deadcode that was lurking around all our monorepo.
It was over 400 files that I had to change and fix today, what a wild ride!

---
# October: 3rd

> October 3rd.

Source: https://kbve.com/journal/10-03/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Tracker SQL User Providers

-   09:05AM

    There was an issue or well a mistake in our tracker sql, we ended up creating an additional table to keep track of the user and their identities.
    This table was under the tracker schema, `trackers.user_providers` and after building it out and making some functions for it, I figured out that the auth schema already has it.
    Since the auth schema has an isolated table for exactly what we need, it would make more sense to just have a function compare against those!
    Later on I will add a LRU for the application side, to help offset the queries to the sql database.
    Anyhow, we updated the tracker sql file and dropped that useless data table and everything is good to go!

### Nvidia Roll $185

-   10:01AM
    
    Made the call to roll a couple of the $185 covered calls into next week for a quick couple thousand.
    This is because I am not too sure if it might be worth having the assignment over the weekend, we could hold off for another week and see if that helps us out.
    If I am correct with the planning, we might be able to move back up to $190 before the end of the month.

### Resource ID ULIDs

-   11:18AM

    Under the common folder for DOTS, I created a basic Ulid.cs helper class.
    I do want to swap that out with the CySharp Ulid library, yet the time is not yet here for that!
    Maybe we do a combination of a big int and ulid, or a dual ulid, with one ulid representing the actual type and another for that exact instance of the entity on the map.
    I will have to look at the performance concerns with this method because it could easily surpass 1,000,000 entity problems, very quickly.
    We can see that it might be around 140MB usage when dealing with all these data points within our resource pool.


## 2024

**Auth**

It is always a great day when dealing with auth!
I been at it all night, just double checking possible bugs and concepts but we are getting closer to something that I would enjoy using and seeing.
There are still some minor changes that we need to work out but I am proud with what we have so far!

**NVDA**

Good to see our sleeper cell stock moving back up towards the $150 mark, I am going to dump some of my 2025 calls ealier because I need the money for a project.
However, I am looking at the 2026 calls already and they are priced decently well considering their growth potential.
I am thinking of just having a couple thousand on standby for the day that nvidia hits another double digit negative, then I am going to sweep in and grab those 2026 calls.

**Kilobase**

The plan is to wrap around the Supabase client with our own javascript library, eventually moving a decent chunk of the HTTP requests into our own webworker.
I am going to start small and slowly migrate the different functions and concepts into the web worker, like dexie but not nanostore.
We need to be careful because parts of the Supabase because it utilizes the localstoage and the web worker would not have access to that, but that is why we want to make sure dexie can communicate between the two types of storage.
Furthermore, we will want to test case the WASM communication but that will be when we do Unity development.

**Atoms**

The peristable generic wrapped around the nanostore will be our next test case for the laser package.
I am going to migrate some of the older `khashvault` code over to the dashboard.
We would also have to include a bunch of helper functions, maybe we could expand it a bit and have some additional helper functions for each generic atom, hmm.

**EventHandler**

Next update would be to integrate our event handler from the Phaser-base into something that can work in svelte too.
It should but let me use this time to double check, we need to add a function into astropad to help logout or signout the user.
Using the event handler for this as a start would make the most sense, we already have the signout in our removeProfile function, thus the only left would be to have the eventhandler handle the execution and verification of the event. 

The first thing we should is create the base object, `MetaData` and then extend that out into all of the `User` specific events that would involve the Auth or anything major.
This would help us keep some level of data integrity from the client-side, thus making some of the future updates a bit easier to manage.

The peristable atoms are still giving us some issues but I think we are getting a bit closer towards moving a good chunk of the react appwrite / rust code back into using the kilobase/supabase.

**Monodon**

Looks like `Monodon` just updated and now has napi v3 support too!
Lets gooo!
I believe this means we can upgrade our nx monorepo again towards v19?
We are still in v18 but there were a couple errors that have been holding us off before upgrading.

**Fudster**

I need to update the pip package for the `fudster` and add some more libraries and deps to it all!
The first major thing to include would be the pgvector + haystack integrations.


**HAMi**

While Charles is being prepared to be operational under the kubnernetes, I figured it would make sense to start up HAMi within the armada namespace.
This would give us access to our GPU worker nodes and let us schedule some of the mlOps that we will need to do in the future.

For now, we will just add the base chart and the yaml configuration.

https://github.com/Project-HAMi/HAMi

---
# October: 4th

> October 4th.

Source: https://kbve.com/journal/10-04/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity 6 CVE

-   01:38PM

    Resolved the Unity 6 CVE issue and upgraded to the latest LTS version.
    This time the upgrade did not have any major issues but also I think our ECS framerate also jumped.
    Now we are reaching around 200FPS, but that might be also because we lowered the amount of entities on the map.
    I will have to loop back around and see if there are any other issues that we might need to resolve.

## 2024

**Dashboard**

The goal for the day is to update the dashboard by integrating it directly with the Supabase!
One the load of the dashboard, we will focus on presenting a drag-able container system, where the user can control the different services that they have active within their account.
In the future, if we launch different AI tools and bots, we want to make it easy for the user to enable and disable them.

**Events**

For the redirects, I am thinking we could setup the redirects directly around the eventEmitter concept?
The type of event that we would create would be the `redirect` but I am not too sure how we would handle the `off` for it once they leave the page.
In a `spa` this would be easy because it would be just moving the code to mimic the redirect but in our case, we actually have to have the javascript exit.

**Profile**

Starting with the profile updates to the Supabase, we want to make sure that the user can update their profile's bio and their avatar URL.
However this might be a bit of a concern in the long term because we have no way to verify the location of the profile image, if its a valid png or jpeg, ect...
I am thinking that there might be a couple solutions to the this problem, we could use the aws storage to keep track of their profile image?
The other option would be to github or image proxy the avatar before loading it on the website.
We could also just disable avatars?

As for the Bio, I am thinking that keeping the limit to 225 characters and make the regex limit the type of characters that can be passed through.

---
# October: 5th

> October 5th.

Source: https://kbve.com/journal/10-05/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity MapDB

-   10:05PM

    We made some progress with the mapdb, finally getting some objects to go from the MDX to the Unity ECS map!
    There are still some tweaks that need to be made, but I am glad that we are making progress on this, if everything goes to plan, we could easily have a couple hundred resources for the map.

## 2024

**Avatar**

For safety reasons and logistics, I am going to just remove the ability to let users upload or reference avatars for now.
I believe the best solution will be to integrate the discord application and use that as a reference to their avatar or maybe do it via github and their profile picture.
This would remove the burden on us to store and fetch the avatar image! Moving it to the imgur, discord, github, ect.. whatever server that we can integrate into the system.

Thus the avatar_url part of the table needs to be deleted and furthermore, we could also remove the ability for the user to change their username.
Both of these might be a security concern for now, as we could have a username squating.

After thinking it through, I believe it would make sense to drop the "avatar_url" and the "bio" from the `user_profile` table, then lock down the whole table.
This is just a security precaution that we want to implement right now and then come back around to making the adjustments again. 

Okay! After dropping the two of them, we can go back around and update the `kilobase` class to adjust for the new schemas.
This means that our current setup will not work at 100% typesaftey because we changed the userprofile to now only be the id, username and the last updated.
In the future, this is where we would place the reference to any additional information that the user profile might require. 

To make the SQLs a bit cleaner, I moved the three migrations into their own subfolder, `user_profiles`. This will make referencing them in the future a bit easier.
I was thinking of also adding additional paths for referencing but this should be fine as is.

**WAL**

While we were playing with the postgres/supabase tables, we came across a new problem that was pretty easy to resolve.
Our postgres default volumnes were around `2Gb` in size but with the massive WAL files, we ended up growing way too far past that!
Furthermore these additional table changes, which have to be applied to the replica sets, caused us to blow past into nearly `3Gb` size!
This caused our database to `crash`, well not crash in the way that it would have been a pain but rather the volume size was just way too small.
The solution was a bit more than just expanding the storage!
I had to go back around and pull the triggers on deleting some of our older instances of VMs, so we shall say its official, RIP Portainer and RIP Coolify.
Both were amazing tools for our eco-system and growth, but it is time we commit fully towards the kubernetes eco-system.
Now the next issue will be migrating the main operating systems into a read-only state but that is for another time in the future.

**SQL**

The SQL file management and migration is a bit disorganized and we might need to find a better way to handle it.
I am currently thinking creating more subfolders inside of the `sql` folder, then moving the different sql files into the right locations.
Furthermore, we will have to add deprecation tags to the older sql files, including those for mysql / planetscale, since we migrated out of that system.


**Backup**

After the WAL issue earlier this morning, I timed my ability to resolve it.
It took about 46mins from crash to production, including figuring out what caused the crash.
I am hoping that this gives me the experience that I would need in future jobs but also building out a bunch of possible test cases would make sense.
These are things thats that I should keep noted and plan around, but the lack of resources does make this harder.
For example, if we want to do a live migration from Cluster A to Cluser B to Cluster C, ugh, we would need all three clusters to be operational and we just do not have the resources to currently do that.
I am looking into ways we could achieve this but at the scale we are operating at, it just would not be possible.
This is what made me realize why services like RDS and managed postgres instances exist for, the fact that you need to have so much extra resources to do live cluster migration is insane.


**Bonobo**

While programming tonight, the jams will be just straight bonobo.
We are going through a couple of his boiler room sets and his Royal UK concerts too.
His music just hits the perfect spot when doing postgres work, that and 80s japanese music blended into hiphop.

**JSONB**

Okay! We are a step closer with building our own public facing profiles aka user cards.
We got the table setup and its under the `enable_user_cards.sql`.

We also have two more queries to run to help stablize the user cards.

The first is to give all the older users a user_card row.

```sql

-- Insert into user_cards for existing users in user_profiles that do not have a user_card yet
INSERT INTO public.user_cards (id, username, bio, socials, style)
SELECT 
    id,
    username,
    NULL,         -- Default bio value, can be adjusted as needed
    NULL,         -- Default socials value, can be adjusted as needed
    NULL          -- Default style value, can be adjusted as needed
FROM public.user_profiles
WHERE id NOT IN (SELECT id FROM public.user_cards);

```

Then there is the materialized view refresh:

```sql 

REFRESH MATERIALIZED VIEW public.user_cards_public;

```
Under the `sync_user_cards_mat_views.sql`, we have a bit cleaner and safer method:

```sql

DO $$
BEGIN
    IF EXISTS (SELECT 1 FROM pg_matviews WHERE matviewname = 'user_cards_public') THEN
        REFRESH MATERIALIZED VIEW public.user_cards_public;
    END IF;
END $$;


```

---
# October: 6th

> October 6th.

Source: https://kbve.com/journal/10-06/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### KBVE Credits

-   08:15AM

    I have to add back the KBVE credits, we have two sql files in the past that had everything already setup for the credit system!
    I am going to take both of those and try to create a 3rd all in one sql file that will hold everything for our khash system, maybe even create a new schema around it.
    The credits will still be 1 million per $1, which we want to automate to a certain extent in terms of payouts and purchases, both would also need audit logs and security.
    
### Twitch Stream

-   09:05AM

    Getting the basics of the OBS setup going, this was long over due and honestly I think it will great to get our stream operational, even if its just for the memes.

### MapSettings Author Script

-   10:06AM

    One of the pieces that we are missing in our setup is the MapSettings authoring script, which will take each of the prefabs that we create and build an internal database for it.
    This is going to be important when we are looking to automate some of the map generation in the future.

### Argo IRC

-   11:36AM
    
    Looks like argo's deployment of the irc server is stuck in a processing stage, going to try and resolve it!
    The irc server is operational but the hang is a bit concerning, so I might as well address that right now.
    The hang is coming from the SSL cert generation and the cert manager, both of these can be addressed in our current unity pipeline.
    Let me push this fix up and then handle some of the click house issues!

## 2024

**NewEntry**

I have been slacking on my journal entries, can not even begin to imagine how bad my docs are getting too.

**Unity**

Spent went way too much time trying to figure out `Unity` version 6 , but I made some solid progress.
However I am back to the original square one and realized we can not have the games repo be open source because the private assets work so much better than any of the open source ones.
With that being said, I am going to migrate the `unity-rareicon` out of the `apps` and into the Azure DevOps!

Under the Azure Repos, we created the `rareicon` repo again and started to migrate some of the older code into this repo.
However we will have to adjust or create another `auth` system for unity to help with the login phase.
For this, I am going to start with a very generic and base concept and work from there.

**Auth**

In perparing for the Auth system, we will create a folder for the `auth` pages and then create the `unity.astro`.
We will use this `https://kbve.com/auth/unity/` as our general endpoint to help us handle the auth system between our supabase and any Unity instance we want to integrate.

**Skeleton**

We should just name all the base skeletons across all our websites with a `id="skeleton"`, instead of the various other side names that we had.
This way we can just control the skeleton through the `header` or `mainlayout` rather than remembering to include it in every instance that we need it in.

**Vuplex**

All of the web-based open source webviews are just a bit trash as of right now.
So we are going back to our old faithful, Vuplex.
The Vuplex instance will load the `https://kbve.com/auth/unity/` at first to help us with the handling of the login.
As for registering, I am thinking that it would just make more sense to link them directly back to the `https://kbve.com/register`, rather than include a way to register directly within the application.

**Corgi**

For the 2D engine that we will be using, I am going with the old faithful of Corgi!
All of this is like a trip back to memory lane, its been such a long time since I had to write and see the word, `GameObject`.
I am going to go through all the example assets that are included with the Corgi engine and see what we can use as a base for our game.
Once we get the base of the game setup, I am going to setup the pipeline for building the unity 6 and the general steam flow.
If everything goes as planned, we can ship to Steam without any major problems.

---
# October: 7th

> October 7th.

Source: https://kbve.com/journal/10-07/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### ClickHouse Postgres

-   04:59PM

    Integration is complete, we are able to query!
    Our quick command to connect to the service is this below:

    ```shell
    talos -n clickhouse port-forward svc/clickhouse-clickhouse-cluster 9000:9000 8123:8123
    ```

    For our quick query, we will do this:

    ```sql
    SELECT *
    FROM postgresql(supabase_postgres, schema='auth', table='identities');
    ```

    This will be a quick test case to make sure that everything works between the external secret and our current query.


## 2024

**Unity**

I been diving deeper into Unity 6, preparing the different plugins and getting ready for the stable release next week.
Since we have about a week to prepare, I am going to go ahead and test more plugins with the pre-release!

**OneJS**

Out of all the plugins that I have installed, it seems that `OneJS` is already setup to be used on unity 6 aka 6000.
This plugin will help us build some general UI systems using tailwindcss, but those ui components might not work on a mobile release.
I am thinking the rare icon game should be released for just steam and we can wrap back around with a new game in the future for mobile.
Or if we need to release to mobile, I can just replace the UI with Unitys library, probably hire a developer to do it for us.

**Auth**

For the Supabase Auth, we will have to finish up the generic endpoint and then build around it.

---
# October: 8th

> October 8th.

Source: https://kbve.com/journal/10-08/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Clickhouse Bi Directional

-   05:35PM

    The goal will be to setup a direct wire between the cnpg and clickhouse cluster!
    Well specifically we want the ability for the the FDW on the postgres to not only read but write to the cluster, and obviously the same from the clickhouse side.
    However we will have to make sure that the data stored in the clickhouse is shared across the replicas, so we do not waste too much of the resources by keeping multiple copies in ram.
    This still requires some work on our end to setup without breaking anything.

### Landing Card Starlight

-   07:59PM

    Finishing up the basic landing card for KBVE, having it utilize the starlight theme and also the virutalized list.
    There are a couple other bugs with the card that we need to resolve, I believe the issue that has been hitting us hard is the this damn margin top that keeps appearing!
    It just ends up offsetting every element by a specific amount and I just can not seem to figure it out.
    Richie came in clutch with that fix, we can move forward with some of the other parts of the code that we need to adjust.

## 2024

**Auth**

Back to focusing on the paraops, getting the base of the unity auth built out, so that that it can help with the user sign in.
We can also place some safety measures around the unity auth, so that if `window.Vuplex` is not found, it would not send the postmessage with the JWT?
I still have to work around the exact way that we could handle this, but I do want to get it all done by tonight.

**Steam Pipeline**

While building out the rest of the auth system, I want to go back and restructure the github actions yaml for building the unity game's pipeline.

**CI Patch**

The `ci-patch` workflow started to fail and it might be because of package conflicts between the main monorepo and the current dependencies under the `@kbve/devops`.
Thus to address this, we will have to find a couple different routes!
The most likely reason we are having this issue is because the `deps` between the package and the monorepo are outdated.
This will be something that I can address but lets see if we can isolate that issue?
I am going to move the action out of the `monorepo` and into its own independant folder.

---
# October: 9th

> October 9th.

Source: https://kbve.com/journal/10-09/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Conch Shell

-   09:15PM

    We are bringing back the classic shell!
    Thanks to a couple free APIS, looking at you Gemini and Groq, I am going to make some quick functions that will handle that for us!
    The goal will be to test out the machine learning calls without having to break anything on the backend side.
    I am thinking that we would store the APIs as a vault secret, then pull that into the edge calls which we will do before making the final calls to gemeni or groq.
    As for the context, this is going to be a bit of a rough part on our end, I am not too sure how much context we will be able to keep, definitely as the conversations grow.

## 2024

**Vuplex**

The plan for today will be to focus on getting the vuplex to communicate with the kbve website.
We are going to continue from yesterday, expanding the vuplex postmessage and event listeners, possibly linking them together with our kilobase events.
Created a helper class under the `Utils` namespace, these are things we can integrate into a final nuget package that will help us in the future game development.

We been making some progress with this part of the vuplex, we can move the data from the kbve website and unity client without any major problems.
However we do need to grab the session and refresh token from the javascript side and then use it to build the supabase client within the unity side.
This way we can then close out the WebView and use just this token to handle our game management!

As for what I understand, we can also also have this operate in an offline mode too but that will be something that we can look into the future.

**NuGet**

Moving all our core code into a namespace would make sense because then we can reuse all of it in the future?
I am thinking we keep parts of the code still isolated, while building out the game but at the same time, we can consolidate the older legacy code into a `KBVE` namespace.
The goal here would be to eventually release it under a nuget package and start to reutilize the code in future projects.
There might be some side-effects but we do not want this to be aimed at the general public, but rather leverage the open source eco-system to create our own hybrid source.
Parts of our game's core codebase being open source is not going to hurt us, but only help us move forward.

**MainTemplate**

Added a minor boolean to the `MainTemplate.astro` that will disable the footer, thus making it a bit easier to handle certain pages on WebView.
Our `unity.astro` under the `auth` should not provide a footer nor a navigation bar!
This should make it a bit easier to handle the resolution of the login page too, since it will not have to render those objects and take up vital space.

**Last Note**

Okay last entry before switching over to the next day for my entries.
I am thinking that it would make sense to abstract away the c# code into our own nuget library, then abstract away the dependencies that we would need by scoping it all into this package?
This is still a bit of work in progress, but I believe it will help a ton with the logic and flow that we are looking to do within the monorepo.
I have to remind myself that this is all part of the learning experience, got to overengineer and learn from the hardest point of view.

<Adsense />

---
# October: 10th

> October 10th.

Source: https://kbve.com/journal/10-10/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Addy Bolts

-   01:15PM

    I am currently working on the ge tracker clone and during that process, I am able to pickup on some random changes that I could utilize in the future.
    For example, I pulled all the items into the clickhouse, then I can see the price changes and how it effects other items that are involved in their production.
    These tweaks will make for some really crazy possible mdx files that we can build in the future!
    I think players would love to see some abstract economic documents that we can generate using this data.
    All of this would just be practice for when we start to move it towards stocks.

### Nvidia Roll

-   04:19PM

    Just under the $185 mark, hitting a low of almost $183, that means that I rolled way too late!
    I really thought it would have dropped further, I made an interesting last second call but we shall see until the next week how it will play out.
    I should have just stayed the course but damn that last roll was too tempting, but hey $190 is not bad at all.


## 2024

**KiloNet**

The GameManager, JSON utils, event system, ect... all of these things can be refactored and rewritten into its own nuget library that we can package up and release.
My goal would be to isolate this part of the codebase from any game that we build, almost making it agnostic and version controlled?
This was something that I wanted to practice and have under my toolbelt as a skill, furthermore, it will make things like FFI in the future easier to implement and even backtrace.

This is another grand task to take on but I am confident that it will be a huge mess, uhh I meant overengineered alien crash landing.
To get started, we will have to tell our dotnet to generate the starter library, then begin stripping out the older code from `unity-rareicon` and `saber`.
Once we get all these things handled, we can then publish this nuget library and import it into the rare icon on the Azure Git Repo.

Okay, getting started with this library / package, to generate it, we will run this command:

```shell

nx g @nx-dotnet/core:lib kilonet --directory=kilonet

```

This will generate our base library that we can import in our various projects.

To import this library in our unity, we will do this:

```json
{
  "dependencies": {
    "com.kbve.kilonet": "https://github.com/KBVE/kbve.git?path=/packages/kilonet#dev"
  }
}
```

We place the dependency to a specific folder, `/packages/kilonet` and then assign the branch with the hash flag, `#dev`.

This way we can pull the code and test it from the dev branch.


**ParaOps**

At the same time we are building this, I want to adjust some of the broken codebase too.
We need to finish adding the itch page to fix the 404 error that was showing up ealier.
One of the larger problems that I need to address was the broken itch io for Fish and Chip!
We updated the astro component and added our own custom phaser component inside of the `kbve.com`, avoiding the `ve` import from astro-ve.
This was an issue with over engineering and this method will help resolve that problem, with the game playable now without any major issues, I believe.
Let us solve the 404 error first and then we can wrap back around with better CSS fix, which will be easier once we can see the game load on itch.

---
# October: 11th

> October 11th.

Source: https://kbve.com/journal/10-11/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Adamantine Vein

-   03:59PM

    I been having a tough time figuring out how I should render the different veins for the game.
    The pixel art for it is another rough skill that I need to improve upon.

### Demon Lore

-   04:56PM

    While working on the pixel images, I should focus on the lore for the different enemies that will appear on the map.
    One of the things that I should do is make it so that when gathering resources, depending on the type, it should anger the spirits.
    Taking the notes from classic movies, chop more trees and get more demons on the map.
    I should focus on having some synergy between the different elements and their creature-based response.

### Unity Session

-   05:53PM

    About to start the unity session, going to get the R3 + mouse over resolved this session as the resources are being added into the game.

## 2024

**Animations**

Spending some time learning how animations work within Unity is always a fun time.
The first animation will be with a 2D sprite and that will have multiple different references.

**JEDI**

Under the `kilonet` package, the first major script that we want to add is the `JEDI.cs` and it will handle our JSON serialization.
However I believe in the future, this can be our first step in doing the Rust FFI and specfically replacing the json methods with a rust binding.

**Packages**

We got our first package for unity loaded into the `rareicon` game on the Azure side!
For now we will continue to migrate some of the legacy code into this package, but the end goal will shift a bit?
Part of the problem that I can see is that version control will be a bit rough because we are using branch names.
The solution to this will be to have our package get either loaded into the unity asset store or we go through nuget?
These are concerns for a future problem, since the goal should be inching closer to getting a steam game published.

**Kilonet**

The next update for the `kilonet` will be focused on resolving some of the vuplux and supabase integrations.
One of the areas that we need to double check are the save states for the json, which are currently hardcoded in, also the supabase anon key and the api is also hardcoded in.
Both of these need to be adjusted, but I am still considering how I would want to handle that.

**Register**

It seems that our register function within Supabase was broken but I was able to figure it out.
During the table creation for the usercard, we were referencing the username table twice, which is not optimal because we already have the username saved in the user profile.
The solution was to drop that column for username on the user card, then adjust the table creation by having the default fields be null and then finally adjusting the materialized view to use a join between the two tables.

<Adsense />

---
# October: 12th

> October 12th.

Source: https://kbve.com/journal/10-12/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Ghostless Session

-   09:45PM

    Since its Sunday, I will be spending majority of the next week focused on Unity.
    We want to aim for a demo before the end of November and maybe hit that Steamfest in Feb 2026!
    This upcoming week will be all ECS focused, getting the UI out of the way too.

## 2024

**Login**

Now we can go back around and adjust the login script within unity to use the kilonet.
We would want to keep the supabase instance and client connected but only if in the `kbve` mode because in `offline` and `steam`, we would not need the supabase client.
For the steam version, we would just handover auth and utility to the Steam SDK, this way the player can still get the achievements and in-game items.
However what we do need to be careful about is to prevent cheating and maybe lockdown parts of our code, hmm, we can get a bit creative with how we want to handle that part too.

**Title**

For the rare icon game, we will focus on three core gameplay options, `Single-Player`, `Steam` and `KBVE`.
The single player will be an offline and casual instance, while the steam mode will be focused on a co-op style of gameplay and finally the kbve version will be for the hardcore players.
We will want to keep the players focused on the single-player first, maybe even lock out the `kbve` until they complete at least one mission on the single-player?
The goal would be to keep players happy regardless of their play style and maybe find some creative ways to make each instance popular?
Like special abilities from the single player could grant you special benefits in the pvp areas?

**State Machine**

In our current state machine codebase, the save file name is just hardcoded to be:

```c#

private const string SaveFileName = "RareIconGameSave.json"; // JSON file name for saving state

```

We want to make this a bit more dynamic, maybe depending on the application's name or just some form of a variable, rather than what it is right now.
For that, we need to update the `StateMachine.cs`, such that when the constructor is being created, we do this:

```c#
    SaveFileName = !string.IsNullOrEmpty(Application.productName) ? Application.productName + "_GameSave.json" : "RareIconGameSave.json";
```

This will let us create the save state based upon the `productName` and `_GameSave.json`!
Let us go ahead and push that out!

**Data**

There is an older folder we created called `_Data`, which holds a bunch of assets under a sub-folder of `BG` and `PixelArt`.
I am going to go ahead and remove those because we will no longer use them in our current game.
It would make more sense to keep the simple ui for now and focus on making it more stylish after we get the core gameplay out.

**SubScene**

After getting the base of the game state resolved, we can move forward with the initial game loading and level picking.
I am going to build off of the MM system and basically reverse engineer how they handle level loading, we see that there are two scripts attached to the button.
The scripts are `Selection Base` and `LevelSelector`, we will peak inside both of those cs files and see what they are doing.

**Double GameManager**

It seems that we have two instances of the GameManager, one in our Kilonet package and another inside of the MoreMountains, so we can avoid this problem by making sure that we reference the exact GameManager when using both libraries.
In the event of using both game managers, we would need to be specific, i.e `KBVE.Kilonet.GameManager` as opposed to just `GameManager`.
Okay! That was the last of the main errors that I wanted to address today.

**Animations**

Updated the KBVE.com website animations to be a bit more in-line with our robotics and gaming side!
We still have a couple more of the components to fix up but I will slowly tackle them as I am updating the website.
The a future update will be around better state machine management and the loading of the riv assets, which could be done off thread.
Hmm, we could have the worker load the asset into the dexie storage and then pull it whenever we want to create the animation, as well as, save its internal state machine.

<Adsense />

---
# October: 13th

> October 13th.

Source: https://kbve.com/journal/10-13/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Hover Refactor

-   11:05PM

    Officially refactoring all of the ResourceUI / hover over resource into an entity flow.
    This refactor is what will make me an official Unity developer, actually doing some cool and unique things that others have not yet.
    I am excited and pretty confident that I will be able to pull this off without any major issues.

## 2024

**Kilobase**

The task that has been waiting for a while, geting the redis extension working again within our postgres instance!
We would have to split this up into a couple different parts, ugh, I hate having to run the docker desktop, it makes everything more painful.
Let me make sure that the cluster is operational, which I can do via the cli through this command: `kubectl get pods -n supabase` and then we can wait the decade, err, the 10mins, for docker desktop to boot up.


**Feels**

The unity engine component that we want focus on will be the Feels component, specifically their `MMSoundManager`.
Now this is where we get into a bit of a tricky mess because we do not know if the extension will be installed in every future project.
The solution would be to create a collection of custom scripting symbols that are specific to the different plugins, extensions and namespaces.
I am also thinking that we would need to isolate those specific extensions into sub-folders, `KBVE.Kilonet.MM` would hold all the `MoreMountains` instances, while `KBVE.Kilonet.Vuplex` would hold the vuplex code?
This approach would make more the most sense for now.

**CryptoThrone**

The next major update for the CryptoThrone.com game will be to include a register and login system for the player.
We will integrate directly to our supabase instance and use this as another example to test case our self hosted instance.
After we migrate this website, we can loop back around and migrate any of the additional domains that we are hosting or managing?
Herbmail does need a whole new UI/UX upgrade and so does RareIcon, hmm, we can do those two afterwards.
As for the HQPlan and the Cityvote, we will hold off on those while doing the docker desktop build because expo will take up too much time and resources.

**Herbmail**

For herbmail, we will have to remove some of the ve references and switch them over to the Astro Pad.

**Rive**

Spent the past day moving the animations out of lottie and into Rive.
My plan is to then utilize some of the animations inside of Unity as well, so that we could a bit of cross-file usage, ideally making the tutorials be on our website rather than in-game.
I changed the hero animation for KBVE and also threw a heavy animation into the footer, both are just small test cases that should have interesting results from the webmaster tools.
For now, I am using our tools to check against the load time, but google's webmaster tooling should be enough, and hmm, it seems that the rive library is the biggest issue.
We could move the loading of the script off the main thread and use a web worker, but that will be an issue for the future me to resolve.

---
# October: 14th

> October 14th.

Source: https://kbve.com/journal/10-14/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### M4 Pro

-   08:13PM

    New macbook is officially back on the table, as building the Unity game on the air is reaching the pain points.
    With two visual studio codes open, Unity editor and a browser, my damn ram usage is maxed out.
    I was able to get the same macbook pro that I ordered earlier this year for about 1K less and double the SSD!

## 2024

**Toastify**

Migrated the toastify from 'astro-ve' to 'astropad'.
We can not migrate DOM scripts to a web worker, so we will have to be careful on how we handle the toast notifcations.
There is the option of using the preline toast but some of our older sites still use toastify, thus we want to make sure we have both as an option.

**Flowbite**

While we are using preline library on kbve, I believe for herbmail we will be using the flowbite library?
Thus we need to migrate the flowbite over from astro-ve to astropad!
There are a couple smaller things that I wanted to adjust for but this should be a small and easy task for now.
For a side note, the rareicon website will be shadui and probably react-three-fiber combined?
The idea of a space dock being the core of the game is just way too good for us to just throw to the side.

**Readme**

Updating the monorepo readme, I will start with fixing up some of the image shields!
Added the fudster package and the nodejs packages to the monorepo.
The readme should include faster links to the docs and exact locations for the different projects/packages.
I suppose we could also move the notes directly into the readme files, then during the build process of kbve.com, we pull the readmes from the dev branch?
This way we do not have to write the readme files twice and have a bit of sync between the docs on the website and the markdown files in each nx project.

**Go**

Let me `go` ahead and add the go nx bindings to our monorepo, which should work fine because we are on nx 18.
We will create the first package like this `go-portside` and then build out the `go-rareicon` from the application side.
This is will be for test casing and the general dirty napkin side of things.
Okay! Doing this before I start driving around like a madman, going to use my phone this time to start the go project.
The goal should be to get this out under the apps folder as `go_icon`, then we can loop back around to get the official readme up and running.
The integration of supabase-go will be then after we get the base pipeline operational, probably could also deploy it to the helm too, hmm.

**DevOps**

Updated the devops library and added a new function to help automate the pull requests.
For this script, we want to make sure that, ugh, you know what, we will just run with what we got!
Let me save the state, I will push back the protobuf update and just begin pushing through the test cases for the patch.
Yay! After 8 test cases but it might have been closer 20 but its okay, who is counting?

**DanDaDan**

Definitely the best anime of 2024, its a perfect blend of ghost stories and durarara!
I believe it should be on everyones watch list, gonna hype it out too.
Yet I hate having to wait each week for a new episode, but hey, its another thing to fill that kill tony void.
Speaking of which, I am super excited for tonights episode of kill tony, I need that laugh.

**Github**

Looks like the actions are breaking because of a workflow, aka `auto-pull`, and the reason behind it breaking is that dockerhub is denying a docker image pull.
There are a couple solutions to this problem, we could forward over our dockerhub login to increase the rates, this would be easy and should resolve that problem.
However, I want to be a bit more complicated and maybe we could just remove that action from the workflow and use our devops library to do the automatic pull for us?
Or we could swap out the action to use `https://github.com/peter-evans/create-pull-request` instead?
The issue that I can see already with our devops library is that it might cause some problems, but hey, we are learning right!

---
# October: 15th

> October 15th.

Source: https://kbve.com/journal/10-15/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Wedding

-   05:00PM

    Shopping the whole day with the family, need to get my outfits ready for the wedding next month.


## 2024

**Herbmail**

The first goal for today will be to rewrite some of the front page parts of herbmail and begin the kilobase integration!
My approach might be less of the split of components and try to just integrate everything from the `/pages` level, which should make future development easier.
Okay let us begin the process, going back and making sure our flowbite library works without any problems.

Oh! I am going to remove the e2e for the herbmail.com, this will be handled through an test action that will operate outside of our monorepo.

**Preline**

Let us go ahead and just remove the flowbite then swap it with preline.
I believe that we can just keep using the preline across all our websites, making it easier for us to write different components without having to go too crazy.
On the other hand, we could just migrate over to shadui and just skip all these extra libraries, hmm.

**Nx v20**

Looks like we can not add the shadui because it requires us to be at least nx v19 or higher, which also means we need to make sure that everything works before moving forward.
The balancing act of keeping nx operational and not having everything break is always a rough one, definitely when moving from nx v18 to nx v20.
During this process, I am already seeing errors and parts of the ubuntu instance crashing, damn.
I never realized that I could crash WSL with a simple command, hmm, ugh the feels are getting rough already. 
Maybe I will try to upgrade the whole repo again but using my macbook.

---
# October: 16th

> October 16th.

Source: https://kbve.com/journal/10-16/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Tar Rift

-   04:00PM

    Looking at all my stocks take a terrible beat, oh well, I got a bunch of call options that expire tomorrow.
    This gives me a great chance to exit those rolls and maybe do something new and refreshing next week.

## 2024

**Astro**

Looks like the migration to a functional v20 nx instance is almost done, however the astro extension seems to fail to execute.
There is already an issue ticket of the problem in the extension repo, so we will just keep track of it and wait to see what the authors do to resolve it.
I am thinking that it will be an easy fix, the error is most likely because of a variable change but I did also notice that in v21, the tasks will be removed?
The best bet would be to wait it out for a week or so, and then 


**DotNet**

I made the decision to remove the dotnet 7 / dotnet 8 direct support because too many issues within my mac and wsl instances.
Since we are having our unity repos now sit outside of the monorepo, we can just move towards removing the dotnet library from our monorepo.
This will be officially done within the next month, we will still keep the the unity packages within our monorepo but not a whole unity game.

**Kilobase**

Trying to resolve the redis extension for the build, but I know that it will be a pain to work through the code again.
We want the kilobase extension to grab the data that gets placed into a table, aka the start of the redis code.
I moved this part of the entry to the 10-17.

---
# October: 17th

> October 17th.

Source: https://kbve.com/journal/10-17/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Rewrite Refactor Rebuild

-   01:13AM

    We are now in the deep sessions of Unity, getting into the max grind.

## 2024

**Redis**

Time to double check our build for the kilobase but this time on the macbook.

**Cargo**

Looks like we have to restructure the way that we handle version bumping because its causing our packages to break during test casing.
We will do the version bumps manually rather than automatically for now because the errors are a bit out of my scope.
Ugh, the migration to Nx v20 has been such a pain, I am almost reaching the burnout zone of programming.

Not too sure how I got around resolving this issue but we dropped a bunch of reference points and were able to get to functional build.
It involved cleaning up all of our cargo and then running a fetch again.

```shell
cargo clean
sudo rm -rf ~/.cargo/registry
cargo update
cargo fetch
```

There was a bunch of looping and cargo lock removing but we got past that hurdle.
Since the supabase docker image is ubuntu 20, we need to drop down the pgrx from `0.12.3` to `0.11.3`.

```shell
cargo install cargo-pgrx --version 0.11.3 --locked
```

What a pile of donkeys splat, had to downgrade back to v1.2.0 for the Rust monodon package to even get our basic builds to work.
This means even at v2.0, we are unable to have stable rust builds, gah!

Well with the version downgrade, we are making some progress.

```

warning: `kilobase` (lib) generated 6 warnings (run `cargo fix --lib -p kilobase` to apply 3 suggestions)
    Finished `release` profile [optimized] target(s) in 0.19s
  Installing extension
     Copying control file to ../../dist/target/kilobase/opt/homebrew/opt/postgresql@15/share/postgresql@15/extension/kilobase.control
     Copying shared library to ../../dist/target/kilobase/opt/homebrew/opt/postgresql@15/lib/postgresql/kilobase.so
 Discovering SQL entities
  Discovered 2 SQL entities: 0 schemas (0 unique), 0 functions, 0 types, 0 enums, 2 sqls, 0 ords, 0 hashes, 0 aggregates, 0 triggers
     Writing SQL entities to ../../dist/target/kilobase/opt/homebrew/opt/postgresql@15/share/postgresql@15/extension/kilobase--15.1.9.sql
    Finished installing kilobase

```

Now we will wrap back around and look through the code again tomorrow, making adjustments to the SQL tables that and some of the logic.

**Expo**

Time to take a break from the rust code and take a look at our Expo configuration.
We have a couple things that we will have to change, including the bbq extension, which has still a bit of cookin left on it.
The command to start expo will be like this:

```shell

pnpm nx start expo-lcagents

```

Next we will take a look at the current source and I believe the theme needs to be defined again.
We can double check the tamagui version, I believe that it needs to be updated as well.
Bumping the tamagui to version 1.115.3, but there should not be other major upgrade yet.
I believe expo could be bumped up but we can wait on that until the iOS and Android pipelines are ready.

Okay the first issue was the dark mode, we want that to be default for right now.
This will be a quick fix and should not cause any major problems, we just flip the logic that would apply the default theme of light to dark.
We can do this inside of the `_layout.tsx` and that solves the dark theme issue.
Next we want to solve the double root problem, this can be done by removing the register root and just export the app with the expo-root.
Okay so we no longer see any errors in the web version, I did not yet test this on the iOS version but we can look at that later on.


**ExpoDoctor**

Since I am using a new laptop, there will be some plugins that are missing that need to be installed.
The shell that we could use to verify that is:

```shell

pnpm npx expo-doctor

```

I also believe that the nx monorepo provides another way to call the expo doctor, but regardless, I do not have the data rates to download all the files that we would need to fix this issue.
When I get back home, I will begin the process of setting up the iOS on the new m3 macbook.

**BBQ**

The next component that I want to add into the bbq would be an account or profile card, but we also need to configure the register and login?
Thinking through what would be the best option for setting up the register / login, I guess since we are using the tamagui, we can just wrap each of the component pieces with generic components.
The customization will be isolated from the smaller component pieces, so we should not have any issues.
To get 

**Kube**

While setting up the expo again, it would be wise to take a look at the kube health, making sure that everything is still functional.
I am going to run the `kubectl get pods -n supabase`, which returns a great status of everything running the past 12 days without any major errors or restarts.
With the version of kilobase v15.1.10 getting ready, we want to prepare a rolling cluster update.


**hCaptcha**

The next issue that we want to tackle is the loading of the hCaptcha within the react native / expo eco-system.
It looks like to grab the library, we will have to do this:

```
pnpm install @hcaptcha/react-native-hcaptcha
```

Then setup a new component, we can call it `hCaptchaWrapper` that would invoke either of the two units based upon if its web or not?
I suppose this would be easier since we can throw that into the BBQ and then reutilize or extend it out based upon how we want to integrate the supabase instance.
For this situation, we will try to avoid placing kilobase directly into this expo logic and just wrap around the supabase too.
Hmm, okay let me quickly build this component out inside of the bbq package and ship that out.

**DanDaDan**

Nothing says Thursday than a fresh episode of Dan Da Dan?
After driving around and touching enough grass, I think it would be great to spend the night just programming away and throwing on a series to stream.

**API**

We can deprecate and remove the `api` component within our apps folder.
Since this application was over a year ago and I have improved a bunch within the rust realm, it would be safe for us to remove it and replace it.
With that being said, right before we do that migration out and kill it, I should prepare the `kiloedge` instance and make sure that we can deploy edge functions through our self hosted instance of Supabase.
The way that we will build those self hosted functions, hmm, it would be to just grab the current version of the supabase edge instance within our docker image.
After grabbing it, we git copy the functions that we want to migrate over to it and then finally build a final image.
Could throw the cache into there too and make sure everything is included, then making it a read-only application would be our next logical step.

---
# October: 18th

> October 18th.

Source: https://kbve.com/journal/10-18/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

-	03:34PM

	Setting up the new macbook and its been a joy so far!
	I am still a bit butthurt about the default username that macbook sets and forgot to change it.
	Everytime I get a new macbook, I always run into this problem.

## 2024

**Sheet**

Currently trying to get the modal or sheet to load the captcha, but damn its been a wild ride.
I am going to assume this is the party where I quickly advance from a simple react native developer to an expert xD.
There are 10 mini bosses that you have to face before becoming the greatest champion ever, or in this case, just getting a damn simple app functional.\

**Fudster**

After the migration of nx to v20, we need to make sure that the python eco-system still works without any major errors.
For this, we will test case the fudster library and see if we can build and add around it.
The python monorepo library or extension we are using is `@nxlv/python`, which is sitting at aroujnd version `"@nxlv/python": "19.1.3",`.
Lets upgrade that to the latest , v19.2.1 and see if can help us with making sure that the python package builds without any issues.

After the upgrade, we are going to bump the haystack version up to the latest version.
We could also move the whole library up to python 3.13 but that can be done later on, first we should tackle the upgrading of the `haystack-ai`.
Fudster package currently sits at `haystack-ai = "^2.2.3"` and we will want to bump it up to `2.6.1`.
For this, here is the sample command that we will run:

```shell

pnpm nx run fudster:add --name haystack-ai

```

Oh, I made a mistake, we need to update it, so it be:


```shell

pnpm nx run fudster:update --name haystack-ai

```

Okay but I believe that did not version bump our main poetry file, however that will be fine for now because the lock was updated.

Next we want to update the `fudster` pip with the latest pgvector pip, since we are working around haystack, hmm.
We will be running this:

```shell
pnpm nx run fudster:add --name pgvector-haystack
```

This will be adding the `pgvector-haystack` and that will be the base for our vector search and memory store.


**Drizzle** 

Looks like we have two more libraries in our package.json that we need to remove.

```json 
"drizzle-orm": "^0.31.1",
"drizzle-zod": "^0.5.1"
```

I will create a new branch and run `pnpm remove drizzle-orm drizzle-zod`.
Let us take a quick branch split before we remove the planetscale library.

**Tamagui**

Taking a break from the python scripting and looking at the `Tamagui` instance under the expo-lcagents.
I believe we will backtrack and remove the portal part of the code and revert back to the general sheet because it seems that the native sheet is a bit too much for now.

Our index right now with the portal looks like this:

```js

import { ExpoRoot } from 'expo-router';
import 'expo-router/entry';
import { PortalProvider } from '@tamagui/portal';

export default function App() {
	const ctx = require.context('./src/app');

	return (
		<PortalProvider shouldAddRootHost>
			<ExpoRoot context={ctx} />
		</PortalProvider>
	);
}

```

However, I am going to remove the `@tamagui/portal` for the time being and the `PortalProvider`.
Rather than spending more time trying to solve the native sheet integration, it would be better to just let it go for now.

**iOS**

Back on the macbook, thus it will be time to focus on the build!
After removing the portal, we need to remove the `"react-native-ios-modal": "^0.1.8",` library as well.
We will try to keep the sheet / modal to the tamagui default rather than the native.

---
# October: 19th

> October 19th.

Source: https://kbve.com/journal/10-19/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### GameJam Prep - Playful AI

-   09:51AM

    I am getting ready to take a quick break from the godot and head directly into another gamejam.
    These next couple entries will be a bit delayed because I am really focused on getting a game done.

-   05:50PM

    The game will be a cat-based afk simulator, how we will go about building this?
    Well I am not too sure but I am thinking we will just use godot and just run with it.

## 2024

**iOS**

We are about to wrap up the iOS session this wekend, or at least that is what I have been telling myself over and over.
With the astro extension not yet being up to date, it is starting to make more and more sense to swap some of the exisiting sites that are under astro to tamamgui.

**Lottie**

To get started with the lottie deployment, we need to add three libraries into the monorepo.
Here is the pnpm command to do that with:

```shell
pnpm install lottie-react-native @dotlottie/react-player @lottiefiles/react-lottie-player
```

After adding it, we have to install and prebuild the expo application.

```shell
pnpm nx install expo-lcagents
pnpm nx prebuild expo-lcagents
```

Here is the demo of how we would utilize it.

```tsx

import React from 'react';
import { YStack } from 'tamagui';
import { LottieAnimation } from './LottieAnimation';

export const MainScreen = () => {
  return (
    <YStack f={1} jc="center" ai="center">
      {/* For local JSON files, pass `require()` directly */}
      <LottieAnimation lottieJSON={require('../assets/json/demo.json')} />
    </YStack>
  );
};

```


**Unity**

Upgrading our current unity game to version 6 is always going to be fun!
Well we are already on unity 6000 aka six but we have not yet updated to the LTS version.
I am planning on doing that tonight, most likely inbetween my react native dev sessions.

**Postgres**

During the signup, I have noticed a terrible bug and that was in our `username` settings as it seems to treat upper and lower case as different unique variables.
This is fine for things like unique link generation or anything of that nature, but for usernames, this is terrible.
The solution will be to update the constrants around the username column, fix the trigger and update function and then run a quick refresh of the materialized views.

**Issues**

I have about 30 more issue tickets that I need to open up!
They will be outlining the next couple steps for this month and leading into the next month.
However, I do not want to overload myself with a bunch of out of scope or useless backlog, at least for now.
It would make more sense to focus on keeping the issue tickets at a healthy sub-50 and making sure that it never gets past the dangerous 100 mark.

**LofiFocus**

Before moving really heavy into the dev cylce of the `LofiFocus`, I would want to map out some basic issues that would help me keep track.
There are two tickets right now that are open for the lofi / jukebox but I will merge those into a new ticket.
Under the new plan for the application, [issue 3076](https://github.com/KBVE/kbve/issues/3076) should be focused on the general expo / tamagui dev.

For the ingress issue, I am going to just rotate the DNS from an A record over to a CNAME, then point it tgo our github organization.
The plan will be to just host the application directly through the github pages.
Hmm, we would need two more issue tickets for some of the libraries that we have to add, but instead of creating a new ticket for those, I will just add them into the [786](https://kbve.com/i#786).

**Mail**

The mail server will be deployed in the mail namespace through the fleet helm.
I will create an issue ticket if we run into any major problems, but I do not think we will run into any issues.

---
# October: 20th

> October 20th.

Source: https://kbve.com/journal/10-20/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Claudia and Codex

-   09:15AM

    The most powerful combination that I have found is using both the codex and claude to really pump out the code.
    Having both of the LLMs check each others work and focus on refactoring while they write is amazing!
    Programming is really evolving and I am all here for it.

## 2024

**TamaGui**

We are getting a bit closer at having the `expo-bbq` become a complete package!
There are about 15 more components pending integration and migration but should be done before the end of the year.
One of the cool perks that will come with this being complete is that we will be able to fast track app production to almost a weekend.
The feeling will be amazing, an idea to a production app within 72 hours.

**LCAgents**

Let me update the deployment pipeline so that the beta branch will just push the code out for the expo.
First we will start the development cycle of the `alpha` branch, which should push our code changes to the `alpha.lc-agents.com` but we still have not yet set that up.
Since the site already looks like trash, we will just push the code out to main and then rotate out later on, once it gets better metrics.

Okay, updated the lottie animations and the dev branch pipeline!
This should make it a bit easier for us to have the code migrations occur without breaking the whole cicd.

**Lottie**

Within the `expo-bbq`, we will start with a lottie hero, which will appear on the first load of the application / website.
I am usually against this type of flow, usually having a heavy website is a bit of a burden but there are some amazing tricks we can utilize in the future to help us out.
The lottie json is around 200kb but an optimized dot lottie would bring it down to 30kb, however we can only use the optimization on the website because the react native integration for lottie seems to be a bit broken.
For this aspect of the integration, we will create the hero component and

---
# October: 21st

> October 21st.

Source: https://kbve.com/journal/10-21/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Sleep is Lost, damnjam.

-   06:00AM

    I am having a tough time keeping my sleep on point through this jam, I can feel myself getting older.
    The amount of hair that is thinning is way too high for this! 

## 2024

**Astro**

Looks like the new astro extension for nx v20 is almost ready to be push out!
Once we get that back into our repo and have it all be functional, we can move the project forward with some more updates.

**Postgres**

We have a couple updates to perform on the postgres instance, but before we do them, I want to make sure we can test case the live cluster migration.
The way that I am thinking of handling this would be through readme updates and having them be the point of activation for controlling the updates.
While gpt is converting over the different templates, I will start the new profile api for rust/herbmail.
I am thinking of calling it: `herbmail-profiles`, this should be a simple profile system that is based upon our supabase instance.

Okay, we were able to resolve the username uniqueness problem and that should be enough of an issue.
We did also make an adjustment to the select for the table, making sure that no one can pick out of it.

Ah wait there was a mistake on the sql query, we still want the user that is logged in to be able to select.
That was just us going a bit too extrememe on the security, oh well.

**Pizza**

The amount of pizza that I been recently eatting is just way too high, I just double checked my orders for the past three months and we had pizza like almost 10 times!
A huge waste of money for some extremely useless calories, ugh.
I also know that when I am home alone for a month, I will be eatting even more pizza, so I should double check my diet on those bad boy pies.

**KillTony**

Tonight is going to be another great tony episode, we got our old boi peters on stage.
I remember when his parents died and his comedy kinda flatline after his parents passed away.
Amazing episode! Yes and the ending, has to be Aris best joke so far, its definitely going to go viral lmao.

---
# October: 22nd

> October 22nd.

Source: https://kbve.com/journal/10-22/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Supabase Login for AFK

-   03:05PM

    Spent way too much time trying to get supabase login system to work doing this gamejam!
    This means int he future we will still have this problem and the amount of solutions still seem really limited.
    I wonder if we can have it setup through the rust side but given the time limit we have, I do not think we will make it.

## 2024

**hCaptcha**

Yesterday we were able to get the captcah to work on mobile but not web, then we got it to work on web but not on mobile.
The growing pains were felt at each inch of my nerves, yet this is part of the learning experience.
I spent some time refactoring and looking into why it was an issue, I am not too sure why the solution works but it does.
I am a bit scared that this solution will fall apart in the near future because these captchas are becoming more and more painful.

**VanillaJS**

On the flipside, I am thinking of building an extremely simple javascript file, one that is just straight vanillaJS that would help integrate some of the basics of the supabase.
The idea here would be to help some newer users get used to Supabase and help them understand the core ideas behind it.

**Sheet**

There were some issues with the sheet but I am going to tackle them right now.
I believe that there are two ways we can solve the sheet problem, the first would be to adjust the way that we call it.
The sheet should have a model, at least that is what the example docs are using and that would make sense.

The other would be to update the tamagui to version v1.116, which looks like it includes fixes to their sheet.
Both make sense and it would be wise that we just do both of them anyhow.

Okay! What a wild trip of fixing all the links and modifications.
We had to drop some of the versions of react native packages, at least so that they would match the tamagui version that we are using.
With that being said, we were able to get the mobile and the web application running without any issue, but damn the sheet is still not working.

**Rust**

For the next rust application, we will try and deploy it through flyio too.
Its going to be a basic key&value database but one that we can call from any endpoint, as long as they have an api key.
This would be like a pastebin type setup but for almost anyone to use , hmm, I might even integrate it with some of the AWS services or maybe add some abstraction layers to it.
Anyhow, I am going to keep this here as a quick note so that I can reference it back later on.

**RSPS**

The journey continues in the adventures of the good old rsps scene, but this time around, I am looking at finally running the dream within its own wrapped docker image.
This would be something that we can deploy through our kubernetes and make it very easy to control through supabase, basically allowing us to launch our PaaS down the line by swapping out the docker image that we would want to run.
There are a couple of moving pieces that we still need to note down but that will come with time.

---
# October: 23rd

> October 23rd.

Source: https://kbve.com/journal/10-23/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### HexMap for AFK

-   01:15AM

    The type of map that our afk game will have is a general hex map or tile set.
    I found a great collection for us to use, the problem will be if we have the time to get it all out before the gamejam ends.
    This is a tough mission and the time that I have is getting smaller and smaller. 

## 2024

**Optimization**

There seems to be an issue with the optimization build that appears on a couple different browsers.
It is even worse because I still do not understand the whole query system for the design but besides that point, there are a couple concepts that also do not really make sense.
There is a part of me that wants to believe that I understand the react render but then there is a whole another part of me that is a bit confused.
We know that react is a virtual dom, yadadada, I have read and seen enough to understand those parts but when trying to build a unified codebase, the errors start to make less cents.

**Ensure Safe State**

Maybe we need to wrap back around the core of the component and make sure that we are using a safe state management?
It would not hurt for us to make sure that we keep track of the state, definitely when rendering and moving around a single page application, hmm.
For this we can take a based approach of using a reference for the component itself and then.
We could update both the `TamaLogin.tsx` and the `TamaRegister.tsx` so that they have callbacks that we can control when utilizing these components.
So the next update will be passing through the callback function and adding more references with mount / state control within the code.
This should provide us with some stability and help with future components, I suppose we could also factor into a `Food.tsx` component that handles all of this for us? 
That means we call -> Food.tsx =>> passing through the generic-T child components and handling the state , but that might just be too much nesting.  

**Tesla** 

What a wild earnings call!
I was expecting the stock to actually drop to sub $180s, but this was a surprise turn of events?
Could investors see the energy business side of Tesla booming with in the next couple years?

**HellBoy**

Well we were playing deadlock a bit earlier in the day and the Abrams character gives me the hellboy vibes.
We decided to step back in time, almost two decades and rewatch the first hellboy movie!
The whole movie was a blast.

Well movie night did not end there, we decided to watch the witch afterwards, which was decent.
I give hellboy a 5 out of 10 and the witch was a 6 out of 10.

The witch had amazing scenes but they did end it a bit too early, there should have been more world building. 
As for hellboy, damn I am so upset because the dark horse comics are filled with so much material, kinda lackluster that they dropped the ball on the story.

**Sheets**

Migrated over the sheets.
I am test casing the new sheets on the login page for expo-lcagents but while I am testing that, I am also reading further into the sheet mounts.
There is a part of me that is thinking that the react 301 bug might be something completely different but I am really hoping that it will be just from this mount issue.
It could have been from the way we were importing the Scroll view, instead of calling it from tamagui, we were calling it directly from react native. 
Hmm, regardless, we have 23 more components to build out and convert to BBQ templates.

---
# October: 24th

> October 24th.

Source: https://kbve.com/journal/10-24/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Rust Combat States - AFK

-   11:00PM

    The night was spent just going through the state management, I believe we will just use a dashmap for this!
    Part of the flaw in our logic is that under the web builds, we will have a tough time managing a fake thread and furthermore moving logic.
    I realized that I should have kept the logic to a rust signal system instead, oh well, next time I will know better.

## 2024

**RSPS**

We should split out the RSPS from the Atlas docker setup and keep them both isolated.
It would make more sense to manage them as different entities.
While building out the expo updates, I started to work on a rsps docker image that still needs to be pushed out and built.
The idea was to remove the chrome and python code from atlas and swap out the client with another jar, making it more focused on running the java virtual machine.
For mouse movement and general automation, we might just use rust and maybe emulate the mouse and keyboard driver.

**Mount**

The minifed error looks like this:

```
Error: Minified React error #301; 
visit https://reactjs.org/docs/error-decoder.html?invariant=301 
for the full message or use the non-minified dev environment for full errors and additional helpful warnings.
```

The actual error is this:

```
 Uncaught Error: 
 Attempted to navigate before mounting the Root Layout component. 
 Ensure the Root Layout component is rendering a Slot, or other navigator on the first render.
```

So we will wrap back around to the router and maybe setup a loading screen type component, hmm, like a universal skeleton?
This means we can wrap backaround and replace the `useRouter` from the expo-router with our custom router, `useBBQ`.
Next we can customize the BBQ router, at least in the future, to have a skeleton / loading screen to help make the transitions from one scene to another very smooth.

Damn it seems that the issue still has not been resolved, maybe we could go back to the board and start removing the redirects that we have on all the applications.
Manually moving from one scene to another would be the only way we can move forward at this point because I still do not understand why we having issues with the redirect.

Ugh okay, I am just going to remove the redirecting because its too much of a pain and we will just present the user with some buttons that will give them the option to go to where they want to go.

**BBQ**

Updated the BBQ component with the base skeleton and added a couple other mount checks.
Replacing the router any with the specific expo router should help with some of the type errors that we were getting.
This should work but I am still on the fenece.

**MediaHook**

I am still having some weird issues with the media query but I will have to reference back to the notes and get a better understanding of them.
There are a couple more things that I want to focus on but we can get there through test casing.

**Captcha**

Maybe the reason we are having that minified bug and react 301 error from the way we are handling the state of the captcha.
The plan is to track back and see if there are any issues with how we are handling the state management within this component.

---
# October: 25th

> October 25th.

Source: https://kbve.com/journal/10-25/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Macbook Quad Code

-   03:15PM

    I am really taking advantage of this 128gb setup.
    I can finally have multiple vscodes running without everything breaking up on me!
    This is just amazing, this is the true power of the future.

-   03:22PM

    For spawns, each time a new npc or monster is added into the scene we should have a portal that appears.
    This portal should be pooled, so we can grab them quickly.

## 2024

-   01:13AM
    - Fudster told me to add the timestamps back, so I will try to do a mixture of it.

    **TimeStamps**

    I should find a couple different ways for me to make my journals a bit more expressive and creative.
    The idea of the timestamps would be better, hmm, that way I can easily figure out the amount of damn hours, err days, I spent trying to resolve this react bug.
    I really can see why people would have issues with react.

-   01:26AM
    - Where is Chippy's buddy that sells the pool spas? Yo, is he gonna install one in his future house, then make it so that he can swim and play csgo.

-   05:12AM
    **Button** 

    We did it!
    I believe I have solved the too many renders problem, bug, headache, ugh.
    Another 20 hours wasted but a decent amount of experience gained.
    ```
    b u t t o n... bUttON, y U no ON, buuuutttoon....
    ```

-   05:21AM
    **RSPS**
    
    Time to take a quick break from the react world and see if we can get this RSPS operational again.


-   06:07AM
    **UserCards**

    Started to add user cards into the application, we will test case it inside of the lc agents demo app.
    The idea would be that each user would get their own linktree style setup, granted they will need to make sure that their email is confirmed.
    Considering that inactive accounts will get deleted, I believe we will not have to worry about it being abused any time soon.
    Funny thing is that we could use it as a way to promote free SEO and grow from that standpoint down the line.
    Or rather at least in the future, but we should focus on the plan at hand, which is making sure that the component works and can be updated.


-   03:01PM

    **DockerFile**
    Yesterday night we were looking at the dockerfile for atlas and it might be time to make the adjustments on launching it.
    There are a couple areas that still need improvements but I am confident that we will have something that will be production ready before the end of the year.
    Taking a look at the dockerfile for the `kilobase`

    ```json
    "container": {
			"executor": "@nx-tools/nx-container:build",
			"defaultConfiguration": "local",
			"options": {
				"engine": "docker",
				"context": "apps/atlas",
				"file": "apps/atlas/Dockerfile",
				"metadata": {
					"images": ["kbve/atlas"],
					"load": true,
					"tags": ["1.42", "1.42.0"]
				},
				"configurations": {
					"local": {
						"tags": ["1.42", "1.42.0"],
						"push": false
					},
					"production": {
						"tags": ["1.42", "1.42.0"],
						"push": true,
						"customBuildOptions": "--push",
						"cache-from": [
							"type=registry,ref=kbve/atlas:buildcache"
						],
						"cache-to": [
							"type=registry,ref=kbve/atlas:buildcache,mode=max"
						]
					}
				}
			}
		}
    ```

    We can hot swap some of the commands and integrate them into our atlas repo.
    Changed up the variables and we should now have a simple build command for our atlas image.
    
-   04:20PM

    **Microbot**
    Almost ready to launch the RSPS, just need to make some more changes to the structure of the script.
    We want it to launch right when the container is ready to run, yet there are a couple things that we want to adjust before we do that.
    In my quest to get that going, I realized that I hate doing docker builds on my ARM and that means we are back to doing anything else.
    Sleep does feel like it would be a good idea.

-   07:15PM

    **Atlas**

    The updated version of atlas is almost ready to be deployed to the kubernetes cluster!
    Hmm, there are a couple adjustments that I will have to make but a spinable bot farm is not too far out of the realm, but this is just for learning purposes.
    It should be noted that majority of this is just a small concept because eventually the whole java client side of Runescape will die off, thus there is no major reason to be worried about it.
    I am looking at this as a small challenge or meme to celebrate the death of osrs java.

-   09:04PM

    **Python**
    Okay time to setup the python hub and getting the core integration ready for the core of handling the communication.
    Let us start with the isolation of the python updates, including the new packages that we will need to add into the script.
    We will switch back around to java integration but getting the hub operational is a top priority before we can integrate it into our java cycle.

-   11:40PM

    **Signal**

    Messing around with the signalr but it seems that we could just drop all of that and just stick with the base websockets.
    I am going to create a new branch for the next day and focus on just using the base websockets to communicate and execute.

---
# October: 26th

> October 26th.

Source: https://kbve.com/journal/10-26/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Playful GameJam

-   05:35PM

    Spent the whole day trying to get the UI resolved for the playful gamejam.


## 2024

-   02:33AM

    Time to remove the signalr code and just run with regular websockets for now.

    ```shell 
    pnpm nx run atlas:remove --name signalrcore
    ```

    Now lets rebuild the docker image and make sure everything is back to normal.
    That will be through using:

    ```shell
    pnpm nx container atlas
    docker run -p 3000:3000 -p 3001:3001 -p 8086:8086 kbve/atlas:1.42
    ```

    Okay! Let us add the handshake and see where we go from there.

-   04:24AM

    **Kube**

    Getting ready to deploy a proof of concept of `Atlas` onto the kubectl.
    We already made a version of it earlier with docker swarm, so switching over to kubes should be easy.

    ```shell
    kubectl config use-context default
    ```
    
    For swapping context between orbstack and the remote kubectl.

-   06:14AM

    **WebSockets**

    The sun rises as I am fixing up these websockets! Ugh!
    It seems that there is a crash when we go to close out the websockets, I am trying to adjust for it.
    ```json
        {
            "channel": "default",
            "content": {
                "command": "execute",
                "packageName": "net.runelite.client.plugins.microbot.util.security",
                "className": "Login",
                "method": "Login",
                "args": ["myUsername", "myPassword", 301],
                "priority": 1
            }
        }
    ```

-   06:18PM

    **Java**

    More updates to the buying gf meme plugin, I am thinking that it might make more sense to do a hybrid version.
    Hmm, that or we need to figure out a better way to define the channels when handling the sockets, both are things that we should consider.
    I should make an issue ticket regarding that as well but there is still some time before we move down that path.

    **LCA**

    More updates are on their way for the lc agents, we need to update the issue tickets around them, maybe get a step by step break down of each component.
    There is still some work that needs to be done for the filler content, but I am thinking a timeline that is specific for the markets and agency work?
    This goes into the whole looking for work type of beat, maybe a scrapper for freelance gigs and bounties could work.

---
# October: 27th

> October 27th.

Source: https://kbve.com/journal/10-27/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Playful Ai Virtual Jam

-   2:03AM

    This jam was a bit sad but I am going to continue to work on the game.
    We ran into a bunch of issues with the UI, I even tried to change the shader control, but honestly, the rust ffi is so much better.

### CityVote

-   09:15PM

    Time to just fully commit to finishing the gamejam, having it under a completely new name.
    Well not new, but it might be time to bring the CityVote game to full force.

## 2024

-   04:40AM

    **Docker**

    I am still having some issues with the python and java websocket communication.
    If dynamically loading the packages does not work, then I think it would make sense to do the hybrid build path.
    The command that would be `dynamic` will then try to load the function dynamically but we could have `execute` , `reset`, ect... as commands that can run without having to load the function.
    This way we can move forward with the production of the scripts.

-   06:28PM

    **Highlander**

    Nothing like closing the month out with the best series, `Highalnder`, which is like unlocking a core memory!
    One of the best tv shows I think I have seen in my life, I just love the lore and backstory.

-   07:17PM

    **Atlas**

    Another day to focus on the atlas deployment, lets go ahead and spin it up.
    To create the container, we will run:

    ```shell
    pnpm xn container atlas
    ```
    
    Then to throw it up, we will do:
    
    ```shell
    docker run -p 3000:3000 -p 3001:3001 -p 8086:8086 kbve/atlas:1.42
    ```

    I should place them into the readme.

-   09:36PM

    **Hellboy**

    Yay! The next movie after Scooby-Doo, 2002, we are watching the next hellboy movie and its perfect.
    If you think about it, they would be a great cross over movie.

    Ah to keep the notes up to date and follow the base format, I need to create a new entry each midnight.

---
# October: 28th

> October 28th.

Source: https://kbve.com/journal/10-28/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### CityVote Map

-   07:21PM

    Added a basic release page for the cityvote game, now I am going to start making some changes.
    Okay the first will be to finish that front page.

## 2024

-   12:49AM

    **Logger**

    The first change we can make is creating a new logger for the `KBVEScript`, which we will call for the logging but allow it to send the message out to the FASTApi.
    This is just a minor tweak that we will need to do.

-   03:29AM

    **Example**

    Okay we are able to set the world!
    This is great, making some progress in the terms of websockets, yessir!

    ```json

    {
            "channel": "default",
            "content": {
                "command": "execute",
                "packageName": "net.runelite.client.plugins.microbot.util.security",
                "className": "Login",
                "method": "setWorld",
                "args": [308],
                "priority": 1
            }
    }

    {
            "channel": "default",
            "content": {
                "command": "execute",
                "packageName": "net.runelite.client.plugins.microbot.util.security",
                "className": "Login",
                "method": "Login",
                "args": ["myUsername", "myPassword", 301],
                "priority": 1
            }
    }


    {
            "channel": "default",
            "content": {
                "command": "execute",
                "packageName": "net.runelite.client.plugins.microbot.kbve",
                "className": "KBVEScripts",
                "method": "AcceptEULA",
                "args": [300, 301],
                "priority": 1
            }
    }

    {
            "channel": "default",
            "content": {
                "command": "execute",
                "packageName": "net.runelite.client.plugins.microbot.kbve",
                "className": "KBVEScripts",
                "method": "AcceptEULA",
                "args": [755, 490],
                "priority": 1
            }
    }

    ```

-   03:58AM

    **DoS**

    Almost knocked my whole docker image offline by creating a wild dos websocket attack, where it kept looping back and fourth xD.
    Yeah we will have to figure out the multiple channels or multi socket setup.
    There should be a better way to handle the errors, hmm.
    For safety reasons, lets go ahead and add a quick button to start and stop the runelite client.

-   08:16AM

    **Coords**

    Okay based upon the screen size of the window being launched, we need to adjust the client so that it launches not in full screen.

    ```json
    
    {"command": "execute", "packageName": "net.runelite.client.plugins.microbot.kbve", "className": "KBVEScripts", "method": "AcceptEULA", "args": [755, 490], "priority": 1}
    
    ```

-   06:52PM

    **Dockerfile**

    Updating the dockerfile so that the new applications open in a normal window mode.
    We can accomplish this using the `NO_FULL` env and that should help with the scaling issue.
    After fixing that error, I am moving towards trying to figure out how to best handle profiles aka login.

---
# October: 29th

> October 29th.

Source: https://kbve.com/journal/10-29/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Godot Rust Integration

-   05:15PM

    Finishing up some of the core integration with the Godot!
    My entries have been a bit delayed because I been hyper focused on the FFI between Godot and Rust threads.

## 2024

-   12:13AM

    **KillTony**

    An amazing kill tony episode, it was a solid 6 out of 10.
    I was expecting their vegas set to be a bit more wild but the bucket pulls were really whack.
    Williams did a great job summarizing the whole set, it seems a bit bland and.

    **Login**

    Next, we want to make sure that login works for any account but I believe we will need to create a new method to handle that for us.
    In this situation, since its a new account, we would have to pass in the profile creation before we can do the `SafeLogin`.

-   04:57AM

    **Driver**

    The python script is throwing some errors but I believe it is because I am testing it on arm and not x86.
    So I will address them again tomorrow when I switch over to windows.
    We could setup the deployment of a dev atlas but that will be something that we can look into after we get the base of the `KBVEScript` running and operational.

-   09:40AM

    **Markets**

    The stock market is looking pretty good for the current situation and I am thinking that we can do a couple more plays before the end of the year.
    I am going to sell some call options against all my tech stocks, ideally only a week or three weeks out, then  with all that captial, I am going to buy some more REITs.
    If everything goes as planned, we are looking at around a net of $8000, which will be about another $70 a month for the rest of my life.
    That is on the lower end of estimates but hey, its a good play.

-   12:30PM

    **Apple**

    New apple products? Okay!
    The mac mini does look great but I am going to skip out on them and see if the older mac minis will drop in price because of this new one?
    I can sense a dope hack n tosh coming into my project bin sometime within the next three years.

-   04:41PM

    **Car**

    I am driving around and doing that roam and foam, a nice chai latte.
    Writing code while sitting on the bench was great for about the first half hour but damn its getting cold.
    I should plan on getting back home.

-   11:58PM

    **Night**

    My quick entry before the night!
    I go sidetracked by an amazing movie, American Psycho, but now I have to perform my own version of it within the binary realm.

---
# October: 30th

> October 30th.

Source: https://kbve.com/journal/10-30/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Nvidia ByeByte

-   04:00PM

    If Nvidia stays above $200 then a good chunk of my call options will execute, so I will need to prepare the taxes for that.
    

## 2024

-   01:50AM

    **Profiles**

    The realm of trying to figure out profiles has begun again, ugh, so much time wasted.
    I am just not understanding how the profiles are being created and stored, hmm.

-   06:44PM

    **Login**
    
    This is actually a two part concept, we want to make sure that we can setup supabase and log into that instance.
    Then after the supabase connection is established, pull the relatable runescape account information and then login from there using that information?
    There are still a couple moving parts that we would need to address before we can really get this going but we will start small.

    The command to add a package will be:

    ```shell

    pnpm nx run atlas:add --name supabase

    ```
    
    Now we need to figure out how to setup the atlas but within the scope of a user.
    Yet going to move on from today, I was not able to create as many notes that I would have liked.

---
# October: 31st

> October 31st.

Source: https://kbve.com/journal/10-31/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Halloween

-   09:45PM

    Did a bit of hanging out with a local crew, it was just a bit off putting because they are all married now.
    Damn, it is even crazier because they have kids as well, which is a change of pace too.

## 2024

-   01:35AM

    **Python**

    Starting the adventures of using supabase python, but its really been a troubling ride.
    I am under the impression that it would be rough but did not realize that I am digging really deep into the void.
    The login system for python can get a bit complex because we have a chunk of different moving parts to account for.

-   06:00AM

    **Expo**

    Decided to take a bit of a break from the java + python world and switch back over to the react native realm.
    I am starting to get a bit back into the drift of just running multiple codespaces again, but will try not to over do it this round.
    We will stick to around 3 max screens for now.

    On a side note, we are now officially done with the [tamagui](https://github.com/KBVE/kbve/issues/786) integration, so we can close that year old ticket out.

-   06:19PM

    **Components**

    Going to build a couple more updates tamagui components, after the minicard and then the next will be an improved slider / carousel tamagui component.
    I will place this inside of its own folder, then make adjustments from there.
    That might be a mistake, I think it will be another name that might not be `slider` but rather hmm.
    We can go with `Gallery` as the base folder and component holder for it all.

-   06:42PM

    **Migration**

    Moving the `plugin` / java code out of Atlas and into the Fudster package.
    The premise will be to decouple the the osrs / rsps from atlas and split the production of the two.
    This is just to make things easier when it comes to optimization and execution.

-   10:00PM

    **Fudster**
    
    For the dockefile, we will focus on the first stage, aka Alpha.
    To keeps things simple, I am going to split the stages up using letters and then give each step a number.
    Moving forward the codename for this project will just be fudster, which is fitting because it will be his anime click of e girls.
    For the stage alpha, the focus will be on building the jar 

-   10:37PM

    **Longlegs**

    To continue the holloween movie adventures, we are watching a new movie from this year, called `Longlegs`.
    Oh snap it includes nick cage, this is going to be a wild run for sure.
    They movie was okay, I would say it was also just above mid but I might have been spoiled with the whole true detective season 1.
    When the bar is set so high, the rest of the ratings get hit with a downgrade.

<Adsense />

---
# November: 01st

> November 01st.

Source: https://kbve.com/journal/11-01/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

-   03:40PM

    Spent the whole night trying to fix the pthread issues between rust and godot.


## 2024

-   03:24AM

    **Fudster**

    Moving over the java files and preparing the dockerfile for building.
    Lets create a quick list of the python libraries that we will need?

    - fastapi
    - uvicorn
    - broadcaster
    - websockets (maybe we might not need it?)
    - anyio
    - aiohttp

    We will run this command to add fastapi:

    ```shell

    pnpm nx run fudster:add --name "fastapi[standard]"

    ```

    This will grab us a bunch of files that we can use for deploying the api in python.
    Cleaned up some of the additional files and we got a solid build, yessir!

-   06:01PM

    **Websockets**

    I am currently restructuring the way we would handle the webscokets, because we need to still make it a bit more flexible yet not over do it.
    Let us start with the base level of the socket management and then we can start to expand upon it.

-   07:33PM

    **Orb**

    To speed up the docker build process, I added a quick orb command.

    ```shell
    ./kbve.sh -nx fudster:orb
    ```
    
    This command will build the fudster container and then use the docker run command to turn it online.
    The goal would be to make testing slight changes easier, I might even go a step further and setup live rebuilds and reloads.

---
# November: 2nd

> November 2nd.

Source: https://kbve.com/journal/11-02/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Session - ECS

-   10:48PM

    Going to take a quick break from the Godot and focus on the unity side of things, we were able to resolve some of the bridge issues.
    Now we can focus on getting the ECS cleaned up and easier to manage. 

-   11:58PM

    Clearing up a bunch of unity entitiy jobs that are blocking the main thread, which is a bit of a pain to track down but we are getting there!
    Each one will help improve the fps by around 2-5, but they will add up quickly because as we clear them up, we can focus on tracking more and more.

## 2024

-   03:14AM

    **Supabase**

    The best way that I can think of integrating supabase might be by making sure that the initial vnc port gets blocked during the docker deployment.
    Only thing that should be open would be the general websocket, hmm.

    **HTML**

    Maybe a solution to the HTML overlay problem is that we need to `window.HSOverlay.autoInit()` the overlay as well?
    I think it might be best to just throw it all away and move onto another issue.
    There has to be a better way to get simple modals with tailwindcss, didnt they create a html5 standard for the modals?

-   09:30AM

    **Maven**

    Finished going down the pipeline of hell and back for mvn builds.
    A part of me is glad that compiling java has gotten so much better than the previous decade, yet there is another part of me that is a bit sadden with the package times.
    Anyhow, we are just under 60 seconds for the jar build, so there is progress on that end.
    Yet if we can get the mvnd to be added into the build process, I believe we can cut the compile time down to sub 30 seconds.

-   08:55PM

    **007**

    Starting November off with one of the best double o seven movies!
    It has been such a long time since I have seen any of the classic or new updated series or movies.
    I did not know that octo took place in India, that is kinda low key cool.

---
# November: 3rd

> November 3rd.

Source: https://kbve.com/journal/11-03/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity ECS NSprites

-	10:53AM

	Decided to fork the NSprites package and make some core changes, mainly in how the render system works.
	I am thinking later on, I could even optimize it to fit further into my specific needs.

## 2024

-   07:24PM

    **Astro**

    There is this temp astro patch that I want to try, which should solve our astro build problem.
    Hmm, okay I tried to the hacky patch to try and resolve the bug but sadly there was no luck.
    Kinda sad tht our whole pipeline has to be held off because of a nx extension breaking, which kinda of does not make logistical sense.
    Spent the whole day trying to get it to work but stil lost in the sauce.
    The only other solution I have would be to just remove the whole astro extension and migrate down to the typescript level of operations.

    Okay the only option that I see is just to drop the nx extension for astro and use a custom typescript builder.
    We will have to remake the commands in the astro nx extension.

    ```json

    "targets": {
		"build": {
			"executor": "@nxtensions/astro:build",
			"options": {}
		},
		"dev": {
			"executor": "@nxtensions/astro:dev",
			"options": {}
		},
		"preview": {
			"executor": "@nxtensions/astro:preview",
			"options": {}
		},
		"check": {
			"executor": "@nxtensions/astro:check"
		},
		"sync": {
			"executor": "@nxtensions/astro:sync"
		}
	}

    ```

    Furthermore I am thinking we can migrate the existing astro websites to expo, besides our kbve main repo.
    RareIcon, Herbmail, ect.. should be all

---
# November: 4th

> November 4th.

Source: https://kbve.com/journal/11-04/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Deadlock got my mind going crazy.

-	01:25PM

	Solved my first major bug with the godot and rust bridge!
	This was a deadlock that was a pain to find because the error was not in the output!
	It turns out that my buffers were just way too small and that we needed to update them to work with the amount of data that was being processed.
	Next I need to figure out the best way to handle websockets.

-	1:41PM

	Ergo supports websockets by default, so that means I could just update the kubernetes to use them.
	There are two sides to this, one will be getting the internal nginx to work within the current ergo eco-system.
	Finally the other side might be to make our own reverse proxy for the IRC.

## 2024

-   04:15PM

    **Supabase**

	There are two points to the supabase, the first one we will be tackling the onboarding function.
	The goal would be to move the process of registering into an isolated scope within the onboarding.
	This way we can make a function that only logged in users can call and it would check if the username is unique but also allows us to rate control the call.
	In the previous way that we were handling it, the username query could have been abused and instead of working around fixing that, it would make more sense to disable guests or anons from using the function.
	By moving more of the future logic into an authenticated role, we can build a better system for controlling the permissions and rate controls.
	So if the user is making too many queries, we can issue a warning and/or a ban.
	Furthermore, we will extend out the kilobase image to include a fail2ban at the container level.

	Hmm, okay so we would tackle the username issue first, then switch over to updating the user card next.
	I create a new sql file called 20241104120000_remove_username_for_auth.sql and that will be what we run to adjust our username function.
	We want this to be only for a situation of giving the username out during the onboarding process, hopefully not updating an exisiting username.

	Ah, to be safe, I will also include this:

	```sql

	-- Check if _user_id is NULL (i.e., the caller is not authenticated)
    IF _user_id IS NULL THEN
        RAISE EXCEPTION 'not_authenticated';
    END IF;

	```

	Even if the `auth.id()` is not providing a valid UUID, I want to make sure the function gracefully fails if the `_user_id` is null.

-	05:39PM

	**HouseOfMemes**

	This season of house of memes is about to be over and I am just waiting for the crazy plot twists to occur!
	Will it be a poll attack? 
	Another massive riot breaking out in NYC?
	There are so many questions and I would be on full alert if I was near any voting booth.

-	06:24PM

	**UserCards**

	Moving forward with the next Supabase adjustment, we have to make minor changes to how we handle the usercards.
	The first being the situation where they get their initial card, hmmmm, I believe it will be during the onboarding phase and we can place null spots into the table.
	However, like the bio, we might have to split the fields of the usercard into a couple different subsections?
	I am still trying my best to figure out the way to handle the json verification for this, which I am going to assume will be just a series of guess and checks until it works.

	```sql

	BEGIN;
	--  Drop older trigger and function
	DROP TRIGGER IF EXISTS on_auth_new_card_created ON auth.users;
	DROP FUNCTION IF EXISTS public.handle_user_card_update();
	COMMIT;

	```

	These two functions will remove the trigger on the `auth.users` and drop the function to `handle_user_card_update()`.
	Similar to how we were handling the `user_profiles` earlier.

-	11:56PM

	**DB**

	The database will be split amoung three core areas that we will focus on, the tables under public, the triggers and finally the functions.
	These will be the point of focus of this week, after we establish a baseline of operating the functions within expo too.
	We know that registering and login work fine, but there was some issues with upodating the bio that need to be resolved.
	The problem we made with that function was that it was not too specific and that needs to be addressed during the user card process.

---
# November: 5th

> November 5th.

Source: https://kbve.com/journal/11-05/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Burn Shader Effect

-	11:30AM

	After a card is used in a combo, we should make sure that there is a cool effect that happens.
	I am thinking that we have the card burn via a direction, maybe at random.
	Then we make sure that the different shader effects are removed as we place back into the pool.

## 2024

-	09:45AM

	**Docs**

	Decided to make a quick repo for the microbot community.
	It was a great refresh for operating inside my own repo without having to deal with a monorepo?
	Without that extra layer, it does make things so much easier to build and quickly deploy.


-	11:40AM

	**Election**

	The day of the year is finally here and I can not wait until the day is over.
	There is going to be a nice release of all that political gunk stuck in everyones mind, its post election nut clarity.

-	01:07PM

	**Supabase**

	Table structure is currently:
		-	`user_cards`
		- 	`user_cards_public`
		-	`user_profiles`

		With the `user_cards_public` being a materialized view, so we will not have to worry too much about it.

	Trigger structure, there are two areas that we need to process for the triggers, the `auth` schema and the `public` schema.
	Under the `auth` schema, we only have the `on_auth_new_card_created` trigger active but that will be disabled in this next query.
	The bigger concern will be under the public schema, where we have 4 more triggers!
		-	`handle_user_card_update` - under table `user_cards` with function `handle_user_card_update`
		-	`handle_user_cards_update` - under table `user_cards` with function `moddatetime`
		-	`handle_user_profile_update` - under table `user_profiles` with function `handle_profile_update`
		-	`handle_user_profiles_update` - under table `user_profiles` with function `moddatetime`

	Finally we have the database functions, which are split into into the two schemas again, `auth` and `public`.
	Under the `public`, we have:
		-	`before_insert_hcaptcha_verfication` with 0 arguements, a return type of trigger and security of invoker.
		-	`create_user_profile` - with `_username` as text, a return type of void and a security definer.

---
# November: 6th

> November 6th.

Source: https://kbve.com/journal/11-06/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### CityVote Docker Image

-	05:45PM

	While working out the bugs within the combat loop, I am going to also look into handling the docker image for the game.
	The website should be built the same way that we did the other ones, using astro and axum would make the most sense.
	`astro-cityvote` and then have it build into `cityvote-deployment` or something of that nature, and finally setup the kube deployment.

## 2024

-	03:38AM

	**PostTrump**

	Looks like the elections are over and we can all finally move on.
	It was way too long of a process and I am so glad this poopfest is officially over.
	Too many people, too many opinions, just a massive rat nest with emotional baggage in each nanometer.

	**Astro**

	To test case the astro migration, I think it would make sense to start with an example repo?
	Let us try to use the rareicon as an example repo that we can build around.
	Eventually we want to either swap it out with a tamagui interface or maybe keep the astro for the landing page.
	Then release an app.rareicon.com for the expo build, but regardless, we will need to migrate and replace the nx extension.
	To get started, we will have to replace the `tsconfig.json` and manually handle some of the linking.
	We can replace this: `"extends": "../../tsconfig.base.json",` with a direct reference to astro's ts base.
	Okay this fix seems to work for `rareicon.com`
	We could also update the `.gitignore` to not add in the `src` folder that gets created.

-	09:51PM

	**BrighterShores**

	Working on a quick proof of concept for a python automation script, hmm, there might be some adjustments that I will have to do but it should work fine.
	The way that I am thinking about it would be to keep it simple, a small auto combat bot and maybe a small cooking bot?
	Both of these would be an easy task to automate and it would be a fun challenge.
	Now that would mean setting up the python auto gui for the `fudster` library, hmm, I wonder if there might be a way around it without using python directly?
	It might just be too much for this test casing, I will stick with the base python library.
	We would have to automate the steam login, hmm, I am thinking we can skip that part too and just have it focus on the general gameplay.
	Now to install and run steam will be interesting, damn, that would mean adding the `steam` package into the container as well.

	Okay when going into the 2nd episode of the brightershores, there is a bit of a skill adjustment, with combating being reset? 
	I am thinking there might be a reason for having the split combat but the fact that the items are also split by the episode makes this way too annoying.
	After spending a solid day playing through the game and giving it a fair shot, I am going to say that it might be best to let the game go.
	I will come back around when the game leaves beta and makes a bit more adjustments, it is definitely not worth the $6 a month either.

-	11:08PM

	**League**

	Time for a quick league match, while I am playing brighter shores on the side.
	The new aram map looks amazing, they did a great job with it!

---
# November: 7th

> November 7th.

Source: https://kbve.com/journal/11-07/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Mana for CityVote

-   03:22PM

    Made a huge mistake, I forgot to include mana inside of the combat stats, so I will have to go through all of the game loop and include it.
    Every character should have mana, those that are melee can have a default special ability to turn mana into health?
    Wait that might be broken, let me think it through, regardless we need to add mana across the board for each of the characters.
    For the regeneration system, maybe we have them either create a campfire or have them visit a local city to help?

-   03:27PM

    For the two structure types, I am thinking that they will be City and Ruins, with the City being a form of top down RPG.
    While the ruins will be a platformer, this gives us a bit of both worlds, making the gameplay loop a bit more interesting while the turns are happening.
    The best way to have this occur would be by setting up the loop , wait, actually the best way to handle this would be to first get unit selection out of the way.
    So ruins == platformer and cities == top down rpg!
    Okay but before we get to that, we will have to make sure there are visual containers for both, and a couple other things like city borders.
    Additional structures we can add can be lumber camps and farms, with the lumber camp, wait hmm.
    Farm will provide +25 food per turn, but use -15 labor.
    Lumber camp would provide +25 labor, but use -15 food.

## 2024

-   12:52AM

    **Astro**

    We got the `rareicon.com` to build and run under the dev without any major issues.
    However there are some issues with the threejs when trying to run the kbve under the custom astro command.
    Finally, we got the base of the astro to build and now we can bring back the main pipeline!
    We had almost three full weeks of down time but we did get a good list of packages to clean up.
    I will make new issue tickets for the packages that we might have to remove.

-   04:22AM

    **TSLA**

    Oh no! Almost the $300 mark!?
    We got two more days before those options expire, I am just hoping it does not cross the $300 mark and praying that we get a bit of room to extend out those calls.

-   05:07AM

    **Herbmail**

    We can keep it astro based but the template should be fixed up and replaced again.
    Yet before we do that , we need to adjust the astro build process for it as well.
    The changes will be the same as the other astro config changes we made earlier, so it should be quick.

-   05:47PM

    **Nx**

    Updating the nx instance to version `v20.0.11` and now looping back around and making sure that everything else works.
    There were some issues with the out-dated plugins but we can address them later this week.

-	06:06PM

	**ShadCN**

	Time to get the herbmail frontpage converted over to a shadcn based template.
	I wonder if we could do it all through chatgpt?
	Wild that in almost 2025 and the astro icons is still broken and not working out of the box?
	I am somewhat surprised that I might have to create and publish a working astro package for icons.

---
# November: 8th

> November 8th.

Source: https://kbve.com/journal/11-08/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### StarYO Kube

-   10:05AM

    Preparing the kube deployment of staryo.

### Unity Session

-   10:00PM

    The whole session went great, we were able to resolve some of the FPS issues and now only some minor core jobs are left for us to resolve.
    I should not say that they are minor job fixes but basically we are making our own cache layer ontop of the ECS that unity provides.

## 2024

-   12:10PM

    **TSLA**

    The run up past $300 is a huge problem for me!
    I am going to have to find a way to postpone the sell off of my 5 contracts, going to roll it into next week at 305 strike.
    Hopefully the post trump era stock cools off next week but this is a dangerous rally, it can easily skip to $400 without me even looking.

-   10:08PM

    **CryptoThrone**

    More updates to the crypto throne, including changing the tileset.
    We might have to go with a new way of handling the tilesets, I think if we switch out of the static and go with a dynamic?
    The map chunking is still broken and I am not too sure if I will be able to fix.
    Maybe instead of having the chunking done during the loading state, I might have to pre-chunk them ahead of time.
    Looking through the different examples, it seems that people use build tools to make a custom json chunkset of the map, which makes sense because javascript is not too powerful.

---
# November: 9th

> November 9th.

Source: https://kbve.com/journal/11-09/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity Sunday Funday

-   10:19AM

    Revisiting the custom cache that we are running ontop of the current unity ECS.
    Our biggest bottleneck seems to be CPU, so once we can get the cache system operational, we should easily see around 200 stable FPS.

## 2024

-   7:30PM

    **Unity**

    Just finished a great 3 hour session in Unity!
    I got a better understanding of the tilemaps, upgraded unity to LTS 6 and made my first sprite animation.
    By next week, I want to create at least 3 or 5 new characters for the game.
    Now I have to spend most of the day working on the different tilemaps.

---
# November: 10th

> November 10th.

Source: https://kbve.com/journal/11-10/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   07:13AM

    **Nx Update**

    Updated the monorepo to nx v20.0.12.
    Also moved up the build process to see where the main branch fails, hopefully we can address that problem tonight.

    **Main**

    The branch seems to build without any major issues, but it did skip a couple libraries from being built.
    What we could do is try to maybe start changing the triggers to be all via readme updates?
    Hmm, I will have to think through it again, let me get some coffee and revisit this concept again within the next hour.

    **Package**

    I am going to go through the package again and see if there are any libraries that we need to update or remove.
    We are no longer supporting `appwrite`, so lets go ahead and remove that one.
    I believe we can also drop the `preact` libraries as well.
    `"@astrojs/preact": "^3.5.3"` and `preact` both could be removed.

-   07:30AM

    **Vue**

    We can take out the `vue` package as well, following the same command from the `preact` earlier.
    ```shell
    pnpm remove @astrojs/vue vue
    ```

    However I will run those later when I get back to the monorepo.
    After we run that, we will need to make sure to clean up the cache.
    
    ```shell
    pnpm nx reset
    ```

-   08:53AM

    **Unity**

    I grabbed the ERW tilesets from Matos and threw them into the `Rareicon` asset folder.
    With the generic collection of tilesets, we should have enough to build a couple generic maps.
    Now the bigger question would be to figure out how to get the hang of the animation.

    **Supabase**

    While making changes to the Unity configuration, I can spend some time thinking through the changes that I want to do with the `user_cards`.
    One of the goals for the user cards after this base update will be to pull the stats from the character sheet and render them.
    We want the goal of the card to contain all the public information that a random guest or user would require.
    So lets take abit of a step back and review the psql for it.

    We will keep parts of the table, like the `CONSTRAINT` for the function, example:

    ```sql

    CONSTRAINT bio_length CHECK (char_length(bio) <= 255), -- Limit bio length to 255 characters
    CONSTRAINT bio_format CHECK (bio ~ '^[a-zA-Z0-9.!? ]*$'), -- Allow alphanumeric characters, spaces, and basic punctuation

    ```

    Okay, yet the `JSONB` needs to be adjusted within the function because it does not let specific nulls through, like if the user has a github but not a twitter.
    
    Wait I am a tart, I can just drop these functions and use the row level security to handle the updating and managing of the table.
    Thus the PSQL will make this so much easier to manage in the future, yay!
    Okay so we will just run these and move forward with the current project.
    
    ```sql

    BEGIN;

    --  Drop older trigger and function
    DROP TRIGGER IF EXISTS on_auth_new_card_created ON auth.users;
    DROP FUNCTION IF EXISTS public.handle_user_card_update();
    DROP FUNCTION IF EXISTS public.handle_new_user_card();
    DROP TRIGGER IF EXISTS handle_user_card_update ON public.user_cards;

    COMMIT;

    ```

    Then we can update the command to just handle these directly for us.
    Oh I made another silly mistake, I have to drop the triggers first then the functions!
    Let me go ahead and fix that up really quick.

-   11:30AM

    **Expo**

    Okay after migrating both the user profile and the user card out of the sign up process, we can begin building out the onboarding process.
    This process will have to be done on both the `@kbve/laser` project and also in the `@kbve/expo-bbq`, since we need to include this for both astro and expo.
    In both situations, I will open four instances of VS Code and tackle them all at the same time!
    This is the peak of development, my brain is going to be broken as I do this xD
    Under the current expo, it will be `packages/expo-bbq/src/components/auth/user/TamaOnboard.tsx` and then inside of that we can build out the component!
    This would be the barebone component, aka, `TamaOnboard`, and it would have two states that it would manage.
    The first state would be for the `username` and making sure that it is unique before setting it up, however it would be noted that it is the user's public username.
    The second state would be for the profile card, the core specific here would be preparing the basic information for the init card.
    Hmm, okay these two states should be enough for us to move forward, I believe we can always go back around and double check the onboarding when it goes live into production.

    I am thinking that for error management, we should push the error up in the component, so that the parent component that calls the Tamaonboard can process the error?
    This would be easier for us to handle, without having to create multiple error handlers inside of the sub-components, okay let me do that next.

    To keep with the standard, the TamaOnBoard will pass up an `OnError` and `OnSuccess` void, both of which can then be managed by the parent component.
    This means we can remove the redirect that is hard coded into the component, yet it does mean we can not specifically highlight where the error is exactly in the form?

    Next, we need to create the actual `onboard.tsx` that we will be using in the expo-lcagents?!
    Since this page will be similar to our login / profile, we can strip them down and grab the components that will be useful for the onboarding.
    The goal will be to keep it simple enough to push towards production, then we can loop back around and work on resolving the specific bugs.
    I do know that the username being taken would be a bug or if the username format is off, both of which we can resolve through the onboarding component. 
    Besides those two additions, I am not too sure what else the onboarding would need?
    I guess we could have them double check the legal docs as well before moving forward, but that is up to the client as well.
    Having the legal documents be a combination is a cool future-like concept but there would be a decent amount of work that has to go into setting that up.

    Then there is the actual content that the website would have, maybe since we are already data mining different job sites, we could link that data back into the website.
    That could be a great way to drive up natural traffic to the site too.

    Updating the `public.create_user_profile` function to return the new username after it gets created.
    Okay let me push this through as the most recent update!

    **FredAgain**

    While working on the expo component, I am jamming to that radio session with Fred and Jim!
    The whole work is flames, just nearly a perfect set for this expo work.
    Here is the link to the [set](https://www.youtube.com/watch?v=DE_yVb3JMD8), which should be thrown into that future music application.

---
# November: 11th

> November 11th.

Source: https://kbve.com/journal/11-11/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   02:18AM

    **Screen**

    Forgot to add the screen for the `onboard` section.
    Let me go ahead and push that up.

-   09:45AM

    **TSLA**

    The stock is sky rocketing in value and these calls are going to take away 500 shares, which is going to be rough for me.
    Those taxes are going to be brutal.

-   06:37PM

    **Realtime**
    
    The real time supabase is the next challenge that I been working through, however there are some issues with the RLS.
    The issue that we will first reference is the 7630 discussion on the Supabase but I believe we did not setup the RLS perfectly for the realtime, thus we can start from that area tonight.

    Full error below:

    ```

    Failed to connect to the channel test: This may be due to restrictive RLS policies. Check your role and try again.

    ```

-   09:14PM

    **Kill Tony**

    Another wonderful session of kill tony, I am actually pretty excited for it!
    Ari getting his seat on the panel, oh yessir.

    While watching the killing of our great tony, I am going to finish up some more of the SQL changes for onboarding.


<Adsense />

---
# November: 12th

> November 12th.

Source: https://kbve.com/journal/11-12/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   05:15AM

    **Early**

    Nothing feels so great like a great new day!
    Today is going to be a big day, I am going to go ham with the publishing and see if I can resolve a bunch of abstract bugs.
    Ugh, I went to check if I had react hook form and the resolves installed and I completely forgot that I did!
    We really need to make sure our package json is cleaned up and ready for these future updates.

    Let me start by making more issue tickets with things that I need to resolve.
    The joys of waking up early and running the greatest command.

    ```shell

    ./kbve.sh -nx expo-lcagents:start
    
    ```

-   06:28PM

    **EXPO**

    The next plan is to adjust the error situation because it seems that the error is not passing up.
    Which means that we have two additional options, one being using an event system and the other using a worklet, hmm, maybe a combo of both?
    Lets go ahead and tackle this right now before I forgot.

    There are six areas that we need to test out, the first is improving the memo utilization and memory usage.
    React should be able to handle the memory management, but we should look at maybe adding our own ways to make this easier, hmm.
    The second part was the `React.lazy` and having it help us offset some of the loading of the more complex animations and components, I suppose that can be used with our offscreen objects.
    The third part would be the `React Context API` but that might be too much of an issue for us to utilize right now, but it does make sense to have it pass some objects.
    The fourth part will be having the useTransitions to help smooth out the hicups and then there are the other additional libraries, ugh!
    I need to becareful not to bloat up the application as well, maybe we can keep these noted and tackle the optimization later on.
    
    So the goal would be to build these components out:

    -   `useIdleCallback`
    -   `useCache`
    -   `useMemory`
    -   `useLazyMemory`
    -   `useOffScreen`
    -   `useVirtual`

    All of them can then be placed into the `core` of our expo package, making it so that we can use them in the future to help us handle some of the future issues that will require optimization.
    

<Adsense />

---
# November: 13th

> November 13th.

Source: https://kbve.com/journal/11-13/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   06:15AM

    **Hooks**

    We are going to migrate in the different hooks to help streamline the app development.
    Here is the list again of the new hooks that we want to add:

    -   `useIdleCallback`
    -   `useCache`
    -   `useMemory`
    -   `useLazyMemory`
    -   `useOffScreen`
    -   `useVirtual`

    These hooks can then be used in the [Register/Onboard page](https://github.com/KBVE/kbve/issues/2212).

    All of these hooks have to be built in a way that will ensure that they can work in both mobile and web, so there might be a bit of a nested ifs to handle the different platforms.
    This feels like we are moving closer to our own useless million concept, but its okay, that is part of the learning process.

    Okay let me first tackle the `useCache` and the `useIdleCallback` for the `expo-bbq`.
    We will create both files under the `/packages/expo-bbq/src/core`

-   04:00PM

    **SpaceEngineer**

    Playing a bunch of Space Engineer with the boys, while trying to get a better understanding of custom hooks within the React/ReactNative realm.
    My goal will be to eventually get to `useWASM()` hook, that would automatically wrap a wasm with the right parameters to be used for both web and mobile.
    However there will be a long time until I get to a working demo of the hook.

-   11:50PM

    **TrueDetective**

    The first season of true detective, oh man is it so good!
    I forgot how amazing this season was, it is a master piece of art.

---
# November: 14th

> November 14th.

Source: https://kbve.com/journal/11-14/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   09:00AM

    **useMemory**

    The `useMemory` hook is almost done, but we still need to fix the offscreen integration and maybe even utilize the `useIdleCallback`.
    Let me get this all pushed out and I will enter the testing realm again tonight.

    After making the hook, we can test it out with a profile component?
    The idea would be to create two files for us to use, the general profile container and then a wrapper around that said container for the rendering and caching.
    The first file would be the Profile itself and the second would be a contaijner that would hold the profile and add the useMemory hook around it?

    I am wondering what would be the best way to handle this without causing too many renders but also making it super fast to load and unload profiles.
    I am also thinking that after we get the useMemory hook to work, we can add another hook that would help us create a pool of the objects that we could render offscreen and then transition them in.
    In theory we would be creating one of those infinite scrolling situations but having it render as they scroll through the application.
    The goal would also be to make sure that it does not pull any additional data, by having it cache the results and then use the cache to help build the profiles.

---
# November: 15th

> November 15th.

Source: https://kbve.com/journal/11-15/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   07:00AM

    **Morning**

    Its so cold, finally the weather is straight hoodie season.
    I been waiting to rock my shawl collection for a while, this is the perfect weather to do it.

-   09:28AM

    **TSLA**

    Oh Fridays! They are always the best, ending the week and seeing where everything sits within the market.
    I am thinking we might be able to survive this week without any major problems, other than a pipeline.

-   09:45AM

    **Azure**

    Time to build out the Azure pipeline and in this situation, we want to focus on getting the unity to build the rareicon game and push the code out.
    Now trying to get this resolved, we first need to fix the azure pipeline and make sure that we can pull from the repo.
    The best move would be test it within the alpha pull request, so lets go ahead and try that out!
    If everything goes as planned, we should be able to build the unity game each time there are changes to the `kilonet` readme.

    To verify the files are from the azure repo, we will just run this command:

    ```shell

    cd azure-rareicon
    echo "Current working directory: $(pwd)"
    echo "Listing all files in the repository:"
    find . -type f
    echo "Listing all contents (including hidden files):"
    ls -la

    ```

    Okay! We ran into another issue, our current build is `6000.0.26f1` and the gameci only has up to `6000.0.25f1` supported.
    We will downgrade the game by one version and once the gameci releases the `6000.0.26f1`, we will upgrade back to the LTS.

    Minor tweaks to the action to fix some path errors, this is always the boring and painful guess and check process! Ugh!

    We got the build process started, now I am going to configure the linking with the unity.
    Yet there seems to be that lack of space issue again, so maybe we need to fix that right now.
    Both builds, the standard windows and the webgl are running out of space, but I believe that might be because some parts of our original repo are way too large and are not needed.
    Thus, we could just remove the checkout of our repo, then come back around in the future and remove the extra unity files that are in our repo.

-   05:50PM

    **Home**

    Just got back home from a wild adventure!
    I love doing a quick exit from parties, but the person hosting the party knows about my Irish exit and gave me a tray to dip with.
    I got to take my classic one pic & dip, now I can focus on the start screen for the game.

---
# November: 16th

> November 16th.

Source: https://kbve.com/journal/11-16/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   02:43PM

    **Unity**

    Making some moves inside of Unity!
    
-   05:41PM

    **Stone Golem**

    While making some changes to the unity game, I am going to quickly trigger a build.
    Turned the stone golem into an ally and I am thinking it is time to replace the hippo with our main character.
    Also, we could add a bunch of different ally characters and make this a bit more of an interesting bullet hell rpg style game, hmmm.

---
# November: 17th

> November 17th.

Source: https://kbve.com/journal/11-17/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   07:45AM

    **Tickets**

    We need to make new adjustments to our issue tickets, I believe placing them under an `unity` tag would make sense.
    This is just a quick shower thought that I had but I will try to add a bit of a better system tonight regarding that.

-   12:17PM

    **TileMap**

    Besides building out the unity game via github actions, I want to see if I can make a script that will streamline the tilemap creation.
    Ideally we would want the tilemap script to make a `world` map, one where you are moving from section A to section B, and as you move through this path, lets say East to West?
    The map would automatically generate the tiles and things that would be in your way through your quest, including mobs, traps, npcs and more?
    This might feel like its going to be a huge part of the gameplay loop, because it will generate additional side content for the player to try out.

-   01:00PM

    **JSON**

    Looks like the json package was missing from the build process, I am not too sure why it got removed or if I forgot to install it in the first place?
    Anyhow, going to add that into the build setup and see if we can move forward with the build process.
    I can already tell there might be a bunch of other issues during the linking process of unity and the final build, but having the bug reports directly there in the logs does make things easier.
    For the ally management, I am thinking we add a couple additional characters for our bullet hell type game, the first was Gala, she will be our space pirate type character.
    We should pull references from cowboy bebop and one piece, maybe a bit of that iron fleet too into her story line.

-   01:58PM

    **WebView**

    Okay it seems that during the WebGL build, it is pulling in the Vuplex configuration, which we do not want.
    i.e
    ```c#

    #if UNITY_WEBGL && !UNITY_EDITOR
        WebGLWebView.FocusUnity();
    #endif
    ```

    So we need to go back around in our code and make those adjustments.
    Actually, instead of wasting my time trying to figre it out, I will just embrace it and pickup the iframe version.
    Might as well set aside a couple hundred dollars for the iOS and Android later tonight too, we will just have to commit.

-   04:20PM

    **WebGL**

    Looks like the WebGL build was done without any major issues, so lets go ahead and link the build to Itch!
    We can have it pull the webgl after its finished from the job and use that finished file for our beloved itch.
    Yay! The game builds and we got a live version on the itch, now lets see if the pipeline will update the builds.
    Going to make a new push right now and see where it goes from there.

---
# November: 18th

> November 18th.

Source: https://kbve.com/journal/11-18/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   01:51AM

    **WebGL**

    Adjusted the WebGL build, going to push up another commit as well.
    We do need to adjust the supabase login, making sure that it works for both Standalone and WebGL.
    Performing that test right now at 5pm, the notes are below.

-   12:50PM

    **Vuplex**

    The `Vuplex` provider provides a way to utilize the webview but we want to focus on making it work through our package.
    However it seems that it crashes on the macbook, so I am going to try to make it work on the windows desktop.
    I am thinking that it might be a missing assembly reference, but I am starting to get annoyed with trying to debug this problem, never felt so much pain!
    However, part of learning a bunch of different languages would have some downsides because they all have their little tricks.

    The login screen has some issues with the pixel density that need to be resolved.
    Resolution is current 1 px per Unity , ugh you know what, I will make the adjustments from the other end.
    Okay, next step will be to grab the username or give them the option to adjust their username.

-   05:05PM

    **WebGL**

    I am going to test the webgl build and how it goes about handling the vuplex changes!
    Hoping, Coping, Copium! errr... that it automatically does its magic without us having to do any major changes.
    We want the login screen to be the same for the Standalone64 build and the Webgl build, if both are working without then we can move forward.

-   06:19PM

    **Penguin**

    Since the first season of the show is complete, I am thinking that it be time to grab the whole thing and setup a stream session for it?
    I am going to try and aim that session right after kill tony, I think it be a great follow up to the show.
    Actually considering that kill tony ends at around 11pm, we might just skip that part and work around the time slots.

-   07:09PM

    **Realtime**

    The best way to handle realtime will be in two parts, we will have the axum that is directly hosting the files listening for smaller sessions and the supabase realtime functions for important information.
    By splitting up the connections, we can manage the temporary sessions through rust, easily removing the pointers and threads while keeping the supabase realtime open for more serious operations!
    Now the question is how to go about building the `rust_rareicon_multiplayer` for this instance?!
    Maybe we do not think too hard about it and just jump right in, possible that we could also make it so that the screen just jumps to a discord session?
    When we wake the title screen, we could set itg up so that it goes directly to the discord wasm scene, hmm, that means we would have to build a full docker image with the axum and the static wasm files?

---
# November: 19th

> November 19th.

Source: https://kbve.com/journal/11-19/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   06:07PM

    **Kilonet**

    Time to start building out the netcode for the unity code.
    `NetworkObjectManager`, `NetworkObject` and `SyncTransform`.
    Well we would also need another library that would generate the ULIDs?
    Okay, lets start with that and then build around it all later on.

    To kepe things simple enough, we will call this the `ULIDHelper` and then call that into the Unity game.
    This helper will be focused on async ulid generation, hopefully not from the main thread either.

-   11:05PM

    **ULIDHelper**

    Okay going to push the first helper out and then see if the unity project accepts it without giving me errors.
    If everything goes as planned, then I will loop back around and see if I can add more files to help with the networking.

---
# November: 20th

> November 20th.

Source: https://kbve.com/journal/11-20/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   01:37AM

    **Meetings**

    Two major meetings coming up on Friday and Saturday, so I need to push the code out quickly.
    Grind is on!

-   12:40PM

    **Contract**

    Finished up some of the contract work that was getting in the way!
    Now I should have some free time to breeze through the networking issues and build something fast.
    The goals will be two parts for today, the first is to get the base mutliplayer working with moving game objects!
    Once this is accomplished, we will go ahead and add an auth system integration and make sure that each game room works without any issue.

-   12:48PM

    **Transport**

    We will be adding the `com.unity.transport` to our build, hopefully this route will be easier but I think I will have to still include a manual jslib.
    I am not too worried about this but I can see it becoming a problem really quickly.
    After that, I am going to switch over to the `kilonet` package and start the process of adding in networking.
    We will be using the `KBVE.Kilonet.Networks` namespace to hold all our networking.
    Inside of the namespace, the first file we will create is this:

    ```c#

    namespace KBVE.Kilonet.Networks
    {
        public interface INetworkTransport
        {
            void Connect(string serverUri);
            void Send(byte[] data);
            void Send(Stream dataStream);
            void Receive(Action<byte[]> onReceive);
            void Receive(Action<Stream> onReceiveStream);
            void Disconnect();
        }
    }
    ```
    
    This will give us a quick roadmap for what we want this package to do for the networking.
    Forgot to include the `System.IO`, going to push that up right now.
    AFter adding in the `INetworkTransport`, we can add the next item to the setup, the `WebSocketTransport.cs`.
    This will be our transport layer for the base networking, oh boi.

    The two main transports again the `WebSocketTransport` and `UDPTransport`, both will take some time to build out.
    When looking at our assembly references, we need to make sure that `Unity.Collections` are included as well as, uh the `Unity.Networking.Transport`!
    Here we go with another round 8 hit xD.

-   01:57PM

    **Conditional**

    For the networking, I am going to split the `WebGL` and `Native` at the manager level.
    We should not have any major issues with the data because we can skip the JSON and stick with a protobuf and binary.
    
-   03:12PM

    **Plan**

    Here is the proposed `Networks` structure that we can try and implement:
    
    -   Managers
        -   NetworkManager
    -   Networks
        -   INetworkTransport
        -   WebSocketTransport
        -   UDPTransport
    
    Yet for the `Protocols` and `Utils`, I am thinking we can move that out of the Networks folder and into the right areas?
    I suppose we can keep the Protocols under the Networks folder strucutre but the Utils should definitely be in their own namespace.

    Under the protocols, we will need:

    -   IMessageProtocol
    -   JsonProtocol
    -   ProtobufProtocol

    As for the Utils, we will need:

    -   ByteUtils - handling all the byte arrays, bitwise operations, bTree algos.
    -   MessageQueue - isolated instance for the queue management, chat, ect...

    This seems like the best way to approach this for now.

-   03:47PM

    **ByteUtils**

    To help with the byte management, since we are trying to move away from the strings, we will need a utility class that will make it easier to manage.
    Eventually we can futher split the base `ByteUtils`, definitely if we need to include unsafe code, but this should be a solid base to work around.
    After updating this library, we will go back around and make some adjustments to the UDP/WS transports, ideally making it so that we can knock out all these errors.
    There are about 20 errors that are still left to resolve with the transport layer, then we can look into the SyncTransform and the different objects, hmm, the protobuf will still be an issue doe.
    If we can get through these bugs within the next couple hours, then it be safe to start the rust code?
    The rust server will be very basic, handling the UDP and WS connections and will be deployed through our kubernetes cluster.
    After it gets deployed through the helm chart, we can start the discord activity build, with our url mapper pointed to the self hosted server.
    By tomorrow, if we get a discord multiplayer build running, it should make the development process even easier because we can just play test it in the call while building it out.

-   07:13PM

    **Events**

    Okay it looks like the UDP and WS Transport layers are okay, seem to be compiling without throwing any errors within the unity editor.
    For now, we can move forward with a couple more files that we will add?
    They will be these:

    -   NetworkEvent
    -   NetworkManager

---
# November: 21st

> November 21st.

Source: https://kbve.com/journal/11-21/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   12:23AM

    **Penguin**

    While working on the networking, it would make sense to throw a show on in the background, since the whole first season is over, we got to watch it.
    Currently on the 2nd episode and its been amazing so far!
    Wait episode 3 already? We are knocking these episodes out without any issues.

-   12:49AM

    **Protocol**

    I been debating on where to place the protocols, I am thinking that it would make sense to have under the networking.
    I want to avoid having too many abstracted namespace because we then have to keep track of all that, ugh.
    Okay so the protocol files will be the IMessageProtocol and that interface will be extended out with the JsonProtocol and the ProtobufProtocol.
    The goal would be have 

-   01:38PM

    **Protobuf**

    We will be adding the `protobuf` library into the asmdef for the kilonet.
    Hopefully that will not crash the package again, going to push it out into the dev branch and see what happens.
    Okay, so far the additions that we have are great but there is a bunch of stuff that is still missing before our meeting tomorrow, hmm.
    Maybe we are moving too fast but the pressure is good for this dev cycle, but the speed is still a bit too slow for my liking.
    There might be a bit of an issue with how we would go about organizing the whole package, at least in the future.

-   11:37PM

    **Penguin**

    Episode 8, the final episode, damn the whole series has been great!
    I been enjoying each episode, each scene, the references and all, its nearly perfect.
    Next up will have to be arcane once its done.

---
# November: 22nd

> November 22nd.

Source: https://kbve.com/journal/11-22/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   03:26AM

    **Rust**

    With the Friday deadline coming up, it would be best to quickly rush the discord build.
    Okay spent the whole night going through the different stages but we are getting somewhere with the game server docker container.


-   02:40PM

    **MMExtensions**

    The next step would be to add the MM Extensions as an unity project.
    Let me get this part rolling while I am working on the game server.
    The package will be the `mmextensions` and we will call them via `KBVE.MMExtensions`, as a reference to the more mountains extensions.

-   08:29PM

    **Unity Session**

    The session went great, we got a better understanding of using MM extensions, tried to do a tri-live-code session too.
    I believe that a couple more instances and we should have a faster flow of updates.
    Good work JigSaw and Silver, yall are great teachers.

---
# November: 23rd

> November 23rd.

Source: https://kbve.com/journal/11-23/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   03:13PM

    **Rareicon**

    The plan is to develop a semi-complex build for our discord deployment of the WebGL build.
    The best approach would be to isolate each aspect and go deeper than a micro service style, we are going cell.
    With that being said, maybe we should watch DBZ too, just to help get the blood flowing.
    In the action, we can create an isolated one that would upload the finished webgl game to the new repo under the docs folder.

-   08:40PM

    **Unity**

    The session went great and I gotten more experienced with the pool system.
    I am going to try and finish up this webgl build tonight, hopefully we can get the remaining docker build up by tomorrow night too.

-   11:00PM

    **Clockwork**

    I remember watching bits of this movie a long time ago and just never understood it.
    Rewatching it now, its actually really based and interesting, especially for the time period that it was made.
    The creativity has aged so well too.

---
# November: 24th

> November 24th.

Source: https://kbve.com/journal/11-24/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   12:41AM

    **BlueSky**

    What is this social media hype about?
    I am thinking that is a decentralized social media site but what is it really about?


-   02:50PM

    **Scenes**

    Looks like when I updated the TopDownEngine, it replaced the scene order, so we will have to go back around and update it.
    I believe that in the next round, we should start looking into removing some of the older assets that are getting imported.

-   03:05PM

    **VContainer**

    Trying to get a better understanding of how we would build that global map and there are a couple things that I will need to understand.
    In order to make the multiplayer easier, we will need to find a way to let the rust code that the live server sends back actually execute certain functions within the unity client.
    The idea here would be to allow the unity runtime to run some of the game logic based upon what the live server says, this way we can sync the data across a session?
    That means the rust server would be handling a decent amount of the actual game and the unity client / runtime would be designed to just handle the rendering and client-side logic?
    Damn this would change the way that we handle this game, hmm, there would be a decent amount of thinking that we would have to do.
    
-   03:19PM

    **Addressables**

    Okay the best way we can work on this project but without having to keep going back to the editor might be by placing all the prefabs as addressable objects?
    Then inside of the code, we can just call them dynamically and use them for the different parts of the scene?
    This would further move unity into a `shell` position and we can basically write our own logic around the shell?
    Explaining this would be tough, so maybe the best way to approach this would be by creating our own version around it.

-   11:50PM

    **LifetimeScope**

    The last part of learning will be focused upon the lifetime scopes.
    I am starting to get a better picture of how all of this would connect and I believe that I can make it work a bit better.
    Granted that making the optimizations before finishing up the game is always risky, but I think it will actually make it easier to maintain the whole game.

---
# November: 25th

> November 25th.

Source: https://kbve.com/journal/11-25/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   12:29AM

    **VContainers**

    Going to continue learning more about the containers and maybe get the first batch finished.
    If we can get the exisiting MM components to load under the VContainer, then it will make extending and gameplay so much easier.

-   12:32PM

    **Helm**

    Time to work out the helm chart!
    We want this helm chart deployment to be easy but also useful, I believe the websockets will be a breeze but the UDP might be an issue.
    Thanks to Fudster, we were able to move past my insecurities and resolve the issue.
    He is a great leader and knows how to get things done.

-   04:30PM

    **Unity**

    Updating the unity game and fixing the missing scenes from the game, almost as if ... uhh... I forgot to include the actual game.
    I think there might be a couple ways to improve the performance by lowering the light map and texture.

---
# November: 26th

> November 26th.

Source: https://kbve.com/journal/11-26/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   01:00PM

    **TSLA**

    We will have to roll the options out to next week and grab the $1000, just to make sure that it works.

-   02:05PM

    **Unity**

    Sound manager vcontianer needs to be fixed, which we need to do before tomorrows meeting.
    I am thinking that we would try to wrap everything inside of a vcontainer, making it easier for us to access the resources.
    For us to setup the sound manager, we would have to link the scriptable object through addresses, which means we need to define them as well.
    Inside of the `mmextensions`, we can add an assembly reference to Unity.

-   11:00PM

    **Arcane**

    Finally got to start the series and its been a wild ride, err, rather a blast, so far.
    I am going to be a bit sad when it ends because it has been a great series, but I am here for it all.
    The new ARAM map also slaps, I love what they did with it and it finally makes zeri, bard and talon both a bit more fun to play.

<Adsense />

---
# November: 27th

> November 27th.

Source: https://kbve.com/journal/11-27/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   02:20AM

    **Unity**

    We got ourselves another unity build to test out.
    While I am doing that, I should look to commission a steam game and bundle?
    Actually, if the artist that we hire does a good job, we could also have the same artist do our steam page assets?
    That would save us a bunch of time too.

-   02:37AM

    **SoundManager**

    Looks like the prefab works even though we are not using the addressable object.
    I am not too sure how I feel about that but for now it will be fine.

-   03:09PM

    **Addressable**

    Looks like the most recent push created the files that we need for addressable-based vcontainers, allowing us to finally call the prefabs during the runtime.
    This will be an interesting way for us to build out the game, I am thinking that the town itself will be the main scene and when entering a mission or camp, we do an additive loading?
    Furthermore we would have to fix the URL maps and also the HTML template a bit more.

-   03:36PM

    **Unity Template**

    The unity template needs to be adjusted so that it does not look like karp on the discord activities page.
    This is an easy fix but I been too distracted to address it!
    Anyhow, I am going to focus on getting that done today, with the postmessage and sendmessage between the player and iframe as well.
    Starting off with the canvas issue:

    ```

    <canvas id="unity-canvas" width={{{ WIDTH }}} height={{{ HEIGHT }}} tabindex="-1"></canvas>

    ```

    We will replace that line and move the styling over to the css part.

    Then add our own custom spinner that should just operate with css / javascript.

    ```html
    
    <div class="spinner"></div>
    
    ```

    I suppose we could do this twice, having another spinner for when the iframe is ready to be displayed?
    Lets say we render the whole iframe and game off-canvas on the static html page that axum offers to Discord, then we can make the adjustments for our own loading screen?
    Once the off-cavans is done, we transition over to the main window , hmm, okay this just a future proof of concept that we can do once the game is closer to becoming ready for launch.

    The meta will be added as a commented out line:

    ```html
    
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">

    ```

    I am thinking that we can assign it dynamically because if the game is played on mobile, we can make sure that the right meta viewport is assigned.

-   08:40PM

    **Lifetime**

    The next part will be to switch back from the asset management and focus on the lifetime and entrypoints, oh boi.
    We still need to setup the level manager and multiplayer level manager, once both of those are setup, we move forward with the player and npc list of prefabs.

-   09:18PM

    **Build**

    While we are making some changes, we should move forward with having a build ready to queue up and run!
    Let me go ahead and move forward the issue, ideally we need to make a couple more changes to the `mmextension` package but there are some issues to resolve.
    
<Adsense />

---
# November: 28th

> November 28th.

Source: https://kbve.com/journal/11-28/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   01:40AM

    **GameServer**

    I am keeping track of the gameserver stats, which comes with some great surprises!
    Our current gameserver is a 4mb docker build with about 2.7mb ram usage!
    I think that has been my best build so far this year, really excited about it as well.
    Yet I think there are some issues with the helm chart and the UDP access, but I think I can figure it out.

-   03:05AM

    **Nightly**

    Still working through the code to help me get a better understanding, but there are so many weird issues that I run into.
    I am still a bit lost in the process of the websockets but I think that might be just a lack of experience?

-   03:10PM

    **CI**

    It looks like we are having some CI build problems and I am not too sure if its from the `SuperTiled` pack or not?
    Maybe what we can do is disable that package or change the image for which the ci-alpha is building from?
    Going to drop the `ubuntu-latest` to `ubuntu-20.04` and see if that can solve that problem.


-   09:57PM

    **Deployment**

    We might have to restructure the deployment, keeping track of what we need for the helm deployment.
    The fleet deployment information is as follows:

    Repo: `https://github.com/KBVE/kbve.git`
    Branch : `dev`
    Paths: `/migrations/kube/charts/rareicon`

    These are all that are needed before we move forward with the helm deployment.
    Let me go ahead and deploy this out now before my next match.


<Adsense />

---
# November: 29th

> November 29th.

Source: https://kbve.com/journal/11-29/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   09:30AM

    **Legal**

    I forgot to include my notes on the legal document situation, since we need them for the steam release and the discord activity release.
    Since both are important, let me look through the notes and figure out the best option for them.
    Inside of the `astro.config.mjs` we need to add the legal directory, which should be easy.
    After adding the configuration, we will migrate the `mdx` into the `docs` folder.


-   01:36PM

    **WebSockets**

    Now that we got the websockets working, we can start moving forward with the multiplayer and chat.
    The best way that we can approach this would be to start small and build around it.
    Furthermore, we could also add the discord bot into the workflow too but that might make our build just a bit larger?
    There are some interesting points that we can look into but for the most part, I think we will just rawdog and run into it all blind.

-   05:17PM

    **Auths**

    For the auth system, we would need to include a couple sealed secrets for the client id and client password, specifically the discord information.
    I am thinking that we could also build it around just a global secret that then pulls those secrets from the vault?
    Both ways could work but for now, since we do not have a vault system fully functional, we will just stick with a basic sealed secret.

<Adsense />

---
# November: 30th

> November 30th.

Source: https://kbve.com/journal/11-30/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   04:04AM

    **Secrets**

    To add our sealed secrets, we will have do a couple things ahead of time before we can do it.
    First we need to update our code to accept the env variable for the discord client and discord secret.
    Both of these will be used for discord sdk communication but we also need to create the sealed secrets too for the fleet.

    The rust code will look like this:

    ```rust
    static ENV_VARS: Lazy<HashMap<&'static str, String>> = Lazy::new(|| {
    let mut map = HashMap::new();
    map.insert(
        "DISCORD_CLIENT_ID",
        std::env::var("DISCORD_CLIENT_ID").expect("DISCORD_CLIENT_ID not set"),
    );
    map.insert(
        "DISCORD_CLIENT_SECRET",
        std::env::var("DISCORD_CLIENT_SECRET").expect("DISCORD_CLIENT_SECRET not set"),
    );
    map
    });
    ```

    The idea here would be to create a static map that holds these two variables because we only write once , but read many.
    This static block will just focus on the first write.

    ```shell
    ./kbve.sh -nx rust_rareicon_gameserver:orb
    ```

-   04:08AM

    **Seals**

    While working on that docker build test, we can run this to generate the seals.

    ```shell
    ./kbve.sh -nx kilobase:seal  --namespace="rareicon" --keyName="DISCORD_CLIENT_SECRET" --secrets="DISCORD_CLIENT_SECRET=pepethefroog"
    ```

-   03:55PM

    **Helm**

    Time to update the docker image for the helm chart and see if we can get the discord oauth / token / login out of the way.
    Inside of the `axum-gameserver.yaml` , we will manually update the rareicon game server image with this hash:
    `image: "kbve/rareicongs@sha256:32fecd31c9d84b002455fc6e10fbdf26d8d693521774b940e3d658d2eb281b5b"`

    I would do this via tag systems but the number of deployments would drive me crazy, or well further insane, or well to the edge of escapism.

-   04:19PM

    **AiBrain**

    We are going to start building out the whole ai brain again but something that we can use just directly through the C# code.
    This way we can work on the ai brain without having to mess around directly with unity.
    Furthermore, this allows us to use this ai code in future projects as well.

---
# Decemeber: 01st

> Decemeber 1st.

Source: https://kbve.com/journal/12-01/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   12:04AM

    **Dec**

    The last month of the year, that means I need to also make sure all the credit card payments are cleared.
    Yet I do also have to double check my car insurance, the year is slowly coming to and end!
    Steam release? When?

-   02:30AM

    **Discord**

    Might as well start working on the discord bot integration while doing the websockets.
    Yet for some reason the passage of the token is throwing some random errors.
    Okay the new token was added and some adjustments were made for the sealed secret too.
    Hmm, I wonder what would be the best way to communicate directly with the unity client from the javascript.

-   02:44PM

    **Core**

    The discord embed sdk should make sure that the user that is in the activity has a valid session.
    We will focus on the `NetworkManager`, making sure that it loads the right configurations.
    Furthermore, we should make sure that the `index.html` has no issues either, hmm.

-   03:52PM

    **NetworkManager**

    For the networking, we have to account for three possible connection points, two being different websockets and the other being the UDP.
    With that being said, having the cross-play will be easier once we get the different connections setup and doing this all in advance will save us time in the future.
    The whole networking will be packaged, so that when we build new games in the future, we will not have to go back and do it again.

    However with that being said, we do need to focus on how we would point the network around and that would include the ability of adding new networks without having issues.
    This does limit the package to being only used with kbve-related services but we can work around that by fixing up adding a couple abstraction methods?
    Like if it does not use the default, we could add the ability to add external networks, maybe a map to hold those and a quick setting that can be changed in the map.

-   04:15PM

    **JavascriptFFI**

    The FFI for JavaScript should be placed under the `Networks` and I believe we might need to move the `NetworkManagerHelper` to be under the `Networks` namespace?
    The first aspect makes sense because the javascript ffi would all be done within the reference of networking.
    Yet the helper might make sense to keep next to the network manager, as it would be rough to keep them too far away.
    For the javascript ffi, since most of it all will be in webgl, I am thinking we could just avoid the interlocked methods.
    And for the rust ffi, we will use the interlocked because those builds are for native, I am just keeping this here as a reference.


<Adsense />

---
# Decemeber: 02nd

> Decemeber 2nd.

Source: https://kbve.com/journal/12-02/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   01:52AM

    **JavaScript FFI**

    Even though we got the websockets wired, we still have a decent amount of work to do!
    There is a decent amount of javascript / discord sdk integration that we still have to finish.
    Ugh, part of me just does not feel like doing it but logically, I need to get it all done asap.
    Sunday was not a funday.
    Okay, so the first error we need to address is making sure that everything using the interop is placed inside of if statements.

-   02:50PM

    **Bounty**

    Taking a quick break from the unity sessions and working on the bounty system.
    I am going to map it out using no code first and then once its functional, I will try to make it in rust.
    The idea would be to automatically manage the bounties, including the verfication, payments, ect...
    The bounty system should create a new invoice and keep track of the sessions?
    Maybe a calendar style integration would make sense too.
    Under `.github/ISSUE_TEMPLATE/` we will create the `bounty.md` file.
    Copy over some of the information into that file next.
    Okay, we got the base of the bounty system out of the way!

-   04:54PM

    **Autopull**

    A new issue ticket to keep track of some chores that need to be done via the Github actions.
    I believe we need to lock down some of the repos and build a quick system that would handle the pull requests.
    We should make it so that the pull requests are also not only created but maybe work towards having the pull request accepted too.

-   06:50PM

    **UnityJS**

    The unity js library will help us bridge the unity webgl and the javascript from the browser.
    We want to make sure that the communication will work on Itch, but that will be in 2025.
    After creating the library using the nx library generation, we need to add a couple more references and deps.
    The discord embed sdk and the cross fetch both will be helpful here.

---
# Decemeber: 03rd

> Decemeber 3rd.

Source: https://kbve.com/journal/12-03/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   04:26AM

    **Commands**

    Need to stay focused and wrap up these discord commands!
    I will also have to finish up the unity send messages afterwards.
    We are moving along, getting there slowly!

-   12:48PM

    **Helm**

    While building out the unity js library, I am going to test out the fudster docker image and the deployment.
    During this test phase, we can also look into extending it out to atlas, with some research going into the sidecar and dynamic host deployments.
    I believe there are some other issues we need to look into, like locking down the individual instances.

-   03:53PM

    **Fudster**

    Okay time to use the gitops skills and deploy the fudster helm chart, probably see what the errors will be while doing so.
    The repo deployment will look like this:

    Repo: `https://github.com/KBVE/kbve.git`
    Branch : `dev`
    Paths: `/migrations/kube/charts/fudster`

    But before we do that, I have to double check the hash for the fudster image, which is `sha256:0ccf7e46e8871098c1e8ca3432933f2f5da92cac1f843d4f877eaef2aa58a1f2`.
    This is before we get the version control setup, I would like to make it so that the library and the docker image both have the same version.
    Then I will create an nx command called `bump` and run a quick shell script to edit:
    - Python wheel - pip version control.
    - ReadMe - The ReadMe to trigger a build.
    - Helm Chart - version that we need to deploy.
    - Project.json - Docker build tag management.

    Those will be the four main edits that we need for an actual version sync across the board.
    Finally once we are in sync, I will use the readme as a way to build the website/docs for the package.

    Commented out the code for the tag and just directly running `image: "kbve/fudster@sha256:0ccf7e46e8871098c1e8ca3432933f2f5da92cac1f843d4f877eaef2aa58a1f2"` and now we can see what happens next.
    Preparing the deployment, okay we were able to get the helm chart deployed but there was some issues with the runelite plugin that we created.
    I forgot to update the java code to the new websocket location and furthermore, the other sideeffect is that the plugin automatically starts, so we can not update the websocket uri directly.
    Okay! Now that we get the image built again, I will have to go back and update the sha256.

---
# Decemeber: 04th

> Decemeber 4th.

Source: https://kbve.com/journal/12-04/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   03:40PM

    **Fudster**

    Repo: `https://github.com/KBVE/kbve.git`
    Branch : `dev`
    Paths: `/migrations/kube/charts/fudster`

-   11:49PM

    **Unity**

    Another great unity session, I am starting to understand the way tilemaps work within unity!
    There are a couple minor things that we still need to adjust for, yet, the overall flow is turning out to be so much better.
    As for the recent updates, I am going to push them up and maybe we can aim to have a playable game that has no mm assets by this weekend?
    If everything goes as planned, we can hit a steam launch before the end of the year, which would feel amazing.

---
# Decemeber: 05th

> Decemeber 5th.

Source: https://kbve.com/journal/12-05/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   02:19PM

    **UnityJS**

    The focus for today will be to finish up the rest of the unity-js pre-alpha code changes and then prepare to release it.
    We could make this a hybrid setup and just push the compiled version directly into the template code, hmm.
    I saw that there is a whole build process injection method too, we can look into that as well.

    We were last working on the `message.ts`, so lets go ahead and switch back over to the `DiscordSDKManager` finishing up the message handler integration and the setup functions.
    Okay the first step that I see is making sure our instances are initialized, specifically the helper and the event manager, then we can integrate the message handler?
    The goal is still the same, we want all our singletons to be called through our instance of `DiscordSDKManager`!
    I did notice that in our notes, we would want to integrate supabase as well from the client side for the javascript functions, this way we can have the wasm build call supabase and have the javascript call it as well.
    There would be an issue where each user now has two instances of a supabase connection, so we could work on making sure that they are both in-sync?
    Hmm, this is just food for thought and we should table this part of the integration until after we get all the discord issues resolved.
    

    Adding the helper will be easy, because we already did it in the `message.ts`, so it will be something like this:
    ```ts

    import {Help} from './helper';
    private helper: typeof Help | null = null;
    this.helper = Help;

    public getHelper(): typeof Help | null {
    return this.helper;
    }

    ```

    After getting the helper added, we can rotate back around and reference the help in the message handler instance.
    Okay we got the base of the sdk setup and then we need to quickly bundle all of this up?
    I saw that vite 6 was out but right now, we will keep using vite 5 until the next nx update.
    To bundle all of this, we will quickly create a new vite configuration file and then a quick command for the nx system.
    Our end result will be:

    ```shell
    ./kbve.sh -nx unity-js:alpha
    ```

    This will take the unity-js code and run it through vite, thus giving us a single esm bundle.
    From this point,we need to figure out the best way to import this and at what level do we need to call it from?
    The obvious choice would be to integrate it all into the rust static build, since that is where we call the nested iframe from.

-   05:10PM

    **Alpha**

    We want the nx commands to move the build esm javascript files from the vite over to the rust static build folder.
    To accomplish this, we will have to make sure that we can easily access , uhh, actually we will just update the vite command to push the vite folders out into a subfolder under the unity-js called `vite` and then just move those files.
    The moving of the files will be done through the nx command, making it a bit easier to manage?
    One of the other options was to just build the whole javascript bundle each time before running the rust files but I feel like that would be too much of an overkill?
    The goal here would be to try and minimize the amount of double builds, hmm, for now we should just focus on getting a functional MVP.
    There can be future adjustments made on how we handle it.


-   05:50PM

    **DiscordAPI**

    We will need to quickly configure the api route for the discord oauth, hmm.
    The way that we can approach this is by skipping any advance wafs or ebpf stuff, keeping it simple for now would be the best option.
    Let me start the route, ship the build and then come back around to making some minor changes that reflect the changes.
    For the time being, I am going to decouple the game server build from the unity games and just keep it isolated because it should be decoupled moving forward.
    Since the game server will also have the ability to handle UDP connections, we can look at the networking for the windows build next week too.

    Updating the cargo toml to use the reqwest library but without the openssl, which will be used to connect and verify the discord token.
    Ugh, told myself that I would keep it simple but it would make sense to wrap the whole discord client call concept into a quick mini-pool, we will have it hold about 10 clients that should give us enough room to handle burst connections.
    Since the call is only for grabbing the access token, we can control that thread quickly by dropping and adding it back into the pool.
    We have enough vcpus to manage a small pool of about 10 clients, so that should be good enough for this part of the code.
    Instead of placing it all inside of the `main.rs`, I will make it a small file called `discord.rs` and then when I get time, I will move it into the jedi crate and we can just call it from there.
    So the first step would be to build out that mini-pool within the application, find the point of failures and once it is functional, we move it over into the jedi crate and call it from there.
    This would give us the flexibility to use it again in the future and speed up compiling time in the future.
    Okay, lets start with building the client out next.

    Oh, for building out the docker image, I think it would make sense to do it on the macbook too because it will be faster on the orbstack.
    Let me push this up and then split the vscode up to a macbook instance.

    The builds will be faster on the mac, so after preparing the orb builder, we can keep track of the shas that get generated and update the helm through the wsl pushes.
    Before making crazy changes, we want to make sure that docker build works without issues on the mac.
    We are using an arm chipset, so I forgot 

<Adsense />

---
# Decemeber: 06th

> Decemeber 6th.

Source: https://kbve.com/journal/12-06/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   07:50AM

    **Gameserver**

    We want to make sure that the gameserver deployments have a connection to our discord proxy.
    Yet it seems that there are no connections to our axum deployment, which means we need to fallback into the client code and see the issues that might be causing the js to not connect.
    The mistake that I realized was that we were calling the DiscordSDKManager but instead we need to call the Manager singleton.
    Pushing that up right now and seeing where it will go from that point.

-   10:05AM

    **Fudster**

    The deployment of `Fudster` is once more below:
    
    Repo: `https://github.com/KBVE/kbve.git`
    Branch : `dev`
    Paths: `/migrations/kube/charts/fudster`

    We will have to wrap around the kong / JWT auth system, which is another adventure that we need to get into.
    I am thinking that we could just have that sit in between the actual websocketify from kasm, ugh, this is always annoying to map out.
    The only solution at this point for the reverse proxy would be to just go back around and fix up the kasm client bundle.

-   09:09PM

    **FFI**

    Okay we are able to establish communication between our gameserver and the discord activities, but there will be still be some additional things that we need to resolve.
    Ugh, okay so we know that once the connection is established, we are sending back, okay this is starting to make more sense to me.
    The best way would be rather to build out a general json connector, it would focus on sending back and fourth the json data between the webgl and javascript.

---
# Decemeber: 07th

> Decemeber 7th.

Source: https://kbve.com/journal/12-07/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   03:49AM

    **Preparing** 

    Next isssue right now is that the core utils are not yet ready to be published.

---
# Decemeber: 08th

> Decemeber 8th.

Source: https://kbve.com/journal/12-08/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   05:54PM

    **Daily Notes**

    Fixing the jslib issues but I am still super sick, ugh.
    The felm and runny nose sucks, gahhhh, I am producing soo much snot xD.

---
# Decemeber: 09th

> Decemeber 09th.

Source: https://kbve.com/journal/12-09/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   07:07PM
    
    **Fluu**

    The flu got me all ducked up, I can feel the ooze production going full force.
    Its terrible and I can not wait for it to pass, I am thinking of just sleeping through it all.

-   07:48PM

    **Javascript**

    Okay so there are two ways we can do the bridge, the first would be through the jslib and if that ends up becoming too much of a pain.
    Then we can add react and use the unity-webgl react library to help us with moving the communication forward.

-   09:30PM

    **Meta**

    We need to create abunch of meta files for each of those folders that we made.
    I forgot that we had to do it, so let me go ahead and do that.

---
# Decemeber: 10th

> Decemeber 10th.

Source: https://kbve.com/journal/12-10/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   03:40PM
    
    **TSLA**

    Holding my whole wallet in their hands, its about to become a shit show but I am here for it all.
    I thought I would be able to claim up the ladder but it looks like its going to be a rough time to find an escape pod.

-   03:47PM

    **Unity**

    Back to the unity drawing board, but this time around we need to make sure that the webgl actually builds.
    Damn, it did not make any of the javascript ffi.
    We will update the javascriptffi and the jsonprotocol, hopefully we get some errors and build failures to work with.

-   06:43PM

    **Imports**

    Looks like we got our first error, but that was nothing more than a salt on my balls.
    The error was not the type that we were looking for but rather one of stupididdy. Wait. let me go back and incorrect the word.

-   06:51PM

    **Fudster**

    While waiting for the unity updates, we will go ahead and demo fudster.

    Repo: `https://github.com/KBVE/kbve.git`
    Branch : `dev`
    Paths: `/migrations/kube/charts/fudster`

---
# Decemeber: 11th

> Decemeber 11th.

Source: https://kbve.com/journal/12-11/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   11:30AM

    Stocks seem to continue to shift.
    I do not have much else to say on markets, other than the tariff?
    Actually it would make more sense to support the industries here in the us.
    By going directly to the small business 

<Adsense />

---
# Decemeber: 12th

> Decemeber 12th.

Source: https://kbve.com/journal/12-12/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   05:31PM

    **Journal**

    I am getting this crazy feeling that the next year is going to be wild.

-   07:07PM

    **Actions**

    There is a tool called zizmor which performs a quick safety check on the action script.
    I believe our actions have some room to be exploited.

    We used this command :
    
    ```shell
    
    zizmor   --gh-token=$(gh auth token) ./.github/workflows
    
    ```

    We got a total of `258 findings (178 suppressed): 0 unknown, 18 informational, 0 low, 58 medium, 4 high`.
    


<Adsense />

---
# Decemeber: 13th

> Decemeber 13th.

Source: https://kbve.com/journal/12-13/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   09:30AM

    **Friday**

    The tesla stock needs to relax, jesus I am going to be rich but damn its too soon.
    The issue is that I wanted more before it becomes way too popular and expensive to hold.
    I can expect tesla to also stock split next year so I need to prepare for that.

---
# Decemeber: 14th

> Decemeber 14th.

Source: https://kbve.com/journal/12-14/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   08:00PM

    **Unity**

    The Unity session came to an end but I have learned so much!

---
# Decemeber: 15th

> Decemeber 15th.

Source: https://kbve.com/journal/12-15/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   08:45PM

    The weather is finally getting better, its been so fucking cold.
    I have a bunch of notes that I need to sync across the three past days.



-   11:00PM

    Taco bell run is required, need to stock up on the processed plastic food!
    Afterwards going to shift back to that unity flow.

---
# Decemeber: 16th

> Decemeber 16th.

Source: https://kbve.com/journal/12-16/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   03:52AM

    **Sleep**

    What is sleep? That is the real question for tonight.

-   07:48PM

    **AStar**

    Doing more research for the unity plugin for astarpathfinder but I also have concerns about performance.
    Will the algo updating be fast enough on the webgl? Hmm, doing more research on that later tonight.

-   08:08PM

    **Fudster**

    For the fudster project, making sure that a different instance is spinned up and limiting the control only to specific user?
    This might be via uuid or I might find a way to handle that initially.

-   08:30PM

    **Proxmox**

    Going through the painful cycle of backing up each container and making sure that everything will run smoothly when performing the update.
    My bigger concern is that we might not have enough ram, so we need to make those adjustments.

-   09:40PM

    **Kubes**

    We just spent a bunch of time trying to get the kubes upgraded from version `v1.30.7` to `v1.31.3`!
    This included some issues with the backups, in which, the VM Worker 4 was just way too heavy or large to backup. 
    Past noticing that specific issue, I already know that we need a new machine to migrate our backups to but that requires me to go to microcity to get that arranged.

---
# Decemeber: 17th

> Decemeber 17th.

Source: https://kbve.com/journal/12-17/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   02:26AM

    **Kilobase**

    During the migration process, we made a small mistake with the longhorn and now have to redeploy the database.
    I am going to take that time to see if there are any updates that we need to do as well.

-   03:20AM

    **PvC**
    
    We got a couple persistent volume claims that are stuck in a weird loop, where we are not too sure if they can be found or not.
    To help debug this porblem, we will be running these two commands:

    ```shell
    kubectl describe pvc pvc-1696b3cc-da05-4753-872c-f88f13e20d0a
    kubectl get pv | grep pvc-1696b3cc-da05-4753-872c-f88f13e20d0a
    ```

    Then it returns this:

    ```
    Error from server (NotFound): persistentvolumeclaims "pvc-1696b3cc-da05-4753-872c-f88f13e20d0a" not found
    8Gi        RWO            Delete           Terminating   armada/redis-data-redis-master-0                 longhorn       <unset>                          86d
    ```

    To grab the location for it, we went ahead and did this:

    ```shell
    kubectl edit pv pvc-1696b3cc-da05-4753-872c-f88f13e20d0a
    ```

    This will allow us to make a couple quick edits to the `finalizers` that hold that pvc.
    In this first case we want to just remove the redis data block, so we will strip out the finalizers holding it.
    Then do this:

    ```shell
    kubectl delete pv pvc-1696b3cc-da05-4753-872c-f88f13e20d0a --grace-period=0 --force
    ```

    We need to locate them inside of our longhorn.

    ```
    orphan-ee68325bd461018c0d1103776ad999b60263d56395c9f9364bc5bd7d2b08a844
    orphan-7bc0707b775aae99dc1927e76ac1677839a2ef7eacbb6509014aafe5cc81c77e
    ```

    The next option might be just best to just delete the deployment and start again?

    Okay we know the redis sits in the `armada-naval`, so we will go ahead and rebuild it from there.
    The first step will be the name, which is going to be `armada-naval` and it will deploy to the `armada` namespace.
    The repository url will be `https://github.com/KBVE/kbve.git` and the branch will be `dev`.
    Afterwards, we want to enable the self healing and set the paths to `/migrations/kube/charts/armada`. Hmm, there is another option to keep resources but we can let longhorn handle that for us.
    While that gets pushed up and prepares to build itself out, we can shift over to the AWS and prepare for the Kilobase launch.

-   03:49AM

    **Kilobase**

    Time to bring the kilobase back around but with more updates and minor fixes as well.
    We need to pull the s3 backup and do the cluster auto-migration / repair but I did want to deploy a new instance of kilobase, hmm.
    I will hold off on that rust adaption for now, too many problems can be an issue for us.
    Same as before but we will swap out the `/migrations/kube/charts/kilobase` path.

-   05:03PM

    **Realtime**

    Now I want to focus on getting the realtime supabase to work, hopefully without having too many errors in this process.

-   11:24PM

    **Redis**

    After getting the long horn and size situation resolved, we will be moving forward with the redis deployment.
    The goal of the redis deployment is to just get a better understanding of how it will work in our eco-system.
    Let me push up the phase zero of the deployment and see where it will go from there.
    Under Armada, I am going to have to add another deployment change.

---
# Decemeber: 18th

> Decemeber 18th.

Source: https://kbve.com/journal/12-18/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   02:54AM

    **Kanban**

    The plan is to make a simple guest kanban for people to practice or quickly use one for whatever task they want.
    To keep the size low, I will have it expire after a year aka 365 days and then we will keep it to around 3 panels , with a set inventory of objects to be added.

-   08:06PM

    **Round2**

    Lets get that realtime going for kanban and maybe we can get live mouse movements too.
    That would mean we would have to setup a multi mouse realtime, hmm, react side that would be keeping track of the mouse state.

-   10:30PM

    **Elemental**

    The operator is up and running, now we need to focus on building the first container image.
    There are a couple things that I need to figure out, like the `Registgration Endpoint` crate and a couple other things.
    The new folder for the configurations will be in the `_os` folder under `/migrations/kube/_os`.

---
# Decemeber: 19th

> Decemeber 19th.

Source: https://kbve.com/journal/12-19/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   04:44Am

    **API**

    Time to remove the older source code for the first kbve api, since we need to slowly take drizzle out of the eco-system & packages.
    Once that is completed, we can update the expo and tamagui libraries!

-   06:28AM

    **NX**

    Upgraed nx to 20.2.0 and some of the smaller plugins!
    I also decided it was time to remove the last parts of drizzle, since that ticket has been open for way too long.
    Let me delete the final config and call that part of it a rest.

-   07:07AM

    **Repo**

    Cleaning up some of the older unity rareicon examples for unity 6 and some nx-go parts.
    We will just clear that up right now so that we can move forward.
    Also removing some of the last of the C# lingerring applications.

-   08:14AM

    **Kanban**

    The next goal would be to get the init kanban setup, including the database entry and the ability for basic CRUD.
    I am thinking that we do an init kanban and work around that for now.

-   11:40PM

    **Raspberry**

    Just got the rpi 8gb model and now I am going to try and figure out a way to get that damn.

---
# Decemeber: 20th

> Decemeber 20th.

Source: https://kbve.com/journal/12-20/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   04:22AM

    **RPi**

    Maybe the image that we used before was wrong? It could be that the documentation or the notes are wrong as well, hmm, I am still a bit stuck on how that came to be.
    Ugh, I am going to have it call it quit because its just too annoying, maybe I can come back around.
    Each image that I am building is either not bootable or there is something that I am missing, hmm.

-   07:40PM

    **Park**

    After cleaning myself up, I decided to take a bit of a break and walk around the park.
    It was so cold that my balls were deep inside, begging to go back to the heat.
    In the future, I should have dressed better and maybe wear the heated vest?
    Cyberpunk is the flow.

-   09:56PM

    **Food**

    I am going to make some quick ramen again, but this time using some of the brooth from yesterday.
    I let it sit with some fresh peppers, peas and carrots, so I know they are all going to be nice little spicy bombs.

-   10:53PM

    **Work**

    Ended up being way too lazy today and should cut that behavaior out!
    I got a whole wife and kids to take care of, xD just kidding, okay next is making sure the new kanban database schema works.
    I know that it will give us the ability to save but there are a couple safety concerns that I need to figure out with the sql.

---
# Decemeber: 21st

> Decemeber 21st.

Source: https://kbve.com/journal/12-21/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   04:00AM

    **Kanban**

    Updating the kanban policies and preparing the jsonb atomic updates.
    A part of me wants to just run the whole websockets for the application through rust and our own custom ingress.
    However we should still look into the performance of the supabase realtime.


-   09:40AM

    **Cold**

    The weather is brick cold, I am just getting way too sleepy and can not handle this lack of heat!
    The 4090s should be spinning up some heat but I been too lazy to go handle that situation either.

-   12:43PM

    **Knocked**

    I tried to stay up for the unity meeting but I am way too tired and I think I am about to ass out.

---
# Decemeber: 22nd

> Decemeber 22nd.

Source: https://kbve.com/journal/12-22/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Journal Mismatch

-   04:15AM

    I been missing some of the journal entries for this whole past month.
    New KBVE website is going to be amazing.

### Unity DOTS Prefabs

-   07:46AM

    Just finished migrating the gameobjects towards a pure ECS/DOTS build.
    However the damn materials are such a pain.

-   06:44PM

    Time to try the prefab generation again, hopefully this time it works without causing problems.

### Robot Unicorn Attack

-   08:14AM

    I am thinking of making a quick game.
    Why? Because it be interesting to see what we can do to keep my mind flowing.

    

## 2024

-   02:00AM

    **Kanban**

    After knocking out for almost a whole day, it was time to head back into the grind.
    The realtime was actually a bit easier than I thought, but lets just make sure everything works at the production level.
    I take it back, there might have to be another way for us to use the kanban, hmm, I am thinking that we could just shift away from the supabase and use amazon key store from AWS?
    We can just skip all of the supabase and just build our own simple storage for key value and call it from there.
    The amount of time this is taking is way too long, I am sure a simple amazon key store would be better suited for this.

-   07:20AM

    **keyDB**

    Okay I am going to backtrack the usage of the supabase and try to use a straight keydb storage as a replacement.
    The base of the application will be under the `rust_kanban` and it will handle the data transfer between the kanban client and the amazon db.
    Considering that the amazon db offers over 200m queries each month, there should not be major issue with this deployment.
    I was considering the fact that we can also cache the kanban through the api too, to save on the calls.
    Okay! after 12 hours, we were able to convert almost everything over to rust!
    Granted I did spend a good chunk of that time doing other things, but now going to make a new note.

-   08:50PM

    **Helm**

    Now to build out the pipeline for the docker build and deploying it all using helm charts.
    Before building out the helm chart, I need to switch back around and make sure that the docker build is good to go.
    This way the hlem chart will deploy that docker image and we can have it sit under the ingress of `kanban.kbve.com`.

---
# Decemeber: 23rd

> Decemeber 23rd.

Source: https://kbve.com/journal/12-23/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

#### Unity DOTS Prefab

-   05:50PM

    Taking a look at Fudster's recent push to resolve the DOTS prefab issue.
    I am hoping that he got it, then I will look at fixing the movement on the map.
    It seems that this is a bandaid because the hybrid render is being applied to everything. 
    Now the other issue is that collision might not work because of that, since gameobjects use a different physics component.
    We will need to figure out a way to convert it over.

### KBVE Main Site

-   07:31PM

    Updating the 404 Error pages so that they no longer give a blank 404 page.
    Later on we can look at improving the pipeline flow.
    Okay the 404 page no longer fails and loads without issues.

## 2024

-   05:15AM

    **Docker**

    Before building out the helm chart, we want to make sure that the docker build is good to go.
    We need it to be published and then have the ability to pull that docker image from the hub before we can move forward with the helm chart.

---
# Decemeber: 24th

> Decemeber 24th.

Source: https://kbve.com/journal/12-24/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

#### Unity Mac Shader Problems

-   01:15AM

    Even after this most recent build, we are running into a shader error.
    However what makes this shader error a major issue is that it does not tell us where it seems to be failing.
    The null point errors and these shader errors are really breaking my mental, I am starting to really feel the pain of game development.
    Each error seems to progress into a whole new error within the eco-system, just takes way too much time to process all of these issues.
    One idea could be to also just drop all the mono and completely switch to DOTS.
    Anyhow, we decided to make an editor script to help us.

### Unity Terrain Shaders

-   11:40PM

    The terrain shaders are still a black void within the DOTS instance.
    Honestly, we got the trees resolved but damn terrain is such a pain, ugh.

## 2024

-   06:57AM

    **Kanban**

    Start the morning off with a fresh deployment of the kanban helm chart.
    To build out the chart we need to make sure.
    `https://github.com/KBVE/kbve.git` This is the repo that we are pulling in and the path is `/migrations/kube/charts/kanban`
    We need to pass in the secrets too, so lets go ahead and resolve that
    ```shell
    ./kbve.sh -nx kilobase:seal --namespace=kanban --keyName=aws-config --secrets=AWS_ACCESS_KEY_I
    ```

    The deployment went well and we got the configurations through without any issues!
    Now we can switch back to the react code and figure out how to talk to the main api.

---
# Decemeber: 25th

> Decemeber 25th.

Source: https://kbve.com/journal/12-25/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Unity RentEarth Build Pipeline

-   06:22PM

    Looks like the Windows, MacOS and Linux builds are somewhat there, we still need to make some tweaks!
    I am currently building out the player hud and then will look at adding some menu options for the player.
    A decent amount of the updates to do this jolly good day!

### Github Leaderboard on KBVE

-   11:45PM

    Before the year ends, I need to put the leaderboard back on the main page of KBVE!
    It would be really interesting if I could make a scoreboard and even turn it into a weird game?
    I am not too sure but I will keep cookin until I get something cool to play with.


## 2024

-   04:14AM

    **Kanban**

    Okay! We are almost done with the generic or well base kanban board.
    Getting it all operational is the goal for today, then I will shift over to adding additional features.
    Okay we need to push forward with some of the minor updates and get the new docker image built out!
    Let me move the rust and react code up for now and loop back around, hopefully resolving the CORS issue.
    The docker image of 1.02 was published, so now I am going to update the helm chart and have it deploy the new one.

-   07:33AM

    **React**

    Okay we got the communication between the kanban and the react component going, now we just need to figure out how to maintain that easy flow.
    Right now its not pulling the right data from the api state, so I am going to focus on resolving that next.

-   02:21PM

    **MerryXMas**

    Happy holidays!
    Forgot to include that in my notes, xD
    I am thinking of redoing the whole kanban system to help keep track of the notes a bit better, maybe even expanding the item collection that would be involved.

---
# Decemeber: 26th

> Decemeber 26th.

Source: https://kbve.com/journal/12-26/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### Github Hero Leaderboard

-   12:47AM

    The core loader board will be just in react and I will try to hardcode the results.
    Yeah there is no need for the react code, because we could just grab the json data from the API during the build process, then just bake it into the build.
    This way we get zero javascript overhead and could even hardcore some crazy css effects because we do not have to promise or await the data.

## 2024

-   09:30AM

    **SPY**

    $600 for SPY!? This is great!

-   01:05PM

    **Items**

    The plan is to rework the kanban data structure, so that we can expand upon it.
    Once the basic saving, loading and notes are done, we can move forward with adding in the AI tools around it.
    If everything can get up and running, we can move back around to the AStar pathfinding in unity.
    Okay the new docker image should start the build and now I am going to update the helm chart.\
    

-   01:34PM

    **GitOps**

    We need the unity game also running, so lets go back around and make sure that rareicon game server is up and running.
    To get the gameserver up and running, we need to include the repo URL, which is `https://github.com/KBVE/kbve.git` and the branch is `dev`.
    Then enable self-healing and add the path, `/migrations/kube/charts/rareicon` and we should have the gameserver up and running for rareicon.

---
# Decemeber: 27th

> Decemeber 27th.

Source: https://kbve.com/journal/12-27/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

### AWS Barman

-   11:00PM

    Resolved the massive space usage that our postgres backup was holding.
    The AWS bill has dropped back down to under $1 for what we have, but there is still some room for improvements.

## 2024

-   03:15PM

    **Laptop**

    For some reason, Fedex did not get a chance to deliver the laptop?
    I did not hear the door bell but now that I am thinking about it, it could have been because of the power that runs to the doorbell being off.
    I will look into that later tonight.

-   06:40PM

    **Sleep**

    Ugh, so tired and hungover, I might just go back to sleep again and refresh my mind.
    I got a bunch of peter and bald playing in the background, while I am taking a quick mental break.

    <Adsense />

---
# Decemeber: 28th

> Decemeber 28th.

Source: https://kbve.com/journal/12-28/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   05:37AM

    **RPI**

    This is the first journal entry from the RPI!
    We were not able to get it working through the elemental os but I think that might be because there just is not enough documentation on it for now?
    Regardless, I think it might just be better to run ubuntu for on the RPI and maybe try to do the `k2d` or some other `edge` setup.
    I will put more notes down for this situation later today.

-   01:29PM

    **Unity**

    Going to spend the next couple hours going through Unity and seeing what changes that I have to do tonight.
    I believe we last left off with the discord integration and the AStar pathing.
    First error with the JavascriptFFI, seems that there was a duplicate function name, so I am going to adjust for that next.

-   03:23PM

    **RareIcon**

    Moving forward, we should just use the gihtub actions to execute the unity builds because the amount of time is just insane from the unity side.
    We are already looking at over 1:22 hours for this most recent build and I am thinking that something else might be wrong?
    Should the linking take this long, it just seems way too insane and maybe it be better to just let the actions handle it moving forward.

---
# Decemeber: 29th

> Decemeber 29th.

Source: https://kbve.com/journal/12-29/

import { Adsense, Tasks } from '@/components/astropad';

## 2025 

### MINDUSTRY

-   8:09PM

    No major entries for the day, just spent way too much time playing mindustry to fully understand where my psych is.
    I am basically binge playing a bunch of this game, I call it advance research xD.
    There are a ton of notes that I have, I might implement some of the concepts within one of my games.

## 2024

-   01:27PM

    **2024**

    The year is about to wrap over, kinda weird.
    There were some changes to account for! 

-   04:01PM

    **Salt**

    I hate to have this entry but it is what it is.

-   06:06PM

    **Unity**

    After yesterday, I been spending some time to become better at Unity

---
# Decemeber: 30th

> Decemeber 30th.

Source: https://kbve.com/journal/12-30/

import { Adsense, Tasks } from '@/components/astropad';

## 2024

-   10:35AM

    **SPY**

    Damn $585? Wild.

-   05:40PM

    **Time?***

    xD.... we deal with it as family

---
# Decemeber: 31st

> Decemeber 31st.

Source: https://kbve.com/journal/12-31/

import { Adsense, Tasks } from '@/components/astropad';

## 2025

-   11:05PM

    Did a quick drop in and out, this needs to become my go to move for all events!
    Bring a bunch of goodies, like chips and beer, then say whats up!
    Afterwards, just dip.


## 2024

-   05:19PM

    **New Years**

    I am super excited for the new year, this is the last entry for this year too?
    Its going to be more interesting that I can go back to my early entries.
    I will have to also get used of updating the 2024 to 2025.

---
# Agones Unreal SDK — Server-Only GameServer Lifecycle Plugin

> Vendored Agones Unreal SDK plugin (server-only) drives GameServer lifecycle Ready, Health, and Shutdown through the Agones sidecar REST API on dedicated builds.

Source: https://kbve.com/project/agones/

## Overview

`Agones` is a pristine mirror of the upstream Agones Unreal SDK
(googleforgames/agones, `release-1.58.0`, Apache-2.0), pinned for the KBVE
dedicated-server stack. It wraps the [Agones](https://agones.dev/) sidecar REST
API so an Unreal dedicated server can register with and be managed by an Agones
`Fleet`. The `UAgonesSubsystem` auto-connects on dedicated-server builds —
polling `/gameserver`, calling `/ready`, and pinging `/health` — so a server
binary becomes allocatable under a Fleet.

## Key facts

| | |
|---|---|
| **Plugin** | `Agones` |
| **Version** | 2.0.0 (upstream `release-1.58.0`) |
| **Engine** | Unreal Engine 5.4+ |
| **License** | Apache-2.0 |
| **Source** | [`packages/unreal/Agones`](https://github.com/KBVE/kbve/tree/main/packages/unreal/Agones) |
| **Platforms** | Linux (dedicated server) |

## Features

- **Auto-connecting subsystem** — `UAgonesSubsystem` connects to the Agones
  sidecar on dedicated-server startup with no manual wiring.
- **Lifecycle over REST** — polls `/gameserver`, calls `/ready`, and pings
  `/health` to keep the pod allocatable and healthy.
- **Server-only module** — `TargetAllowList: ["Server"]` keeps the plugin out
  of client and editor builds.
- **Vendored + pinned** — an unmodified upstream mirror; see `VENDORING.md` for
  the upstream pin and resync steps.

## FAQ

**What is the Agones Unreal SDK plugin?**
It is a pristine vendored mirror of the upstream googleforgames/agones Unreal SDK
(`release-1.58.0`, Apache-2.0), pinned for the KBVE dedicated-server stack. It
wraps the Agones sidecar REST API so an Unreal dedicated server can register
itself with an Agones Fleet.

**How does the plugin manage the GameServer lifecycle?**
The `UAgonesSubsystem` auto-connects on dedicated-server builds. It polls
`/gameserver`, calls `/ready`, and pings `/health` against the Agones sidecar so
the server binary becomes allocatable and stays healthy under a Fleet.

**Is the Agones plugin compiled into client or editor builds?**
No. The module declares `TargetAllowList: ["Server"]`, so it is only built into
dedicated-server targets and never into client or editor builds.

## Related

- [KBVEAgones](/docs/project/kbveagones) — the KBVE-specific ROWS wiring layered on top of this vendored SDK.
- [KBVEROWS](/docs/project/kbverows) — Rust Open World Server backend integration for UE5.

---
# Agones Factorio — Managed Dedicated Server

> Agones-managed Factorio dedicated server with the KBVE scenario plus a lifecycle shim (Ready/Health, SIGTERM save flush) on the factoriotools rootless base.

Source: https://kbve.com/project/agones-factorio/

## Overview

KBVE-baked Factorio dedicated-server image, designed to run as an Agones `GameServer` on the production Kubernetes cluster (issue #11138).

The image is a thin layer on top of `factoriotools/factorio:2.0.76-rootless`:

- **Lifecycle shim** — `shim/agones-shim.sh` execs the Factorio binary, copies bakeable defaults into `/factorio/config/` only when a ConfigMap mount hasn't already provided the file, drives `Ready()` + a periodic `Health()` heartbeat when `AGONES_SDK_HTTP` is set, and traps `SIGTERM` so Agones-initiated shutdowns get a clean autosave.
- **KBVE scenario** — `scenarios/kbve/` is our own Lua scenario, redmew-inspired but written fresh so we can grow the soft-mod layer in-tree (join/leave broadcasts, donor perks, chat commands).
- **RCON + console-log plumbing** — when `FACTORIO_RCON_PASSWORD` is set the shim opens RCON bound to `127.0.0.1:27015` (loopback-only by default) and passes `--console-log` so the planned chat-relay sidecar can stream `[CHAT]/[JOIN]/[LEAVE]/[COMMAND]` markers off a shared `emptyDir` volume.
- **Rootless** — UID 845 `factorio`, so the eventual `GameServer` PodSpec can require `runAsNonRoot: true` without a SecurityContext fight.

## Key facts

| | |
|---|---|
| **Image** | `kbve/agones-factorio` |
| **Base** | `factoriotools/factorio:2.0.76-rootless` |
| **Orchestration** | Agones `GameServer` on Kubernetes |
| **License** | KBVE |
| **Source** | [`apps/agones/factorio`](https://github.com/KBVE/kbve/tree/main/apps/agones/factorio) |
| **Tracking** | Issue #11138 |

## Features

- **Agones lifecycle shim** — `Ready()` / periodic `Health()` and SIGTERM-driven autosave.
- **KBVE scenario** — an in-tree Lua soft-mod layer (joins, donor perks, chat commands).
- **RCON + console-log plumbing** — loopback RCON and `--console-log` for the relay sidecar.
- **Rootless** — runs as non-root UID 845.

## Phasing

| Phase | Scope |
|---|---|
| 0 | Custom image + scenario + lifecycle shim (this entry) |
| 1 | `apps/kube/agones/factorio/` GameServer/Fleet + UDP exposure |
| 2 | ConfigMap-driven `server-settings.json` + ExternalSecret for matchmaking token and RCON password |
| 3 | Chat-relay sidecar (`apps/agones/factorio/relay/`, Rust) — log tail + RCON + IRC client; IRC → existing Discord bridge |
| 4 | PVC + save-rotation CronJob + public download URL |
| 5 | Observability — log shipping + RCON metrics + UPS / player-count alerts |

## Container

`kbve/agones-factorio` (local) / `ghcr.io/kbve/agones-factorio` (production), built via the standard nx container target:

```bash
./kbve.sh -nx agones-factorio:container
```

## Runtime knobs

| Env | Default | Notes |
|---|---|---|
| `FACTORIO_SCENARIO` | `kbve` | Scenario directory under `/factorio/scenarios/` |
| `FACTORIO_PORT` | `34197` | UDP listen port |
| `FACTORIO_CONFIG_DIR` | `/factorio/config` | Mount a ConfigMap here in Phase 2 |
| `FACTORIO_CONSOLE_LOG` | `/shared/log/console.log` | Tailable by the Phase 3 relay sidecar |
| `FACTORIO_RCON_PORT` | `27015` | TCP, loopback-only by default |
| `FACTORIO_RCON_BIND` | `127.0.0.1` | RCON listen address |
| `FACTORIO_RCON_PASSWORD` | _(unset)_ | When unset, RCON is not opened |
| `AGONES_SDK_HTTP` | _(unset)_ | When unset, SDK calls are skipped — local `docker run` works without Agones |
| `AGONES_READY_DELAY` | `30` | Seconds before `Ready()` |
| `AGONES_HEALTH_INTERVAL` | `5` | `Health()` cadence |

## FAQ

**What is the Agones Factorio image?**
A KBVE-baked Factorio dedicated-server OCI image built to run as an Agones
`GameServer` on the production Kubernetes cluster, layered on the factoriotools
rootless base.

**How does the Agones lifecycle shim work?**
The shim execs the Factorio binary, seeds config defaults when no ConfigMap is
mounted, drives `Ready()` plus a periodic `Health()` heartbeat, and traps
`SIGTERM` so shutdowns get a clean autosave.

**Can the image run locally without Agones?**
Yes. When `AGONES_SDK_HTTP` is unset the SDK calls are skipped, so a plain
`docker run` works without an Agones controller.

## Related

- [Agones Factorio Relay](/docs/project/agones-factorio-relay) — chat-relay sidecar bridging RCON, IRC, and Discord.
- [Agones](/docs/project/agones) — the game-server orchestration platform.
- [Minecraft Server](/docs/project/mc) — sibling Agones game server.

## References

- Issue #11138 — original planning ticket
- factoriotools/factorio — upstream image (rootless variant)
- Agones `GameServer` CRD — https://agones.dev/site/docs/reference/gameserver/

---
# Agones Factorio Relay

> Rust sidecar for the Agones-managed Factorio server — tails the console log, speaks RCON, bridges chat to kbve IRC, and writes telemetry to ClickHouse.

Source: https://kbve.com/project/agones-factorio-relay/

## Overview

Rust binary that runs as a sidecar container in the Factorio Agones GameServer pod (`apps/kube/agones/factorio/`, landing in Phase 1 / 3b). It exists so the factorio container itself can stay vanilla — no Agones SDK plumbing, no chat-bridge logic, no telemetry — and lifecycle work happens out-of-process where it can be iterated without rebuilding the 1+ GB Factorio image.

Three roles, one process:

- **Log tail** — reads `/shared/log/console.log` (written by the factorio container via `--console-log`) and emits typed `GameEvent`s for `[CHAT] / [JOIN] / [LEAVE] / [COMMAND] / [STATS]` markers.
- **IRC bridge** — forwards `[CHAT]` plus join/leave events to the configured channel (default `#general`) on the existing kbve IRC network. IRC → Discord is already wired by the `irc-gateway` service, so this is the single integration point the game needs.
- **ClickHouse writer** — inserts snapshots, player events, and rotation rows into `gameops.factorio_*` (schema in `packages/data/ch/schemas/factorio.sql`). 14-day raw TTL, 90-day rotation history.

Phase 3a (this entry) ships the crate scaffold so the image builds and publishes. The IRC, RCON, and ClickHouse modules are stubbed and log only. Real impl lands in Phase 3c (IRC + RCON wiring) and Phase 4d (ClickHouse insert + scenario.lua `[STATS]` emitter).

## Architecture (target — Phase 3c+)

```
┌──────────────────────────────────────────────────────────┐
│ GameServer Pod                                           │
│                                                          │
│ ┌──────────────┐  ┌────────────────┐  ┌──────────────┐   │
│ │  factorio    │  │ factorio-relay │  │ agones-sdk   │   │
│ │              │  │                │  │ (injected)   │   │
│ │ udp:34197 ←──┼──┼─→ rcon 27015   │  │              │   │
│ │ rcon:27015 ──┼─→│  127.0.0.1     │  │ http:9358    │   │
│ │              │  │                │  │ grpc:9357    │   │
│ │ writes →     │  │ reads →        │  │              │   │
│ │ /shared/log/ │  │ /shared/log/   │  │              │   │
│ │ console.log  │  │ console.log    │  │              │   │
│ └──────┬───────┘  └────────┬───────┘  └──────────────┘   │
│        │                    │                            │
│        └────emptyDir: /shared/log────┘                   │
│                                                          │
│  IRC out ←──── factorio-relay ────→ irc.kbve.com:6697    │
│  CH writes ←─── factorio-relay ───→ gameops.factorio_*   │
└──────────────────────────────────────────────────────────┘
```

## Runtime knobs

| Env | Default | Notes |
|---|---|---|
| `FACTORIO_CONSOLE_LOG` | `/shared/log/console.log` | Tailable shared volume mounted from the same `emptyDir` as the factorio container |
| `FACTORIO_RCON_ADDR` | `127.0.0.1:27015` | Same-pod loopback; RCON server lives in the factorio container |
| `FACTORIO_RCON_PASSWORD` | _(required)_ | Mounted from `SealedSecret` |
| `IRC_SERVER` | `irc.kbve.com` | |
| `IRC_PORT` | `6697` | TLS |
| `IRC_USE_TLS` | `true` | |
| `IRC_NICK` | `factorio-bot` | |
| `IRC_CHANNEL` | `#general` | Single channel for v1. Multi-channel routing is Phase 3c+ scope |
| `IRC_PASSWORD` | _(unset)_ | NickServ identify |
| `FACTORIO_SERVER_ID` | `factorio-default` | Stamps every ClickHouse row; later: `factorio-vanilla-1`, `factorio-pvp-1`, etc. |
| `FACTORIO_SCENARIO_DEFAULT` | `kbve` | Fallback when a `[STATS]` line doesn't include scenario |
| `CLICKHOUSE_URL` | _(unset)_ | When unset, the ClickHouse writer is disabled; the relay still bridges IRC ↔ RCON |
| `CLICKHOUSE_USER` | _(unset)_ | |
| `CLICKHOUSE_PASSWORD` | _(unset)_ | |
| `CLICKHOUSE_DATABASE` | `gameops` | |
| `AGONES_SDK_HTTP` | _(unset)_ | Base URL of the in-pod Agones SDK sidecar (e.g. `http://127.0.0.1:9358`). When unset, the relay-side health module is a no-op |
| `AGONES_HEALTH_INTERVAL_SECS` | `5` | TCP-probes the local RCON port every N seconds, POSTs `/health` to Agones SDK on success |
| `AGONES_RCON_PROBE_TIMEOUT_SECS` | `2` | How long to wait for the TCP probe before treating RCON as down |
| `AGONES_INITIAL_READY_DELAY_SECS` | `0` | Delay before the relay also POSTs `/ready` (single source-of-truth liveness; `60` in prod) |

## Phase 5 — `sim_director` (design map)

Moves the simulation "brain" into the relay so the in-game Lua mod can stay thin (just per-tick sensors) while strategic decisions — evolution-driven raids, scheduled events, ClickHouse-driven economy gifts — run out-of-process. RCON commands still execute inside the Factorio tick loop, so this module saves nothing on the hot path; the win is _consolidation_: rules, schedules, and telemetry-driven logic live in one Rust crate that is unit-testable, hot-redeployable, and reusable across servers when a second one lands.

### Split of responsibilities

| Layer | Responsibility | Why there |
|---|---|---|
| Factorio Lua mod | Per-tick event hooks (`on_entity_died`, `on_player_built_entity`, `on_research_finished`), `[STATS]` console emitter, narrow `rcon.print(...)` JSON helpers | Hot path — must run inside the tick |
| `factorio-relay :: sim_director` | Poll snapshots, evaluate rules, schedule cron events, ClickHouse-driven decisions, RCON action dispatch | Strategic cadence (5–30s), Rust testability, external state |
| `factorio-relay :: rcon_pool` | Single shared RCON connection with a serialized command queue, rate limit, retries | One TCP conn, never burst the tick |

### Proposed module layout

```
apps/agones/factorio/relay/src/
├── sim_director/
│   ├── mod.rs            // entrypoint: spawn poller + scheduler + rule engine
│   ├── state.rs          // SimSnapshot { tick, evolution, pollution, players, ups, ... }
│   ├── poller.rs         // periodic single-RCON snapshot via game.table_to_json
│   ├── triggers.rs       // Trigger enum + cooldown bookkeeping
│   ├── actions.rs        // Action enum + Lua-string builders (SpawnBiterWave, GiftItems, ...)
│   ├── scheduler.rs      // cron-like timed events (raids every 30m, daily reset, ...)
│   └── rules.rs          // declarative Rule { trigger, action, cooldown, name }
├── rcon_pool.rs          // shared mpsc-backed RCON queue (also used by irc_bridge)
└── rcon_client.rs        // promoted from stub to real connection (Phase 3c work)
```

### Data flow

```
ticker (poll_interval) ──► poller.rs ──► SimSnapshot ──┐
                                                       │
log_tail GameEvent ────────────────────────────────────┤
                                                       ▼
scheduler.rs cron tick ────────────────► triggers.rs (eval + cooldown)
                                                       │
                                                       ▼
                                                   actions.rs
                                                       │
                                                       ▼
                                                   rcon_pool ──► Factorio
                                                       │
                                                       ▼
                                                   ch_writer (audit row)
```

### Snapshot shape

One RCON call per poll cycle; Lua side packs a JSON blob so Rust deserializes a single payload instead of round-tripping per field.

```lua
/silent-command rcon.print(game.table_to_json({
    tick = game.tick,
    evolution = game.forces.enemy.evolution_factor,
    players = #game.connected_players,
    pollution = game.get_pollution({0,0}),
    ups = game.speed,
    surfaces = { ["nauvis"] = game.surfaces["nauvis"].day_time }
}))
```

```rust
struct SimSnapshot {
    captured_at: chrono::DateTime<chrono::Utc>,
    tick: u64,
    evolution: f64,
    players: u32,
    pollution: f64,
    ups: f64,
    surfaces: HashMap<String, f64>,
}
```

### Triggers + actions (sketch)

```rust
enum Trigger {
    EvolutionAbove { threshold: f64 },
    PollutionAbove { center: (i32, i32), value: f64 },
    PlayerCountChanged,
    TickDivisible { every_ticks: u64 },
    Cron(String),                 // "*/30 * * * *"
    LogEventMatched(GameEventKind),
}

enum Action {
    SpawnBiterWave { size: u32, distance: u32, surface: String },
    GiftItems { player: String, items: Vec<(String, u32)> },
    Broadcast(String),
    SetEvolution(f64),
    RawLua(String),               // admin-gated escape hatch
}

struct Rule {
    name: &'static str,
    trigger: Trigger,
    action: Action,
    cooldown: Duration,
}
```

Phase 2 ships hardcoded rules; Phase 3 promotes to a TOML/YAML rule file mounted via `ConfigMap` and watched with `notify`.

### ClickHouse schema additions

Lives in `packages/data/ch/schemas/factorio.sql` alongside the existing `factorio_*` tables.

```
sim_snapshots (
    ts          DateTime64(3),
    server_id   LowCardinality(String),
    tick        UInt64,
    evolution   Float64,
    pollution   Float64,
    players     UInt16,
    ups         Float64
)

sim_actions (
    ts          DateTime64(3),
    server_id   LowCardinality(String),
    rule_name   LowCardinality(String),
    action_kind LowCardinality(String),
    lua         String,
    status      Enum8('sent'=1, 'failed'=2, 'dry_run'=3),
    latency_ms  UInt32
)
```

`sim_actions` becomes the canonical audit log of every relay-issued RCON command — searchable, retainable, and the first place to look when an unexpected biter wave shows up at 03:00.

### Runtime knobs (proposed)

| Env | Default | Notes |
|---|---|---|
| `SIM_DIRECTOR_ENABLED` | `true` | Master switch; `false` keeps the rest of the relay running with no director |
| `SIM_POLL_INTERVAL_SECS` | `10` | Snapshot cadence |
| `SIM_RULE_PATH` | _(unset)_ | When set, loads rules from a YAML/TOML file; unset uses the hardcoded Phase 2 set |
| `SIM_EVO_THRESHOLD` | `0.30` | Default evolution-above trigger value (Phase 2) |
| `SIM_RAID_MIN_INTERVAL_SECS` | `1800` | Floor on auto-raid frequency |
| `SIM_RCON_RATE_LIMIT_QPS` | `4` | Cap on RCON commands per second across all callers |
| `SIM_DRY_RUN` | `false` | Log actions to `sim_actions` with `status='dry_run'`, never send them. Forced on in CI |

### Phasing

| Phase | Scope | Outcome |
|---|---|---|
| P1 | Promote `rcon_client` from stub to real connection; add `rcon_pool` with serialized queue; ship `SimSnapshot` poller writing rows to `sim_snapshots` only | Readable evolution/tick/UPS curves in ClickHouse; no game-facing side effects |
| P2 | `triggers.rs` + `actions.rs` with hardcoded `EvolutionAbove → Broadcast` and `Cron("*/30 * * * *") → SpawnBiterWave` rules; `sim_actions` audit rows | First closed sim loop, full audit trail |
| P3 | External rule file (`SIM_RULE_PATH`), hot-reload via `notify`, admin IRC commands `!reloadrules` / `!dryrun on` | Rule edits without redeploy |
| P4 | ClickHouse-driven decisions: query aggregates (last hour deaths, top miners) and act (gift packs, broadcast leaderboards) | Telemetry feeds back into sim |
| P5 | Multi-server fan-out: shared rules + per-server overrides; cross-server raids | Coordinated server #2+ |

### Safety rails

- **`SIM_DRY_RUN=true`** in CI and during initial prod rollout; nothing reaches Factorio until a human flips the switch.
- **Per-rule cooldown** (`Rule::cooldown`) — required, no default of zero, so `EvolutionAbove(0.3)` doesn't fire every poll.
- **RCON QPS cap** (`SIM_RCON_RATE_LIMIT_QPS`) enforced by a tokio `Semaphore` in `rcon_pool`. Sized so director + IRC bridge + `agones_health` together can never burst the tick.
- **`RawLua` action gated by IRC admin allowlist** — never auto-fired by a trigger, only by an explicit operator command.
- **All actions audited** in `sim_actions`, dry-runs included — no silent commands.

### Open questions

- Rule source: TOML file on a `ConfigMap` volume vs. a `sim_rules` ClickHouse table. File-on-volume is simpler and ArgoCD-friendly; CH-backed enables web UI editing later.
- Cron parser: `cron` crate vs. an ad-hoc interval struct. Probably `cron` once we have more than two time-based rules.
- Lua-mod ↔ relay event contract: keep the current `[CHAT] / [JOIN] / [STATS]` console markers (relay tails them) or add a structured `[SIM]` channel for richer per-tick events the director wants. Lean toward extending the marker set rather than introducing a second transport.

## FAQ

**What does the Agones Factorio relay do?**
It runs as a sidecar in the Factorio GameServer pod, tailing the console log,
speaking RCON to the game container, bridging chat to the kbve IRC `#general`
channel, and writing telemetry to the gameops ClickHouse database.

**Why is chat and telemetry logic in a sidecar instead of the Factorio image?**
Keeping it out-of-process lets the Factorio container stay vanilla and lets the
relay be iterated and redeployed without rebuilding the 1+ GB Factorio image.

**How does chat reach Discord?**
The relay forwards chat and join/leave events to the kbve IRC network, and the
existing `irc-gateway` service already relays IRC to Discord, so IRC is the
single integration point the game needs.

## Related

- [Factorio CTL](/docs/project/factorio-ctl) — REST control API that reads the telemetry this relay produces.

## Refs

- Tracking issue #11138
- Schema PR — `packages/data/ch/schemas/factorio.sql`
- Sibling Phase 0 image — `kbve/agones-factorio`

---
# KBVE API — Central Multi-Tenant API Service

> KBVE API is the central multi-tenant API for KBVE projects, a Rust/axum service (axum-kbve) with Supabase-backed auth and a SQL database.

Source: https://kbve.com/project/api/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

## Information

We will provide official documentation for the API, which will be based on the frameworks Supabase, Strapi, and Appwrite.
This documentation will serve as the primary reference for our multi-tenant API, encompassing all general reference points.
However, to facilitate the onboarding process for new developers, we aim to expand upon the existing reference material, enhancing clarity and accessibility.
This approach will ensure that developers can efficiently understand and utilize the API, promoting a smoother integration experience.

<Aside type="note">

-   Official documentation will be provided for the API, which is written in [Rust](/application/rust/), [Python](/application/python/) and the database is in [SQL](/application/sql/).
-   This documentation will hold all the general reference points for the multi-tenet API, however we would need to expand upon the reference material and try to make it easier to onboard new developers.

</Aside>

## Auth

-   Auth Journal
    -   For the core of the API, we will use JWT as the `key` in between the $User and $API.
-   React JSX

    -   The first mod will be the core auth system between the client $User and server $API, which includes the register and login. While we build it out, we will include generic defensive components into the foundation, then re-visit and apply external security, such as limits and firewalls (some may operate outside of the API).
        -   Cookie Storage (of the JWT)
            -   Cookie - `token` - will store the client $User JWT.
            -   Cookie - `user` - will store the client $User data.
            -   Library: `react-cookie` will be used to help maintain the cookies.

-   For the Appwrite JWT, we will be holding it inside of a session store from Nanostores, at least as of right now.

### API Keys

API keys serve as unique identifiers, allowing our application to communicate seamlessly with our servers.
Rather than asking for a user's password— which can pose security risks— these keys authenticate requests by proving that the application making the request is authorized.
Think of them as special passwords generated specifically for the software, ensuring secure data exchange while keeping user credentials confidential.
By utilizing API keys, we prioritize both the user's privacy and the integrity of our platform.

#### v0

The current method of storage has a couple risks that we need to migrate, including the way the data is being encrypted within the storage of the database.

### API Install Introduction

In the dynamic world of software, where even a moment's downtime can make or break user trust, managing the API installation process is paramount. P
resently, our journey starts at Proxmox, winds through qEMU, and culminates in Docker Swarm.
From there, Portainer takes the baton to deploy the image.
While most of our front-end instances proudly wear the labels of applications or static pages, there are those intriguing outliers - the edge cases where we might stumble upon SSR or hybrid applications.
Let's dive deeper into this fascinating setup.

The current API installation process needs to be migrated but it currently sits as this:

-   Proxmox -> qEMU -> Docker Swarm
-   Portainer -> Deploy Image

With all front-end instances being either applications or static pages.
There might be a couple edge cases where we have SSR or hybrids applications.

### v1

For v1, we would like you to look into the [Appwrite documentation](/application/appwrite/)

### v0

The following information below is for installing the older API, which was just a MariaDB cluster with Strapi.

### Locker

### Locker Information

The locker will serve as a client-side storage for variables and data points that we do not need to `hit` the main server for!

The current locker that we are using as of August 12th, 2023 is below, but if we need to extend it out further, we shall.

### Locker

The locker, aka a client-side storage, that allows web applications to store data directly in a user's browser, offering speed and offline accessibility.
However, to ensure data integrity and security, locking mechanisms can be implemented, restricting unwanted or concurrent modifications.
Think of it as a personal vault in your browser, where the combination is known only to trusted sources

```typescript
export type kbveLocker = {
	username: string;
	phone: string;
	last: string;
	uuid: string;
	avatar: string;
	github: string;
	instagram: string;
	email: string;
	theme: 'dark' | 'light' | 'auto';
};
```

### Locker Storage

For the management of the locker storage on the client-side, we will be using [nanostores!](/application/javascript#nanostores).
There is an option to extend AES encryption ontop of the stored values but that will be something that we can implement in the start of the next year.

### Uptime Notes

Uptime is the heartbeat of any API, indicating its reliability and performance in real-time.

Ensuring consistent availability is crucial, as even minor downtimes can impact user experience and trust.

Diving deep into the world of API uptime, this documentation equips you with the tools to vigilantly monitor and enhance your service's responsiveness.

-   ![API Uptime Badge](https://api.checklyhq.com/v1/badges/checks/206925a6-0f7b-4669-a4fd-b61b3f5b70fc?style=for-the-badge&theme=default&responseTime=true)

The current uptime badge is handled by ChecklyHQ, however we could build out our own uptime management software down the line.
This would be an interesting test case for the NodePy, having it automatically do test cases every hour.
I will make an issue ticket when I feel like it would be time to set this up.

**Goals**

In the vast cosmos of software, APIs are the Jedi Masters, bridging the divide between different software galaxies.
Like the Force in Star Wars, they bind and intertwine disparate systems, ensuring harmony in the digital universe.
By sculpting robust and intuitive APIs, we're not just coding; we're forging lightsabers for the next generation of developers, ensuring the saga continues seamlessly.
The API is an unique construct that extends outside of the normal universe, the net that holds the sky.

## Discord.sh

Starting this project next, leaving a basic note.

## FAQ

**What is the KBVE API?**
The KBVE API is the central multi-tenant API for KBVE projects, implemented as the
axum-kbve Rust service. It exposes shared endpoints for auth and data and is built
on Supabase, with reference documentation aimed at onboarding new developers.

**What technologies power the KBVE API?**
The API is written in Rust (axum-kbve) with Python tooling and a SQL database, and
it builds on Supabase, Strapi, and Appwrite as reference frameworks for the
multi-tenant surface.

**How is the KBVE API deployed?**
It runs in production in the `kbve` namespace as the `kbve/kbve` image, deployed
via `apps/kube/kbve/manifest/kbve-deployment.yaml`, with an `axum-kbve-e2e` test
suite gating releases.

## Related

- [Metrics](/docs/project/metrics) — observability service that captures telemetry across KBVE apps.
- [CryptoThrone.com](/docs/project/cryptothrone) — game backend built on the same axum stack.

---
# AR — Augmented Reality Glasses and SDK Research Notes

> KBVE augmented reality (AR) research notes covering AR glasses hardware such as the Nreal Air and their SDKs for building spatial and heads-up experiences.

Source: https://kbve.com/project/ar/

## Overview

This page collects KBVE's **augmented reality (AR)** research — hardware notes on AR
glasses and their software development kits. It is an evolving concept page rather
than a shipped software package, capturing candidates for spatial and heads-up
experiences as they are evaluated.

## Key facts

| | |
|---|---|
| **Topic** | Augmented reality glasses + SDKs |
| **Status** | Research / notes (evolving) |
| **Current hardware** | Nreal Air AR Glasses |
| **Focus** | Spatial and heads-up experiences |

## Focus areas

- **AR glasses hardware** — evaluating wearable displays such as the Nreal Air.
- **SDK evaluation** — reviewing each device's SDK for building AR applications.
- **Spatial / heads-up experiences** — how AR overlays could pair with KBVE apps.

## FAQ

**What is the KBVE AR project?**
It is a research and note-taking page for augmented reality work at KBVE, tracking AR
glasses hardware and their SDKs as candidates for building spatial and heads-up
experiences.

**Which AR glasses does this page cover?**
The current notes focus on the Nreal Air AR glasses and their SDK, with more hardware
and SDK evaluations to be added over time.

## Related

- [Pirate](/project/pirate/) — a KBVE game jam project exploring another interactive medium.

---
# ARC Runner — Custom GitHub Actions Runner Image

> Custom GitHub Actions Runner image for the arc-runner-set scale set, baking git-lfs, unzip, jq, gh, kubectl, and dbmate into the actions/runner base.

Source: https://kbve.com/project/arc-runner/

## Overview

`arc-runner` is the custom Actions Runner Controller image consumed by the `arc-runner-set` scale set in the `arc-runners` namespace. It layers a small bundle of build tooling on top of `ghcr.io/actions/actions-runner` so CI jobs do not have to `apt-get install` the same packages on every cold start.

### Why a custom image

Workflows that run on `arc-runner-set` currently install `git-lfs`, `unzip`, and similar tools as the first step of every job. The Unity build matrix in `ci-unity.yml` re-installs `git-lfs` once per build target — three installs per workflow run today, more as we add Unity targets. Cumulatively this adds minutes of wall-clock time to every Unity matrix and burns ARC pod CPU on apt repo round-trips that are identical across runs.

A baked image fixes the pattern in three ways:

1. **No cold-start `apt-get`** — every tool the runner pool needs is on `PATH` the moment the runner pod starts.
2. **Air-gap-safe under apt mirror outages** — image dependencies are pinned via the upstream `actions-runner` tag plus `apt` snapshots; a transient `archive.ubuntu.com` outage no longer fails Unity matrix legs.
3. **Single source of truth** — bumping a tool happens once in this Dockerfile + version, not in every workflow that references it.

### Image layout

| Binary | Purpose |
|--------|---------|
| `actions-runner` | Upstream GitHub Actions self-hosted runner (`/home/runner/run.sh`) |
| `git-lfs` | Forgejo LFS pulls (rareicon Unity, future chuck UE5) |
| `unzip` | butler installer + generic archive tooling |
| `jq` | Manifest dispatch + workflow shell glue |
| `xz-utils` | `.tar.xz` extraction (Unity, butler, SDK installers) |
| `gh` | GitHub CLI for workflows that shell out to it |
| `curl` | Inherited from upstream, kept explicit for downstream callers |
| `ca-certificates` | TLS trust for HTTPS-fetched dependencies |
| `rsync` | Cross-host file sync (Unity / UE asset shuffling) |
| `build-essential` + `pkg-config` | Native-build deps for crates that compile C/C++ on the runner (`ci-uniti`, `ci-dashboard`) |
| `protobuf-compiler` + `libprotobuf-dev` | `protoc` for crates that codegen from `.proto` (used six times across `ci-uniti`) |
| `gettext-base` (`envsubst`) | k8s manifest rendering (`ci-dbmate-deploy`) |
| `postgresql-client` (`psql`) | Seed/init step in `ci-dbmate-validate` |
| `kubectl` | Pinned k8s client used by `ci-dbmate-deploy`; version controlled by `KUBECTL_VERSION` build arg |
| `dbmate` | Pinned migrator. `ci-dbmate-validate` runs it directly; `ci-dbmate-deploy` invokes it via the in-cluster Job (image bake = parity); version controlled by `DBMATE_VERSION` build arg |

The image runs as the upstream `runner` user by default. The pod spec sets `runAsUser: 0` and the entrypoint hands control to `/home/runner/run.sh`; a sudoers entry for `root` is baked in so a future cleanup can drop the inline `command:` override on `arc-runner-set`.

### Build args

| Arg | Default | Purpose |
|-----|---------|---------|
| `ACTIONS_RUNNER_VERSION` | `2.335.1` | Upstream `ghcr.io/actions/actions-runner` tag the image is layered onto. Bump to follow upstream minor releases. |
| `KUBECTL_VERSION` | `1.31.0` | Pinned `kubectl` release. SHA verified against `dl.k8s.io/release/v<KUBECTL_VERSION>/bin/linux/amd64/kubectl.sha256` at build. |
| `DBMATE_VERSION` | `2.28.0` | Pinned `dbmate` release. Tracks the in-cluster `ci-dbmate-deploy` Job image for parity. |

### Used by

- `apps/kube/github/runners/manifests/values.yaml` — `template.spec.containers[].image` and `template.spec.initContainers[].image` will flip to `ghcr.io/kbve/arc-runner:<tag>` in a follow-up PR. The first publish of this image happens on the upstream runner image; subsequent rebuilds run on the custom image itself.

### Rollout sequence

This page tracks the image artefact only. The full migration runs across three PRs to keep rollback cheap:

1. **First publish** — `ghcr.io/kbve/arc-runner:0.1.1` via the standard `ci-docker.yml` dispatch path. The `:latest` tag is built locally; CI promotes the `ci-{sha}` build to `:<mdx-version>` at publish time, so the version in [arc-runner.mdx](./arc-runner.mdx) frontmatter is the source of truth — `project.json` does not hardcode it.
2. **Follow-up** — flip both `image:` references in `arc-runner-set` values.yaml and bump the `kbve.com/restart-trigger` annotation.
3. **Follow-up** — strip the `Install git-lfs` step (and any other `apt-get install` band-aids) from `ci-unity.yml` once the new runner pods are confirmed serving jobs.

### Version cadence

- Track upstream `actions/runner` minor releases in `ACTIONS_RUNNER_VERSION`. Patch bumps can ride along on dependabot.
- Every image publish bumps both `version.toml` (rebuild trigger via the dispatch manifest) and the `kbve.com/restart-trigger` annotation in values.yaml (forces a runner pod roll).

## FAQ

**What is the arc-runner image?**
It is a custom Actions Runner Controller image consumed by the `arc-runner-set` scale set in the `arc-runners` namespace. It layers build tooling on top of the upstream `ghcr.io/actions/actions-runner` base so CI jobs do not `apt-get install` the same packages on every cold start.

**Why bake tools into the runner instead of installing them per job?**
Baking removes cold-start `apt-get` calls, stays air-gap-safe under apt mirror outages, and gives a single source of truth so bumping a tool happens once in the Dockerfile instead of in every workflow.

**Which build args control the arc-runner image?**
`ACTIONS_RUNNER_VERSION` pins the upstream runner tag, `KUBECTL_VERSION` pins the `kubectl` release (SHA-verified at build), and `DBMATE_VERSION` pins the `dbmate` migrator to match the in-cluster `ci-dbmate-deploy` Job.

## Related

- [Kilobase](/project/kilobase) — the Postgres image migrated by the `dbmate` tooling baked into this runner.
- [DiscordSH Bot](/project/discordsh-bot) — one of the workflows that runs on the `arc-runner-set` scale set.

---
# Aria2 Proxy — KubeVirt Download Proxy Image

> Alpine-based download proxy image for KubeVirt VM provisioning — bundles aria2 and a python3 HTTP file server with a tini PID 1 reaper.

Source: https://kbve.com/project/aria2-proxy/

## Overview

Purpose-built Alpine image for the KubeVirt download-proxy Deployment in the `angelscript` namespace. Replaces the previous `FROM alpine:3.21 + apk add aria2` pattern that added a 30+ second cold start to every pod restart and made the proxy dependent on upstream mirror availability during CI build stages.

### Why a custom image

The download-proxy sits between the Windows/macOS builder VMs and the public internet. Its job is to pull large artefacts (UE5 ~40 GB, Visual Studio Build Tools ~5 GB, macOS Xcode .xip ~15 GB) with resume + multi-connection support, drop them on a shared PVC, and serve them back to the VM over plain HTTP to avoid Cilium VXLAN masquerade NAT dropping long-lived TCP connections.

A custom image makes that reliable in three ways:

1. **No cold-start `apk add`** — aria2 and python are baked in, so the pod is serving within seconds of scheduling.
2. **Air-gap-safe** — the image's dependencies are pinned via the Alpine release tag; a transient Alpine mirror outage does not block VM provisioning.
3. **Signal handling** — tini runs as PID 1 so kubelet's `SIGTERM` propagates cleanly, stopping in-flight downloads instead of leaving aria2 hanging through the grace period.

### Image layout

| Binary | Purpose |
|--------|---------|
| `aria2c` | Downloader with resume, retry, and multi-connection support |
| `python3` | Serves completed downloads via `python3 -m http.server` |
| `tini` | PID 1 reaper so `SIGTERM` shuts down cleanly |
| `ca-certificates` | TLS trust for HTTPS upstream sources |

Runs as uid/gid `1000` (`appuser`). Workdir is `/downloads`. Ports `6800` (aria2 RPC) and `8080` (file-server HTTP) are exposed; the Deployment's pod network namespace is shared across containers so both bind into the same netns.

### Used by

- `apps/kube/kubevirt/download-proxy/deployment.yaml` — both containers (`aria2` + `file-server`) use this image; the Deployment provides the `command:` per container.

## FAQ

**What is the aria2-proxy image for?**
It is a purpose-built Alpine image for the KubeVirt download-proxy Deployment in
the `angelscript` namespace, pulling large build artefacts (UE5, Visual Studio
Build Tools, Xcode) with resume and multi-connection support and serving them
back to builder VMs over plain HTTP.

**Why use a custom image instead of `apk add aria2`?**
Baking aria2 and python into the image removes a 30-plus second cold-start
`apk add` on every pod restart, makes provisioning air-gap-safe against Alpine
mirror outages, and runs tini as PID 1 so `SIGTERM` propagates cleanly to stop
in-flight downloads.

**What ports and user does aria2-proxy use?**
It runs as uid/gid `1000` (`appuser`) with workdir `/downloads`, exposing port
`6800` for the aria2 RPC and `8080` for the python file server; the Deployment
shares one pod network namespace across both containers.

## Related

- [KBVE Kubectl](/docs/project/kubectl) — kubectl image used across the same KubeVirt jobs.

---
# ARPG Server — Authoritative Grid Game Host on Axum

> ARPG Server is an authoritative grid game host — axum + tokio + simgrid headless Bevy sim on Agones, serving the ARPG isometric action RPG over WebSocket.

Source: https://kbve.com/project/arpg-server/

## Overview

`arpg-server` is the authoritative shared-world host for the **ARPG** (Diablo-style isometric action RPG client under `astro-kbve` arcade). It pairs an `axum` WebSocket router with the `simgrid` headless bevy grid simulation, so movement validation, occupancy, and snapshot framing stay server-owned. Like `cryptothrone-server` it is grid-authoritative — collision is tile occupancy and "physics" is integer grid math — but runs an isolated world (its own seed, registry, and spawn tables) on its own Agones Fleet.

## Key facts

| | |
|---|---|
| **App** | `arpg-server` |
| **Version** | 0.1.22 |
| **Stack** | Rust (axum + tokio + Bevy headless via simgrid) |
| **Deploy** | Agones Fleet (`apps/kube/agones/arpg/manifests/fleet.yaml`) |
| **Image** | `kbve/arpg-server` |
| **Protocol** | simgrid JSON, `PROTOCOL_VERSION` 14 |
| **Default listen** | `0.0.0.0:7979` (`ARPG_SERVER_ADDR`) |
| **Source** | [`apps/agones/arpg/server`](https://github.com/KBVE/kbve/tree/main/apps/agones/arpg/server) |

### Responsibilities

- Terminate the `/ws` WebSocket upgrade and verify the inbound Supabase JWT (dev-accept fallback when the secret is unset).
- Drive the `simgrid` sim tick on a tokio multi-thread runtime, fanning out authoritative snapshots.
- Admit players into roster slots and spawn the procedural world — an open grid seeded with wandering hostiles — shared across the map.
- Run the Agones SDK lifecycle (`Ready` / `Health` / `Shutdown`) so the Fleet can manage the pod; degrades gracefully outside Agones for local dev.

### Relationship to the client

The browser client lives at `apps/agones/arpg/web/src/game/` (the standalone vite app — see [ARPG Web](/project/arpg-web/)) and connects over `PUBLIC_ARPG_GAME_WS` (default `wss://arpg.kbve.com/ws`). Isometric projection is a client-side render transform only; the server keeps everything in orthogonal tile `(x, y)` space and speaks the shared simgrid JSON protocol (`PROTOCOL_VERSION` 14).

### Layout

```
apps/agones/arpg/server/
├── Cargo.toml         # package manifest (path-dep to ../../../../packages/rust/simgrid)
├── Dockerfile         # multi-stage chisel build (cargo-chef + sccache); no webkit stage
├── project.json       # nx build / run / container targets
├── version.toml       # ci-publish version sentinel
└── src/
    ├── main.rs        # tokio entry + Agones lifecycle + graceful shutdown
    ├── agones.rs      # Agones SDK heartbeat
    ├── dungeon.rs     # seeded room-corridor generator (mirrors client systems/dungeon.ts)
    └── game.rs        # ARPG spawn config (player tile, wandering hostiles)
```

## Build

```bash
nx run arpg-server:build-release
```

Or directly:

```bash
cargo build --release -p arpg-server
```

Release binary lands at `dist/target/release/arpg-server`.

## Container

```bash
nx run arpg-server:container
```

Drops `kbve/arpg-server:latest` + version tag. CI uses the `ci` configuration with sccache + registry buildcache (`ghcr.io/kbve/arpg-server:buildcache`) on the shared `ghcr.io/kbve/chisel-ubuntu-axum` base. Default listen `0.0.0.0:7979` (override via `ARPG_SERVER_ADDR`).

## Sim core

Shares the `simgrid` crate (`packages/rust/simgrid`): postcard/JSON wire types, Supabase HS256 auth, axum WS transport, and the bevy headless `build_app` / `run_sim_loop`. The host registers ARPG spawn systems into `simgrid`'s ordered `SimSet` stages; transport and movement stay generic. The dungeon generator is **shared logic** — the server must produce the identical floor set the client's `systems/dungeon.ts` does for a given `DUNGEON_SEED`, so collision agrees on both sides (Mulberry32 PRNG, domain-separated per-chunk seeds, `CHUNK_SIZE=20`). Server is authoritative for occupancy; client predicts.

## Wire protocol

Speaks the shared simgrid JSON protocol (`PROTOCOL_VERSION` 14). The client wire surface (`@kbve/laser` `GameClient`) is complete and the server answers it.

### Client → server

| Frame | Sent when | Server duty |
|-------|-----------|-------------|
| `Join { jwt, kbve_username }` | on socket open | verify JWT (dev-accept fallback), admit to a roster slot, reply `Welcome` |
| `Step { dir }` | float body crosses a tile line | validate one cardinal tile move vs occupancy, advance the player |
| `MoveTo { tile }` | left-click destination | server-side pathfind/route the player toward `tile` (or accept as intent) |
| `Action { id, target }` | attack | resolve combat for action `id` (`ACTION_ATTACK`) against entity `target` |
| `Face { facing }` | aim turn | record 16-dir facing so remote clients render the right pose |
| `Heartbeat`, `Leave` | keepalive / disconnect | liveness + slot release |

### Server → client

| Event | Carries | Client handler |
|-------|---------|----------------|
| `Welcome` | `your_slot`, kind `registry` | seed registry + slot |
| `Snapshot` | players (slot→username), entities (eid, kind, tile, owner, hp, max_hp, **z**) | `applyEntitySync` + `reconcileFloat`, filtered to the local floor |
| `Ephemeral(Combat)` | target eid, dmg, crit | floating damage + flash |
| `Ephemeral(Projectile)` | shooter, origin, dir, kind | spawns the arrow visual from the server, not a local tween |
| `Ephemeral(Floor)` | `{ z, tile }` | local player took a stair — snap to `tile`, switch floor, re-stream dungeon |
| `Ephemeral(Stats / Pickup / ...)` | per-event | follow-up (loot, inventory) |

## Z-floors & stairs

The dungeon has a **z-axis**: each floor is its own endless seeded dungeon (`floor_seed = mix(world_seed, z)`, floor 0 = the ground layout / identity). This is a shared simgrid feature, not ARPG-only — single-floor games (cryptothrone) attach no `Floor` component and behave exactly as before (every entity on z = 0, `z` omitted on the wire).

- **Collision** is z-aware: `WalkableMap::is_walkable_z(z, tile)` / `find_path_z`. A `Floor(i32)` component (default 0) on each entity selects its layer; sim systems read it via `Option<&Floor>`.
- **Stairs** are a generic `Stairs` resource — `Explicit(Vec<StairLink>)` for hand-placed maps or `Dungeon { seed, descend_key }` for the endless ARPG, which derives two seed-driven stairs (down/up) per floor. Stepping a stair tile moves the player to the linked tile on the adjacent floor and emits the `Floor` ephemeral.
- **Locks** gate a stair on a key item: descending is gated on `descend_key` (the player must hold it in inventory); ascending is free. The ground floor seeds a `dungeon-key` near spawn.

Cross-language parity: the Rust `arpg_dungeon` and the client `systems/dungeon.ts` produce byte-identical floors (frozen FNV-1a fingerprint — `3726471204` for seed `0x5eed1`, floor 0, window `(0,0)..(80,80)`), asserted on both sides.

## Client authority

The offline client (`DEBUG_LOCAL_PLAYER`) resolves combat and movement locally; online, authority is the server's. The handoff is in place:

1. **Single position truth** — `applySnapshot` reconciles the server tile into `floatState` via `reconcileFloat`.
2. **Combat over the wire** — `fireBowAt(aim, target?)` sends `action(ACTION_ATTACK, target)` with the real target eid (null = server resolves the aim line); the click-attack no longer double-fires.
3. **Server-driven projectiles** — the arrow visual spawns from the `Projectile` ephemeral; `applyLocalHit` is gated behind `localMode`.
4. **Facing sync** — `client.face(facing)` fires on aim/movement change (cardinal, only on change).
5. **Floor + event subscriptions** — `projectile` and `floor` join `combat`; snapshot entities are filtered to the local floor.

Offline mode keeps the local resolution (gated on `localMode`) so single-player testing works with no server.

## Discord Activity

The game runs as a Discord Activity by reusing the existing web tier — no new app. The game already lives at `kbve.com/arcade/arpg`; the Activity adds a dedicated embed page + a session-exchange backend on `axum-kbve`, and the game WebSocket rides the existing `arpg.kbve.com`.

**Pieces:**

- **Embed page** — `arpg.kbve.com/discord/arpg/` (`index.html` + `arpg.js`, built by `nx run arpg:web-build-discord` from `apps/agones/arpg/web/src/embed/discord.tsx` into the vite app's `dist/discord/arpg/`, served by the arpg nginx). Boots the Discord SDK, runs OAuth, fetches a session, then mounts `ReactIsoArpgApp` with `embedSession` (skips the Supabase gate + name prompt). The whole Activity now lives on the arpg origin alongside the app + art.
- **Session backend** — `axum-kbve` `POST /api/v1/discord/session` (on kbve.com — it holds `DISCORD_CLIENT_SECRET`). Exchanges the OAuth `code` → Discord token → user → linked KBVE profile (fast-registers via GoTrue admin + `tracker.*` RPCs on the shared Supabase DB) → mints the Supabase-valid HS256 JWT the game server accepts. Reached cross-origin from the Activity via the `/arpg-session` mapping. Ported from `axum-cryptothrone`.
- **Game WS** — the existing `wss://arpg.kbve.com/ws`, reached through a portal URL Mapping `/arpg-game → arpg.kbve.com` (`patchUrlMappings`), so the socket is allowed inside the Activity iframe.

**Portal config (Discord Developer Portal → Activities → URL Mappings):**

| Mapping | Target | Purpose |
|---------|--------|---------|
| `/` (root) | `arpg.kbve.com/discord/arpg/` | Activity page + `arpg.js` (same-origin, loaded relatively) |
| `/arpg-game` | `arpg.kbve.com` | game WebSocket (`/ws`, a sibling of the `/discord/arpg/` dir) |
| `/arpg-assets` | `arpg.kbve.com` | game art at `/assets/...` (CORS-enabled); the embed sets the client asset base to `/arpg-assets` |
| `/arpg-session` | `kbve.com` | the axum session backend (cross-origin); the embed fetches `/.proxy/arpg-session/api/v1/discord/session` |

Everything the Activity loads is proxied through `*.discordsays.com`, so each external host (game WS, art, session backend) needs a URL Mapping. The page + `arpg.js` are same-origin under the portal root, so they load relatively.

**Env (axum-kbve):** `DISCORD_CLIENT_ID`, `DISCORD_CLIENT_SECRET`, `SUPABASE_JWT_SECRET` (required); `GOTRUE_INTERNAL_URL` / `SUPABASE_URL` for fast-register; leave `DISCORD_REDIRECT_URI` **unset** (the RPC authorize flow rejects an explicit redirect_uri). **Build (discord):** `PUBLIC_DISCORD_CLIENT_ID` baked in by the `--mode discord` build in `apps/agones/arpg/web/vite.config.ts` (web Dockerfile ARG) — must be set or terser dead-code-eliminates the boot body. Register a Discord Activity application pointing its root at `arpg.kbve.com/discord/arpg/`.

### Status

Alpha — endless seeded multi-floor dungeon (stairs + key-locked descent) with one hostile kind, proving end-to-end multiplayer; Discord Activity embed + session backend in place (point a Discord app at it once the image is baked). World content (npcdb/itemdb, zones, loot tables) is a follow-up.

## FAQ

**What is the ARPG Server?**
ARPG Server is the authoritative shared-world host for KBVE's ARPG, a Diablo-style
isometric action RPG. It pairs an `axum` WebSocket router with the `simgrid`
headless Bevy grid simulation, keeping movement validation, occupancy, and snapshot
framing server-owned.

**How does the ARPG Server stay authoritative?**
The server keeps everything in orthogonal tile `(x, y)` space with integer grid
math; collision is tile occupancy. It validates each move against occupancy, drives
the sim tick on a tokio multi-thread runtime, and fans out authoritative snapshots.
Isometric projection is a client-side render transform only.

**Which wire protocol does the ARPG Server speak?**
It speaks the shared simgrid JSON protocol (`PROTOCOL_VERSION` 14), handling `Join`,
`Step`, `MoveTo`, `Action`, `Face`, `Heartbeat`, and `Leave` frames and emitting
`Welcome`, `Snapshot`, and `Ephemeral` events for combat, projectiles, floor
changes, and stats.

## Related

- [ARPG Web](/docs/project/arpg-web) — the browser client that connects to this server over `/ws`.
- [Cryptothrone Server](/docs/project/cryptothrone-server) — the sibling grid-authoritative host sharing the simgrid crate.

---
# ARPG Web — Standalone Vite Game Client and CDN

> Standalone Vite + React ARPG client served as static files at arpg.kbve.com, the single source of truth feeding the arcade page and Discord Activity embed.

Source: https://kbve.com/project/arpg-web/

## Overview

`arpg-web` is a standalone [Vite](https://vite.dev) + React client for the **ARPG**, served as static files behind nginx. It **is** the single source of truth for the game — the source lives at `apps/agones/arpg/web/src/game/`. The two other play surfaces (the Astro page at `kbve.com/arcade/arpg/` and the Discord Activity embed) consume a built **bundle** emitted from this app rather than the game source, so all three surfaces run one build.

### Why a separate app

Booting the full `astro-kbve` site (Starlight + hundreds of content pages + the proto/content pipeline) just to serve one game page is heavy. This app pulls only what the game needs, so it builds and boots fast, and gives `arpg.kbve.com` a real frontend instead of only the WebSocket endpoint.

### Single source of truth

The game source, embed entries, and sprite art all live under `apps/agones/arpg/web/`. The only cross-repo dependency is `@kbve/laser` (net + phaser helpers), aliased to its package source; the optional r3f layer is stubbed since the game never uses three.js. Three build modes share that one source:

- default (`vite build`) → the standalone app for `arpg.kbve.com` (`dist/`)
- `--mode embed` → `window.ArpgEmbed` IIFE → `dist/arpg-embed.js`, served by `arpg.kbve.com` and loaded cross-origin by `kbve.com/arcade/arpg`
- `--mode discord` → Discord Activity bundle → `dist/discord/arpg/arpg.js` (same arpg origin; the Activity portal proxies its page root to `arpg.kbve.com/discord/arpg/`)

`arpg.kbve.com` is the CDN: it serves the app, the embed bundle (`/arpg-embed.js`), the Discord Activity (`/discord/arpg/`), and the Git-LFS-tracked sprite art (`public/assets/arcade/arpg/`, blobs on `git.kbve.com/KBVE/arpg.git`). The other surfaces load the bundle, Activity page, and art cross-origin from it (nginx sends `Access-Control-Allow-Origin: *` on `/assets/` and `/arpg-embed.js`). Nothing arpg-specific ships into the astro site.

## Build

```bash
nx run arpg:web-build           # app + embed bundle -> dist/ (arpg.kbve.com serves both)
nx run arpg:web-build-embed     # embed bundle only -> dist/arpg-embed.js
nx run arpg:web-build-discord   # Discord bundle -> dist/discord/arpg/arpg.js
```

`web-build` runs `vite build && vite build --mode embed && vite build --mode discord`, so `apps/agones/arpg/web/dist` holds the standalone app (`index.html`), the embed bundle (`arpg-embed.js`), and the Discord Activity bundle (`discord/arpg/arpg.js`). The container bakes all of it behind nginx, so **arpg.kbve.com is the CDN** — `kbve.com/arcade/arpg` loads `arpg.kbve.com/arpg-embed.js` cross-origin (like the art), the Discord Activity loads from `arpg.kbve.com/discord/arpg/`, and nothing arpg-specific is bundled into the astro site.

## Container

```bash
nx run arpg:container-web
```

Multi-stage: a Node stage runs the Vite build with prod endpoints baked in (`PUBLIC_ARPG_GAME_WS=wss://arpg.kbve.com/ws`, `PUBLIC_SUPABASE_URL=https://supabase.kbve.com`), then an `nginx:alpine` stage serves the static `dist` on `:5402` with an SPA fallback. CI publishes `kbve/arpg-web`.

## Auth

The client runs the real Supabase login (`buildNetConfig` → `src/lib/auth.ts`, a web-local Supabase session bridge); the resulting session JWT is verified by `arpg-server` against Supabase GoTrue (shared `jedi` JWT cache). An empty/invalid token is denied — there is no guest path.

## Deploy

`arpg.kbve.com` routes split: `/ws` (and the WebSocket upgrade) → the `arpg-server` game pods on `:7979`; everything else → this static app on `:5402`. See `apps/kube/agones/arpg/manifests/web-deployment.yaml` and `game-httproute.yaml`.

## Testing

Playwright e2e for the whole stack lives in `apps/agones/arpg/arpg-e2e` (Nx project `arpg-e2e`):

```bash
nx run arpg-e2e:e2e          # boots arpg-server + this web app, runs server + web specs
nx run arpg-e2e:e2e:server   # arpg-server only (handshake + live sim)
nx run arpg-e2e:e2e:web      # this app via the Vite dev server (SPA shell, boot)
nx run arpg-e2e:e2e:cdn      # the built nginx image — CORS, embed + Discord bundles
```

- **Server** — signs a Supabase-style HS256 JWT (the server runs in local-secret mode) and drives the JSON wire from Node. Covers the handshake (`Welcome` carries `PROTOCOL_VERSION` 14 + the `player`/`goblin`/`coin`/`dungeon-key` registry; protocol / auth / empty-token / missing-username each emit a `Reject`) **and** the live sim: the admitted player shows up in the snapshot roster, the seeded world spawns goblins, a `Step` input advances the player tile, ticks + `input_ack` progress, a second login under the same username evicts the first (newest-wins), and two distinct players share the world on separate slots.
- **Web** — boots the Vite dev server with the prod Supabase URL injected and asserts the app shell loads, mounts its root, serves the SPA fallback, and boots with no uncaught console error.
- **CDN** (`e2e:cdn`) — runs the built `kbve/arpg-web` nginx image (needs Docker, so it's the container tier like `irc-e2e:e2e:docker`) and asserts the real CDN headers the other surfaces depend on: `Access-Control-Allow-Origin: *` on `/arpg-embed.js` and `/assets/`, the Discord Activity page + bundle under `/discord/arpg/`, and the SPA fallback. Build the image first (`nx run arpg:container-web`).

### Status

Beta — local dev runs the full stack via `nx run arpg:dev`; production `arpg.kbve.com` serves this client once the image is baked and the HTTPRoute split lands.

## FAQ

**What is arpg-web?**
arpg-web is a standalone Vite + React client for the ARPG, served as static files behind nginx at `arpg.kbve.com`. It is the single source of truth for the game, with source under `apps/agones/arpg/web/src/game/`.

**How do the three ARPG play surfaces share one build?**
The Vite source builds three modes — the standalone app for `arpg.kbve.com`, an embed IIFE bundle loaded cross-origin by `kbve.com/arcade/arpg`, and a Discord Activity bundle. `arpg.kbve.com` acts as the CDN that serves all of them plus the Git-LFS sprite art.

**Does arpg-web support guest play?**
No. The client runs a real Supabase login and the resulting session JWT is verified by `arpg-server` against Supabase GoTrue. An empty or invalid token is denied — there is no guest path.

## Related

- [ARPG Server](/docs/project/arpg-server) — the game server this client connects to over `/ws`.
- [ROWS](/docs/project/rows) — the shared Rust game backend used across KBVE games.

---
# Atlas — Autonomous Machine Learning Agent Concepts

> Atlas is the KBVE machine learning agent project and glossary covering autonomous agents, model training, layered neural networks, and ML systems.

Source: https://kbve.com/project/atlas/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';


## Overview

Atlas is the KBVE machine learning agent project and a concept glossary for the
building blocks of autonomous ML systems. It walks through what it means for an
agent to be **autonomous**, how models are **trained**, how **layered** neural
networks are structured, what defines an **agent**, and how the pieces compose
into a full machine learning **system** — from data collection through
deployment and monitoring. Atlas ships as a container image so the project can be
launched locally with a single Docker command.

## Information

<Aside>

To quickly launch the Atlas image, you can use **docker run -d -p 3000:3000 kbve/atlas**

</Aside>

### Autonomous

-   In the context of machine learning agents, `autonomous` refers to the ability of an agent to make decisions, take actions, or perform tasks without explicit instructions from a human. Instead, the agent relies on its training, data inputs, algorithms, and sometimes even its own self-generated strategies to perform its functions. Here are a few key points to understand about autonomous machine learning agents:

-   -   `Learning and Adapting` : Autonomous agents not only operate on their own but also have the capacity to learn from their environment and experiences. This ability to adapt makes them more effective over time.
-   -   `Decision-making` : Autonomous agents make decisions based on their training data, learned experiences, and sometimes rules or guidelines embedded in them. They assess the current situation and take appropriate actions based on patterns they've recognized.
-   -   `No Continuous Human Oversight` : Once deployed, an autonomous agent doesn't need constant human supervision. However, this doesn't mean humans are out of the loop; there might be periodic checks, updates, or interventions, especially if the agent isn't behaving as expected.
-   -   `Self-correction` : Some advanced autonomous agents can recognize when they make an error or when there's a more efficient method to achieve their goal. They can then adapt their strategies accordingly.
-   -   `Goal-oriented` : Typically, autonomous agents have specific tasks or goals. Their autonomy is directed towards achieving these objectives as efficiently and effectively as possible.
-   -   `Interaction with Environment` : In many cases, especially with agents operating in complex environments, there is an element of interaction with the environment. The agent takes in information, processes it, makes decisions, acts, and then receives feedback from the environment, creating a continuous loop.

-   It's essential to note that "autonomy" in machine learning is not absolute. The degree to which an agent is autonomous can vary. Some might only operate within strict boundaries or specific conditions, while others might have broader operational capabilities.

### Training

-   In the context of machine learning, `training` refers to the process by which a machine learning model learns from a set of data to make predictions or decisions without being explicitly programmed to perform the task. Here's a more detailed breakdown:

-   -   `Data` : Training begins with a dataset, which consists of input data and the corresponding correct outputs. This dataset is called the training dataset.
-   -   `Model Architecture` : Depending on the problem at hand, an appropriate machine learning algorithm or model architecture is chosen.
        This could be a linear regression for simple trend predictions, a deep neural network for image recognition, or any other algorithm suitable for the specific task.
-   -   `Learning Algorithm` : The chosen model uses a learning algorithm to adjust its internal parameters.
        This adjustment happens iteratively, where the model makes a prediction using the training data, compares its prediction to the actual output, and then adjusts its parameters to reduce the error.
-   -   `Objective/Cost/Loss Function` : The difference between the model's predictions and the actual output is measured using an objective function, sometimes referred to as a cost or loss function.
        The goal of training is to minimize this function.
-   -   `Iteration` : The learning algorithm typically makes multiple passes over the training data, each time updating the model's parameters to reduce the error.
        The model is said to "converge" when additional training no longer significantly reduces the error.
-   -   `Validation` : While the model is being trained, it's also important to periodically test its performance on a separate dataset (called the validation dataset) to ensure it's not just memorizing the training data (a problem known as overfitting).

-   Once training is complete, the model should have adjusted its parameters such that it can make accurate predictions on new, unseen data.
    This final test, usually on another separate dataset called the test dataset, evaluates the model's true predictive capability.

### Layered

-   "Layer" is related to neural networks, especially deep learning, as the concept of `layer` refers to a collection of nodes operating together at a specific depth within the network.
-   Deep learning models, like convolutional neural networks (CNNs) and recurrent neural networks (RNNs), can have multiple layers, which is why they're often referred to as "deep" networks.

### Agent

-   "Agent" typically refers to any entity that perceives its environment through sensors and acts upon that environment through actuators.
-   The primary goal of an `agent` is to perform actions that maximize some notion of cumulative reward.
-   The `agent` achieves this by learning the best strategy from its experiences, often without being explicitly programmed to perform a specific task.

### Systems

-   `System` typically refers to a combination of algorithms, data, and processes designed to perform a specific task or set of tasks based on data-driven learning.
    Furthermore, a machine learning system can be broken down into several components:

-   -   `Data Collection` : Before training a model, relevant data must be collected. This could be images, text, sensor readings, or any other type of data.
-   -   `Data Preprocessing` : Once data is collected, it often needs to be cleaned, normalized, or transformed in some way to be suitable for training.
-   -   `Model Selection` : Based on the task at hand, a particular algorithm or type of model (e.g., neural network, decision tree, support vector machine) is chosen.
-   -   `Training` : This is the process where the chosen model learns patterns from the training data.
        The model adjusts its internal parameters based on the feedback from a loss function, which indicates how well the model is performing.
-   -   `Validation` : During or post-training, a separate set of data (validation data) is used to tune the model and prevent overfitting.
-   -   `Testing` : Once the model is trained and tuned, its performance is evaluated on a test set, which consists of data it has never seen before.
-   -   `Deployment` : If the model performs satisfactorily on the test set, it can be deployed in a real-world setting, whether it's for predicting stock prices, diagnosing diseases, or any other application.
-   -   `Maintenance and Monitoring` : Once deployed, the performance of the model needs to be continuously monitored. It may require periodic retraining or fine-tuning based on new data or changing conditions.

## FAQ

**What is an autonomous machine learning agent?**
In machine learning, autonomous means an agent can make decisions, take actions,
and perform tasks without explicit human instruction. It relies on its training,
data inputs, and algorithms, learning and adapting from its environment and
self-correcting over time, though autonomy is a spectrum rather than absolute.

**What does training mean in machine learning?**
Training is the process where a model learns from a dataset of inputs and correct
outputs. A learning algorithm iteratively adjusts the model's parameters to
minimize a loss function, with validation on a separate dataset guarding against
overfitting until the model converges.

**How do you run the Atlas image?**
You can launch the Atlas image with `docker run -d -p 3000:3000 kbve/atlas`.

## Related

- [Graph](/docs/project/graph) — related KBVE data and knowledge-graph tooling.
- [Python KBVE](/docs/project/python-kbve) — the Python toolkit behind KBVE ML and automation work.

---
# RentEarth API — itch.io Download Backend

> Rust Axum backend for the RentEarth game — resolves signed itch.io desktop downloads and serves the Vite + TanStack web frontend at the root.

Source: https://kbve.com/project/axum-rentearth/

## Overview

`axum-rentearth` is the Rust [Axum](https://github.com/tokio-rs/axum) backend
for the RentEarth game. It resolves RentEarth desktop downloads from itch.io via
the shared `jedi` itch client and serves the Vite + TanStack single-page web at
`/`. It mirrors `axum-chuckrpg`, sharing the same route shape and itch client.

## Key facts

| | |
|---|---|
| **App** | `axum-rentearth` |
| **Version** | 0.1.1 |
| **Language** | Rust (Axum, askama, tokio) |
| **License** | KBVE |
| **Source** | [`apps/rentearth/axum-rentearth`](https://github.com/KBVE/kbve/tree/main/apps/rentearth/axum-rentearth) |
| **Image** | `kbve/axum-rentearth` |
| **Status** | beta |

## Features

- **Signed itch.io downloads** — `/downloads/{platform}` redirects to the signed
  itch URL for the requested platform via the shared `jedi` itch client.
- **Downloads page** — `/downloads` renders an askama page listing the available
  builds.
- **Live build state API** — `/api/downloads` exposes the current per-platform
  build state that the web frontend consumes.
- **Bundled web** — serves the RentEarth Vite + TanStack SPA at `/`, with an SPA
  fallback so client-routed paths resolve after explicit API and download routes.
- **Health checks** — `/health` and `/api/health` for liveness probes.

## Usage

```
GET /downloads/{platform}   -> 302 redirect to signed itch.io URL
GET /downloads              -> HTML downloads page (askama)
GET /api/downloads          -> JSON per-platform build state
GET /health                 -> liveness
```

## FAQ

**What does axum-rentearth do?**
It resolves RentEarth desktop downloads from itch.io through the shared `jedi`
itch client and serves the RentEarth Vite + TanStack web frontend at the root
path.

**How does a platform download work?**
A request to `/downloads/{platform}` redirects to the signed itch.io URL for
that platform, while `/api/downloads` exposes the live per-platform build state
the web consumes.

**How does it relate to axum-chuckrpg?**
It mirrors `axum-chuckrpg`'s route shape and shares the `jedi` itch client, but
serves the RentEarth game instead of ChuckRPG.

## Related

- [ChuckRPG](/docs/project/chuckrpg) — sibling Axum download backend this service mirrors.

---
# Bevy Battle — Turn-Based Combat Crate

> Bevy turn-based battle crate — damage resolution, effects, class procs, and enemy AI as a pure Rust core plus an optional Bevy ECS plugin.

Source: https://kbve.com/project/bevy-battle-crate/

## Overview

`bevy_battle` is a generic turn-based battle plugin for [Bevy](https://bevyengine.org/) 0.18.
It packages **damage resolution, effects, class procs, and enemy AI** as a pure Rust
core with an **optional Bevy ECS layer**, so the same combat logic can run inside a
full game or inside a headless FFI build. Battles are driven by a **seeded RNG**
for deterministic, reproducible results.

## Key facts

| | |
|---|---|
| **Package** | `bevy_battle` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_battle`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_battle) |
| **Categories** | game-development, game-engines |

## Features

- **Pure Rust core** — types, enums, and combat math in `types.rs` with zero Bevy
  dependency, usable from FFI cdylibs and mobile crates.
- **Optional Bevy ECS plugin** — the `bevy` feature (default) adds `Component` /
  `Event` / `Resource` / `Message` derives, the `BevyBattlePlugin`, snapshot/world
  helpers, and the full combat system pipeline.
- **Deterministic RNG** — `BattleRng` seeds every roll so battles reproduce exactly.
- **Global tuning** — `CombatModifiers` resource adjusts combat behavior in one place.
- **Enemy AI hook** — integrates `bevy_behavior` behavior trees for enemy turn logic.

## Usage

```rust
use bevy::prelude::*;
use bevy_battle::BevyBattlePlugin;

App::new()
    .add_plugins(BevyBattlePlugin)
    .run();
```

Disable the default `bevy` feature (`default-features = false`) to consume only the
pure type surface from FFI or headless crates.

## FAQ

**What does the bevy_battle crate do?**
It provides generic turn-based battle types — damage resolution, effects, class
procs, and enemy AI — as a pure Rust core plus an optional Bevy ECS plugin.

**Can bevy_battle be used without Bevy?**
Yes. The default `bevy` feature adds the `BevyBattlePlugin` and ECS derives, but
disabling default features leaves a plain Rust type surface suitable for FFI
cdylibs and headless serializers.

**Are battles deterministic?**
Yes. A seeded `BattleRng` resource drives combat rolls, so the same seed and
inputs reproduce the same outcome for testing and replay.

## Related

- [Bevy Behavior Crate](/docs/project/bevy-behavior-crate) — behavior-tree engine that powers enemy turn AI.
- [Bevy Skills Crate](/docs/project/bevy-skills-crate) — skill definitions that feed combat.
- [Bevy Player Crate](/docs/project/bevy-player-crate) — character controller for the same engine.

---
# bevy_behavior — Game-Agnostic Behavior Tree Engine for Bevy

> bevy_behavior is a game-agnostic behavior tree engine for Bevy with composable Selector/Sequence nodes, cooldown tracking, and observation traits for NPC AI.

Source: https://kbve.com/project/bevy-behavior-crate/

## Overview

`bevy_behavior` is a game-agnostic behavior tree engine for [Bevy](https://bevyengine.org/).
It provides the core `BehaviorNode` trait, `Selector` / `Sequence` composite
nodes, a tick-based cooldown system, and observation traits that let the same
tree logic drive NPCs across Minecraft, Bevy Isometric, Discord MUD, and Unity
without game-specific coupling. The core is pure Rust; the optional `bevy`
feature adds ECS integration.

## Key facts

| | |
|---|---|
| **Package** | `bevy_behavior` |
| **Version** | 0.1.0 |
| **Language** | Rust (edition 2024, optional Bevy 0.18) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_behavior`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_behavior) |
| **Categories** | game-development, game-engines |

## Features

- **Generic tree** — `BehaviorNode` is generic over an Observation type and an
  Action type, so each game supplies its own snapshot and command enum.
- **Composite nodes** — `Selector` and `Sequence` compose leaves into trees.
- **Cooldown tracking** — `BehaviorContext`, `CooldownState`, and `TickCooldown`
  gate actions by tick, per-NPC and globally.
- **Observation traits** — `Positioned`, `Healthed`, `Aware`, and `Ticked` let
  built-in leaves query an NPC's world without knowing the concrete struct.
- **Zero-dep core** — pure Rust by default; the optional `bevy` feature adds
  `Resource` / `Component` derives for in-ECS evaluation.

## FAQ

**What is the bevy_behavior crate?**
`bevy_behavior` is a game-agnostic behavior tree engine for Bevy. It provides the
core `BehaviorNode` trait, `Selector` and `Sequence` composite nodes, a
tick-based cooldown system, and observation traits so the same tree logic can
drive NPCs across Minecraft, Bevy Isometric, Discord MUD, and Unity.

**How is a behavior tree parameterized?**
The tree is generic over an Observation type (an immutable snapshot the NPC can
see, implementing `Positioned`, `Healthed`, `Aware`, and `Ticked`) and an Action
type (a game-defined command enum). A mutable `BehaviorContext` carries the
current tick and cooldown handles per evaluation.

**Does bevy_behavior require Bevy?**
No. The core crate is pure Rust with zero framework dependency. Enabling the
optional `bevy` feature adds Bevy `Resource` and `Component` derives for in-ECS
tree evaluation.

## Related

- [Isometric](/docs/project/isometric) — the KBVE isometric engine whose NPC AI uses this behavior engine.
- [bevy_quests](/docs/project/bevy-quests-crate) — sibling game-agnostic Bevy crate for quest data.

---
# Bevy Cam — Isometric Camera Crate

> Bevy isometric camera crate with pixel snapping, multiplicative zoom, and a two-stage render-to-texture pipeline for crisp pixel-art rendering.

Source: https://kbve.com/project/bevy-cam-crate/

## Overview

`bevy_cam` is an isometric camera plugin for [Bevy](https://bevyengine.org/) 0.18,
built for the KBVE isometric engine. It renders the 3D world through a
**two-stage render-to-texture pipeline** so pixel art stays crisp at any window
size, follows a target entity with **pixel-grid snapping**, and offers optional
**multiplicative scroll-wheel zoom**.

## Key facts

| | |
|---|---|
| **Package** | `bevy_cam` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_cam`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_cam) |
| **Categories** | game-development, rendering |

## Features

- **Two-stage pixel pipeline** — a scene camera renders the 3D world to a
  low-resolution texture at `pixel_density` pixels per world unit
  (nearest-neighbor), and a display camera upscales it to the window via a
  fullscreen sprite, avoiding a full 3D material pass.
- **Pixel-snapped follow** — the scene camera tracks entities marked
  `CameraFollowTarget`, snapping on all three camera-space axes to kill
  sub-pixel jitter.
- **Multiplicative zoom** *(optional `zoom` feature)* — uniform-feeling zoom
  that scales by a fixed percentage per notch and interpolates smoothly.
- **Display-camera hooks** — the display camera carries a `DisplayCamera`
  marker so games can attach post-processing after startup.

## Usage

```rust
use bevy_cam::{IsometricCameraPlugin, CameraConfig, CameraFollowTarget};

app.add_plugins(IsometricCameraPlugin::new(CameraConfig {
    offset: Vec3::new(15.0, 20.0, 15.0),
    viewport_height: 20.0,
    pixel_density: 32,
    ..default()
}));

// Attach CameraFollowTarget to whatever entity the camera should track:
commands.spawn((Transform::default(), CameraFollowTarget));
```

## FAQ

**What does the bevy_cam crate do?**
It provides an isometric camera plugin for Bevy 0.18 that renders the 3D scene
to a low-resolution texture at a fixed pixel density, then upscales it with
nearest-neighbor sampling for crisp pixel-art output.

**How does the camera follow a target?**
Attach the `CameraFollowTarget` component to any entity. The scene camera tracks
it and snaps to the pixel grid on all three camera-space axes to eliminate
sub-pixel jitter.

**Is scroll-wheel zoom supported?**
Yes, behind the optional `zoom` feature flag. Zoom is multiplicative — each
notch scales by a fixed percentage and interpolates smoothly toward the target —
and is off by default to avoid wasted system dispatch on fixed-camera games.

## Related

- [Bevy Player Crate](/docs/project/bevy-player-crate) — player controller that pairs with the camera follow target.
- [Isometric](/docs/project/isometric) — the KBVE isometric engine this camera powers.

---
# bevy_chat — IRC Chat & Event Bridge Crate

> bevy_chat is a headless async IRC client crate for MUD and game clients, unifying native tokio TCP and WASM WebSocket transports with an optional Bevy plugin.

Source: https://kbve.com/project/bevy-chat-crate/

## Overview

`bevy_chat` is a headless async IRC client and event bridge for MUD and game
clients. It provides a unified `ChatClient` API across native
([tokio](https://tokio.rs/) TCP) and WASM (`web_sys::WebSocket`) targets, with an
optional [Bevy](https://bevyengine.org/) plugin that bridges IRC traffic into ECS
events. It is used by the KBVE Discord bot, the Lightyear server, and the
in-browser isometric game.

## Key facts

| | |
|---|---|
| **Package** | `bevy_chat` |
| **Language** | Rust (edition 2024) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_chat`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_chat) |
| **Categories** | game-development, network-programming |

## Features

- **Dual transport, one API** — native builds use tokio TCP to IRC on port 6667;
  WASM builds use `web_sys::WebSocket` against an IRC-over-WebSocket gateway
  (`wss://chat.kbve.com`). Selected at compile time via `cfg(target_arch)`.
- **Identical public surface** — `ChatClient`, `connect`, `send`, and
  `subscribe` / `drain_incoming` behave the same on both targets.
- **Bevy plugin** *(optional `plugin` feature)* — `ChatPlugin` bridges incoming
  IRC traffic into ECS events for the isometric game.
- **FFI surface** *(optional `ffi` feature, native only)* — a C-FFI layer for
  JNI and `csbindgen` consumers.

## Usage

```rust
use bevy_chat::{ChatClient, IrcConfig};

let cfg = IrcConfig::default();
let client = ChatClient::connect(cfg).await?;
```

## FAQ

**What is the bevy_chat crate?**
bevy_chat is a headless async IRC client that bridges chat and events for MUD and
game clients. It exposes an identical public API across native tokio TCP and WASM
WebSocket targets, with an optional Bevy plugin that forwards IRC traffic into ECS
events.

**How does bevy_chat pick a transport?**
The transport is selected at compile time via `cfg(target_arch)`. Native builds
use tokio TCP to an IRC server on port 6667, while WASM builds use
`web_sys::WebSocket` against an IRC-over-WebSocket gateway such as
`wss://chat.kbve.com`.

**What optional features does bevy_chat offer?**
The `plugin` feature adds a Bevy `ChatPlugin` that bridges IRC traffic into ECS
events, and the `ffi` feature exposes a C-FFI surface for JNI and `csbindgen`
consumers on native targets. The default build is the headless client with
neither pulled in.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera crate for the same engine.
- [uevy skills](/docs/project/bevy-skills-crate) — skill progression crate that shares the Bevy plugin pattern.

---
# bevy_db — Async Key-Value Persistence for Bevy

> bevy_db is a cross-platform async key-value persistence crate for Bevy — redb on native, IndexedDB on WASM, all I/O off the game thread via bevy_tasker.

Source: https://kbve.com/project/bevy-db-crate/

## Overview

`bevy_db` is a cross-platform async key-value persistence crate for
[Bevy](https://bevyengine.org/), built for the KBVE isometric engine. It exposes
one Bevy-facing API backed by two storage engines and keeps every read and write
off the game thread so the schedule never stalls.

- **Native** — `redb`, a pure-Rust B+tree store on disk.
- **WASM** — `rexie` over IndexedDB in the browser.

All I/O is dispatched off the game thread via
[`bevy_tasker`](/project/bevy-tasker-crate/). Game systems poll `DbRequest<T>`
handles with `try_recv()` to drain results without blocking the frame.

## Key facts

| | |
|---|---|
| **Package** | `bevy_db` |
| **Language** | Rust (Bevy) |
| **Native backend** | `redb` (pure-Rust B+tree) |
| **WASM backend** | `rexie` (IndexedDB) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_db`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_db) |

## Features

- **One API, two backends** — the same `Db` handle works on native and WASM; the
  backend is selected at compile time.
- **Off-thread I/O** — all persistence work is dispatched through `bevy_tasker`,
  so game systems never block on disk or IndexedDB.
- **Poll-based results** — pending operations return a `DbRequest<T>` that systems
  drain with `try_recv()`, fitting naturally into a Bevy schedule.
- **Backend-agnostic errors** — a single `DbError` enum abstracts over redb and
  IndexedDB failure modes.

## Usage

```rust
use bevy::prelude::*;
use bevy_db::{BevyDbPlugin, Db, DbRequest};

App::new()
    .add_plugins(BevyDbPlugin::default())
    .run();
```

## FAQ

**What does the bevy_db crate do?**
It provides async key-value persistence for Bevy with a single game-facing API and
two backends — `redb`, a pure-Rust B+tree, on native platforms and `rexie` over
IndexedDB in the browser on WASM.

**How does bevy_db avoid stalling the game loop?**
All disk and IndexedDB I/O runs off the game thread through the `bevy_tasker`
crate. Game systems poll `DbRequest` handles with `try_recv()` to drain results
without blocking the schedule.

**What is the public API surface of bevy_db?**
`BevyDbPlugin` initializes the backend and inserts the `Db` resource, `Db` is the
request handle for `get` / `put` / `delete`, `DbRequest<T>` is the pending async
result polled with `try_recv()`, and `DbError` is the backend-agnostic error enum.

## Related

- [bevy_tasker](/project/bevy-tasker-crate/) — the off-thread task pool that runs all bevy_db I/O.
- [bevy_supa](/project/bevy-supa-crate/) — Supabase-backed persistence for Bevy that complements local key-value storage.

---
# bevy_inventory — Slot-Based Inventory Crate for Bevy

> bevy_inventory is a generic slot-based inventory crate with item stacking, transfer, search, and serde snapshots — pure Rust core, optional Bevy ECS.

Source: https://kbve.com/project/bevy-inventory-crate/

## Overview

`bevy_inventory` is a generic, slot-based inventory crate with item stacking, transfer, search, and serde-driven snapshots. The core is pure Rust; Bevy ECS integration is opt-in behind the `bevy` feature. Unlike inventory crates that ship a fixed item type and a hard Bevy dependency, `bevy_inventory` lets you bring your own item enum and stays usable inside FFI cdylibs and headless consumers.

## Key facts

| | |
|---|---|
| **Package** | `bevy_inventory` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18, edition 2024) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_inventory`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_inventory) |
| **Categories** | game-development, game-engines |

## Features

- **Bring your own item enum** — implement `ItemKind` (with `display_name` and `max_stack`) and the crate handles the rest.
- **Automatic stacking** — items stack up to `ItemKind::max_stack` per slot, splitting across slots as needed within a configurable slot capacity.
- **Slot operations** — `swap_slots`, `remove_at_slot`, and `get_slot` support drag-and-drop UI integration, plus `has_room_for` capacity queries and case-insensitive `search`.
- **Serde all the way** — `Inventory` and `ItemStack` derive `Serialize`/`Deserialize` for save files, network sync, and FFI snapshots (behind the `snapshot` feature).
- **Optional Bevy plugin** — the `bevy` feature adds `InventoryPlugin`, `LootEvent` / `InventoryFullEvent` observers, and `SplitStackAction` / `MergeStackAction` / `MoveSlotAction` UI actions.

## Usage

```rust
use bevy_inventory::{Inventory, ItemKind};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
enum Item { Wood, Stone, Gold }

impl ItemKind for Item {
    fn display_name(&self) -> &'static str {
        match self { Item::Wood => "Wood", Item::Stone => "Stone", Item::Gold => "Gold" }
    }
    fn max_stack(&self) -> u32 {
        match self { Item::Gold => 10, _ => u32::MAX }
    }
}

let mut inv = Inventory::<Item>::new(16);
inv.add(Item::Wood, 50);
inv.add(Item::Gold, 25);
assert_eq!(inv.count(Item::Gold), 25);
```

## FAQ

**What is the bevy_inventory crate?**
`bevy_inventory` is a generic, slot-based inventory crate with item stacking, transfer, search, and serde-driven snapshots. It has a pure Rust core with optional Bevy ECS integration behind a feature flag.

**Does bevy_inventory require Bevy?**
No. The default build works, but the crate can run as plain Rust with zero Bevy dependency when the `bevy` feature is disabled, which suits FFI cdylibs (uniti) and non-Bevy consumers like `discordsh-bot`.

**How do I define custom item types?**
Implement the `ItemKind` trait on your own item enum, providing `display_name` and `max_stack`. Items then stack automatically up to `max_stack` per slot, and every type round-trips through serde for save files and network sync.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera crate from the same Bevy package group.
- [bevy_supa](/project/bevy-supa-crate) — transport-agnostic Supabase client sibling crate.
- [DiscordSH Bot](/project/discordsh-bot) — a non-Bevy consumer that uses this crate for the embed dungeon game.

---
# bevy_items — Proto-Driven Item Registry Crate

> Proto-driven item definitions for Bevy games — compiles itemdb.proto into typed Rust structs with a searchable ItemDb registry.

Source: https://kbve.com/project/bevy-items-crate/

## Overview

`bevy_items` provides proto-driven item definitions for [Bevy](https://bevyengine.org/)
games in the KBVE isometric engine. It compiles the shared `itemdb.proto`
schema into typed Rust structs via `prost` and wraps them in a searchable
`ItemDb` resource, so any game can load the same item registry and query it
consistently.

## Key facts

| | |
|---|---|
| **Package** | `bevy_items` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_items`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_items) |
| **Categories** | game-development, game-engines |

## Features

- **Proto-driven schema** — `itemdb.proto` is the single source of truth; `prost-build` generates the Rust item structs at build time.
- **Searchable `ItemDb` resource** — query items by slug, ULID, type flags, or rarity.
- **JSON loading** — `ItemDb::from_json()` parses `/api/itemdb.json`, handling string-to-enum conversion automatically.
- **Game-agnostic** — the same registry serves Isometric, DiscordSH, and other Bevy games.
- **Optional inventory adapter** — the `inventory` feature wires in `bevy_inventory`.

## Usage

```toml
[dependencies]
bevy_items = { path = "packages/rust/bevy/bevy_items" }
```

The item pipeline flows from `itemdb.proto` through `prost-build` into Rust
structs, while the same proto feeds a Zod schema and human-authored Astro MDX
content served as `/api/itemdb.json`, which `ItemDb::from_json()` loads at
runtime.

## FAQ

**What does the bevy_items crate do?**
It compiles the shared `itemdb.proto` schema into typed Rust structs via `prost`
and wraps them in a searchable `ItemDb` Bevy resource, so any game can load the
same item registry and query it by slug, ULID, type flags, or rarity.

**Where do bevy_items item definitions come from?**
The `itemdb.proto` file is the source of truth. Human-authored content lives in
Astro MDX files at `kbve.com/itemdb`, is served as `/api/itemdb.json` at build
time, and `ItemDb::from_json()` parses that JSON into proto structs with
automatic string-to-enum conversion.

**Is bevy_items tied to a specific game?**
No. It is game-agnostic — Isometric, DiscordSH, and other Bevy games load the
same proto item registry, keeping item data consistent across the KBVE
ecosystem.

## Related

- [Bevy Inventory Crate](/docs/project/bevy-inventory-crate) — inventory layer that pairs with the item registry.
- [KBVE ItemDB](/docs/project/kbveitemdb) — the shared item database and MDX content source.

---
# bevy_kbve_net — Shared Lightyear Multiplayer Protocol Crate

> bevy_kbve_net is a Bevy 0.18 + lightyear 0.26 networking crate defining KBVE's shared multiplayer protocol — replicated components, inputs, and channels.

Source: https://kbve.com/project/bevy-kbve-net-crate/

## Overview

`bevy_kbve_net` is the shared networking crate for KBVE's [Bevy](https://bevyengine.org/)
multiplayer games. It defines the **lightyear protocol** — replicated components,
player input types, message payloads, and channels — that both the client and the
server compile against, so both halves agree on the wire format. It targets Bevy
0.18 and lightyear 0.26.

## Key facts

| | |
|---|---|
| **Package** | `bevy_kbve_net` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18, lightyear 0.26) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_kbve_net`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_kbve_net) |
| **Categories** | game-development, network-programming |

## Features

- **Shared protocol plugin** — `ProtocolPlugin` registers the replicated
  components, inputs, messages, and channels once for both sides.
- **Rich message surface** — position and vitals sync, inventory and equipment
  updates, crafting requests/results, creature capture and state events, skill XP
  grants, and username set flows.
- **lightyear backend** — replication, prediction, interpolation, native input,
  and netcode; the `client` feature adds WebSocket, WebTransport, and UDP
  transports (plus a wasm32 WebSocket path for browser builds).
- **Optional feature set** — `npcdb` pulls creature types from `bevy_npc`,
  `creatures` adds capture/sync systems via `bevy_tasker` and `dashmap`.
- **Worldgen helpers** — deterministic tile hashing and loot rolls
  (`hash2d`, `object_at_tile`, `roll_loot_at`) shared across client and server.

## FAQ

**What does the bevy_kbve_net crate do?**
It defines KBVE's shared lightyear multiplayer protocol for Bevy 0.18 — the
replicated components, player inputs, message types, and channels used by both the
client and the server so both halves speak the same wire format.

**Which networking backend does bevy_kbve_net use?**
It builds on lightyear 0.26 with replication, prediction, interpolation, native
input, and netcode. The optional `client` feature adds WebSocket, WebTransport, and
UDP transports, including a wasm32 WebSocket path for browser builds.

**What optional features does the crate expose?**
The `npcdb` feature pulls creature types from `bevy_npc`, the `creatures` feature
adds capture and sync systems via `bevy_tasker` and `dashmap`, and the `client`
feature enables transport selection and connection lifecycle for the client half.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — the isometric camera crate for the same KBVE Bevy engine.
- [Bevy NPC Crate](/docs/project/bevy-npc-crate) — creature source behind the `npcdb` feature.

---
# bevy_mapdb — Proto-Driven Map Registry Crate for Bevy

> Game-agnostic Bevy crate that compiles mapdb.proto into typed Rust structs and wraps them in a searchable MapDb resource for zones, regions, and world objects.

Source: https://kbve.com/project/bevy-mapdb-crate/

## Overview

`bevy_mapdb` provides proto-driven map definitions for [Bevy](https://bevyengine.org/) 0.18 games in the KBVE isometric engine. It compiles `mapdb.proto` into typed Rust structs via `prost` and wraps them in a searchable `MapDb` resource, so any game can load the same shared map registry and query zones, regions, and world object definitions by slug, ULID, biome, or type.

## Key facts

| | |
|---|---|
| **Package** | `bevy_mapdb` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_mapdb`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_mapdb) |
| **Categories** | game-development, game-engines |

## Features

- **Proto-driven schema** — `mapdb.proto` compiles into typed Rust structs at build time via `prost` / `prost-build`.
- **Searchable registry** — `MapDb` looks up zones, regions, and world object defs by `ProtoMapId`, `ref`, or ULID, and filters zones by biome or type.
- **Multiple load paths** — `MapDb::from_json`, `MapDb::from_bytes` (proto binary), and `MapDb::from_proto` (in-memory `MapRegistry`).
- **Game-agnostic** — `BevyMapDbPlugin` registers an empty `MapDb`; games populate it at startup and insert it as a resource.

## Usage

```rust
use bevy::prelude::*;
use bevy_mapdb::{BevyMapDbPlugin, MapDb};

fn load_maps(mut commands: Commands) {
    let json = include_str!("path/to/mapdb.json");
    let db = MapDb::from_json(json).expect("Failed to parse map JSON");
    commands.insert_resource(db);
}
```

## FAQ

**What does the bevy_mapdb crate do?**
It compiles `mapdb.proto` into typed Rust structs via `prost` and wraps them in a searchable `MapDb` Bevy resource, so any game can query zones, regions, and world object definitions by slug, ULID, biome, or type.

**How do you load map data into bevy_mapdb?**
`MapDb` parses from three sources — `MapDb::from_json` for the mapdb JSON artifact, `MapDb::from_bytes` for a proto binary, and `MapDb::from_proto` for an in-memory `MapRegistry`. Insert the result as a Bevy resource during startup.

**Is bevy_mapdb tied to a specific game?**
No. It is game-agnostic. Any Bevy game can load the same shared proto map registry; `BevyMapDbPlugin` registers an empty `MapDb` that the game populates at startup.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera plugin for the same engine.
- [Isometric](/docs/project/isometric) — the KBVE isometric engine these crates power.

---
# Bevy NPC — Proto-Driven NPC Registry Crate

> Bevy NPC crate that compiles npcdb.proto into typed Rust structs with a searchable NpcDb registry queryable by slug, ULID, type, rarity, or family.

Source: https://kbve.com/project/bevy-npc-crate/

## Overview

`bevy_npc` provides proto-driven NPC definitions for [Bevy](https://bevyengine.org/)
games in the KBVE isometric engine. It compiles the shared `npcdb.proto` into
typed Rust structs via `prost` and wraps them in a searchable `NpcDb` Bevy
resource. The crate is game-agnostic: any title can load the same proto NPC
registry and query it by slug, ULID, type flags, rarity, or creature family.

## Key facts

| | |
|---|---|
| **Package** | `bevy_npc` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_npc`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_npc) |
| **Categories** | game-development, game-engines |

## Features

- **Proto-driven types** — `npcdb.proto` is compiled to typed Rust structs at
  build time with `prost`, keeping the NPC schema in sync across games.
- **Searchable registry** — the `NpcDb` resource is queryable by slug, ULID,
  type flags, rarity, or creature family.
- **Multiple load paths** — hydrate from JSON (`from_json`), a proto binary
  (`from_bytes`), or a decoded proto (`from_proto`).
- **Optional `creature` feature** — adds ECS components for creature pooling,
  capture, and interaction (`CreaturePoolIndex`, `CreatureState`,
  `CapturedCreatures`, `CreatureCaptureEvent`, `CreaturePlugin`).

## Usage

```rust
use bevy::prelude::*;
use bevy_npc::{BevyNpcPlugin, NpcDb};

fn load_npcs(mut commands: Commands) {
    let json = include_str!("path/to/npcdb.json");
    let db = NpcDb::from_json(json).expect("Failed to parse NPC JSON");
    commands.insert_resource(db);
}
```

## FAQ

**What does the bevy_npc crate do?**
It compiles the shared `npcdb.proto` into typed Rust structs via `prost` and
wraps them in a searchable `NpcDb` Bevy resource, so any game can load one proto
NPC registry and query it by slug, ULID, type flags, rarity, or creature family.

**How do you load NPC data into bevy_npc?**
Add `BevyNpcPlugin` to register an empty `NpcDb` resource, then populate it at
startup from JSON with `NpcDb::from_json`, from a proto binary with
`NpcDb::from_bytes`, or from a decoded proto with `NpcDb::from_proto`, and insert
it via commands.

**What is the optional creature feature?**
The `creature` feature enables game-agnostic ECS components for creature pooling,
capture, and interaction — `CreaturePoolIndex`, `CreatureState`,
`CapturedCreatures`, `CreatureCaptureEvent`, and `CreaturePlugin`.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera plugin for the same engine.
- [KBVE NPC Database](/docs/project/kbvenpcdb) — the NPC data source behind the proto registry.

---
# Bevy Pathfinder — Flow Field Crate

> Bevy flow-field pathfinding crate with grid walkability, shared-goal BFS direction fields, and chokepoint detection. Pure Rust core, optional Bevy feature.

Source: https://kbve.com/project/bevy-pathfinder-crate/

## Overview

`bevy_pathfinder` is a grid-based flow-field pathfinding crate for
[Bevy](https://bevyengine.org/) tile worlds. It stacks three layers on a
tile-based map: a walkability grid, BFS-computed direction fields toward one or
more shared goals, and a narrow-passage detector. The core is pure Rust; the
optional `bevy` feature adds ECS integration.

## Key facts

| | |
|---|---|
| **Package** | `bevy_pathfinder` |
| **Version** | 0.1.1 |
| **Language** | Rust (optional Bevy feature) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_pathfinder`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_pathfinder) |
| **Categories** | game-development, pathfinding, ai |

## Features

- **`BlockGrid`** — 2D walkability grid with per-cell height and terrain cost.
- **`FlowField`** — BFS-computed direction vectors pointing every walkable cell
  at one or more goals. Agents share a goal and look up their next move in O(1)
  instead of running per-agent A*.
- **`FlowGate`** — narrow-passage detector, useful for ambush AI, territory
  control, and patrol route generation.
- **Pure-Rust core** — no engine dependency by default; enable the `bevy`
  feature for `Resource` derives and ECS integration.

## FAQ

**What does the bevy_pathfinder crate do?**
It provides grid-based flow-field pathfinding for tile worlds — a walkability
grid, BFS-computed direction fields toward shared goals, and a narrow-passage
(chokepoint) detector.

**Why flow fields instead of per-agent A*?**
When many agents share the same goal, a single BFS builds a direction field once
and every agent looks up its next move in O(1), avoiding a separate A* search
per agent.

**Is Bevy required to use it?**
No. The crate is pure Rust by default; enabling the optional `bevy` feature adds
`Resource` derives for ECS integration.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera crate for the same Bevy engine.
- [Bevy Player Crate](/docs/project/bevy-player-crate) — player controller that consumes movement targets.

---
# Bevy Player — Character Controller Crate

> Bevy kinematic character controller crate with Avian3D physics — gravity, jump, collision-aware movement, direction mapping, and fall-damage events.

Source: https://kbve.com/project/bevy-player-crate/

## Overview

`bevy_player` is a kinematic character controller for [Bevy](https://bevyengine.org/) 0.18,
built on **Avian3D** physics. It handles **gravity, jumping, collision-aware
movement**, input-to-direction mapping, and **fall-damage events**, exposing a
single `PlayerPlugin` configured with a `PlayerConfig` so games get a working
character out of the box.

## Key facts

| | |
|---|---|
| **Package** | `bevy_player` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy 0.18, Avian3D 0.5) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_player`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_player) |
| **Categories** | game-development, simulation |

## Features

- **Avian3D physics** — 3D f32 kinematic body with collision-aware movement.
- **Configurable tuning** — `PlayerConfig` sets speed, gravity, and jump velocity.
- **ECS components** — `Player` and `PlayerPhysics` mark and drive the controller.
- **Direction mapping** — `DirectionMap` converts keyboard input into movement.
- **Fall damage** — `FallDamageEvent` fires on hard landings for the game to react.
- **Spawn helper** — `spawn_player_entity()` spawns a fully configured player.

## Usage

```rust
use bevy::prelude::*;
use bevy_player::{PlayerPlugin, PlayerConfig};

App::new()
    .add_plugins(PlayerPlugin::new(PlayerConfig::default()))
    .run();
```

## FAQ

**What does the bevy_player crate do?**
It is a kinematic character controller for Bevy 0.18 built on Avian3D physics,
providing gravity, jumping, collision-aware movement, and fall damage.

**How do I configure movement speed and jump?**
Pass a `PlayerConfig` to `PlayerPlugin::new` — it tunes speed, gravity, and jump
velocity, and `spawn_player_entity` spawns a fully configured player.

**How is fall damage handled?**
The controller emits a `FallDamageEvent` on hard landings so the game can apply
damage or feedback in its own systems.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera that follows the player.
- [Bevy Battle Crate](/docs/project/bevy-battle-crate) — turn-based combat for the same engine.
- [Bevy Pathfinder Crate](/docs/project/bevy-pathfinder-crate) — navigation for entities.

---
# bevy_quests — Proto-Driven Quest Registry for Bevy Games

> bevy_quests compiles questdb.proto into typed Rust structs and wraps them in a searchable QuestDb Bevy resource queryable by slug, ULID, category, or tags.

Source: https://kbve.com/project/bevy-quests-crate/

## Overview

`bevy_quests` provides proto-driven quest definitions for [Bevy](https://bevyengine.org/)
games. It compiles `questdb.proto` into typed Rust structs via `prost` and wraps
them in a searchable `QuestDb` resource. The crate is game-agnostic — any game
can load the same proto quest registry and query it by slug, ULID, category, or
tags. It backs the KBVE isometric engine's quest data.

## Key facts

| | |
|---|---|
| **Package** | `bevy_quests` |
| **Version** | 0.1.0 |
| **Language** | Rust (edition 2024, Bevy 0.18) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_quests`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_quests) |
| **Categories** | game-development, game-engines |

## Features

- **Proto-driven** — `build.rs` compiles `questdb.proto` into typed Rust structs
  with `prost` and `prost-build`.
- **Searchable registry** — `QuestDb` indexes quests for lookup by slug, ULID,
  category, or tags.
- **Multiple loaders** — populate from Astro JSON (`from_json`), a proto binary
  (`from_bytes`), or decoded proto (`from_proto`).
- **Bevy plugin** — `BevyQuestsPlugin` registers an empty `QuestDb` resource for
  games to fill at startup.

## Usage

```rust
use bevy::prelude::*;
use bevy_quests::{BevyQuestsPlugin, QuestDb};

fn load_quests(mut commands: Commands) {
    let json = include_str!("path/to/questdb.json");
    let db = QuestDb::from_json(json).expect("Failed to parse quest JSON");
    commands.insert_resource(db);
}
```

## FAQ

**What does the bevy_quests crate do?**
`bevy_quests` provides proto-driven quest definitions for Bevy games. It compiles
`questdb.proto` into typed Rust structs via `prost` and wraps them in a
searchable `QuestDb` Bevy resource, so any game can load the same quest registry
and query it by slug, ULID, category, or tags.

**How are quests loaded into a Bevy game?**
Load from Astro JSON with `QuestDb::from_json`, from a proto binary with
`QuestDb::from_bytes`, or from decoded proto with `QuestDb::from_proto`, then
insert the resulting `QuestDb` as a Bevy resource. `BevyQuestsPlugin` registers
an empty `QuestDb` that games populate during startup.

**Is bevy_quests tied to a specific game?**
No. It is game-agnostic. Any game can load the same proto quest registry, since
quest content lives in the shared questdb proto rather than in the crate.

## Related

- [Isometric](/docs/project/isometric) — the KBVE isometric engine that consumes this quest registry.
- [bevy_behavior](/docs/project/bevy-behavior-crate) — sibling game-agnostic Bevy crate for NPC behavior trees.

---
# bevy_skills — Skill Progression Crate for Bevy

> bevy_skills is a Rust skill-progression crate — a pure-Rust core tracking per-entity XP, levels, and skill checks, with an optional Bevy ECS plugin and events.

Source: https://kbve.com/project/bevy-skills-crate/

## Overview

`bevy_skills` is a skill-progression system for [Bevy](https://bevyengine.org/)
games. It tracks per-entity skill XP and levels, fires events on level-up, and
provides skill checks for gating interactions (mining, woodcutting, cooking,
smithing, alchemy, combat, and more). The core is pure Rust with an optional Bevy
ECS integration, so it also serves FFI cdylibs and headless consumers.

## Key facts

| | |
|---|---|
| **Package** | `bevy_skills` |
| **Version** | 0.1.0 |
| **Language** | Rust (edition 2024) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_skills`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_skills) |
| **Categories** | game-development, game-engines |

## Features

- **Skill catalogue** — `SkillRegistry`, `SkillDef`, and `SkillId` register named
  skills with a category and optional icon.
- **Per-entity state** — `SkillProfile` and `SkillEntry` track XP and level per
  entity.
- **Quadratic XP curve** — `XpCurve` is configurable per skill.
- **Message pipeline** *(bevy feature)* — `GrantXpMsg`, `LevelUpMsg`,
  `SkillCheckMsg`, and `SkillCheckResultMsg` drive a publish/subscribe flow.
- **Optional Bevy plugin** — `BevySkillsPlugin` registers resources, messages,
  and systems. The `bevy` feature is on by default and can be disabled so the
  crate compiles with zero Bevy dependency for FFI and headless use.

## Usage

```rust
use bevy::prelude::*;
use bevy_skills::{BevySkillsPlugin, SkillRegistry, SkillDef, GrantXpMsg, LevelUpMsg};

App::new()
    .add_plugins(BevySkillsPlugin)
    .add_systems(Startup, |mut registry: ResMut<SkillRegistry>| {
        registry.register(SkillDef {
            r#ref: "mining".into(),
            name: "Mining".into(),
            xp_curve: None,
            category: "gathering".into(),
            icon: None,
        });
    });
```

## FAQ

**What does the bevy_skills crate do?**
bevy_skills is a skill-progression system for games. It tracks per-entity skill XP
and levels, fires events on level-up, and provides skill checks for gating
interactions such as mining, woodcutting, cooking, smithing, alchemy, and combat.

**Can bevy_skills be used without Bevy?**
Yes. The core is plain Rust with a quadratic `XpCurve`, `SkillRegistry`, and
`SkillProfile` and has zero Bevy dependency. The optional `bevy` feature (on by
default) adds the `BevySkillsPlugin`, Component and Message derives, and the ECS
systems, and can be disabled for FFI cdylibs and headless consumers.

**How does XP progression work in bevy_skills?**
Each skill uses a configurable quadratic `XpCurve`. Sending a `GrantXpMsg` for an
entity and skill adds XP; when a threshold is crossed the crate emits a
`LevelUpMsg`, and `SkillCheckMsg` / `SkillCheckResultMsg` gate interactions by
level.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera crate for the same engine.
- [bevy_chat](/docs/project/bevy-chat-crate) — chat and event bridge crate that shares the optional-Bevy-plugin pattern.

---
# bevy_statemachine — State Snapshot Bridge for Bevy

> bevy_statemachine is a thread-safe state snapshot bridge for Bevy, exposing ECS resources to Tauri IPC, WASM JS, and lightyear via JSON and bincode.

Source: https://kbve.com/project/bevy-statemachine-crate/

## Overview

`bevy_statemachine` is a thread-safe state snapshot bridge for
[Bevy](https://bevyengine.org/). It exposes ECS resources to external consumers —
Tauri IPC, WASM JavaScript, and lightyear networking — so a running game's state
can be read from outside the ECS world without racing the schedule. Snapshots are
available as JSON or bincode.

## Key facts

| | |
|---|---|
| **Package** | `bevy_statemachine` |
| **Version** | 0.1.0 |
| **Language** | Rust (Bevy) |
| **Serialization** | JSON (`serde`, default) + bincode (optional) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_statemachine`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_statemachine) |

## Features

- **Thread-safe snapshot bridge** — exposes ECS state to external threads and
  consumers without blocking the Bevy schedule.
- **Multiple consumers** — designed for Tauri IPC, WASM JavaScript, and lightyear
  networking off the same snapshot.
- **Monotonic versioning** — `snapshot_version::<T>()` returns a monotonic counter
  so consumers can detect fresh state cheaply.
- **Dual serialization** — JSON via `serde_json` (default `serde` feature) and
  compact binary via the optional `bincode` feature.

## Usage

```rust
use bevy::prelude::*;
use bevy_statemachine::{StateSnapshotPlugin, get_snapshot, get_snapshot_json};

fn main() {
    App::new()
        .add_plugins(StateSnapshotPlugin::<MyState>::new())
        .run();
}
```

## FAQ

**What does the bevy_statemachine crate do?**
It is a thread-safe state snapshot bridge for Bevy that exposes ECS resources to
external consumers such as Tauri IPC, WASM JavaScript, and lightyear networking,
with both JSON and bincode serialization.

**How do you read a state snapshot from bevy_statemachine?**
Add `StateSnapshotPlugin` generic over your state type, then call
`get_snapshot::<T>()` for the latest snapshot, `get_snapshot_json::<T>()` for a
JSON string, or `snapshot_version::<T>()` for the monotonic version counter.

**What serialization formats does bevy_statemachine support?**
The default `serde` feature provides JSON serialization via `serde_json`, and the
optional `bincode` feature adds binary serialization for compact transport.

## Related

- [bevy_db](/project/bevy-db-crate/) — cross-platform async persistence for Bevy state.
- [bevy_supa](/project/bevy-supa-crate/) — Supabase-backed state sync for Bevy games.

---
# bevy_supa — Agnostic Supabase PostgREST Client Crate

> bevy_supa is a transport-agnostic Supabase (PostgREST) client crate with native reqwest+rustls HTTP, a WASM fetch stub, and optional Bevy ECS integration.

Source: https://kbve.com/project/bevy-supa-crate/

## Overview

`bevy_supa` is a transport-agnostic Supabase / PostgREST client. The default feature set ships the `native` HTTP transport (`reqwest` + rustls). Bevy integration is opt-in so lean consumers (JNI cdylibs, CLIs) stay slim. It originally lived inside the `kbve` crate as `entity::client::supabase` and was extracted so JNI plugins, CLIs, and Bevy games can share one client without dragging diesel, axum, or tower along.

## Key facts

| | |
|---|---|
| **Package** | `bevy_supa` |
| **Language** | Rust (edition 2024) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_supa`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_supa) |
| **Categories** | game-development, web-programming::http-client |
| **Default transport** | `native` (`reqwest` + rustls) |

## Features

| Feature | Description |
| --- | --- |
| `native` (default) | `reqwest` + rustls native HTTP transport |
| `wasm` | Browser `fetch` transport (stub — not yet implemented) |
| `bevy` | `BevySupaPlugin` + `SupaClient` Bevy `Resource` |

- **Lean by default** — no diesel, no tower, no Bevy in the default feature set; disable default features when only the type surface is needed (build scripts, codegen).
- **One client, two callers** — the same `SupaClient` serves JNI MC plugins (no Bevy) and Bevy games (`Resource`) with no newtype wrapper.
- **Schema-aware RPC** — `rpc_schema` sets `Content-Profile` / `Accept-Profile` headers to reach non-default PostgREST schemas.
- **JWT layering** — `with_jwt` swaps just the `Authorization` header so service-role and per-user JWTs coexist.

## Usage

```rust
use bevy_supa::SupaClient;

let client = SupaClient::from_env()
    .ok_or("SUPABASE_URL + SUPABASE_SERVICE_ROLE_KEY missing")?;

let resp = client
    .rpc_schema(
        "service_verify_link",
        serde_json::json!({ "p_mc_uuid": "0123", "p_code": 123456 }),
        "mc",
    )
    .await?;
```

## FAQ

**What is the bevy_supa crate?**
`bevy_supa` is a transport-agnostic Supabase / PostgREST client. The default feature set ships the native HTTP transport (`reqwest` + rustls), Bevy integration is opt-in, and a WASM browser `fetch` transport is stubbed for later.

**Can bevy_supa be used without Bevy?**
Yes. The same `SupaClient` is used from JNI MC plugins with no Bevy and from Bevy games as a `Resource` when the `bevy` feature is enabled, so lean consumers like JNI cdylibs and CLIs stay slim.

**How does bevy_supa target non-default PostgREST schemas?**
`SupaClient::rpc_schema` sets the `Content-Profile` and `Accept-Profile` headers so PostgREST routes RPC calls to non-default schemas such as `mc` or `tracker`, and `with_jwt` swaps just the `Authorization` header so service-role and per-user JWTs coexist on one client.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — camera crate from the same Bevy package group.
- [bevy_inventory](/project/bevy-inventory-crate) — sibling slot-based inventory crate.
- [Kilobase](/project/kilobase) — the custom Supabase-based Postgres image this client can target.

---
# bevy_tasker — Cross-Platform Async Task Crate

> Cross-platform async task spawning for Bevy — web workers via microtask queue on WASM, thread pool on desktop, one API across targets.

Source: https://kbve.com/project/bevy-tasker-crate/

## Overview

`bevy_tasker` provides cross-platform async task spawning for
[Bevy](https://bevyengine.org/) games. It presents one API — `spawn` and
`spawn_local` — that maps to a desktop thread pool or to WASM web workers /
microtask queue depending on the target, so game code stays identical
everywhere.

## Key facts

| | |
|---|---|
| **Package** | `bevy_tasker` |
| **Version** | 0.1.1 |
| **Language** | Rust (Bevy) |
| **License** | MIT |
| **Source** | [`packages/rust/bevy/bevy_tasker`](https://github.com/KBVE/kbve/tree/main/packages/rust/bevy/bevy_tasker) |
| **Categories** | game-development, asynchronous |

## Features

- **Desktop thread pool** — tasks run on a pool sized to `std::thread::available_parallelism`, wired through crossbeam channels.
- **WASM microtask queue** — without atomics, tasks run via the browser's `queueMicrotask`.
- **WASM web workers** — with atomics, `spawn` dispatches `Send` futures to web workers via a shared work queue.
- **Pinned local tasks** — `spawn_local` pins `!Send` futures to the spawning thread via `Atomics.waitAsync`.
- **Uniform API** — every path returns an `async_task::Task`; `await`, drop to detach, or `.cancel()`.

## Usage

```rust
use bevy_tasker::spawn;

let task = spawn(async {
    42
});
```

## FAQ

**What does the bevy_tasker crate do?**
It provides cross-platform async task spawning for Bevy games. On desktop it
runs tasks on a thread pool sized to available parallelism; on WASM it
dispatches work to the browser microtask queue or web workers, all behind one
API.

**How does bevy_tasker behave on WASM versus desktop?**
On WASM without atomics tasks run via `queueMicrotask`; with atomics, `spawn`
dispatches `Send` futures to web workers via a shared work queue and
`spawn_local` pins `!Send` futures to the spawning thread. On desktop tasks run
on a crossbeam-channel-backed thread pool.

**Is the bevy_tasker API the same across platforms?**
Yes. Every path returns an `async_task::Task`, so calling code is identical
across targets — `await` it, drop it to detach, or `.cancel()` it.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — isometric camera crate in the same Bevy game stack.
- [Bevy KBVE Net Crate](/docs/project/bevy-kbve-net-crate) — networking layer that uses async tasks.

---
# Brackeys Game Jam — KBVE Godot + Rust Idle Space Shooter

> KBVE's Brackeys Game Jam entry — an idle Asteroids-style space shooter built in Godot with Rust (GDExtension) around the theme Nothing Can Go Wrong.

Source: https://kbve.com/project/brackeys/

import {
	Aside,
	Steps,
	Card,
	CardGrid,
	Code,
	FileTree,
} from '@astrojs/starlight/components';
import AdsterraAds from '@/components/kbve/AdsterraAds.astro';

## Overview

This page documents KBVE's entry for the **Brackeys Game Jam 2025.1**, an idle
Asteroids-style space shooter built in [Godot](/application/godot/) with
[Rust](/application/rust/) via GDExtension. The jam theme is **Nothing Can Go
Wrong** — you pilot a lone mining ship, harvest resources from asteroids, and
upgrade your vessel while anomalies keep things interesting. The notes below cover
the design flowchart, gameplay loop, resource system, layers, and asset credits.

## Key facts

| | |
|---|---|
| **Event** | Brackeys Game Jam 2025.1 |
| **Engine** | Godot + Rust (GDExtension) |
| **Genre** | Idle Asteroids-style space shooter |
| **Theme** | Nothing Can Go Wrong |
| **Core loop** | Mine asteroids, earn resources, upgrade the ship |
| **Key assets** | Kenney Space Shooter Redux (CC0), Foozlecc Void Fleet, OpenGameArt audioknobs |

## Barckeys Game Jam 


### 2025.1

This will be KBVE entry to the Barckeys Game Jam!!
For this entry, we will be using [Godot](/application/godot/) with [Rust](/application/rust/)

The main theme for the jam is `Nothing Can Go Wrong`.

The theme for the sister jam, hosted by Wild, is `ERASE` and the wild cards are:

* Mimic - Something is not what it seems.
* Style Shift - Visuals switch between two art styles.
* Shopaholic - include some kind of shopping mechanism.

<AdsterraAds label="Sponsored" />

#### Submission

-   `How does the game fit the theme?`

    Nothing can go wrong when you are piloting the ship! We made a game that is similar to Asteroids but the ship does not automatically get destoried.
    Our goal was to make an idle space game that you can play anytime you want, without having to pay attention or worry about destruction.
    However we did add some challenges and bonuses to the game!
    
-   `What code and assets did you not make from scratch during the jam, if any?`

    Code, we used godot and a couple extension examples, like GDExt.
    As for the assets, we used several from Kenny.nl, OpenGameArt and itch assets, all of which are listed in our game description.
    This includes but not limited to, Auidioknobs from OpenGameArt, Kenny.nl's Space Redux, VOID pack by Foozlecc from Itch, Galaxy Pixel Art by Iftikhar Alam from Vecteezy / IftiStock.com and Pixel Space BG by Norma 2D from Itch.
    


#### Team

Official Team Sign In Sheet! Make a fork and then a pull request with your name and itch.

- [h0lybyte](https://kbve.itch.io/)
- [SummationX](https://summationx.itch.io/)
- Ron?
- Spaceman ?

### FlowChart

Starting the basics of the flow chart, while writing out the rust code.

```mermaid

classDiagram
    direction LR

    class GameManager {
        - UserDataCache user_data_cache
        - Gd<CacheManager> cache_manager
        - Gd<ClockMaster> clock_master
        - Gd<MusicManager> music_manager
        - Gd<Maiky> ui_manager
        + init() GameManager
    }

    
    namespace UserDataManagement {
        class UserDataCache {
            - HashMap<String, Variant> map
        }

        class UserData {
            + String username
            + String email
            + f32 opacity
            + bool fullscreen
            + Option<String> theme
            + new() UserData
        }
    }

    namespace Caching {
        class CacheManager {
            - ResourceCache<Texture2D> texture_cache
            - ResourceCache<CanvasLayer> canvas_layer_cache
            - ResourceCache<Control> ui_cache
            - ResourceCache<AudioStream> audio_cache
            - Gd<ShaderCache> shader_cache
            + init() CacheManager
        }

        class ResourceCache~T~ {
            - HashMap<String, Gd<T>> map
        }

        class ShaderCache
    }

    class ClockMaster
    class MusicManager
    class Maiky

    GameManager --> UserDataCache
    GameManager --> CacheManager
    GameManager --> ClockMaster
    GameManager --> MusicManager
    GameManager --> Maiky

    UserDataCache --> UserData : manages
    CacheManager --> ResourceCache : manages
    CacheManager --> ShaderCache : contains

    Spacer --|> GameManager : separates


```

### GameDocs

Game description
You wake up in a miner spaceship, and everybody is gone. And worse of it all, sparks appear in different 
parts of the ship, concluding that the space ship already undergoes different hardship and you hope that nothing goes wrong.

### UIUX
An analog spaceship UI could have scratched metal textures, 
dimly glowing buttons, slightly flickering holographic elements, and a worn-down control panel vibe.
crt display?
inspired by spaceteam

### Gameplay Loop
- Mine asteroids and harvest scraps across the space to earn money. 
- Fix and upgrade you ship.
- You will encounter various anomly that can be good or bad for you.

### Assets

#### Space Shooter Redux
The spaceship asset pack that we will be using is from [Kenny Space Shooter Redux](https://kenney.nl/assets/space-shooter-redux), released as a CC0.
There are two folders, `_space-shooter-redux` and `space-shooter-redux`, all of the assets from the pack are under the `_space-shooter-redux` and objects that we will use will be copied over to `space-shooter-redux`.
Without having to dump a bunch of assets, I will try to use as many as needed and then going to delete the `_space-shooter-redux` folder.

#### auidioknobs
This asset will be used as UI panel that players will interact with in the world. [auidioknobs](https://opengameart.org/node/7969), released as CC-BY-3.0.
Credited to ville.seppanen@gmail.com

#### Galaxy Pixel Art

The first three objects for the universe layer were made by Iftikhar Alam from Vecteezy / IftiStock.com.

#### Pixel Space Background

The main background of the `timespace` layer comes from the [Space Backgorund Pixel Art Pack](https://norma-2d.itch.io/space-backgrounds-pack).

#### Void Fleet Pack

The spaceship will come from the [Void Fleet Pack 3](https://foozlecc.itch.io/void-fleet-pack-3) , which is released as a CC0 license.
Then there is the [Void Fleet Pack 1](https://foozlecc.itch.io/void-fleet-pack-1), that we will be using for the main ship.

#### Pixel Art Sci Fi Spaceships

This is the spaceship asset pack from FrostWindz, [Pixel Art Sci Fi Spacepack](https://frostwindz.itch.io/pixel-art-sci-fi-spaceships).

### Layers

These are the layers that I am thinking we will be operating in:

```

2d_physics/layer_1="timespace"
2d_physics/layer_2="universe"
2d_physics/layer_3="galaxy"
2d_physics/layer_4="environment"
2d_physics/layer_5="planet"
2d_physics/layer_6="spaceship"
2d_physics/layer_7="npc"
2d_physics/layer_8="entity"
2d_physics/layer_9="projectile"

```

The first three layers, `timespace`, `universe` and `galaxy` will act as the background layers and the `environment` will be the first delta-time layer from the client-side point of view.
Using the layer 1 through 3, we can create a parallax style simulation of space.
The actual ship that the player controls will inherit the layer 6 aka `spaceship`.
Finally we would split the `npc` and `entity` layer because we might want the `npc` to have additional abilities, like a star path finding.


<Steps>

1.  Timespace
    - Tracks the time without a reference to frames.

2.  Universe
    - Client-side background

3.  Galaxy
    - Sub-background with the purpose of creating a parallax effect.

4.  Environment
    - Tracks the delta-time, with a reference to the client's frame.

5.  Planet
    - This layer will include spacestations and presents an entity that has true collision.
    - Players will be to enter the planet, which can open up minigames or special UI screens.

    The first planet that we will be adding is an Earth-like one, located at X: 0, Y: 0!
    This planet will serve as the base shop for upgrading your ship.

6.  Spaceship
    - The actual layermask for the player.

7.  NPC
    - Layermask for pirates or friendly ships.

8.  Entity
    - Layermask for objects that can be mined, cause damage and/or hold any interaction.

9.  Projectile
    - Ammo shells and lasers, used to raycast hits as well.

</Steps>

### Global Resources

The idea behind this singleton is to hold the spaceship stats and resources, including the gold, metal, stone, ect...
I went ahead and designed it to be modular, so we can add any resource we want without having to go crazy trying to refactor it in.

Current List of Resources:

```json
{
	"gold": 0,
	"stone": 0,
	"metal": 0,
	"gems": 0
}
```

<Steps>

1.  Gold
    - This is the main currency of the game.

2.  Stone
    - A resource for building objects within the ship.

3.  Metal
    - A limited resource for building upgrades for the ship.

4.  Gems
    - A rare resource for special upgrades.

</Steps>

#### Entity

```
Asteroid
Meteor
Comet

```

<Steps>

1.  Asteroid
    -   Large entity that spawns meteors upon destruction.
    -   Drops stone resources.
    -   Poolable Entity, can be expanded from the spaceport upgrade.

2.  Meteor
    -   Medium entity that gets created after an asteroid is hit by laser.
    -   Drops metal resources.
    -   Moves slowly but despawns after leaving the scene.
    -   Poolable Entity, increase from 1-3 drop to 5+ as an upgrade from the spaceport.

3.  Comet
    -   Small entity that has a chance to spawn after a meteor is hit by a laser.
    -   Rare drops like gold and gems but always drops metal.
    -   Moves quickly and despawns after leaving the scene.
    -   Poolable Entity, but limited to only max of 5 that drop on the screen, % of drop increases via upgrades from the spaceport.


</Steps>

#### Resource Examples

```

Global.earn_resource("gold", 100, "Mission Reward: Killing Fudster") 
Global.earn_resource("stone", 50, "Mining Bonus")  

```

For using the resources, it would be like this:

```

if Global.spend_resource("gold", 50, "Bought Shield Upgrade"):
    print("Purchase successful!")
else:
    print("Not enough gold!")

```

Then on the UI, we can listen to the signals and make changes.

```

func _ready():
    Global.connect("resource_changed", _on_resource_updated)
    Global.connect("resource_receipt", _on_resource_receipt)

func _on_resource_updated(resource_name, new_value):
    print(resource_name + " updated: " + str(new_value))

func _on_resource_receipt(resource_name, amount, new_value, invoice):
    print("Transaction: ", invoice, " Resource: ", resource_name, " Amount: ", amount, " New Balance: ", new_value)

```

#### Drop Rate

The default drop rate of resources like stone will be 3 to 15, then we can use the space port to transfer the stone into metal.
Furthermore, we could add special asteroids that spawn into the game with bonus resources like gold, gems and metals. 

When an asteroid is hit initially, it should break into smaller ones that will include the chance to spawn a rare comet.


### Weapons

The first weapon that we will introduce is the laser for the spaceship, later on we will include a couple more guns, maybe a machine gun type weapon.
Majority of the laser's logic will be stored under `/scripts/laser.gd` and we will not implement any sort of pooling for it yet, that might be something that I will look into later on.


### Heat

Heat management is vital when piloting the ship because once the player goes over the heat, the ship should stop moving.
The movement of the engines and the lasers would stop, thus it acts like an anti-spam.
As for the heat release, we will have a couple keys to help the exhausting of the said heat, but we can go further into that before finishing up the game.

### Earth

The Earth planet will be on layer 5 with collision mask being for layer 6 aka the spaceship.
Once the player is within the collision circle of the planet, a display will come up that says "Press X to Interact with the Planet!".
After the player presses the X, it should open up the shop UI and let the player purchase upgrades.

## FAQ

**What is KBVE's Brackeys Game Jam entry?**
It is KBVE's submission to Brackeys Game Jam 2025.1, built in Godot with Rust via
GDExtension. The game is an idle Asteroids-style space shooter where you pilot a
mining ship, harvest scraps from asteroids, and upgrade your ship — themed around
Nothing Can Go Wrong.

**What is the game's theme and premise?**
The jam theme is Nothing Can Go Wrong. You wake alone on a mining spaceship as
sparks appear across the ship, and you hope nothing goes wrong while piloting it.
The ship is not automatically destroyed, so it plays as a low-pressure idle space
game with optional challenges and bonuses.

**Which engine and assets does the entry use?**
The game uses Godot with Rust (GDExtension) and third-party assets including Kenney
Space Shooter Redux (CC0), audioknobs from OpenGameArt (CC-BY-3.0), Foozlecc Void
Fleet packs, Galaxy Pixel Art, and Norma 2D's Pixel Space background.

## Related

- [Godot](/application/godot/) — the engine powering this jam entry.
- [Rust](/application/rust/) — the language used via GDExtension for the game logic.

---
# Charles — KBVE Internal Machine Learning GPU Cluster

> Charles is KBVE's internal machine-learning build — a multi-GPU deep-learning workstation with NVIDIA RTX 4090 cards and DDR5 memory on Proxmox.

Source: https://kbve.com/project/charles/

## Overview

Charles is KBVE's internal machine-learning build and project: a multi-GPU deep-learning workstation intended to cluster NVIDIA RTX 4090 cards for training and serving models. This page captures the hardware notes and software stack behind the build.

## Key facts

| | |
|---|---|
| **Name** | `charles` |
| **Role** | Internal machine-learning build/project |
| **GPU** | NVIDIA RTX 4090 (MSI Suprim Liquid X) |
| **RAM** | DDR5, 32GB up to 256GB+ per node |
| **Virtualization** | Proxmox |
| **Orchestration** | Docker + Kubernetes |

## Information

Picture a symphony of GPUs, each singing in computational harmony within a single machine.
This ensemble isn't just for show; it's tailored for the demanding concertos of machine learning.
In this digital orchestra, every GPU strikes a note, turning data into artful insights!

## Hardware

These are the hardware notes for `charles`, our internal machine learning build/project.

### GPU

NVIDIA RTX 4090 - The 4090 series has a couple different variants on the market, but since we want to cluster them together, it might make more sense to look at liquid cooled instances.

The 4090 that we are using right now is the Suprim LiquidX from MSI.

### RAM

While the required RAM for constructing a GPU cluster for deep learning varies based on specific use-cases and requirements, we'll outline key considerations to guide your decision-making process.

The RAM sticks we are using are DDR5.

### Dataset Size

When preprocessing and loading large datasets into main memory, a substantial amount of RAM is crucial for fast access, as it's quicker than persistent storage.
Standard memory configurations may fall short for extensive datasets.
Therefore, 128GB, 256GB, or even more RAM could be essential, especially with on-the-fly data augmentation or transformation.

### Concurrent Tasks

Running concurrent tasks like data preprocessing, serving models, or multiple training jobs on one machine demands ample RAM.
Sufficient memory ensures efficient multitasking and optimal performance during simultaneous operations.

### GPU-System Communication

Adequate system RAM is essential to prevent bottlenecks when data is transferred between the CPU and GPU.
Remember that while GPU memory (VRAM) is crucial for model training, the system RAM plays a role in staging and preparing data.

### Software Overhead

Running the operating system, deep learning frameworks, databases, and other necessary software tools will also consume RAM.

### Scaling Strategy

If your cluster, managed through solutions like Docker and Kubernetes, is designed to distribute tasks across multiple nodes, each node might not require a vast amount of RAM.
Instead, RAM can be allocated according to the specific role and demand of each node, enhancing your scaling strategy.

### RAM CONFIG

-   Entry-Level Configuration: At least 32GB to 64GB of RAM per node.
-   Mid-Range Configuration: Between 64GB to 128GB of RAM per node.
-   High-End Configuration: 256GB or more per node, especially if you're working with vast datasets or complex multi-stage workflows.

Remember to always tailor your cluster's configuration to your specific needs.
Monitoring tools can help gauge memory usage in real-time and assist in making informed decisions about future upgrades.

---

## Software

### Proxmox

The setup for the Charles will be in our [Proxmox Applications page](/application/proxmox/).

### ML

This section will be for the machine learning and ai eco-system + notes.

### Gaming

This section will be for our gaming section.

## FAQ

**What is Charles?**
Charles is KBVE's internal machine-learning build and project — a multi-GPU deep-learning workstation designed to cluster NVIDIA RTX 4090 cards for training and serving machine-learning models.

**What GPUs and memory does Charles use?**
Charles runs NVIDIA RTX 4090 GPUs (currently the MSI Suprim Liquid X, chosen for liquid cooling to enable clustering) with DDR5 RAM, scaling from 32-64GB entry-level up to 256GB or more per node for large datasets.

**How is Charles managed?**
Charles is set up through KBVE's Proxmox environment, with Docker and Kubernetes used to distribute deep-learning workloads across nodes so RAM can be allocated per node role.

## Related

- [LofiFocus](/docs/project/lofifocus) — a KBVE AI project that trains and serves generative audio models.

---
# Chisel Ubuntu Axum — Minimal Runtime Base Image

> Shared chiseled Ubuntu 24.04 runtime base image for all KBVE Axum services, bundling jemalloc, libpq5, and CA certificates in a scratch-based image.

Source: https://kbve.com/project/chisel/

## Chisel Ubuntu Axum

Shared chiseled Ubuntu 24.04 runtime base image for all KBVE Axum services.

### What is Chisel?

[Chisel](https://github.com/canonical/chisel) is a tool from Canonical that slices Ubuntu packages into minimal filesystem layers. Instead of a full Ubuntu image (~80MB+), chisel extracts only the exact files needed — resulting in a scratch-based image with just the runtime libraries.

### Contents

- **Chiseled Ubuntu 24.04 rootfs** — minimal, no shell, no package manager
- **jemalloc** — memory allocator pre-configured via `LD_PRELOAD`
- **libpq5** — PostgreSQL client library
- **CA certificates** — for HTTPS/TLS connections
- **Non-root user** — `appuser:10001`

### Usage

Service Dockerfiles reference this as their runtime base:

```dockerfile
FROM ghcr.io/kbve/chisel-ubuntu-axum:24.04 AS runtime

COPY --from=builder --chown=10001:10001 /app/target/release/my-service /app/my-service

EXPOSE 4321
USER 10001:10001
ENTRYPOINT ["/app/my-service"]
```

This eliminates ~3 Docker stages (chisel + jemalloc + libpq) from each service Dockerfile, saving build time and disk space in CI.

### Services

| Service | Status |
|---|---|
| `axum-discordsh` | planned |
| `axum-kbve` | planned |
| `axum-memes` | planned |
| `axum-herbmail` | planned |
| `axum-chuckrpg` | planned |
| `axum-cryptothrone` | planned |

## FAQ

**What is the chisel-ubuntu-axum base image?**
It is a shared chiseled Ubuntu 24.04 runtime base image for all KBVE Axum
services, built with Canonical's chisel so it contains only the runtime
libraries — jemalloc, libpq5, and CA certificates — on a scratch-based,
shell-less rootfs.

**Why use a chiseled image instead of full Ubuntu?**
Chisel slices Ubuntu packages into minimal filesystem layers, extracting only
the exact files needed. This yields a much smaller image than the ~80MB+ full
Ubuntu base and removes the shell and package manager, shrinking the attack
surface.

**How does it simplify service Dockerfiles?**
Services reference it as their runtime base with `FROM
ghcr.io/kbve/chisel-ubuntu-axum`, which eliminates about three build stages
(chisel, jemalloc, libpq) per service and saves build time and disk space in CI.

## Related

- [API](/docs/project/api) — Axum service that runs on this runtime base.
- [Herbmail](/docs/project/herbmail) — another KBVE Axum service targeting this image.

---
# ChuckRPG — Open World RPG Backend API

> Rust Axum backend for ChuckRPG, an Unreal open-world multiplayer RPG — serves the website, game API, and signed itch.io desktop downloads.

Source: https://kbve.com/project/chuckrpg/

## Overview

ChuckRPG is an open-world multiplayer RPG powered by Unreal Engine with OWS
(Open World Server) as its game backend. This project page tracks
`axum-chuckrpg` — the Rust [Axum](https://github.com/tokio-rs/axum) backend that
serves the ChuckRPG website, game API, and signed itch.io desktop downloads via
the shared `jedi` itch client.

## Key facts

| | |
|---|---|
| **App** | `axum-chuckrpg` |
| **Version** | 0.1.9 |
| **Language** | Rust (Axum, askama, tokio) |
| **License** | KBVE |
| **Source** | [`apps/chuckrpg/axum-chuckrpg`](https://github.com/KBVE/kbve/tree/main/apps/chuckrpg/axum-chuckrpg) |
| **Image** | `kbve/chuckrpg` |
| **Status** | beta |

## Features

- **Website + game API** — serves the ChuckRPG web frontend and backend API.
- **Signed itch.io downloads** — `/downloads/{platform}` redirects to the signed
  itch URL for the requested platform via the shared `jedi` itch client.
- **Downloads page** — `/downloads` renders an askama page of available builds.
- **Live build state API** — `/api/downloads` returns the current per-platform
  build state.
- **Health checks** — `/health` and `/api/health` for liveness probes.

## Usage

```
GET /downloads/{platform}   -> 302 redirect to signed itch.io URL
GET /downloads              -> HTML downloads page (askama)
GET /api/downloads          -> JSON per-platform build state
GET /health                 -> liveness
```

## FAQ

**What is ChuckRPG?**
ChuckRPG is an open-world multiplayer RPG powered by Unreal Engine with OWS
(Open World Server) as its game backend.

**What does the axum-chuckrpg service do?**
It is the Rust Axum API service that serves the ChuckRPG website, game API, and
resolves signed itch.io desktop downloads via the shared `jedi` itch client.

**How do desktop downloads work?**
A request to `/downloads/{platform}` redirects to the signed itch.io URL, while
`/api/downloads` exposes the live per-platform build state the web consumes.

## Related

- [RentEarth API](/docs/project/axum-rentearth) — sibling Axum download backend with the same route shape.

---
# CityVote — Deckbuilder Civ Strategy Game

> CityVote is a KBVE game concept blending Civ-style empire building with Balatro-like deckbuilding — card suits drive Gold, Food, Labor, and Faith resources.

Source: https://kbve.com/project/cityvote/

## Overview

CityVote is a KBVE game concept blending **Civilization-style empire building** with
a **Balatro-inspired deckbuilder**. Card suits map to four core resources — Gold,
Food, Labor, and Faith — that feed one another in an economic loop. The design
keeps a **turn-based** economy and combat system while layering in some
**real-time** movement, using turn state to interpolate the real-time play.

## Key facts

| | |
|---|---|
| **Project** | CityVote |
| **Type** | Deckbuilder civ strategy game (design) |
| **Inspiration** | Civilization 1/2, Balatro |
| **Resources** | Gold, Food, Labor, Faith |
| **Status** | Concept / design notes |

## Features

- **Deckbuilder core** — card suits produce and consume empire resources.
- **Four-resource economy** — Diamonds (Gold), Hearts (Food), Spades (Labor), Clubs (Faith).
- **Economic loop** — each resource funds the production of the next.
- **Hybrid pacing** — turn-based system with a real-time movement and combat layer.

## Information

The CityVote game will be a mixture of Civ 1+2 and the Balatro, maybe I should say its a deckbuilder civ game, with a solid automated turn based combat system.
Yet I thought it be interesting to keep game a bit more realtime, with some actual movement and combat happening but also keep a turn based system!
This will be used to help with the interpolation for the realtime.


## Resources

### Gold

-   The economic engine of the whole empire, this will be fundamental for the expansion, we could get a bit more diplomatic with how the gold will work out.

### Food

-   Supply for new units and population happiness.

### Labor

-   Production and the ease of new equipment.

### Faith

-   The religion and reputation of the empire throughout the realm.

### Card Mechanics

| Suit       | Resource        | Function       | Example producers  | Example consumers      |
| ---------- | --------------- | -------------- | ------------------ | ---------------------- |
| ♢ Diamonds | Gold/Wealth     | Economy        | Mine, trade post   | Construction, upgrades |
| ♥ Hearts   | Food/Vitality   | Growth/upkeep  | Farm, mill         | Units, healing         |
| ♠ Spades   | Labor/Force     | Work/Combat    | Workshop, barracks | Crafting, attacks      |
| ♣ Clubs    | Knowledge/Faith | Research/Magic | Library, shrine    | Spells, tech tree      |

### Economic Square

-   Diamonds → fund growth (buy farms/labs)
-   Hearts → sustain population that generates Spades (labor)
-   Spades → construct buildings that produce Clubs (knowledge)
-   Clubs → unlock techs that multiply Diamond output




---

### AI - 2024


**Rewrite** This information is from Bard and Google.

Cities are complex systems that generate a vast amount of data. 
This data can be used to improve the efficiency and effectiveness of city services, make better decisions about urban planning, and improve the quality of life for citizens.

City data mining is the process of extracting knowledge from this data.
It can be used to identify patterns, trends, and relationships that would not be visible to the naked eye. This knowledge can then be used to improve the way cities operate.

City information software is a type of software that is used to collect, store, and analyze city data. It can help cities to manage their data more effectively and to make better use of it.

There are many different types of city information software available. Some of the most common types include:

- **Geographic information systems (GIS)**: GIS software is used to store and visualize spatial data. It can be used to create maps, analyze land use, and track changes to the environment.
- **Sensor networks:** Sensor networks are made up of a large number of sensors that collect data about the environment. This data can be used to monitor things like traffic, air quality, and water levels.
- **Big data analytics:** Big data analytics software is used to analyze large datasets. This software can be used to identify patterns and trends that would not be visible to the naked eye.

City data mining and city information software are powerful tools that can be used to improve the way cities operate. By using these tools, cities can make better decisions about urban planning, improve the efficiency and effectiveness of city services, and improve the quality of life for citizens.

Here are some examples of how city data mining and city information software are being used to improve cities:

-   **Traffic management:** City data mining is being used to improve traffic management. By analyzing data from traffic sensors, cities can identify congested areas and make changes to traffic signals to improve flow.
-   **Public safety:** City data mining is being used to improve public safety. By analyzing data from crime reports, cities can identify crime hotspots and deploy resources more effectively.
-   **Waste management:** City data mining is being used to improve waste management. By analyzing data from trash cans, cities can identify areas where waste is accumulating and make changes to collection schedules.
-   **Public transportation:** City data mining is being used to improve public transportation. By analyzing data from ridership, cities can identify areas where service is needed and make changes to routes or schedules.

These are just a few examples of how city data mining and city information software are being used to improve cities. As these technologies continue to develop, we can expect to see even more innovative ways to use them to make our cities better places to live.



## Notes

The notes for cityvote.com are still a bit out-dated, but I will get back to updating them soon!

## FAQ

**What is CityVote?**
CityVote is a KBVE game concept that mixes Civilization-style empire building with
a Balatro-inspired deckbuilder, using card suits to drive four core resources.

**What resources does CityVote use?**
Four resources — Gold, Food, Labor, and Faith — mapped to Diamonds, Hearts,
Spades, and Clubs, forming an economic loop where each resource feeds the next.

**Is CityVote turn-based or real-time?**
Both. The design keeps a turn-based combat and economy system while adding some
real-time movement and combat, with turn-based state used to interpolate the
real-time layer.

## Related

- [Unreal Rareicon](/docs/project/unreal-rareicon) — another KBVE strategy game project.
- [KBVEGameplay](/docs/project/kbvegameplay) — shared gameplay effect framework.

## REF

References for the cityvote project have to be updated as well.

---
# CryptoThrone.com — King of the Hill Strategy Game

> CryptoThrone.com is a King of the Hill strategy game where you defend the throne against waves of NPCs, build your settlement, and battle other players.

Source: https://kbve.com/project/cryptothrone/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';


## CryptoThrone

We do not want to disclose too much information on the plot of the game, but we do have a gambit or two or a few.
When there are updates to fix around the core.


<Adsense />


### Roadmap

The core of the roadmap is broken into 10 phases that have 10 bullet points in them.
These 100 total bullet points give us a rough concept to build and foreplay around the game, the engine and the initial hurdles that we will face.

#### Phase 1: Concept and Planning

In this phase, the core idea of CryptoThrone.com is defined, market research is conducted, the target audience is identified, and the project timeline is created.
A development team is assembled, and initial documents for game design and marketing strategy are drafted.
Budget and funding plans, along with legal considerations, are also established.

<Steps>

1. **Define Core Concept**
2. **Market Research**
3. **Identify Target Audience**
4. **Create Project Timeline**
5. **Assemble Development Team**
6. **Develop Initial Game Design Document**
7. **Create Initial Art Style Guide**
8. **Draft Initial Marketing Strategy**
9. **Set Budget and Funding Plan**
10. **Legal Considerations and IP Protection**

</Steps>

#### Phase 2: Branding and Design

This phase focuses on creating the visual identity of CryptoThrone.com.
It includes designing the logo, developing brand guidelines, creating concept art, designing the UI/UX, and developing website mockups.
Branding materials and promotional video concepts are also created.

<Steps>

11. **Design Logo**
12. **Develop Brand Guidelines**
13. **Create Color Palette**
14. **Design Typography**
15. **Create Concept Art for Key Characters**
16. **Design Initial UI/UX Wireframes**
17. **Create Initial Website Mockups**
18. **Design Social Media Graphics**
19. **Develop Branding Materials (Business Cards, Banners, etc.)**
20. **Create Promotional Video Concepts**

</Steps>

#### Phase 3: Technical Setup

The technical foundation for the game is established in this phase.
This includes choosing the game engine, setting up the development environment, creating the initial game repository, setting up project management tools, and developing initial API specifications.
Security protocols and cloud infrastructure are also implemented.

<Steps>

21. **Choose Game Engine (e.g., Unity, Unreal Engine)**
22. **Set Up Development Environment**
23. **Set Up Version Control System (e.g., Git)**
24. **Create Initial Game Repository**
25. **Set Up Project Management Tools (e.g., Jira, Trello)**
26. **Establish Coding Standards and Guidelines**
27. **Create Initial Database Schema**
28. **Set Up Cloud Infrastructure (e.g., AWS, Azure)**
29. **Implement Basic Security Protocols**
30. **Develop Initial API Specifications**

</Steps>

#### Phase 4: Game Development

The core game mechanics and assets are developed in this phase.
This includes creating character models, designing environments, implementing combat and resource management systems, and developing multiplayer mechanics.
AI behavior for NPCs and the leaderboard system are also created.

<Steps>

31. **Create Player Character Models**
32. **Develop NPC Character Models**
33. **Design Throne Room Environment**
34. **Develop Settlement Building Mechanics**
35. **Implement NPC Wave Mechanics**
36. **Develop Combat Mechanics**
37. **Implement Resource Management System**
38. **Create AI Behavior for NPCs**
39. **Develop Multiplayer Mechanics**
40. **Implement Leaderboard System**

</Steps>

#### Phase 5: Audio and Visuals

This phase focuses on the audio and visual components of the game.
The game soundtrack is designed, sound effects are recorded, animations and special effects are created, and all audio components are integrated.
Graphics are optimized for performance.

<Steps>

41. **Design Game Soundtrack**
42. **Record Sound Effects**
43. **Implement Background Music**
44. **Add Sound Effects to Game Mechanics**
45. **Create Animations for Characters**
46. **Design Special Effects (e.g., Explosions, Magic)**
47. **Implement Voiceovers (if needed)**
48. **Optimize Graphics for Performance**
49. **Test and Adjust Visual Effects**
50. **Integrate All Audio Components**

</Steps>

#### Phase 6: Website and Marketing

The official website and marketing materials are developed in this phase.
This includes building the website's backend and frontend, integrating cryptocurrency wallets, implementing SEO best practices, creating initial blog content, and setting up social media profiles.
Email marketing campaigns are also developed.


<Steps>

51. **Develop Website Backend**
52. **Create Website Frontend**
53. **Implement User Registration/Login**
54. **Integrate Cryptocurrency Wallets**
55. **Develop Blog and News Section**
56. **Set Up Community Forums**
57. **Implement SEO Best Practices**
58. **Create Initial Blog Content**
59. **Develop Email Marketing Campaigns**
60. **Set Up Social Media Profiles**

</Steps>

#### Phase 7: Testing and QA

A comprehensive testing plan is developed and executed in this phase.
Test cases are created, unit and integration testing are performed, and a bug tracking system is implemented.
Alpha and beta testing are conducted with internal and external users, respectively, to gather feedback and fix identified bugs.

<Steps>

61. **Develop Testing Plan**
62. **Create Test Cases for Game Mechanics**
63. **Perform Unit Testing**
64. **Conduct Integration Testing**
65. **Implement Bug Tracking System**
66. **Perform Alpha Testing with Internal Team**
67. **Gather Feedback from Alpha Testers**
68. **Fix Identified Bugs**
69. **Conduct Beta Testing with External Users**
70. **Gather Feedback from Beta Testers**

</Steps>

#### Phase 8: Pre-Launch

In this phase, the game mechanics are finalized, and the game is optimized for performance.
Final marketing materials are created, press releases are prepared, and promotional events are planned.
Early access options are set up, and customer support channels are prepared for the official launch.


<Steps>

71. **Finalize Game Mechanics**
72. **Optimize Game Performance**
73. **Create Final Marketing Materials**
74. **Prepare Press Releases**
75. **Develop Launch Trailer**
76. **Reach Out to Influencers and Streamers**
77. **Set Up Pre-Order or Early Access Options**
78. **Finalize Website Content**
79. **Set Up Customer Support Channels**
80. **Prepare for Official Launch**

</Steps>

#### Phase 9: Launch

CryptoThrone.com is officially launched in this phase. Server performance is monitored, immediate issues are addressed, and the community is engaged through social media.
Launch metrics and KPIs are tracked, and promotional events are conducted to boost visibility and engagement.


<Steps>

81. **Launch Game Officially**
82. **Monitor Server Performance**
83. **Address Any Immediate Issues**
84. **Engage with Community on Social Media**
85. **Track Launch Metrics and KPIs**
86. **Send Out Press Releases**
87. **Promote Game Through Paid Advertising**
88. **Launch Promotional Events and Contests**
89. **Monitor Feedback from Players**
90. **Provide Ongoing Customer Support**

</Steps>


#### Phase 10: Post-Launch

Post-launch activities focus on gathering player feedback, releasing patches and updates, and developing new content.
Marketing efforts are expanded, monetization strategies are optimized, and the community is engaged for suggestions.
Seasonal events and updates are planned, and a long-term roadmap is developed based on post-launch metrics.

<Steps>

91. **Gather Comprehensive Player Feedback**
92. **Identify Areas for Improvement**
93. **Release Patches and Updates**
94. **Develop New Content and Features**
95. **Expand Marketing Efforts**
96. **Optimize Monetization Strategies**
97. **Engage with Community for Suggestions**
98. **Plan Seasonal Events and Updates**
99. **Analyze Post-Launch Metrics**
100. **Develop Long-Term Roadmap**

</Steps>

### Coin Economy

CryptoThrone runs an **internal coin economy** — the in-world currency players earn and spend inside the game. It is **fully isolated** from the KBVE account ledger (Khash / Credits). These two must never cross.

#### The currency

Money is inventory items, defined in itemdb (MDX is source of truth):

| Item | ref | key | Stack | buy_price | Notes |
|------|-----|-----|-------|-----------|-------|
| Coin | `coin` | 533 | stackable, max 50 | 1 | copper base unit, spendable |
| Gold Bar | `gold-bar` | 538 | not stackable (max 1) | 150 | high denomination, store of value |

- **Source of truth:** `apps/kbve/astro-kbve/src/content/docs/itemdb/coin.mdx` and `gold-bar.mdx`. Edit MDX, then `nx run astro-kbve:sync:itemdb` — never hand-edit generated JSON/binpb.
- **Denomination:** `coin` carries `compress: { target_ref: 'gold-bar', ratio: 100 }`. 100 coins = 1 gold bar. Matched server-side by `GOLD_BAR_VALUE = 100` (`packages/rust/simgrid/src/sim.rs`).

#### How it's earned

In `apps/agones/cryptothrone/server/src/game.rs`:

- `GOBLIN_LOOT_REF = "coin"`, `WOLF_LOOT_REF = "coin"` — common mobs drop coins.
- `BOSS_LOOT_REF = "gold-bar"` — the goblin-general boss drops a gold bar.
- Ground spawns seed loose coins (e.g. 5× coin at plaza tile `(12, 9)`).

Coins live in the player's **server-side inventory** (simgrid authority), synced to the client via the `InventorySync` ephemeral.

#### Spending & compression

`spend_coins()` (`packages/rust/simgrid/src/sim.rs`) is the single spend path. `coin_balance()` sums coins + gold bars at 100:1 for total spendable value. On shortfall, `spend_coins()` auto-breaks a gold bar into coins — a bet larger than a 50-coin stack transparently consumes multiple stacks or a bar. Compression is opaque to the player: no manual "convert" action.

#### Isolation boundary (enforced)

- **CryptoThrone coins** = in-world inventory items (`coin` / `gold-bar`), authoritative in simgrid, scoped to the game world.
- **KBVE Khash / Credits** = real account-level balances in the jedi `wallet:*` ledger (`packages/rust/jedi/src/state/`).

No game-side code path reads or writes the jedi wallet, and vice versa. Gambling, drops, and shops touch **only** the coin/gold-bar items. Rationale: keep game-economy inflation and gambling RNG contained to the world; never expose the real account ledger to in-game exploits.

<Aside type="danger" title="Do not cross the boundary">
Future economy work (shops, casino, crafting, fees) must operate on `coin` / `gold-bar` items only, go through simgrid inventory mutations + `InventorySync`, and respect the 100:1 denomination. Never reach for the jedi `wallet:*` ledger from game code.
</Aside>

#### Consumers

- **Blackjack table** (`CASINO_TABLE_REF = "cloud-city:casino:6,8"`) settles bets in `coin` only via `spend_coins()` / `coin_balance()` — `packages/rust/simgrid/src/blackjack/system.rs`. No ledger touch.

## FAQ

**What is CryptoThrone.com?**
CryptoThrone.com is a King of the Hill strategy game where players defend the
throne against waves of NPCs, build a settlement, and challenge other players to
become the ruler. It is inspired by epic fantasy and tower-defense games.

**How is CryptoThrone.com built and hosted?**
It is a KBVE game app (`apps/cryptothrone`) with a Rust `axum-cryptothrone`
backend, deployed to production on the Agones game-server stack via
`apps/kube/cryptothrone/manifest/cryptothrone-deployment.yaml`.

**What genre is CryptoThrone.com?**
It is a King of the Hill strategy game blending settlement building,
tower-defense-style NPC waves, and competitive player-versus-player battles for
control of the throne.

## Related

- [Unity RareIcon](/docs/project/unity-rareicon) — another KBVE game client.
- [API](/docs/project/api) — the shared axum API stack that game backends build on.


<Giscus />

---
# CryptoThrone Server — Authoritative Axum + Bevy Grid Host

> CryptoThrone authoritative grid game server pairs an axum WebSocket router with the simgrid headless Bevy sim on tokio, on a chiseled Ubuntu Agones runtime.

Source: https://kbve.com/project/cryptothrone-server/

## Overview

`cryptothrone-server` is the authoritative shared-world host for **CryptoThrone**. It pairs an `axum` WebSocket router with the `simgrid` headless bevy grid simulation, so movement validation, occupancy, and snapshot framing stay server-owned. Unlike `nd-server`'s rapier2d match sim, CryptoThrone is grid-authoritative — collision is tile occupancy and "physics" is integer grid math, so the runtime stays light.

### Responsibilities

- Terminate the `/ws` WebSocket upgrade and verify the inbound Supabase JWT (dev-accept fallback when the secret is unset).
- Drive the `simgrid` sim tick (20 Hz) on a tokio multi-thread runtime, fanning out 10 Hz snapshots.
- Admit players into roster slots and spawn the CloudCity world — wandering NPCs and monsters — for everyone in the shared map.
- Run the Agones SDK lifecycle (`Ready` / `Health` / `Shutdown`) so the Fleet can manage the pod; degrades gracefully outside Agones for local dev.

### Layout

```
apps/agones/cryptothrone/server/
├── Cargo.toml         # package manifest (path-dep to ../../../../packages/rust/simgrid)
├── Dockerfile         # multi-stage chisel build (cargo-chef + sccache); no webkit stage
├── project.json       # nx build / run / container targets
├── version.toml       # ci-publish version sentinel
└── src/
    ├── main.rs        # tokio entry + Agones lifecycle + graceful shutdown
    ├── agones.rs      # Agones SDK heartbeat
    └── game.rs        # CloudCity spawn config (player tile, monks, birds)
```

## Build

Local build via nx:

```bash
nx run cryptothrone-server:build-release
```

Or directly through cargo:

```bash
cargo build --release -p cryptothrone-server
```

The release binary lands at `dist/target/release/cryptothrone-server` per the workspace target dir convention.

## Container

```bash
nx run cryptothrone-server:container
```

Drops a `kbve/cryptothrone-server:latest` + version tag locally. CI uses the `ci` configuration with sccache + registry buildcache (`ghcr.io/kbve/cryptothrone-server:buildcache`). The runtime image uses the same `ghcr.io/kbve/chisel-ubuntu-axum` chisel base as the other Axum services. Default listen is `0.0.0.0:7979` (override via `CT_SERVER_ADDR`).

## Sim core

The grid sim lives in the shared `simgrid` crate (`packages/rust/simgrid`): postcard wire types, Supabase HS256 auth, axum WS transport, and the bevy headless `build_app` / `run_sim_loop`. The host registers its CloudCity spawn systems into `simgrid`'s ordered `SimSet` stages, so game content stays in the app crate while transport and movement stay generic.

## Deployment

An Agones `Fleet` (`apps/kube/agones/cryptothrone/`) runs the GameServer pods; the web tier (`axum-cryptothrone`) allocates one via `POST /api/join`. Image must land on `ghcr.io/kbve/cryptothrone-server` before the Fleet can scale up.

## Status

Beta. Shared-world sim with wandering NPCs/monsters; browser client + WSS edge for allocated dynamic ports still in progress.

## FAQ

**What is the CryptoThrone server?**
`cryptothrone-server` is the authoritative shared-world host for CryptoThrone. It
pairs an `axum` WebSocket router with the `simgrid` headless Bevy grid simulation
on a tokio multi-thread runtime, keeping movement validation, occupancy, and
snapshot framing server-owned.

**How does CryptoThrone differ from a physics-based server?**
CryptoThrone is grid-authoritative rather than physics-based. Collision is tile
occupancy and movement is integer grid math, so unlike `nd-server`'s rapier2d
match sim, the runtime stays light. The sim ticks at 20 Hz and fans out 10 Hz
snapshots.

**How is the CryptoThrone server deployed?**
An Agones `Fleet` runs the GameServer pods, and the web tier (`axum-cryptothrone`)
allocates one via `POST /api/join`. The image must land on
`ghcr.io/kbve/cryptothrone-server` before the Fleet can scale up. The server also
runs the Agones SDK lifecycle (`Ready`, `Health`, `Shutdown`).

## Related

- [Isometric](/docs/project/isometric) — sibling Bevy multiplayer game in the KBVE stack.
- [Agones](/docs/project/agones) — the GameServer lifecycle SDK used to manage these Fleet pods.

---
# @kbve/devops — Proto-to-Zod Codegen and CI/CD Helper Library

> @kbve/devops is a DevOps helper library with proto-to-zod codegen, GitHub Actions helpers, sanitization, and CI registry management for the KBVE monorepo.

Source: https://kbve.com/project/devops/

## Overview

`@kbve/devops` is a DevOps helper library written by the KBVE team to streamline
development and production tasks across the monorepo. It provides **proto-to-zod
code generation**, **GitHub Actions helpers**, **input sanitization**, and **CI
registry management** so CI/CD pipelines stay consistent and low-maintenance.

## Key facts

| | |
|---|---|
| **Package** | `@kbve/devops` |
| **Version** | 0.0.19 |
| **Language** | TypeScript (ESM) |
| **Key deps** | `@bufbuild/protobuf`, `dompurify` |
| **License** | MIT |
| **Source** | [`packages/npm/devops`](https://github.com/KBVE/kbve/tree/main/packages/npm/devops) |

## Features

- **Proto-to-zod codegen** — generates Zod validation schemas from Protocol Buffer
  definitions via `@bufbuild/protobuf`.
- **GitHub Actions helpers** — utilities that automate repetitive workflow tasks in
  KBVE's CI/CD pipelines.
- **Sanitization** — HTML/input sanitization backed by `dompurify`.
- **CI registry management** — powers the CI dispatch manifest registry used to
  build and publish monorepo artifacts.

## FAQ

**What is the @kbve/devops library?**
It is a DevOps helper library published by the KBVE team that provides proto-to-zod
code generation, GitHub Actions helpers, input sanitization, and CI registry
management to streamline the monorepo's CI/CD pipelines.

**What does @kbve/devops use for schema generation?**
It generates Zod validation schemas from Protocol Buffer definitions using the
`@bufbuild/protobuf` toolchain, and uses `dompurify` for HTML sanitization.

**Where is @kbve/devops used?**
It is used across the KBVE monorepo to power the CI dispatch manifest registry,
automate GitHub Actions workflow tasks, and provide shared validation and
sanitization utilities.

## Related

- [KhashVault](/project/khashvault/) — a companion KBVE npm library for browser-side cryptography.

---
# DiscordSH — Discord Server Topsite with Voting and Bump

> DiscordSH is a topsite for Discord servers featuring a voting and bump system, built on Rust/Axum, Supabase, Redis, and an Astro frontend.

Source: https://kbve.com/project/discordsh/

## DiscordSH

This is unofficial notes and docs for discordsh.

### Overview

DiscordSH is a topsite designed to promote Discord servers through a dual mechanic of **voting** and **bumping**.
It serves as a platform where server owners and members can increase visibility by engaging with these systems, helping servers gain traction and attract new users.
These unofficial notes aim to clarify how DiscordSH operates based on its core features.

### Voting System
- **Frequency**: Users can vote for a server once every 12 hours.
- **Ranking**: Servers are ranked based on the total number of votes received. Those with the most votes appear higher on the list, increasing their exposure.
- **Reset Cycle**: All votes reset monthly, giving every server a fresh chance to climb the rankings each month.
- **Purpose**: Encourages consistent community engagement and rewards active participation with visibility.

### Bump System
- **Mechanism**: Unlike voting, bumping is a continuous stream of recently promoted servers. When a server is "bumped," it appears in this stream, showcasing the latest activity.
- **No Reset**: There’s no monthly reset for bumps—it's a real-time feed of the most recently bumped servers.
- **Purpose**: Provides an alternative promotion method focused on immediacy rather than cumulative effort, ideal for quick visibility boosts.

### Key Differences
| Feature       | Voting System           | Bump System           |
|---------------|-------------------------|-----------------------|
| **Frequency** | Once per 12 hours       | No fixed limit (stream-based) |
| **Ranking**   | Cumulative, monthly reset | Latest activity only  |
| **Goal**      | Long-term visibility    | Short-term exposure   |

### Tips for Server Owners
1. **Maximize Votes**: Encourage your community to vote every 12 hours to maintain a high ranking, especially early in the month to build momentum.
2. **Leverage Bumps**: Use the bump system for quick visibility spikes, such as during events or recruitment drives.
3. **Combine Strategies**: Pair consistent voting with periodic bumps to balance sustained growth and immediate attention.

### Notes
- DiscordSH’s voting reset aligns with a competitive cycle, making it distinct from perpetual ranking systems on other topsites.
- The bump stream’s simplicity offers flexibility but lacks the prestige of top vote rankings.
- No official API or detailed documentation is referenced here; this is an unofficial interpretation based on observed functionality.

### Potential Enhancements (Speculative)
- **Vote Reminders**: A bot integration could notify users when their 12-hour voting window resets.
- **Bump Analytics**: Tracking bump frequency and resulting joins could help optimize usage.
- **Categories/Tags**: Filtering servers by type (e.g., gaming, social) might improve discoverability—unclear if currently implemented.

* * *

## Development
This section outlines the technical foundation of DiscordSH, based on inferred architecture and common practices for a topsite with voting and bumping features.

### Tech Stack
- **Databases**:
  - **Supabase**: Provides a scalable, real-time PostgreSQL database with a RESTful API and WebSocket support. Likely used for core data like server listings and user votes.
  - **Postgres**: The underlying database managed by Supabase, handling structured data storage (e.g., server metadata, vote counts).
  - **Redis**: A fast, in-memory store for ephemeral data, such as bump timestamps or session caches, ensuring low-latency operations.
- **Frontend**: Built with **Astro** (static site generation) paired with **Alpine.js** (lightweight interactivity) and **React** (dynamic components), balancing performance and reactivity.
- **Backend**: Powered by **Rust** with the **Axum** framework, offering a high-performance, thin layer that integrates Supabase and Redis.
- **Deployment**: Runs on a **Kubernetes** cluster, enabling scalability, resilience, and automated management of containerized services.

### RESTful API

DiscordSH leverages two RESTful APIs:

- **Supabase REST API**: Automatically provided by Supabase, exposing database operations (e.g., GET servers, POST votes) with built-in authentication and row-level security.
- **Axum REST API**: A custom thin layer written in Rust/Axum, wrapping Supabase and Redis interactions. It likely handles:
  - Vote submissions (e.g., rate-limiting to enforce 12-hour cycles).
  - Bump processing (e.g., pushing to Redis and updating the stream).
  - Aggregating metrics or caching responses for efficiency.
- The Axum layer acts as a mediator, adding business logic and reducing direct frontend reliance on Supabase.

### WebSockets

WebSockets enable real-time features, such as live vote updates or bump stream refreshes. Data is exchanged in two formats:
- **JSON**: Human-readable, used for simplicity and debugging. Example payloads for testing:

  ```json
  // Client -> Server (e.g., bump request)
  {
    "action": "bump",
    "server_id": "12345",
    "timestamp": "2025-04-09T12:00:00Z"
  }

#### WS Commands

Below are example JSON payloads for WebSocket commands, primarily interacting with key-value operations (likely backed by Redis).
These commands support setting, retrieving, and watching data in real time.
Nested Direct Command Set / Get / WATCH:


| Command         | Description                          | Example JSON Payload                                                                 |
|-----------------|--------------------------------------|-------------------------------------------------------------------------------------|
| **SET**         | Sets a key-value pair without TTL    | ```json    { "message": { "Command": { "command": { "Set": { "key": "1", "value": "pop" } } } } }    ``` |
| **SET with TTL**| Sets a key-value pair with a time-to-live (in seconds) | ```json    { "message": { "Command": { "command": { "Set": { "key": "1", "value": "pop", "ttl": 30 } } } } }    ``` |
| **GET**         | Retrieves the value for a key        | ```json    { "message": { "Command": { "command": { "Get": { "key": "1" } } } } }    ``` |
| **WATCH**       | Subscribes to updates for a key      | ```json    { "message": { "Watch": { "key": "1" } } }    ``` |

- **Notes**:
  - The `Command` object nests `Set` or `Get` under a `command` field, suggesting a structured protocol for key-value operations.
  - `WATCH` uses a flatter structure, likely for subscribing to real-time updates (e.g., vote changes or bump events).
  - TTL (time-to-live) in `SET with TTL` expires the key after the specified duration (e.g., 30 seconds), useful for temporary data like cooldowns.

#### WS Thin Layer JSON
The thin layer (Axum) also supports WebSocket commands with a simpler JSON structure, designed for real-time interactions with the backend (e.g., Redis or Supabase).

| Command         | Description                          | Example JSON Payload                                                                 |
|-----------------|--------------------------------------|-------------------------------------------------------------------------------------|
| **SET**         | Sets a key-value pair without TTL    | ```json    { "type": "set", "key": "mykey", "value": "myvalue" }    ```            |
| **SET with TTL**| Sets a key-value pair with a time-to-live (in seconds) | ```json    { "type": "set", "key": "mykey", "value": "myvalue", "ttl": 9000 }    ``` |
| **WATCH**       | Subscribes to updates for a key      | ```json    { "type": "watch", "key": "mykey" }    ```                              |

- **Notes**:
  - These commands use a flat structure with a `type` field to specify the action, contrasting with the nested `WS Commands` above.
  - `SET with TTL` specifies a 9000-second (2.5-hour) expiration, ideal for longer-term real-time data like bump visibility or vote buffers.
  - `WATCH` enables clients to receive live updates for a key, such as vote increments or bump stream changes, leveraging WebSocket’s real-time capabilities.
  - Likely used for lightweight, frontend-driven interactions with the thin layer’s WebSocket endpoint.



## DevLog

This is for unprocessed notes and logs from the DiscordSH development process. It includes various JSON payloads and other data structures used in the application.

For testing the websockets, we have these two JSONs:


### WS Unit Commands


```json

{
  "message": {
    "Command": {
      "command": {
        "Set": { "key": "1", "value": "pop", "ttl": 30 }
      }
    }
  }
}

```

Then to get:

```json

{
  "message": {
    "Command": {
      "command": {
        "Get": { "key": "1" }
      }
    }
  }
}

```

Watch Command:

```json

{
  "message": {
    "Watch": {
      "key": "1"
    }
  }
}

```


```json

{ "type": "set", "key": "mykey", "value": "myvalue" }

```

Thin JSON 2

```json

{ "type": "set", "key": "mykey", "value": "myvalue", "ttl": 9000 }


```

Thin Watch

```json

{ "type": "watch", "key": "mykey" }


```

## FAQ

**What is DiscordSH?**
DiscordSH is a topsite for Discord servers that promotes them through two
mechanics — a voting system and a bump system — helping server owners increase
visibility and attract new members.

**How does DiscordSH voting differ from bumping?**
Voting is cumulative — users vote once every 12 hours, servers rank by total
votes, and votes reset monthly for long-term visibility. Bumping is a real-time
stream of recently promoted servers with no reset, aimed at short-term exposure.

**What is the DiscordSH tech stack?**
These unofficial notes describe an Astro frontend with Alpine.js and React, a
Rust and Axum backend as a thin layer over Supabase and Postgres with Redis for
ephemeral data, and Kubernetes for deployment, with real-time features over
WebSockets.

## Related

- [DiscordSH Bot](/docs/project/discordsh-bot) — the companion Discord bot for the topsite.

---
# DiscordSH Bot — Standalone Discord Gateway Bot

> DiscordSH Bot is a standalone poise/serenity Discord gateway bot with slash commands, an embed dungeon game, GitHub integration, and an n8n forwarder.

Source: https://kbve.com/project/discordsh-bot/

## Overview

`discordsh-bot` is the standalone Discord gateway bot extracted from the axum-discordsh monolith. It handles all Discord interactions independently of the HTTP server.

### Features

- Poise/serenity Discord gateway with shard support
- Slash commands: `/github`, `/gh`, `/dungeon`, `/ping`, `/status`, `/health`, `/admin`, `/skills`, `/n8n`
- Embed Dungeon game with bevy_battle combat, bevy_inventory item management
- GitHub issue/PR management with SVG card rendering
- Player persistence via Supabase
- HMAC-signed forwarder into in-cluster n8n (`/n8n`)
- Minimal health HTTP server for k8s probes

## Environment Variables

Required at runtime. In production the values come from `discordsh-config` (ConfigMap) and the `discordsh-redis-secret` / `discordsh-supabase-shared` / `discordsh-n8n-hmac` Secrets. For the dev container, drop them into `apps/discordsh/discordsh-bot/.env` (loaded via `dotenvy` at startup) — anything missing simply disables the related feature instead of failing the boot.

### Core

| Variable                    | Required | Default       | Notes                                                               |
| --------------------------- | -------- | ------------- | ------------------------------------------------------------------- |
| `DISCORD_TOKEN`             | Yes\*    | —             | Bot token. \*Resolved from Supabase Vault in prod if unset locally. |
| `GUILD_ID`                  | No       | —             | Dev guild for fast slash-command registration                       |
| `SHARD_ID` / `SHARD_COUNT`  | No       | single-shard  | Distributed sharding                                                |
| `HEALTH_PORT`               | No       | `4322`        | Health server bind port                                             |
| `FONT_PATH`                 | No       | `alagard.ttf` | Card render font                                                    |
| `SYMBOL_FONT_PATH`          | No       | `NotoSansSymbols-Regular.ttf` | Unicode symbol font                                                 |
| `DB_PATH`                   | No       | —             | Local KV (redb) path for L2 profile cache                           |

### Supabase / GitHub

| Variable                    | Required | Notes                                              |
| --------------------------- | -------- | -------------------------------------------------- |
| `SUPABASE_URL`              | No       | API URL; enables persistence + shard tracker       |
| `SUPABASE_SERVICE_ROLE_KEY` | No       | Service-role JWT; pair with `SUPABASE_URL`         |
| `GITHUB_TOKEN`              | No       | PAT for `/github` + `/gh` commands                 |
| `GITHUB_DEFAULT_REPO`       | No       | Default `owner/name` (default `KBVE/kbve`)         |
| `GITHUB_ALLOWED_REPOS`      | No       | Comma-separated repo allowlist                     |

### n8n forwarder (`/n8n`)

`/n8n <webhook_path> [args]` forwards Discord input to the in-cluster n8n webhook receiver. Every payload is signed `X-KBVE-Signature: sha256=HMAC(secret, "{ts}.{body}")` so n8n workflows verify origin + reject replays in a Function node. All three required vars must be present or the command unregisters itself.

| Variable             | Required | Default | Notes                                                                 |
| -------------------- | -------- | ------- | --------------------------------------------------------------------- |
| `N8N_BASE_URL`       | Yes      | —       | `http://n8n.n8n.svc.cluster.local:5678/webhook/` in cluster; `https://n8n.kbve.com/webhook/` for dev against public n8n |
| `N8N_HMAC_SECRET`    | Yes      | —       | Shared secret with the n8n workflow (`$env.N8N_HMAC_SECRET`)          |
| `N8N_ALLOWED_PATHS`  | Yes      | —       | Globset allowlist, comma-separated (e.g. `kbve/*,deploy-*`)           |
| `N8N_RATE_LIMIT`     | No       | `1`     | Max calls per user per window                                         |
| `N8N_RATE_WINDOW`    | No       | `5`     | Sliding window length in seconds                                      |

Dev-container `.env` example:

```ini
N8N_BASE_URL=https://n8n.kbve.com/webhook/
N8N_HMAC_SECRET=<shared>
N8N_ALLOWED_PATHS=kbve/*,deploy-*
N8N_RATE_LIMIT=1
N8N_RATE_WINDOW=5
```

In production the same secret lives once as a SealedSecret in the `n8n` namespace and is mirrored into `discordsh` via ExternalSecret — see `apps/kube/discordsh/seal-n8n-hmac.sh`.

## FAQ

**What is the DiscordSH Bot?**
`discordsh-bot` is the standalone Discord gateway bot extracted from the axum-discordsh monolith. It handles all Discord interactions independently of the HTTP server, built on the poise/serenity gateway with shard support.

**What can the DiscordSH Bot do?**
It serves slash commands (`/github`, `/gh`, `/dungeon`, `/ping`, `/status`, `/health`, `/admin`, `/skills`, `/n8n`), runs an embed dungeon game with bevy_battle combat and bevy_inventory items, manages GitHub issues and PRs with SVG card rendering, persists players via Supabase, and forwards HMAC-signed requests into in-cluster n8n.

**How does the `/n8n` command stay secure?**
Every `/n8n` payload is signed with `X-KBVE-Signature: sha256=HMAC` over the timestamp and body so n8n workflows verify origin and reject replays. Requests are also filtered by a globset allowlist, and all three required env vars must be present or the command unregisters itself.

## Related

- [DiscordSH](/project/discordsh/) — HTTP server (Astro site, REST API).
- [bevy_inventory](/project/bevy-inventory-crate) — the inventory crate powering the embed dungeon game.

---
# Droid — Web, Shared & Service Worker Manager for JavaScript

> Droid is a lightweight TypeScript library that manages service, shared, and web workers behind a unified API to offload heavy work and background tasks.

Source: https://kbve.com/project/droid/

## Overview

`@kbve/droid` is a lightweight manager for **service workers, shared workers, and
web workers** in modern JavaScript and TypeScript apps. It abstracts away the
boilerplate and browser inconsistencies of worker setup, messaging, and lifecycle
so developers can offload heavy computation, enable background tasks, and keep the
main thread responsive. Droid is framework-agnostic — usable from vanilla JS or
alongside React, Vue, and Angular.

## Key facts

| | |
|---|---|
| **Package** | `@kbve/droid` |
| **Version** | 0.1.1 |
| **Language** | TypeScript |
| **License** | MIT |
| **Source** | [`packages/npm/droid`](https://github.com/KBVE/kbve/tree/main/packages/npm/droid) |
| **Registry** | npm |

## Features

- **Unified worker API** — register, manage, and message service, shared, and web
  workers through one consistent interface.
- **Prebuilt workers** — canvas, IndexedDB (DB), WebSocket, and Supabase shared /
  DB workers ship as ready exports.
- **comlink-backed messaging** — ergonomic RPC-style calls into workers instead of
  raw `postMessage` plumbing.
- **Framework-agnostic** — works in vanilla JS or with React, Vue, and Angular.
- **Robust dependency stack** — `dexie` for IndexedDB, `zod` for schema validation,
  `@nanostores/persistent` for state, and `flatbuffers` for compact payloads.

## Usage

```bash
npm install @kbve/droid
```

## FAQ

**What is the Droid package?**
Droid is a lightweight, framework-agnostic TypeScript library that manages service
workers, shared workers, and web workers behind a unified API, simplifying setup,
communication, and lifecycle management so apps can offload heavy work off the main
thread.

**Which worker types does Droid support?**
Droid handles service workers for offline support, shared workers for cross-tab
communication, and web workers for parallel processing. It ships prebuilt workers
including canvas, IndexedDB, WebSocket, and Supabase shared and DB workers.

**Does Droid work with React, Vue, or Angular?**
Yes. Droid is framework-agnostic and works in vanilla JavaScript as well as with
React, Vue, or Angular. It uses comlink for worker messaging and dependencies such
as dexie, zod, and nanostores under the hood.

## Related

- [Laser](/docs/project/laser) — sibling KBVE npm package for Phaser + React Three Fiber game UIs.

---
# Edge Functions — Supabase Deno Workers and Firecracker

> KBVE Supabase edge functions running as isolated Deno V8 workers, with a two-tier isolation model that dispatches heavier workloads to Firecracker microVMs.

Source: https://kbve.com/project/edge/

## Overview

Supabase edge functions service built on `supabase/edge-runtime:v1.73.2`. Each function runs as an isolated Deno V8 worker with 150 MB memory and a 60-second timeout. The main router (`functions/main/index.ts`) handles JWT verification, per-function env allowlisting, and worker dispatch.

### Function Registry

| Function | Description |
|----------|-------------|
| `health` | Core health check (public, no JWT) |
| `meme` | Meme feed and reactions |
| `discordsh` | Discord server integration |
| `user-vault` | User API token management |
| `guild-vault` | Guild token management |
| `vault-reader` | System secret access (service_role only) |
| `argo` | ArgoCD API proxy with diagnostics |
| `logs` | ClickHouse observability logs |
| `ows` | OWS admin operations |

### Shared Modules

All functions share utilities under `functions/_shared/`:

- **`cors.ts`** — CORS headers with origin allowlist
- **`supabase.ts`** — JWT parsing, Supabase client factories, role guards
- **`validators.ts`** — Input validation, body size limits, SSRF protection
- **`formats.ts`** — Regex patterns for UUIDs, ULIDs, Discord snowflakes, etc.
- **`firecracker.ts`** — Firecracker microVM client (Tier 2 dispatch)

kube:
    stack: application
    environment: prod
    tier: api
    owner: h0lybyte
    criticality: medium
---

## Firecracker MicroVM Integration

### Two-Tier Isolation

The edge platform uses a two-tier isolation model. Tier 1 (Deno workers) handles standard TypeScript functions. Tier 2 (Firecracker microVMs) handles workloads that need full OS-level isolation — arbitrary binaries, untrusted code, or long-running processes.

| Tier | Isolation | Boot Time | Use Case |
|------|-----------|-----------|----------|
| 1 | V8 isolates (Deno workers) | ~10ms | TypeScript edge functions |
| 2 | Firecracker microVMs | ~125ms | Arbitrary binaries, untrusted code |

### Architecture

Edge functions in Tier 1 act as the control plane. When a request needs VM-level isolation, the function dispatches to the Firecracker service via an internal REST API. The two tiers are fully independent — a VM crash never affects edge function availability.

```
Edge Runtime Pod (Tier 1)         Firecracker Service Pod (Tier 2)
┌─────────────────────┐           ┌──────────────────────────┐
│ Deno V8 Workers     │  HTTP →   │ REST API → Firecracker   │
│ health, meme, vault │  :9001    │ /dev/kvm via device plugin│
│ argo, logs, ows ... │           │ ┌────┐ ┌────┐ ┌────┐    │
└─────────────────────┘           │ │VM1 │ │VM2 │ │VM3 │    │
                                  │ └────┘ └────┘ └────┘    │
                                  └──────────────────────────┘
```

### Client Library

Edge functions use the shared `firecracker.ts` client to dispatch VM workloads:

```typescript
import { runVM } from "../_shared/firecracker.ts";

const result = await runVM({
  rootfs: "alpine-minimal",
  vcpu_count: 1,
  mem_size_mib: 128,
  timeout_ms: 30000,
  entrypoint: "/usr/local/bin/worker",
  env: { TASK: "compute", INPUT: payload },
});
// result.stdout, result.stderr, result.exit_code, result.duration_ms
```

### API Endpoints (firecracker-ctl)

| Method | Path | Description |
|--------|------|-------------|
| `POST` | `/vm/create` | Create and start a microVM |
| `GET` | `/vm/{vm_id}` | Get VM status |
| `GET` | `/vm/{vm_id}/result` | Get stdout/stderr/exit_code after completion |
| `DELETE` | `/vm/{vm_id}` | Force-terminate a running VM |
| `GET` | `/health` | Service health check |

### Rootfs Images

Pre-built minimal root filesystems stored as OCI artifacts in GHCR:

| Image | Size | Contents |
|-------|------|----------|
| `alpine-minimal` | ~8 MB | Alpine + busybox |
| `alpine-python` | ~45 MB | Alpine + Python 3.12 |
| `alpine-node` | ~40 MB | Alpine + Node.js 22 LTS |
| `ubuntu-rust` | ~120 MB | Ubuntu minimal + Rust toolchain |

### Security

- Firecracker jailer enforces cgroup + seccomp + chroot per VM
- No root inside microVMs — all capabilities dropped
- Read-only rootfs with tmpfs overlay for scratch
- Kubernetes NetworkPolicy restricts ingress to edge-runtime pods only
- VM timeout enforced both client-side (edge function) and server-side (firecracker-ctl)

### Kubernetes Resources

All manifests live in `apps/kube/firecracker/manifests/`:

- **Deployment** — `firecracker-ctl` with `/dev/kvm` device plugin, `kvm=true` node selector
- **Service** — ClusterIP on port 9001
- **PVC** — 2Gi Longhorn volume for rootfs image cache
- **NetworkPolicy** — Ingress only from `app: functions` pods
- **ArgoCD Application** — `selfHeal: false` during early phases

### Phased Rollout

- **Phase 1** (merged) — Design document, K8s manifests, edge client library
- **Phase 2** (current) — Environment wiring, documentation, deployment integration
- **Phase 3** — E2E tests, ClickHouse monitoring, KEDA autoscaling
- **Phase 4** — TAP networking, warm VM pool, multi-node scheduling

## FAQ

**What are KBVE edge functions?**
They are Supabase edge functions built on `supabase/edge-runtime`, where each function runs as an isolated Deno V8 worker with 150 MB memory and a 60-second timeout. The main router handles JWT verification, per-function env allowlisting, and worker dispatch.

**What is the two-tier isolation model?**
Tier 1 is Deno V8 isolates (~10ms boot) for standard TypeScript edge functions. Tier 2 is Firecracker microVMs (~125ms boot) for arbitrary binaries, untrusted code, or long-running processes needing OS-level isolation. A VM crash never affects edge function availability.

**How do edge functions dispatch a Firecracker microVM?**
Functions call the shared `firecracker.ts` client's `runVM` helper, which dispatches to the Firecracker service over an internal REST API with a rootfs image, vCPU/memory limits, timeout, entrypoint, and env, then returns stdout, stderr, exit code, and duration.

## Related

- [ROWS](/docs/project/rows) — a KBVE game backend that also runs on the cluster.
- [Kilobase](/docs/project/kilobase) — the Supabase/Postgres data layer behind these functions.

---
# ERust — egui and eframe Component Crate

> ERust is a Rust crate that extends egui and eframe with reusable generic states, widgets, and components for building KBVE desktop and WASM apps.

Source: https://kbve.com/project/erust-crate/

## Overview

`ERust` is a Rust crate that extends [egui](https://github.com/emilk/egui) and
`eframe` with reusable, generic states, widgets, and components. It gives KBVE
applications a shared foundation for immediate-mode GUIs that run on native
desktop and in the browser via WebAssembly. ERust depends on the internal `holy`
crate and integrates HTTP (`ehttp`), image decoding, and Supabase state helpers.

## Key facts

| | |
|---|---|
| **Package** | `erust` |
| **Version** | 0.1.7 |
| **Language** | Rust (egui / eframe 0.34) |
| **License** | MIT |
| **Source** | [`packages/rust/erust`](https://github.com/KBVE/kbve/tree/main/packages/rust/erust) |
| **Targets** | native desktop, WASM (wasm32) |

## Features

- **egui / eframe extensions** — generic application state, widgets, and
  components layered on top of the immediate-mode GUI stack.
- **Feature-gated backends** — the default `egui` feature enables egui, eframe,
  and image support; the optional `tauri` feature integrates with Tauri shells.
- **Cross-platform** — builds for native desktop with the glow backend and for
  WebAssembly via `wasm-bindgen-futures`.
- **State + networking helpers** — bundled Supabase state module and `ehttp`
  for making HTTP requests from the UI.

## FAQ

**What is the ERust crate?**
ERust is a Rust package that extends egui and eframe with reusable generic
states, widgets, and components, giving KBVE apps a shared foundation for
immediate-mode GUIs on desktop and WASM.

**Which features does ERust expose?**
The default `egui` feature pulls in egui, eframe, and image support for widgets
and application state, while an optional `tauri` feature integrates ERust with
Tauri-based shells.

**Does ERust run in the browser?**
Yes. It targets both native desktop via eframe with the glow backend and
WebAssembly through `wasm-bindgen-futures` for wasm32 builds.

## Related

- [Holy Crate](/docs/project/holy-crate) — internal dependency ERust builds on.
- [KBVE Crate](/docs/project/kbve-crate) — companion Rust crate in the workspace.

---
# Factorio CTL — Agones Control REST API

> Rust Axum REST API for the Agones-managed Factorio server — reads GameServer status via kube-rs and ClickHouse-backed player telemetry for the staff dashboard.

Source: https://kbve.com/project/factorio-ctl/

## Overview

Rust Axum + utoipa REST API for the Agones-managed Factorio dedicated server. Mirrors [`firecracker-ctl`](/docs/project/firecracker-ctl/): cluster-internal only, surfaced through the staff dashboard via a same-origin proxy (`/dashboard/factorio/proxy`, `DASHBOARD_VIEW`). Routes use the `/factorio/*` prefix — never `/fc/*`, which belongs to firecracker-ctl.

This entry registers the crate so the image builds and publishes. The Kubernetes Deployment ships with `replicas: 0` until the image is available, then scales to 1.

### API Endpoints (read-only, this slice)

| Method | Path | Description |
|--------|------|-------------|
| `GET` | `/factorio/health` (+ `/health`) | Liveness, build identity, in-cluster kube-client presence |
| `GET` | `/factorio/server` | Agones `GameServer` status (state / node / address / port) + latest telemetry snapshot |
| `GET` | `/openapi.json` | utoipa spec for the dashboard Scalar viewer |

### Design

- **GameServer status** is read via `kube-rs` with a raw request to the Agones API (no CRD vendoring), so an Agones schema bump can't break the build.
- **Player count comes from ClickHouse** (`gameops.factorio_snapshots`), not RCON — RCON binds loopback-only on the gameserver pod and is unreachable cross-pod. The relay sidecar is the telemetry producer; factorio-ctl reads the latest snapshot.

### Runtime knobs

| Env | Default | Notes |
|---|---|---|
| `FACTORIO_CTL_PORT` | `9002` | Listen port |
| `FACTORIO_NAMESPACE` | `factorio` | GameServer namespace |
| `FACTORIO_GAMESERVER` | `factorio` | GameServer name |
| `FACTORIO_SERVER_ID` | `factorio-1` | Stamps telemetry lookups |
| `CLICKHOUSE_ENDPOINT` | _(unset)_ | When unset, telemetry fields are omitted from `/factorio/server` |
| `CLICKHOUSE_USER` / `CLICKHOUSE_PASSWORD` | _(unset)_ | From the `clickhouse-credentials` ExternalSecret |
| `CLICKHOUSE_DATABASE` | `gameops` | |

### Kubernetes Resources

In `apps/kube/agones/factorio/manifests/factorio-ctl.yaml`:

- **Deployment** — `replicas: 0` until the image publishes, then scale to 1
- **Service** — ClusterIP on port 9002
- **RBAC** — ServiceAccount + Role granting `get/list/watch` on `agones.dev/gameservers`

### Follow-ups (tracking #12735)

- Mutating endpoints: `/factorio/server/restart` · `/factorio/server/save` · `/factorio/saves/*` · `/factorio/rotation/*` · `/factorio/rcon/exec` · `/factorio/players`.
- Dashboard "control" tab consuming factorio-ctl.

## FAQ

**What is factorio-ctl?**
A Rust Axum + utoipa REST API for the Agones-managed Factorio dedicated server,
exposing GameServer status and telemetry to the staff dashboard through a
same-origin proxy.

**Where does the player count come from?**
From ClickHouse (`gameops.factorio_snapshots`), not RCON — RCON binds
loopback-only on the gameserver pod and is unreachable cross-pod, so the relay
sidecar produces telemetry and factorio-ctl reads the latest snapshot.

**How does it read GameServer status without breaking on Agones upgrades?**
It uses `kube-rs` with a raw request to the Agones API rather than vendoring the
CRD, so an Agones schema bump cannot break the build.

## Related

- [Agones Factorio Relay](/docs/project/agones-factorio-relay) — sidecar that produces the telemetry factorio-ctl reads.

## Refs

- Tracking issue #12735 (supersedes #11138)
- Sibling pattern — [`firecracker-ctl`](/docs/project/firecracker-ctl/)

---
# Firecracker CTL — MicroVM Control API

> Rust Axum REST API for managing Firecracker microVMs — VM lifecycle, ephemeral code execution, and persistent HTTP endpoints with per-VM TAP networking.

Source: https://kbve.com/project/firecracker-ctl/

## Overview

Rust Axum REST API for managing Firecracker microVMs. Provides VM lifecycle management (create, poll, destroy) with per-VM timeout enforcement and in-memory state tracking via DashMap.

## Key facts

| | |
|---|---|
| **Image** | `kbve/firecracker-ctl` |
| **Language** | Rust (Axum) |
| **Service** | ClusterIP :9001 |
| **License** | KBVE |
| **Source** | [`apps/vm/firecracker-ctl`](https://github.com/KBVE/kbve/tree/main/apps/vm/firecracker-ctl) |
| **Requires** | `/dev/kvm`, `kvm=true` node selector |

## Features

- **VM lifecycle API** — create, poll status, fetch results, and destroy microVMs.
- **Ephemeral code execution** — user code booted into a VM via a raw block drive.
- **Persistent endpoints** — named long-lived VMs exposing HTTP servers (`-net` only).
- **Two ecosystems** — untrusted MMDS-only VMs and VPN-tunneled networked VMs.
- **Pre-built rootfs** — Alpine minimal/python/node ext4 images built in-cluster.

### API Endpoints

| Method | Path | Description |
|--------|------|-------------|
| `POST` | `/vm/create` | Create and start a microVM |
| `GET` | `/vm/{vm_id}` | Get VM status |
| `GET` | `/vm/{vm_id}/result` | Get stdout/stderr/exit_code after completion |
| `DELETE` | `/vm/{vm_id}` | Force-terminate a running VM |
| `GET` | `/vm` | List all VMs |
| `GET` | `/health` | Service health check |

### Code Execution Flow

1. User code arrives via `env.CODE` in the create request
2. Code is written to a raw block file (512-byte padded)
3. Block file attached as second Firecracker drive (`/dev/vdb`)
4. Entrypoint passed via `boot_args` (`fc_entrypoint=/usr/bin/python3`)
5. VM init script reads code from `/dev/vdb`, writes to `/tmp/code`, execs entrypoint

### Rootfs Images

Pre-built ext4 root filesystems built in-cluster via ArgoCD PostSync hook:

| Image | Size | Contents |
|-------|------|----------|
| `alpine-minimal` | 32 MB | Alpine + busybox |
| `alpine-python` | 128 MB | Alpine + Python 3.12 |
| `alpine-node` | 128 MB | Alpine + Node.js |

### Kubernetes Resources

All manifests in `apps/kube/firecracker/manifests/`:

- **Deployment** — `firecracker-ctl` with `/dev/kvm` device plugin, `kvm=true` node selector
- **Service** — ClusterIP on port 9001
- **PVC** — 2Gi Longhorn volume for rootfs + vmlinux kernel
- **NetworkPolicy** — Ingress from edge-runtime + dashboard proxy only
- **KEDA ScaledObject** — minReplicas=1, cron scales to 2 during peak hours
- **Rootfs Init Job** — ArgoCD PostSync hook, builds ext4 images in-cluster

## Two Ecosystems

Firecracker runs in two parallel deployments in the same namespace, chosen by trust level:

| Deployment | Network | Access | Use Case |
|------------|---------|--------|----------|
| `firecracker-ctl` | None (MMDS only) | Edge functions + dashboard | Ephemeral, untrusted code execution |
| `firecracker-ctl-net` | Gluetun/WireGuard VPN | Dashboard only (staff) | Persistent endpoints with outbound internet |

`firecracker-ctl-net` shares its network namespace with a Gluetun sidecar — all VM traffic exits through a WireGuard tunnel, so user code in VMs never sees the raw host network. This is the only ecosystem that hosts persistent endpoints.

## Persistent Endpoints (`/fc/*`)

Long-lived VMs that expose HTTP servers, routed by name from the public edge. Think Fly.io Machines or Cloud Run — deploy once, stays up until explicitly stopped. Lives in the networked ecosystem only.

### Request Flow

```
Browser → kbve.com/fc/{name}/*
       → kbve-gateway (path prefix /fc/)
       → kbve-service:4321 (axum-kbve)
       → /fc/{name}/{*path} handler (staff auth)
       → firecracker-ctl-net.firecracker.svc:9001/proxy/{name}/{*path}
       → VM tap IP:{http_port}/{*path}
       → response
```

Two hops of reverse proxy: axum-kbve authenticates + scopes to staff, firecracker-ctl-net does name→VM lookup and forwards over TAP.

### API Additions (firecracker-ctl-net only)

| Method | Path | Description |
|--------|------|-------------|
| `POST` | `/fc/deploy` | Deploy a persistent VM with a unique name + http_port |
| `GET` | `/fc/list` | List all persistent endpoints with status |
| `GET` | `/fc/{name}` | Get a single endpoint's metadata + health |
| `DELETE` | `/fc/{name}` | Stop and destroy a persistent endpoint |
| `ANY` | `/proxy/{name}/{*path}` | Reverse-proxy HTTP into the named VM |

Deploy payload includes rootfs image, entrypoint, optional code blob (raw drive), env vars (via MMDS), http_port, vcpu/memory. No timeout field — persistent VMs live until `DELETE`.

### Networking (TAP per VM)

Persistent endpoints require TAP networking (deferred in Phase 1 for ephemeral VMs — MMDS was enough for outbound-only workloads). Inbound HTTP to a specific guest IP:port is not reachable via MMDS.

- Each persistent VM gets a `/dev/net/tun` TAP device inside the firecracker-ctl-net pod netns
- A private /30 per VM out of `172.18.0.0/16` (host .1, guest .2)
- firecracker-ctl maintains `name → tap_ip:http_port` map for the proxy
- Guest gets the IP via kernel `ip=` boot args; no DHCP needed
- Gluetun's iptables rules already allow the pod netns internal subnets; VM egress flows out the WireGuard tunnel unchanged

### Lifecycle

- **Deploy** → allocate TAP + IP, boot VM, wait for `GET http://{tap_ip}:{http_port}/health` (configurable path), mark healthy
- **Unhealthy** → mark `degraded`; proxy still forwards; restart is manual (no auto-restart in phase 1)
- **Delete** → SIGTERM the VMM process, release TAP + IP, remove from map
- **Pod restart** → all persistent endpoints lost (in-memory state only). Phase 2 adds on-disk persistence + automatic redeploy.

### Rootfs Requirements

A persistent-VM rootfs must:
- Boot with `ip=...::::eth0:off` kernel args (kernel-side config, no DHCP)
- Run an HTTP server on the declared `http_port` as PID 1 (or via a wrapper that re-execs entrypoint)
- Respond to `GET /health` with `200` when ready

New rootfs image planned: `alpine-python-web` (Alpine + Python + uvicorn + a tiny FastAPI shim), `alpine-node-web` (Alpine + Node + express shim). Tracked as `alpine-python` / `alpine-node` derivatives in the rootfs init job.

### Security

- Path prefix `/fc/*` is staff-gated at axum-kbve (same permission as `/dashboard/*` routes)
- VMs cannot reach each other — Firecracker jailer isolates per-VM netns; TAP devices sit on a bridge with inter-guest traffic dropped
- VMs cannot reach cluster services — NetworkPolicy already denies cluster egress from the pod; Gluetun's firewall drops anything not going through the tunnel
- Outbound is metered by the VPN provider, not KBVE — no per-endpoint quotas in phase 1

### Phased Delivery

- **Phase 1** — docs + routing skeleton: `/fc/*` gateway entry, axum-kbve handler, firecracker-ctl 501 stubs
- **Phase 2a** — IP allocator (`Ipv4Pool`, `IpAllocation`): pure logic, thread-safe, carves `/30` subnets from `172.18.0.0/16` (16384 slots). 13 unit tests.
- **Phase 2b** — TAP device manager (`TapManager`): shells out to `ip` + `iptables` to create TAPs and install pod-level NAT/FORWARD rules. Idempotent init. Command assembly factored into pure builders with 13 more unit tests.
- **Phase 2c** — lifecycle registry: `/fc/deploy` allocates IP + creates TAP + registers in DashMap; `/fc/list` / `/fc/{name}` / `DELETE /fc/{name}` wired end-to-end; endpoints land in `pending` status. VM process spawn deferred to 2e. `FC_PERSISTENT_ENDPOINTS_ENABLED` env gate ensures only the `-net` deployment carries persistent state.
- **Phase 2d** — HTTP forwarder: `/proxy/{name}/{*path}` reverse-proxies to `http://{guest_ip}:{http_port}/{path}` preserving method/headers/body; streams response.
- **Phase 2e** — VM lifecycle: actually spawn the Firecracker VMM with the TAP attached and `ip=` kernel boot args; transition `pending → starting → healthy`. Health-check loop marks `degraded` on failure.
- **Phase 3** — web-server rootfs images (`alpine-python-web`, `alpine-node-web`) + example deployments
- **Phase 4** — dashboard UI: deploy form, endpoint list, health badges, logs viewer
- **Phase 5** — on-disk state + auto-redeploy on pod restart
- **Phase 6** — per-endpoint quotas + metrics dashboard

## FAQ

**What does Firecracker CTL do?**
It is a Rust Axum REST API that manages Firecracker microVMs — creating, polling,
and destroying them — with per-VM timeout enforcement and in-memory state tracking
via DashMap.

**How is user code executed inside a VM?**
Code arrives via `env.CODE`, is written to a padded raw block attached as a second
drive (`/dev/vdb`), and the VM init reads it, writes `/tmp/code`, and execs the
entrypoint passed through `boot_args`.

**What are persistent endpoints?**
Long-lived VMs in the networked `-net` deployment that expose HTTP servers over
per-VM TAP networking, routed by name from the public edge and living until
explicitly deleted.

## Related

- [Firecracker Python Web](/docs/project/firecracker-python-web) — Python web rootfs image.
- [Firecracker Node Web](/docs/project/firecracker-node-web) — Node.js web rootfs image.
- [Firecracker Python Net](/docs/project/firecracker-python-net) — networked Python endpoint image.

---
# Firecracker Node Web — Fastify-Ready Alpine Node 22 Rootfs

> Fastify-ready Alpine 3.21 + Node 22 Firecracker rootfs for long-lived dashboard IDE endpoints, baking fastify, undici, zod, and pino so VMs boot ready.

Source: https://kbve.com/project/firecracker-node-web/

## Overview

Fastify-ready Node rootfs used by the **staff-side** Firecracker deployment (`firecracker-ctl-net`). Built as a multi-stage Docker image whose final layer (alpine 3.21 + `/rootfs.ext4`) ships a `cp` entrypoint so the in-cluster stage Job can run the image directly and copy `/rootfs.ext4` onto the firecracker rootfs PVC.

This is the **long-lived deploy** rootfs for Node endpoints submitted through the dashboard IDE — week-to-month TTL VMs where paying a build-time `npm install` is the right tradeoff for instant boot. Quick one-shot Node VMs keep the smaller `alpine-node` rootfs plus the shared `npm-cache.ext4` drive.

## What's baked in

- Alpine 3.21 + Node.js 22 LTS + npm
- `fastify`, `@fastify/cors`, `@fastify/helmet`, `@fastify/static`, `undici`, `zod`, `pino`, `pino-pretty`, `dotenv`, `nanoid`, `date-fns`, `commander`, `chalk` resolved into `/usr/lib/node_modules`
- `ca-certificates-bundle`, `ca-certificates`, `iproute2`
- `/etc/resolv.conf` with `1.1.1.1` and `8.8.8.8`
- `/init` mounts `/proc`, `/sys`, `/dev`, brings up `lo` + `eth0`, exports `NODE_PATH=/usr/lib/node_modules`, then `exec /entrypoint`

## Ecosystem

| Image | Runtime | Deployment | Network | Server lib baked |
|-------|---------|-----------|---------|------------------|
| `alpine-python` | Python | `firecracker-ctl` (public quick) | none | no |
| `alpine-node` | Node | `firecracker-ctl` (public quick) | none | no |
| `firecracker-python-net` | Python | `firecracker-ctl-net` (staff, short-lived) | TAP via Gluetun/WireGuard | requests/httpx |
| `firecracker-python-web` | Python | `firecracker-ctl-net` (staff, long-lived) | TAP via Gluetun/WireGuard | FastAPI |
| `firecracker-node-web` (this) | Node | `firecracker-ctl-net` (staff, long-lived) | TAP via Gluetun/WireGuard | Fastify |

## Build

```bash
npx nx run firecracker-node-web:container
npx nx run firecracker-node-web:extract
```

Output: `packages/docker/firecracker/node/web/dist/node-web.ext4`.

## Publish

```bash
npx nx run firecracker-node-web:container:production
```

Pushes `ghcr.io/kbve/firecracker-node-web:latest` and `:<version>`.

## FAQ

**What is the Firecracker Node Web rootfs?**
It is a Fastify-ready Alpine 3.21 + Node.js 22 LTS rootfs used by the staff-side
Firecracker deployment (`firecracker-ctl-net`). It is built as a multi-stage
Docker image whose final layer ships a `cp` entrypoint so an in-cluster stage Job
copies `/rootfs.ext4` onto the firecracker rootfs PVC.

**Why bake npm dependencies into the image?**
This is the long-lived deploy rootfs for Node endpoints submitted through the
dashboard IDE, running week-to-month TTL VMs. Paying a build-time `npm install`
is the right tradeoff for instant boot, so fastify, undici, zod, pino, and the
`@fastify` ecosystem ship already resolved into `/usr/lib/node_modules`.

**When should I use alpine-node instead?**
Quick one-shot Node VMs use the smaller `alpine-node` rootfs plus the shared
`npm-cache.ext4` drive. Use `firecracker-node-web` only for long-lived staff
endpoints that benefit from pre-baked server libraries.

## Related

- [Memes](/docs/project/memes) — sibling Docker-pipeline application in the KBVE stack.

---
# Firecracker Python Net — Network Alpine Python Rootfs

> Network-capable Alpine + Python rootfs image for the staff-side firecracker-ctl-net deployment, baking requests, httpx, certifi, CA bundle, and public DNS.

Source: https://kbve.com/project/firecracker-python-net/

## Overview

Network-capable Python rootfs image used by the **staff-side** Firecracker deployment (`firecracker-ctl-net`). Built as a multi-stage Docker image whose final layer (alpine 3.21 + `/rootfs.ext4`) ships a `cp` entrypoint so the in-cluster stage Job can run the image directly and copy `/rootfs.ext4` onto the firecracker rootfs PVC.

This image is **not** for the public sandbox quick-mode VMs. Those keep the no-network `alpine-python` rootfs from [apps/vm/firecracker-ctl/rootfs/Dockerfile.alpine-python](apps/vm/firecracker-ctl/rootfs/Dockerfile.alpine-python) — sandboxing without internet egress is the safety property.

## What's baked in

- Alpine 3.21 + Python 3.12
- `py3-pip`, `py3-requests`, `py3-httpx`, `py3-urllib3`, `py3-certifi`
- `ca-certificates-bundle`, `ca-certificates`, `iproute2`
- `/etc/resolv.conf` with `1.1.1.1` and `8.8.8.8`
- `/init` mounts `/proc`, `/sys`, `/dev`, brings up `lo` + `eth0`, then `exec /entrypoint`

## Two ecosystems

| Image | Deployment | Network | DNS | requests baked |
|-------|-----------|---------|-----|----------------|
| `alpine-python` (existing) | `firecracker-ctl` (public quick) | none | no | no |
| `firecracker-python-net` (this) | `firecracker-ctl-net` (staff persistent) | TAP via Gluetun/WireGuard | yes | yes |

## Build

```bash
npx nx run firecracker-python-net:container
npx nx run firecracker-python-net:extract
```

Output: `packages/docker/firecracker/python/net/dist/python-net.ext4`.

## Publish

```bash
npx nx run firecracker-python-net:container:production
```

Pushes `ghcr.io/kbve/firecracker-python-net:latest` and `:<version>`.

## FAQ

**What is the Firecracker Python Net image?**
It is a network-capable Alpine 3.21 plus Python 3.12 rootfs image for the
staff-side `firecracker-ctl-net` deployment. It bakes in requests, httpx, urllib3,
certifi, the CA-certificates bundle, and a `resolv.conf` pointing at public DNS.

**How is Firecracker Python Net different from alpine-python?**
The `alpine-python` rootfs used by the public quick-mode `firecracker-ctl` VMs
ships with no network, no DNS, and no requests, keeping sandboxes egress-free.
Firecracker Python Net is the opposite, with TAP networking via Gluetun/WireGuard,
DNS, and HTTP libraries baked in for the staff persistent deployment.

**How is the Firecracker Python Net rootfs built and delivered?**
It is a multi-stage Docker image whose final Alpine layer ships a `cp` entrypoint,
so an in-cluster stage Job runs the image directly and copies `/rootfs.ext4` onto
the firecracker rootfs PVC.

## Related

- [Metrics](/docs/project/metrics) — Dockerized Rust service in the same infrastructure family.

---
# Firecracker Python Web — FastAPI-Ready Rootfs Image

> FastAPI-ready Alpine + Python Firecracker rootfs for long-lived dashboard-IDE endpoints, baking fastapi, uvicorn, starlette, websockets, and the requests stack.

Source: https://kbve.com/project/firecracker-python-web/

## Overview

FastAPI-ready Python rootfs used by the **staff-side** Firecracker deployment (`firecracker-ctl-net`). Built as a multi-stage Docker image whose final layer (alpine 3.21 + `/rootfs.ext4`) ships a `cp` entrypoint so the in-cluster stage Job can run the image directly and copy `/rootfs.ext4` onto the firecracker rootfs PVC.

This is the **long-lived deploy** rootfs for endpoints submitted through the dashboard IDE — week-to-month TTL VMs where paying a build-time pip install is the right tradeoff for instant boot. Quick one-shot VMs keep the smaller `alpine-python` rootfs plus the shared pip-cache.

## What's baked in

- Alpine 3.21 + Python 3.12
- `py3-pip`, `py3-requests`, `py3-httpx`, `py3-urllib3`, `py3-certifi` (apk)
- `fastapi`, `uvicorn`, `starlette`, `python-multipart`, `email-validator`, `websockets`, `anyio`, `sniffio`, `h11`, `click` (pip, musllinux wheels)
- `ca-certificates-bundle`, `ca-certificates`, `iproute2`
- `/etc/resolv.conf` with `1.1.1.1` and `8.8.8.8`
- `/init` mounts `/proc`, `/sys`, `/dev`, brings up `lo` + `eth0`, then `exec /entrypoint`

## Three ecosystems

| Image | Deployment | Network | DNS | requests baked | FastAPI baked |
|-------|-----------|---------|-----|----------------|---------------|
| `alpine-python` | `firecracker-ctl` (public quick) | none | no | no | no |
| `firecracker-python-net` | `firecracker-ctl-net` (staff, short-lived) | TAP via Gluetun/WireGuard | yes | yes | no |
| `firecracker-python-web` (this) | `firecracker-ctl-net` (staff, long-lived) | TAP via Gluetun/WireGuard | yes | yes | yes |

## Build

```bash
npx nx run firecracker-python-web:container
npx nx run firecracker-python-web:extract
```

Output: `packages/docker/firecracker/python/web/dist/python-web.ext4`.

## Publish

```bash
npx nx run firecracker-python-web:container:production
```

Pushes `ghcr.io/kbve/firecracker-python-web:latest` and `:<version>`.

## FAQ

**What is the firecracker-python-web rootfs?**
It is a FastAPI-ready Alpine 3.21 plus Python 3.12 Firecracker rootfs image built for
the staff-side long-lived deployment. It bakes fastapi, uvicorn, starlette,
websockets, and the requests/httpx stack so VMs boot with the server libraries
already on disk.

**How does firecracker-python-web differ from the other Firecracker rootfs images?**
`alpine-python` is the public quick rootfs with no network and no baked libraries,
`firecracker-python-net` adds TAP networking, DNS, and the requests stack for
short-lived staff VMs, and `firecracker-python-web` additionally bakes the FastAPI
server stack for long-lived endpoints submitted through the dashboard IDE.

**How is the firecracker-python-web image built and published?**
It is a multi-stage Docker build whose final layer ships a `cp` entrypoint that copies
`/rootfs.ext4` onto the firecracker rootfs PVC. Build with
`nx run firecracker-python-web:container` and extract; the production target pushes
`ghcr.io/kbve/firecracker-python-web` at `latest` and the version tag.

## Related

- [firecracker-python-net](/project/firecracker-python-net/) — the short-lived staff rootfs with networking but no FastAPI stack.
- [firecracker-ctl](/project/firecracker-ctl/) — the Firecracker control plane that deploys these rootfs images.

---
# Fudster — Composable ML Library and CLI for KBVE

> Fudster is a composable Python ML library and CLI for haystack-ai and pgvector integrations, with async HTTP/WebSocket API clients and optional tooling extras.

Source: https://kbve.com/project/fudster/

## Overview

Fudster is a composable Python ML library and CLI for haystack-ai and pgvector integrations, built as a thin layer around the KBVE core. It bundles broadcast and API models, async HTTP and WebSocket clients, and application clients (RuneLite, Chrome, Discord, screen, noVNC), all exposed through the `fudster` command-line entry point.

## Key facts

| | |
|---|---|
| **Package** | `python-fudster` (PyPI `fudster`) |
| **Version** | 1.0.3 |
| **Language** | Python `>=3.12,<3.14` |
| **License** | MIT |
| **Source** | [`packages/python/fudster`](https://github.com/KBVE/kbve/tree/main/packages/python/fudster) |
| **CLI** | `fudster` |

## Features

- **Composable ML core** — designed for haystack-ai and pgvector integrations, layered on top of the `kbve` package.
- **API surface** — `Routes`, `CORS`, `WS`, and `APIConnector` for building FastAPI-backed async HTTP and WebSocket services.
- **Built-in clients** — `CoinDeskClient`, `PoetryDBClient`, `GroqClient`, and `WebsocketEchoClient`, plus app clients like `RuneLiteClient`, `ChromeClient`, and `DiscordClient`.
- **Broadcast + data models** — `BroadcastModel`, `CommandModel`, `HandshakeModel`, RSS, poem, and game-event models.
- **Optional extras** — `automation`, `browser`, `ocr`, and `vnc` extras keep heavy dependencies (opencv, seleniumbase, pytesseract, websockify) off the core install.

## Usage

```bash
pip install fudster

# development inside the KBVE monorepo
pnpm nx test python-fudster
pnpm nx lint python-fudster
pnpm nx build python-fudster
```

## FAQ

**What is Fudster?**
Fudster is a composable Python ML library and CLI built around the `kbve` core, focused on haystack-ai and pgvector integrations. It ships API models, async HTTP/WebSocket clients, and a `fudster` command-line entry point.

**How do I install Fudster?**
Install it from PyPI with `pip install fudster`. It requires Python 3.12 or newer and pulls in `kbve`, `pydantic`, `fastapi`, `aiohttp`, and related async and parsing dependencies.

**What optional extras does Fudster provide?**
Fudster offers opt-in extras kept off the core install — `automation` (opencv, pyautogui, humancursor), `browser` (seleniumbase), `ocr` (pytesseract), and `vnc` (websockify, websockets) — plus an `all` extra that bundles them together.

## Related

- [Python KBVE](/project/python-kbve) — the core `kbve` package Fudster is built on.

---
# Graph — 3D Visualization of Interconnected MDX Notes

> KBVE Graph is a 3D visualization of interconnected MDX notes, inspired by the Obsidian Graph View, for exploring relationships between notes.

Source: https://kbve.com/project/graph/

import {
  Aside,
  Steps,
  Card,
  CardGrid,
  Code,
  FileTree,
} from '@astrojs/starlight/components';

import { Giscus, Adsense } from '@/components/astropad';

## Graph

Introducing the KBVE Graph, a revolutionary upgrade to traditional graph views. 
Inspired by the Obsidian Graph View, our 3D graph visualization brings your interconnected MDX notes to life in a dynamic three-dimensional space.
Each node represents a unique note within our collection, seamlessly connected to related notes, providing an immersive and intuitive way to explore your data.
Navigate through the intricate web of information with ease, gaining deeper insights and a clearer understanding of complex relationships within your notes.


## Roadmap

The general roadmap outlining the key steps to create and deploy the KBVE 3D Graph:

<Steps>

1. **Project Planning and Requirements Gathering**
   - Define the scope and objectives of the KBVE Graph project.
   - Identify key features and functionalities needed for the 3D graph.
   - Gather and organize the MDX notes data to be visualized.

2. **Technology Stack Selection**
   - Choose a 3D rendering library (e.g., Three.js, Babylon.js).
   - Select a framework for building the application (e.g., React, Vue).
   - Decide on a backend technology for data management (e.g., Node.js, Python).

3. **Initial Setup**
   - Set up the development environment.
   - Initialize the project with the chosen framework and libraries.
   - Configure version control with Git.

4. **Data Preparation**
   - Parse and structure the MDX notes into a suitable format for visualization.
   - Create a schema for nodes and edges representing the notes and their connections.

5. **Graph Data Management**
   - Develop or integrate a database to store and manage the graph data.
   - Implement APIs for retrieving and updating graph data.

6. **3D Graph Visualization**
   - Set up the 3D rendering context using the chosen library.
   - Implement the core functionality to render nodes and edges in 3D space.
   - Add interactivity features like zoom, pan, and rotation.

7. **Node and Edge Representation**
   - Design visual representations for nodes and edges.
   - Implement different styles and colors to distinguish node types and connections.

8. **Interactivity and User Controls**
   - Add user controls for navigating the 3D graph (e.g., mouse and keyboard controls).
   - Implement node selection and tooltip functionality for detailed information.

9. **Search and Filter Functionality**
   - Develop features for searching and filtering nodes based on keywords and attributes.
   - Implement highlighting and focus mechanisms for search results.

10. **Performance Optimization**
    - Optimize rendering performance for large graphs.
    - Implement lazy loading and level of detail (LOD) techniques.

11. **UI/UX Design**
    - Design a user-friendly interface for interacting with the graph.
    - Add UI elements like menus, buttons, and information panels.

12. **Testing**
    - Conduct unit tests and integration tests to ensure functionality.
    - Perform user testing to gather feedback and improve usability.

13. **Documentation**
    - Create comprehensive documentation for users and developers.
    - Include setup guides, API documentation, and usage instructions.

14. **Deployment Preparation**
    - Set up hosting for the application (e.g., AWS, Heroku).
    - Configure continuous integration and deployment pipelines.

15. **Initial Deployment**
    - Deploy the application to a staging environment for final testing.
    - Conduct a thorough review and fix any issues identified.

16. **Launch**
    - Deploy the application to the production environment.
    - Announce the launch and provide access to users.

17. **Post-Launch Monitoring**
    - Monitor application performance and user feedback.
    - Address any bugs or issues that arise post-launch.

18. **Ongoing Maintenance**
    - Regularly update the application with new features and improvements.
    - Maintain the backend and ensure data integrity.

19. **Community and Support**
    - Build a community around the KBVE Graph project.
    - Provide support and gather feedback for continuous enhancement.

20. **Future Enhancements**
    - Plan and implement advanced features like collaboration, real-time updates, and AI-driven insights.
    - Continuously improve the user experience based on feedback and technological advancements.

</Steps>

## FAQ

**What is the KBVE Graph?**
The KBVE Graph is a 3D visualization of interconnected MDX notes, inspired by
the Obsidian Graph View, where each node represents a note and edges represent
connections between related notes.

**What is the KBVE Graph inspired by?**
It is inspired by the Obsidian Graph View, extending the traditional 2D graph
into a dynamic three-dimensional space for a more immersive way to explore note
relationships.

**How will the KBVE Graph be built?**
The roadmap outlines selecting a 3D rendering library such as Three.js or
Babylon.js, parsing MDX notes into a node-and-edge schema, adding interactivity
like zoom, pan, rotation, search, and filtering, then optimizing performance for
large graphs.


<Adsense />


<Giscus />

---
# HerbMail — Global Gourmet Herbs & Spices Delivery Platform

> HerbMail is a global online herbs and spices platform with regional kits, seasonal specials, rare finds, subscription boxes, and a Spice Sommelier tool.

Source: https://kbve.com/project/herbmail/

## Introduction

HerbMail.com - Your Global Gateway to Gourmet Herbs and Spices

Welcome to HerbMail.com, where the fragrant secrets of the world's most exotic herbs and spices are just a click away.
Our mission is simple: to bring the world's finest flavors right to your kitchen doorstep.
Whether you are a seasoned chef looking for the perfect pinch of rare saffron or a home cook eager to experiment with aromatic herbs, HerbMail.com is your ultimate spice rack!

## Key facts

| | |
|---|---|
| **App** | `herbmail` |
| **Version** | 0.1.1 |
| **Backend** | Rust (axum), image `kbve/herbmail` |
| **Deploy** | KBVE application Kubernetes stack (prod) |
| **License** | KBVE |
| **Source** | [`apps/herbmail`](https://github.com/KBVE/kbve/tree/main/apps/herbmail) |

## Explore Our Products

-   **Regional Herb Kits:** Curated selections from specific regions like Provence, Tuscany, Kerala, and Sichuan.
-   **Seasonal Specials:** Limited-time offerings that highlight the best of what's in season, from fresh peppermint in winter to wild sage in summer.
-   **Rare Finds:** Exotic and hard-to-find spices that can transform any meal into a gourmet experience.

## Innovations for Growth

### Subscription Boxes

Subscribe to a world of flavors with our monthly spice box subscription.
Each box features a selection of herbs and spices tailored to your culinary preferences, along with recipes, usage tips, and the fascinating stories behind each spice.

### Interactive Spice Sommelier

Our digital Spice Sommelier helps you pair the perfect herbs and spices with your meals.
Just enter your ingredients, and our AI-driven tool will suggest the best spices to enhance your dish.

### HerbMail Community and Workshops

Join live online workshops hosted by seasoned chefs and spice experts.
Learn new recipes, get tips on herb and spice pairings, and connect with fellow culinary enthusiasts.

## Marketing Magic

### Engaging Social Media Campaigns

HerbMail.com's social media strategy is designed to inspire and engage culinary enthusiasts, showcasing the beauty and versatility of herbs and spices.
By utilizing vibrant visuals and engaging content on platforms like Instagram, Pinterest, and Facebook, the company aims to:

-   Share recipes and cooking tips from renowned chefs and spice experts
-   Highlight the unique benefits and uses of different herbs and spices
-   Showcase the story behind each product, from the origin to the production process
-   Collaborate with influencers and food bloggers to expand reach and credibility
-   Create interactive content, such as polls and quizzes, to increase engagement and foster a sense of community
-   Monitor and respond to customer feedback and inquiries in a timely and professional manner

By engaging with followers and providing valuable content, HerbMail.com aims to build a loyal customer base and drive traffic to their website, ultimately increasing sales and brand visibility.

### Collaborative Ventures

Partnering with renowned chefs and popular cooking shows can elevate our brand's visibility and credibility, enticing more customers to explore our offerings.

-   Hosting guest chefs or influencers on HerbMail.com's social media channels or blog to share recipes and tips, increasing engagement and reach.
-   Co-branding products with renowned chefs, such as signature spice blends or exclusive collaborations.
-   Sponsoring cooking competitions or events, providing HerbMail.com with exposure to a wider audience.
-   Offering exclusive recipes or content from collaborating chefs to subscribers, enhancing the value of the subscription boxes.
-   Creating co-branded content, such as recipe books or cooking videos, to showcase the partnership and offer additional value to customers.
-   Collaborating on charity events or initiatives, aligning HerbMail.com with positive social impact and further enhancing brand image.

### Loyalty Rewards Program

Customers can earn points for every purchase, which can be redeemed for discounts, free products, or exclusive access to special events and releases.

-   Points can be accumulated through various actions, such as sharing products on social media or referring friends to HerbMail.com.
-   Customers can track their points and rewards progress through their account dashboard.
-   Tiered rewards system allows customers to unlock additional benefits as they accumulate more points.
-   Points can be used to purchase exclusive merchandise, such as branded aprons or cookbooks.
-   Customers can redeem points for personalized consultations with HerbMail's spice experts or virtual cooking classes.
-   Points can be combined with other promotions and discounts to maximize savings.

## Sustainability Commitment

HerbMail.com's sustainability commitment extends beyond eco-friendly packaging and fair trade practices. The company is dedicated to sourcing high-quality herbs that are produced and consumed in ways that sustain human and environmental health. This involves:

-   Adhering to strict quality control standards
-   Supporting sustainable farming practices, such as regenerative agriculture and pollinator-friendly methods
-   Promoting biodiversity and soil health
-   Partnering with organizations that prioritize racial justice, regenerative farming, and health & wellness
-   Reducing waste and carbon emissions through recycling and closed-loop systems
-   Providing transparency about the origin and production of herbs used in their products

By implementing these practices, HerbMail.com aims to contribute to the long-term health of the planet and the communities that grow their herbs.

## Join Us on a Culinary Journey!

Visit us at HerbMail.com and discover how easy and enjoyable it is to bring the rich tastes of the world into your home kitchen.
Sign up today and receive 10% off your first order.
Let’s spice up your mealtime adventures together!

## FAQ

**What is HerbMail?**
HerbMail.com is a global online platform for gourmet herbs and spices, offering
regional herb kits, seasonal specials, and rare hard-to-find finds delivered to
your kitchen.

**What services does HerbMail offer?**
HerbMail offers monthly spice-box subscriptions tailored to your tastes, an
AI-driven Spice Sommelier that pairs herbs and spices to your ingredients, live
online workshops with chefs, and a loyalty rewards program.

**How is HerbMail built and hosted?**
HerbMail runs on an axum (Rust) backend shipped as the `kbve/herbmail` Docker image
and deployed on the KBVE application Kubernetes stack in production.

## Related

- [API](/docs/project/api) — the KBVE core API service.
- [Edge](/docs/project/edge) — KBVE edge application services.

---
# holy — Rust Proc-Macro Derives for Structs

> holy is a Rust proc-macro crate with derive macros for getters, setters, observers, fuzz constructors, and input sanitization to end struct boilerplate.

Source: https://kbve.com/project/holy-crate/

import { Content as HolyReadme } from '../../../../../../../packages/rust/holy/README.md';

## Overview

`holy` is a Rust proc-macro library that ships derive macros for everyday struct chores: getters, setters, observers, fuzz constructors, and input sanitization. Pulling it as a path or crates.io dependency keeps each consumer free of hand-rolled boilerplate and centralizes policy changes — new sanitize rules, observer hooks, and the like — in one crate.

## Key facts

| | |
|---|---|
| **Package** | `holy` |
| **Version** | 0.2.1 |
| **Language** | Rust (proc-macro) |
| **License** | MIT |
| **Derives** | Getters, Setters, Observer, Fuzz, Sanitize |
| **Source** | [`packages/rust/holy`](https://github.com/KBVE/kbve/tree/main/packages/rust/holy) |

## FAQ

**What is the holy crate?**
`holy` is a Rust proc-macro library shipping derive macros for everyday struct chores — getters, setters, observers, fuzz constructors, and input sanitization — so consumers avoid hand-rolled boilerplate.

**Which derive macros does holy provide?**
`Getters`, `Setters`, `Observer` (change events), `Fuzz` (random constructors for tests), and `Sanitize` (`.sanitize()` plus per-field methods driven by `#[holy(sanitize = ...)]` rules).

**What sanitization rules does the Sanitize derive support?**
String rules like `trim`, `lowercase`, `uppercase`, `alphanumeric`, `escape_html`, `nul_strip`, `control_strip`, `slug`, and `truncate(N)`, plus `clamp(min, max)` for numeric fields; rules run in the order written and `Option<String>` fields run only when `Some`.

## Reference

<HolyReadme />

---
# KBVE IoT Edge Worker — WireGuard k8s Node

> Cloud-init template and bootstrap helper to join a local dev VM (OrbStack, Lima, UTM) to the KBVE Talos cluster as a remote worker over WireGuard.

Source: https://kbve.com/project/iot-edge-worker/

## Overview

`iot-edge-worker` is a cloud-init template + shell helper for joining a local dev machine (OrbStack, Lima, or UTM VM) to the main KBVE Talos cluster as a remote worker over WireGuard.

It does **not** ship as a runtime binary or Docker image — the artifact is the template itself, rendered per-laptop and consumed by the VM host at first boot.

## Why

The main KBVE cluster runs on Talos at Hetzner. For dev/experimentation we want a way to pull an idle laptop into the cluster as extra compute without:

- Installing a full Talos OS on the laptop
- Running kubelet-in-a-container (privileged, fragile)
- Opening inbound ports on the home network

WireGuard solves the network problem (the laptop dials out to a fixed endpoint), and a plain `kubeadm join` on a minimal Alpine/Ubuntu VM gives us a real kubelet that the Talos control plane sees as a normal worker.

## Architecture

```
Talos cluster (Hetzner)
    │
    ├─ apiserver (10.88.0.1:6443 over WireGuard)
    └─ wireguard endpoint (public IP:51820)
           ↕
        WireGuard tunnel
           ↕
    OrbStack / Lima / UTM VM on laptop
    └─ Alpine or Ubuntu minimal
           └─ wg-quick@wg0 (systemd)
           └─ containerd
           └─ kubelet (joined via kubeadm token)
```

The worker is tainted `edge=true:NoSchedule` and labeled `role=edge`, so existing workloads don't accidentally schedule to it — only pods that explicitly tolerate the taint and target the label.

## Files

| File | Purpose |
|---|---|
| `cloud-init.yaml.tmpl` | cloud-init template with WireGuard config, kubeadm install, systemd units |
| `bootstrap.sh` | Generates a wireguard keypair and renders the template with per-laptop values |
| `project.json` | Nx lint target (shell syntax check + yamllint) |
| `version.toml` | Version tracking |

## Operator workflow

1. **Generate a wireguard keypair on the laptop:**
   ```bash
   ./bootstrap.sh keygen > wg0.key
   wg pubkey < wg0.key  # copy this pubkey
   ```

2. **On the Talos side, add the peer to the server-side wireguard config** and restart the wg-quick service. Record the server's wireguard public key and endpoint.

3. **Generate a kubeadm bootstrap token** on any Talos control-plane node:
   ```bash
   kubeadm token create --print-join-command
   # outputs: kubeadm join <apiserver> --token <TOKEN> --discovery-token-ca-cert-hash <HASH>
   ```

4. **Render the cloud-init** with all the collected values:
   ```bash
   ./bootstrap.sh render \
       --name edge-laptop-01 \
       --wg-private-key "$(cat wg0.key)" \
       --wg-address 10.88.0.12/32 \
       --wg-peer-pubkey <talos-wg-pubkey> \
       --wg-endpoint <talos-public-ip>:51820 \
       --wg-allowed-ips 10.96.0.0/12,10.244.0.0/16 \
       --apiserver https://10.88.0.1:6443 \
       --token <TOKEN> \
       --ca-hash <HASH> \
       --k8s-version 1.33 \
       > edge-laptop-01.cloud-init.yaml
   ```

5. **Deploy the VM** using OrbStack, Lima, or UTM:
   ```bash
   # OrbStack (when cloud-init support lands):
   orbctl create alpine edge-laptop-01 --cloud-init=./edge-laptop-01.cloud-init.yaml

   # Lima (works today):
   limactl start --name=edge-laptop-01 ./edge-laptop-01.cloud-init.yaml

   # UTM: import the cloud-init as a user-data seed ISO
   ```

6. **Verify from the Talos side:**
   ```bash
   kubectl get nodes
   # NAME              STATUS   ROLES    AGE   VERSION
   # edge-laptop-01    Ready    <none>   2m    v1.33.x
   ```

## Scheduling to the edge worker

Workloads that want to run on the edge worker must tolerate the taint and target the label:

```yaml
spec:
  nodeSelector:
    role: edge
  tolerations:
    - key: edge
      operator: Equal
      value: "true"
      effect: NoSchedule
```

## Scope (v1)

- Single-arch amd64 (cloud-init pulls kubeadm amd64 binaries)
- Manual keygen + token workflow (no automation yet)
- Container workloads only — **Firecracker microVMs are out of scope** because they need nested KVM, which requires M3+ Apple Silicon and adds fragility

## Future work

- arm64 branch of the template
- Rust CLI (`kbve-edge-bootstrap`) that pulls credentials from Vault/ESO and handles the whole workflow
- Reconciler on the Talos side that auto-removes stale edge nodes + revokes their wireguard peers
- Nested-virt Firecracker support (separate project, M3+ only)

## FAQ

**What is iot-edge-worker?**
A cloud-init template plus shell helper that joins a local dev machine (OrbStack,
Lima, or UTM VM) to the main KBVE Talos cluster as a remote worker over
WireGuard.

**Does it ship as a binary or Docker image?**
No. The artifact is the cloud-init template itself, rendered per-laptop and
consumed by the VM host at first boot — there is no runtime binary.

**How are edge workloads kept off normal nodes?**
The worker is tainted `edge=true:NoSchedule` and labeled `role=edge`, so only
pods that explicitly tolerate the taint and target the label schedule onto it.

---
# IRC Gateway — WebSocket-to-IRC Bridge

> Rust Axum IRC gateway bridging WebSocket clients to an Ergo IRC server with JWT auth, per-channel Valkey history, rate limiting, and a shared chat schema.

Source: https://kbve.com/project/irc-gateway/

## Overview

The IRC Gateway is a Rust Axum service that bridges **WebSocket clients to an Ergo
IRC server**. It adds **JWT authentication**, **per-channel chat history** backed by
Valkey, **rate limiting**, and a **shared chat message schema** (`bevy_chat`) so
web and game clients speak the same vocabulary as the underlying IRC network. It
fronts KBVE's `/minechat` and `/gamechat` channels.

## Key facts

| | |
|---|---|
| **Image** | `kbve/irc-gateway` |
| **Language** | Rust (Axum, Tokio) |
| **Backend** | Ergo IRC server + Valkey |
| **Auth** | JWT (jsonwebtoken) |
| **License** | KBVE |
| **Source** | [`apps/irc/irc-gateway`](https://github.com/KBVE/kbve/tree/main/apps/irc/irc-gateway) |

## Features

- **WebSocket ↔ IRC bridge** — proxies WebSocket sessions onto Ergo IRC connections.
- **JWT auth** — validates tokens before granting channel access.
- **Per-channel history** — a listener task per channel rings recent PRIVMSGs for backscroll.
- **Rate limiting** — ingress throttling to protect the IRC backend.
- **Shared chat schema** — `bevy_chat` `ChatMessage` ⇄ IRC PRIVMSG translation.
- **REST + WebSocket transports** — HTTP endpoints alongside the live socket.

## Usage

Built and deployed as the `kbve/irc-gateway` container on Kubernetes; clients
connect over WebSocket with a valid JWT to join a channel and receive recent
history plus live messages.

## FAQ

**What does the IRC Gateway do?**
It is a Rust Axum service that bridges WebSocket clients to an Ergo IRC server,
adding JWT authentication, per-channel chat history, rate limiting, and a shared
chat message schema.

**How is chat history handled?**
A dedicated listener task per channel holds its own IRC connection and appends
every PRIVMSG to a per-channel ring buffer, so freshly connected clients can be
shown recent backscroll.

**What transport and auth does it use?**
It exposes WebSocket and REST transports over Axum with JWT verification, and uses
the shared `bevy_chat` schema to translate between `ChatMessage` and IRC PRIVMSG frames.

## Related

- [Bevy Chat Crate](/docs/project/bevy-chat-crate) — shared chat message schema.
- [DiscordSH](/docs/project/discordsh) — Discord bridge sharing the chat pipeline.
- [Minecraft Server](/docs/project/mc) — game server feeding the `/minechat` channel.

---
# Isometric — Bevy Multiplayer Browser Game (WASM + Tauri)

> KBVE Isometric is a multiplayer isometric browser game built in Rust with Bevy 0.18, lightyear networking, and avian3d physics, running as WASM and Tauri.

Source: https://kbve.com/project/isometric/

import {
    Aside,
    Steps,
    Card,
    CardGrid,
} from '@astrojs/starlight/components';

## Overview

The **Isometric** game is KBVE's flagship multiplayer browser experience — an isometric 3D world built entirely in Rust with Bevy 0.18, networked via lightyear, and rendered through WebGPU in the browser.

<CardGrid>
    <Card title="Bevy 0.18" icon="rocket">
        Full ECS game engine compiled to WASM with WebGPU rendering
    </Card>
    <Card title="Multiplayer" icon="star">
        lightyear networking with WebSocket and WebTransport (QUIC)
    </Card>
    <Card title="Physics" icon="puzzle">
        avian3d rigid-body physics with isometric collision
    </Card>
    <Card title="Cross-platform" icon="laptop">
        WASM web app + Tauri 2 native desktop
    </Card>
</CardGrid>

## Architecture

The game runs as a **client** that connects to an **authoritative server** hosted inside `axum-kbve`. The server runs a headless Bevy app with lightyear server plugins and avian3d physics.

### Transport Layer

| Transport      | Protocol | Path                        | Use Case                  |
| -------------- | -------- | --------------------------- | ------------------------- |
| WebSocket      | TCP/TLS  | `wss://kbve.com/ws`        | Primary (all browsers)    |
| WebTransport   | QUIC/UDP | `https://wt.kbve.com:5001` | Low-latency (Chrome/Edge) |

WebTransport is preferred when available. Safari and older browsers fall back to WebSocket automatically.

### Shared Crates

| Crate            | Purpose                                              |
| ---------------- | ---------------------------------------------------- |
| `bevy_inventory` | Slot-based inventory with auto-stacking              |
| `bevy_items`     | Proto-driven item database from Astro itemdb         |
| `bevy_cam`       | Isometric camera controller                          |
| `bevy_kbve_net`  | Protocol types shared between client and server      |
| `bevy_tasker`    | Async task bridge for WASM/native                    |

## Features

- Procedural isometric terrain with tile-based collision
- Day/night cycle with dynamic lighting and fireflies
- Resource gathering (trees, rocks, ores, flowers, mushrooms)
- 16-slot inventory backed by 117+ proto-driven item definitions
- Creature system (frogs, fireflies) with behavioral AI
- Server-authoritative physics and entity replication
- JWT authentication with Supabase
- Pixel-art post-processing shader

## Running Locally

<Steps>
1. **Full local stack** (game + server):
   ```sh
   nx run isometric:quick
   ```

2. **WASM dev only** (no server):
   ```sh
   nx run isometric:dev
   ```

3. **Desktop build** (Tauri):
   ```sh
   nx run isometric:build:tauri
   ```

4. **Connect desktop to production**:
   ```sh
   GAME_SERVER_URL=wss://kbve.com/ws cargo run -p isometric-game
   ```
</Steps>

## Item Database

Items are defined as MDX files in the [itemdb collection](/itemdb/) and baked into the game binary at compile time. To regenerate after adding items:

```sh
node apps/kbve/isometric/scripts/sync-itemdb.mjs
```

## FAQ

**What is the KBVE Isometric game?**
Isometric is KBVE's flagship multiplayer browser game — an isometric 3D world
built entirely in Rust with Bevy 0.18, networked via lightyear, and rendered
through WebGPU in the browser. It also ships as a Tauri 2 native desktop app.

**How does Isometric handle networking?**
The game runs as a client that connects to an authoritative headless Bevy server
hosted inside `axum-kbve`. Transport is WebTransport (QUIC/UDP) when available,
falling back to WebSocket (TCP/TLS at `wss://kbve.com/ws`) on Safari and older
browsers.

**How are items defined in Isometric?**
Items are authored as MDX files in the itemdb collection and baked into the game
binary at compile time. Run the `sync-itemdb` script to regenerate after adding
items; the build currently ships 117+ proto-driven item definitions.

## Related

- [Bevy Cam Crate](/docs/project/bevy-cam-crate) — the isometric camera controller powering this game.
- [bevy_behavior](/docs/project/bevy-behavior-crate) — behavior tree engine driving the creature AI.
- [CryptoThrone Server](/docs/project/cryptothrone-server) — sibling Bevy multiplayer server in the KBVE stack.

---
# Jedi — Juggernaut Electronic Data Interchange Crate

> Jedi is the Juggernaut Electronic Data Interchange (EDI) Rust crate — a data-exchange layer with entity models, JWT/JWKS, RCON, and a shared ClickHouse client.

Source: https://kbve.com/project/jedi-crate/

## Overview

`jedi` is the **Juggernaut Electronic Data Interchange (EDI)** package for KBVE.
It provides a robust, scalable data-exchange layer written in Rust, extended
through the holy crate, and is reused across KBVE services for entity modeling,
token verification, RCON, and database access. Dry-run for devs:
`./kbve.sh -nx jedi:dry --no-cloud`.

## Key facts

| | |
|---|---|
| **Package** | `jedi` |
| **Version** | 0.2.2 |
| **Language** | Rust (edition 2024) |
| **License** | MIT |
| **Source** | [`packages/rust/jedi`](https://github.com/KBVE/kbve/tree/main/packages/rust/jedi) |
| **Homepage** | [kbve.com/application/rust/#jedi](https://kbve.com/application/rust/#jedi) |

## Features

- **Entity + builder models** — `entity`, `builder`, and `state` modules for
  structured data exchange.
- **Auth primitives** — `jwks` and `jwt_cache` modules for JWKS-based JWT
  verification with caching.
- **RCON** — an `rcon` module for remote console command exchange.
- **Proto types** — prost / tonic-generated `proto` module shared across
  services.
- **Optional database plumbing** — Postgres (`tokio-postgres`, `bb8`) and a
  ClickHouse client behind feature flags, using `rustls` TLS throughout.
- **Sanitization** — `ammonia` for HTML/PII cleaning in the exchange path.

## FAQ

**What is the Jedi crate?**
Jedi is the Juggernaut Electronic Data Interchange (EDI) package for KBVE. It
provides a robust, scalable data-exchange layer in Rust, with entity models,
builders, JWT/JWKS verification, an RCON module, and prost-generated proto types
shared across KBVE services.

**What does the Jedi crate include?**
Its modules include `builder`, `entity`, `jwks`, `jwt_cache`, `proto`, `rcon`,
`state`, and `wrapper`. It bundles axum, tokio, reqwest with rustls, dashmap, and
optional Postgres and ClickHouse plumbing behind feature flags.

**Where is the Jedi crate used?**
Jedi is a shared KBVE crate reused across services — for example the metrics
ingest service uses its ClickHouse client to batch telemetry inserts, and auth
paths use its JWKS and JWT cache for token verification.

## Related

- [Metrics](/docs/project/metrics) — observability service that reuses the Jedi ClickHouse client.
- [API](/docs/project/api) — the axum-kbve API that builds on shared Rust crates.

---
# Job Board — Curated Vetted Freelance Platform (Rust/Axum)

> Job Board is a curated, both-sides-vetted freelance platform for game dev, with a decoupled Rust/Axum API, Supabase auth, and a vertical-agnostic data model.

Source: https://kbve.com/project/jobboard/

import AstroGithubReadme from '@kbve/astro/components/social/github/Readme/AstroGithubReadme.astro';

## README

<AstroGithubReadme url="https://raw.githubusercontent.com/KBVE/kbve/refs/heads/main/apps/jobboard/README.md" />

* * *

## Job Board

> Status: **Phase 0 scaffolded** — `apps/jobboard` Axum service boots, `jobboard.proto` wired into the build. **Auth = Supabase** (JWT `sub` = `auth.users.id`); the Phase-0 first-party auth/sessions in the Rust code is a dead end to be removed. **Schema migration shipped** (`20260615120000_jobboard_tables.sql`): 23 tables, ULID-as-uuid PKs, junction tables (no array refs), state/money/lifecycle CHECK constraints, RLS lockdown, `updated_at` triggers; all user refs → `auth.users(id)`. No seed yet. Phases 1–10 below remain spec.

A **curated, both-sides-vetted job board for freelance work** — think Upwork/Fiverr, but gated and quality-first. Sanctioned members post gigs, other sanctioned members take them up, and the platform handles discovery, matching, and messaging. Money moves off-platform in v1 (lead-gen model); monetization is built behind abstraction hooks to switch on later.

**Game development is the launch vertical, not the ceiling.** We pioneer in game dev (art, code, audio, design, QA *for games*) because it's an underserved, portfolio-driven niche where curation wins — but the data model, taxonomy, and matching are **vertical-agnostic by design**. Adding a new vertical (e.g. video production, music, dev/IT, design, writing) is a data operation (seed a `Vertical` + its taxonomy), **not** a schema change or code change.

**Architecture is decoupled:** a standalone **Rust/Axum REST API** (own DB access, own first-party auth — no third-party auth SaaS) serving a **separate frontend client** (framework TBD) over HTTP. This keeps the API reusable across web, future mobile, and integrations.

### Positioning / moat
- **Curation is the wedge.** Both posters and takers are vetted, so quality is the product. Every gig is legit; every applicant is screened.
- **Vertical-first go-to-market, horizontal data model.** We win one vertical at a time (game dev first) by speaking its language, while the underlying platform stays general so we can expand without re-platforming.
- **Portfolio-first.** Talent in creative/technical verticals is hired by *seeing* work (characters, gameplay clips, playable builds, reels, repos), not reading résumés. The portfolio system is a first-class feature across every vertical.

* * *

## Personas & roles

| Persona | What they do | Vetting |
|---|---|---|
| **Poster** | Has work (indie dev, studio, publisher, agency, business). Posts gigs, reviews applicants, selects talent. | Vetted (org/identity + intent) |
| **Taker** | Does work (artist, programmer, audio, designer, QA, and every other vertical's specialists). Builds a portfolio, applies to gigs. | Vetted (portfolio review) |
| **Admin** | Platform staff. Reviews membership applications, moderates gigs, manages verticals + taxonomy, handles reports. | Internal |

- A single account can hold **both** capabilities (`poster` and `taker`), granted independently during vetting.
- Capabilities are the authorization primitive — encoded as a bitmask on the existing `User.role` field (see protobuf section).
- A member can operate in **one or more verticals**; their granted disciplines/skills are scoped per vertical.

* * *

## Verticals & taxonomy

The platform is organized around **verticals** (top-level service areas) and a **controlled, admin-managed vocabulary** scoped to each vertical — so filtering and matching work without free text, and so a new vertical can be launched without touching code.

- **Vertical** — the top-level service area. Game Dev is vertical #1. Others (Video, Audio/Music, Software/IT, Design, Writing, Marketing…) are added later as data.
- **Discipline** — a category of work *within a vertical* (data-driven taxonomy, not a hardcoded enum).
- **Tool/Platform** — engines, software, frameworks relevant to the vertical.
- **Skill tag** — finer-grained, controlled-but-extensible.

> **Why no hardcoded discipline enum?** An earlier draft baked game-dev disciplines into a protobuf bitmask. That ties the schema to one vertical. Instead, disciplines/tools/skills all live in the `Taxonomy` table, each row scoped by `vertical_id`. Gigs and profiles reference taxonomy **ids**, so a new vertical is purely a seed-data operation. (If a vertical later needs ultra-fast bitmask filtering, a per-vertical cached bitmask can be derived from taxonomy ids without changing the contract.)

### Game-dev vertical — seed vocabulary (example)
This is the *first vertical's* seed data, illustrating the pattern — not a fixed part of the schema:

- **Disciplines:** 2D Art, 3D Art, Animation/Rigging, Programming, Technical Art/Shaders, Audio (Music/SFX/VO), Game Design, Level Design, Narrative/Writing, UI/UX, QA/Testing, Porting, Localization, Production/PM, Community.
- **Tools/Engines:** Unity, Unreal, Godot, GameMaker, Bevy, Custom; tools — Blender, Maya, ZBrush, Substance, Photoshop, Spine, FMOD, Wwise.
- **Skill tags:** `netcode`, `humanoid-rigging`, `pixel-art`, `procgen`, `shader-graph`, `vertical-slice`.

> Admin-managed vocabulary so new verticals, disciplines, tools, and skills can be added without code changes.

* * *

## Core flows

### A. Membership / vetting (both sides)
1. Sign up (first-party auth — email/password or OAuth).
2. Choose intended capabilities: **post work**, **take work**, or **both**; and the vertical(s) of interest.
3. Complete application — statement + portfolio links; talent pick vertical(s) + disciplines/tools, posters add org info.
4. Submit → application status `pending`.
5. Admin reviews in the vetting queue → approve/reject **per capability**.
6. On approval → capability bit set on `User.role`; user unlocks profile + the granted actions.

### B. Poster posts a gig
1. Approved poster creates a gig (title, vertical, discipline(s), scope, budget, tools, skills, deadline).
2. Publish → `OPEN` (optionally `PENDING_REVIEW` if gig moderation is enabled).
3. Gig enters discovery.

### C. Taker discovers & applies
1. Browse / search / filter gigs (vertical, discipline, tool, budget…).
2. View gig detail.
3. Apply — cover message, proposed rate, attach relevant portfolio items (gated on `taker`).
4. Poster notified.

### D. Selection & engagement
1. Poster reviews applicants, shortlists, messages candidates.
2. Poster accepts one → `Engagement` created, gig → `FILLED`, others auto-declined/notified.
3. Work + payment happen **off-platform** (v1).
4. Either party marks the engagement complete.
5. Both leave reviews → reputation accrues (aggregated into `User.reputation`).

### E. Admin / moderation (cross-cutting)
- Vetting queue, gig takedowns, report handling, vertical + taxonomy management, audit log.

* * *

## Data model (Postgres)

Accessed via **`sqlx`** (async, compile-time-checked queries; migrations via `sqlx migrate`). Each table is mirrored by a protobuf message (see below). Reused entities map to existing protos; new entities to the `jobboard` package.

| Table | Source proto |
|---|---|
| `auth.users` (identity) | **Supabase** — referenced by `user_id` FKs, not recreated |
| `profiles` (base) | **reuse** `Profile` (kbveproto) |
| `verticals` | new `jobboard.Vertical` |
| `talent_profiles` | new `jobboard.TalentProfile` |
| `client_profiles` | new `jobboard.ClientProfile` |
| `member_applications` | new `jobboard.MembershipApplication` |
| `portfolio_items` | new `jobboard.PortfolioItem` (+ reuse `MediaAttachment`) |
| `taxonomy` (disciplines/tools/skills, scoped per vertical) | new `jobboard.Taxonomy` |
| `gigs` | new `jobboard.Gig` |
| `applications` | new `jobboard.Application` |
| `engagements` | new `jobboard.Engagement` |
| `reviews` | new `jobboard.Review` |
| `conversations`, `messages` | new `jobboard.Conversation` / `Message` (+ reuse `MediaAttachment`) |
| `notifications` | new `jobboard.Notification` |
| `reports`, `audit_log` | new (admin) |
| `invoices`, `settings`, `globals` (monetization hooks) | **reuse** `Invoice`, `Setting`, `Global` (kbveproto) |

* * *

## Tech architecture (decoupled)

### Backend — Rust API service
| Concern | Choice | Why |
|---|---|---|
| Framework | **Axum** (Tokio) | Fast, ergonomic, tower middleware ecosystem |
| Auth | **Supabase** — verify the Supabase JWT (`sub` = `auth.users.id`, `kbve_username` claim), no first-party user/session store | Reuses existing KBVE identity; same model as `apps/rows` |
| DB access | **jedi `PgCluster`** (tokio-postgres + bb8, rw/ro/any split, RLS caller-scoped reads, valkey cache) | House pattern (matches `axum-kbve`); free read/write split + RLS + caching |
| Migrations | **dbmate** (`packages/data/sql/dbmate/migrations`) — schema deferred, not committed yet | Repo-standard migration tool; one system across the monorepo |
| DB | Postgres — KBVE CNPG/Supabase cluster via `KBVE_PG_RW_URL` | Shared cluster; `jobboard` schema isolates the tables |
| Wire format | `prost`/`tonic` protobuf over `jedi.JediEnvelope` | Reuses the KBVE proto/envelope transport |
| Media | S3-compatible (Cloudflare R2) | Rust-friendly; private deliverables |
| Search | Postgres FTS (v1) → Meilisearch later | Meilisearch is Rust-native, easy upgrade |
| Notifications | In-app (DB) v1; email later | Keep v1 lean |

### Frontend — TBD (decided in a later phase)
- Pure HTTP client of the API. Candidates: Astro + React (KBVE-native), Next.js (frontend-only), or React SPA.
- Auth carried as httpOnly session cookie (browser) — already supported by the API design.

**Authorization model:** Axum middleware/extractors authenticate the session/token; route guards check the `Capability` bitmask on `User.role` (`POSTER`/`TAKER`/`ADMIN`); ownership checks (e.g. gig owner) enforced per-handler.

* * *

## Deployment

The deployable surface lives in `apps/jobboard`: `Dockerfile` (chiseled Ubuntu axum base), `version.toml`, and nx `project.json` (`build` / `test` / `lint` / `run` / `container` / `containerx`). The container build context is the repo root.

### Container image
- Built via `./kbve.sh -nx jobboard:container` → `kbve/jobboard:latest` (+ version tag); production config also tags `ghcr.io/kbve/jobboard`.
- Multi-stage cargo-chef build (planner → cook → builder → runtime) on `ghcr.io/kbve/chisel-ubuntu-axum`. Runtime image runs `/app/jobboard` as uid 10001, exposes `5400`.
- Protos are **vendored** (`apps/jobboard/src/proto/jobboard.rs`); the image build does not run `protoc`. Regenerate only when the `.proto` changes: `BUILD_PROTO=1 cargo build -p jobboard` (and revert the incidental jedi proto regen before committing).

### Runtime environment (env var contract)
| Var | Required | Default | Notes |
|---|---|---|---|
| `KBVE_PG_RW_URL` | yes | — | jedi `PgCluster` primary (rw). `DATABASE_URL` is mapped to it if unset (dev convenience). |
| `KBVE_PG_RO_URL` | no | = rw | Read replica; falls back to rw. |
| `KBVE_PG_ANY_URL` | no | = rw | Any-instance read fallback. |
| `HTTP_HOST` | no | `0.0.0.0` | Bind host. |
| `HTTP_PORT` | no | `5400` | Bind port. |
| `SECURE_COOKIES` | no | `false` | Set `true` behind TLS (sets `Secure` on the session cookie). |
| `RUST_LOG` | no | `jobboard=info,tower_http=info` | Tracing filter. |

jedi `PgCluster` also honors its standard `KBVE_PG_*` tuning knobs (pool sizes, timeouts, search_path, pooler rewrite, CA bundle) — see `packages/rust/jedi/src/state/pg.rs`. TLS bypasses transparently when the URL carries `sslmode=disable` (in-cluster), engages for `sslmode=require` (external).

### Probes
- Liveness: `GET /health` (always 200 when the process is up).
- Readiness: `GET /ready` (200 when the DB cluster health probe passes, 503 otherwise) — gate traffic on this.

### Kubernetes / ArgoCD (shipped)
Deployed under `apps/kube/jobboard/` into the **`kbve` namespace** (own ArgoCD app):
- `jobboard-deployment.yaml` — Deployment (`ghcr.io/kbve/jobboard:<ver>`, port 5400, liveness `/health`, readiness `/ready`, Reloader) + `jobboard-service` (ClusterIP 5400). Reuses the kbve-ns `supabase-shared` secret for `KBVE_PG_RW_URL`/`_RO`/`_ANY` (no new ExternalSecret).
- `httproute.yaml` — `jobs.kbve.com` → `jobboard-service:5400`, parented to `kbve-gateway`. **No cert/ReferenceGrant/gateway-listener needed**: `jobs.kbve.com` is covered by the existing `https-kbve` wildcard listener (`*.kbve.com`, cert `kbve-wt-tls`).
- `jobboard-serviceaccount.yaml` — `jobboard-sa`, `automountServiceAccountToken: false`. **No RBAC Role/RoleBinding** — the pod never calls the k8s API.
- `application.yaml` registered in `apps/kube/kustomization.yaml` (kube-root app-of-apps).
- ArgoCD apps track `main`; PRs land on `dev`, so the manifest reaches the cluster only after the periodic dev→main release.

### MDX-driven image-tag automation
The frontmatter above (`version`, `image`, `version_toml`, `version_target`, `deployment_yaml`) registers jobboard in `.github/ci-dispatch-manifest.json` (regenerate via `astro-kbve:build` → `astro-kbve:sync:ci-manifest`; registry entry in `@kbve/devops` `registry.ts`). On a `version:` bump here, `ci-docker.yml`'s version gate (MDX `version` > `version.toml`) builds + pushes `ghcr.io/kbve/jobboard:<ver>`, then `utils-post-publish.yml` opens an atom PR that `sed`-updates `version.toml`, `Cargo.toml`, and the **deployment image tag** in `jobboard-deployment.yaml`. First publish uses the `version.toml = 0.0.1` sentinel so the gate fires.

### Database schema
**Source of truth**: `packages/data/sql/schema/jobboard/jobboard.sql` — the canonical desired-state DDL (same convention as `schema/meme`, `schema/ows`, etc.). The **dbmate** migration `packages/data/sql/dbmate/migrations/20260615120000_jobboard_tables.sql` is the applied delta that brings prod to that state, generated from / kept identical to the schema file. The proto (`packages/data/proto/jobboard/jobboard.proto`) is the third leg and tracks the same shape. 23 tables, hardened with constraints, junction tables, RLS lockdown, and `updated_at` triggers. No seed (separate follow-up migration).

- **Identity is Supabase.** No `jobboard.users` / `jobboard.sessions` — every owner column is `user_id uuid references auth.users(id)`. The service trusts the Supabase JWT (`sub`); reputation/capabilities live on jobboard rows or are derived.
- **Primary keys**: lookup tables (`verticals`, `taxonomy`) use `bigint generated always as identity`; entity tables use **ULID-as-uuid** — `uuid default public.gen_ulid()::uuid` (the house generator's 32-hex output casts to a 16-byte binary uuid whose time prefix makes it chronologically sortable → non-enumerable + cheap keyset feeds). `user_id` is `uuid` → `auth.users`.
- **Junction tables** replace all `*_ids` arrays (real FKs + uniqueness): `talent_verticals`, `talent_taxonomy`, `client_verticals`, `member_application_verticals`, `portfolio_tags`, `gig_taxonomy`, `application_portfolio_items`. Single-vertical entities (`gig_taxonomy`, `portfolio_tags`) carry `vertical_id` and use **composite FKs** to `gigs(id, vertical_id)` / `portfolio_items(id, vertical_id)` + `taxonomy(id, vertical_id)`, so a tag must belong to the entity's own vertical (cross-vertical tagging is rejected). `talent_taxonomy` is **also vertical-aligned** — composite FKs to `talent_verticals(user_id, vertical_id)` + `taxonomy(id, vertical_id)`, so a talent can only tag taxonomy within a vertical they've joined.
- **State integrity**: CHECK constraints on every enum/bitmask column (ranges from the proto enums — `budget_type` 0–3; gig/notification `status`/`kind in (0,1,2,4,8,16)` treated as **single-value** enums; `reports.target_kind in (1..4)` = `ReportTarget`, `reports.status in (0..3)` = `ReportStatus`), money invariants (`min ≤ max`, `≥ 0`, `currency ~ '^[A-Z]{3}$'`, minor units), **identifier/text** rules (slug/name `^[a-z0-9]+(-[a-z0-9]+)*$` — no leading/trailing/double hyphens; non-empty bounded `label`/`title`/`reason`/`action`), lifecycle invariants (member-app review state, one-pending-per-user partial unique, gig publication state — OPEN/closed states **require** `published_at`, engagement `status↔completed_at` lifecycle [COMPLETED⇒`completed_at ≥ started_at`, else null] + one-per-gig, **null-safe** distinct-parties / distinct-reviewer-reviewee so double account deletion can't trip the check, participant `left_at ≥ joined_at`), unique review-per-(engagement, reviewer), message content non-empty + size caps (body ≤ 20k, ≤ 10 attachments), `jsonb_typeof` checks.
- **Messaging**: `conversation_participants` has a surrogate `id` PK; messages reference the **participant** via composite FK `(conversation_id, sender_participant_id) → conversation_participants(conversation_id, id)` with **`ON DELETE NO ACTION`** — a participant row can't be hard-deleted while it has messages (participants leave by setting `left_at`, never by row deletion), yet a full conversation delete still cascades cleanly (NO ACTION defers to statement end; RESTRICT would break that). On account deletion the participant's `user_id` is `SET NULL` (anonymized) and **messages are preserved** (they key off the immutable participant id, not the auth uuid). Per-participant read cursor (`last_read_message_id`, conversation-scoped composite FK with column-list `SET NULL`), not a single `messages.read_at`.
- **Indexes** are feed/keyset-oriented: partial gig feeds `where status = 2` (`vertical_id, published_at desc, id desc` + global), applicant/poster application queues, message cursor, partial unread-notifications, reports queue, reviewee history, portfolio ordering (`user_id, sort_order, created_at desc, id desc`), member-application history + moderation queue, active-participant partial (`user_id, conversation_id where left_at is null`), and reverse indexes on every junction's non-leading column.
- **Bounds + self-documentation**: length caps on all free text (`headline`/`org_name`≤200, `about`≤2000, descriptions≤5–20k, `cover_message`/`body`≤10k, `portfolio_links` ≤20) and `comment on column` on every enum/bitmask column (`GigStatus`, `EngagementStatus`, `ReportTarget`, …) so the integer↔meaning mapping lives in the catalog and can't silently drift from the proto/Rust enums.
- **Delete policy** (middle ground): personal data `CASCADE` (profiles, portfolio, notifications, member applications, conversation participants); commercial/moderation history `SET NULL` + nullable (gigs.poster_id, applications.applicant_id, engagements, reviews, reports, audit_log, **and** conversation_participants.user_id) so the marketplace + chat record survives account deletion. Snapshot/display-name capture deferred.
- **RLS / privileges** locked to a **service-role-only** model (the Rust service reaches the schema via its privileged jedi pool, NOT via PostgREST/`authenticated`): `create schema jobboard authorization postgres`; RLS enabled on all 23 tables; `force` on the strictly server-mediated tables (`engagements`, `reviews`, `member_applications`, `reports`, `audit_log`); `revoke all on all tables/sequences from anon, authenticated`; **role-specific** `alter default privileges for role postgres … revoke` (the generic form only covers the running role); schema `revoke from public` with **no `authenticated` usage grant** — so `authenticated` gets `permission denied for schema jobboard` (verified). The `set_updated_at()` fn is `revoke … from public` + `owner to postgres`. **No plpgsql/PostgREST RPC layer** — the jobboard **Axum service is the single writer** and reaches the schema via its jedi pool connecting as a **BYPASSRLS role** (`service_role` or `postgres`), which is required because `force row level security` binds even the table owner (superusers/BYPASSRLS bypass it). RLS + `force` therefore act purely as defense-in-depth against any future direct/PostgREST path; the real authorization + multi-step invariants live in the service. (If direct client reads are ever wanted, add PostgREST grants + SELECT policies, or `public.*` proxy wrappers, per feature phase.)
- Verified up + down on Postgres 17 (stub `auth.users`/`gen_ulid`): 23 tables, 60 indexes, schema owner `postgres`; negative battery confirms cross-vertical tag, non-joined talent taxonomy, bad slug, empty label, over-length text, >20 portfolio links, unpublished-OPEN gig, COMPLETED-without-`completed_at`, dup review, empty message, cross-conversation cursor, bad `target_kind`/`target_id`, and `authenticated` schema access all reject — while a full conversation delete cascades and a direct participant delete (with messages) is blocked, preserving history.

**Enforced in the jobboard Axum service, not DDL** (nullable historical FKs + temporal/identity rules can't be plain CHECKs). The service is the single writer; each multi-step invariant is a Rust transaction (`conn.transaction()` + `SELECT … FOR UPDATE` on the gig/application rows), with the DB constraints as the safety net underneath — no plpgsql RPCs: portfolio-item ownership on application attach (`portfolio.user_id = application.applicant_id`); engagement creation (lock gig + accepted application, verify caller, reject competing applications, flip gig status, audit — one tx); reviews must have `reviewer`/`reviewee ∈ engagement parties`, `reviewer ≠ reviewee`, engagement `COMPLETED`; **non-null identities on insert** (the nullable id columns exist only for `ON DELETE SET NULL`, never for fresh rows); message send must reject `left_at is not null` participants (and optionally cursor-before-join); member-application review transitions; reports moderation; capability/role grants.

**Other deferred follow-ups**: seed migration; per-phase RLS SELECT policies; conversation inbox denormalization (`conversations.last_message_at/id`, maintained in the send RPC); attachment element-type validation (array-of-objects, RPC/helper); proto entity `id` fields `uint64 → bytes` (uuid) + `Message.sender` → participant id. The `down` (`drop schema … cascade`) is **bootstrap-only** — mark irreversible once prod data exists.

* * *

## REST API surface (Axum)

All mutations go through the API; the frontend is a pure client. Auth via session cookie or `Authorization: Bearer`. Versioned under `/api/v1`.

```
# Auth
POST   /auth/register            email/password signup
POST   /auth/login               -> session cookie / token
POST   /auth/logout
GET    /auth/me                  current user + capabilities
GET    /auth/oauth/:provider     start Discord/GitHub/Steam flow
GET    /auth/oauth/:provider/cb  callback

# Verticals & taxonomy
GET    /verticals                list active verticals
GET    /verticals/:id/taxonomy   disciplines/tools/skills for a vertical
POST   /admin/verticals          [admin] create vertical
POST   /admin/taxonomy           [admin] add discipline/tool/skill

# Membership / vetting
POST   /applications             submit membership application
GET    /admin/applications       [admin] vetting queue
POST   /admin/applications/:id/decision   [admin] approve/reject per capability

# Profiles & portfolio
GET    /talent                   browse/filter talent (vertical, discipline, tool…)
GET    /talent/:username
PATCH  /me/profile
GET/POST/PATCH/DELETE /me/portfolio[/:id]

# Gigs
GET    /gigs                     browse/filter (vertical, discipline, tool, budget…)
POST   /gigs                     [poster] create
GET    /gigs/:id
PATCH  /gigs/:id                 [poster, owner]
POST   /gigs/:id/close           [poster, owner]

# Applications to gigs
POST   /gigs/:id/applications    [taker] apply
GET    /gigs/:id/applications    [poster, owner] list applicants
PATCH  /applications/:id         shortlist/decline/withdraw
POST   /applications/:id/accept  [poster] -> creates engagement, fills gig

# Messaging
GET    /conversations
GET    /conversations/:id/messages
POST   /conversations/:id/messages

# Engagements & reviews
POST   /engagements/:id/complete
POST   /engagements/:id/reviews

# Moderation
POST   /reports
GET    /admin/reports            [admin]
```

* * *

## Protocol Buffers

The platform's wire/storage contract is protobuf. The proto root is `packages/data/proto/` (the shared protoc include root — cross-package imports already work there). We add one new file — `packages/data/proto/jobboard/jobboard.proto` (package `jobboard`).

> **Phase 0 reality check.** The reuse table below was aspirational; the actual repo differs, and Phase 0 ships `jobboard.proto` as **standalone** (it defines its own `MediaAttachment` rather than importing one) to sidestep cross-package include friction. Corrections to the table: identity protos live in `packages/data/proto/kbve/kbveproto.proto` **with no `package` declaration** (so they are awkward to `import` into a packaged file — reuse happens at the DB/service layer, not via proto import); there is **no** `status.proto` (`MediaAttachment` was invented locally; the closest existing is `kbve.forum.Attachment`); the Discord listing template is `kbve/discordsh.proto` (`DiscordServer` + `ServerTag`), **not** `disoxide.proto`; there is **no** `store.proto`/`StoreService` (only `jedi/redis.proto`'s `RedisService`). `JediEnvelope`/`MessageKind`/`PayloadFormat` (`jedi/jedi.proto`) and `RedisService` are real and reusable. As later phases need true cross-file reuse, give `kbveproto.proto` a package and import from the shared root.

### What we reuse (do not recreate)

| Need | Reused proto | Where it lives | Notes |
|---|---|---|---|
| **Auth / credentials** | `Auth` | `kbveproto.proto` | Already has email, hash, salt, reset token+expiry, verification token+expiry, status, last_login, failed_login_attempts, lockout_until, 2FA secret, recovery codes. This *is* our first-party auth model — use as-is. |
| **User identity** | `User` | `kbveproto.proto` | `userid, username, role, reputation, exp, created_at`. We encode capabilities into `role` (bitmask) and aggregate review scores into `reputation`. |
| **Base social profile** | `Profile` | `kbveproto.proto` | `name, bio, github, instagram, discord, unsplash, userid`. Vertical-specific fields go in a new `TalentProfile` that references the same `userid` — we extend, not duplicate. |
| **Bearer API tokens** | `Apikey` | `kbveproto.proto` | For non-browser clients (`Authorization: Bearer`). |
| **Monetization hooks** | `Invoice`, `Setting`, `Global` | `kbveproto.proto` | Wired only when monetization switches on. |
| **Media (portfolio/attachments)** | `MediaAttachment` | `status.proto` | `url, media_type (bitmask), caption`. Embedded by `PortfolioItem` and `Message`. |
| **Listing pattern** | `DiscordServer`, `DiscordTag` | `disoxide.proto` | Template (not copied): bitmask `status`/`categories`, inline SQL CHECK comments, URL regex, `updated_at`. `Gig`, `Vertical`, and `Taxonomy` follow this convention. |
| **Transport envelope** | `JediEnvelope`, `MessageKind`, `PayloadFormat` | `jedi.proto` | Job board messages travel as `payload` bytes inside `JediEnvelope`. Existing `MessageKind` bits (`AUTH`, `HTTP_API`, `WEBSOCKET`, `REDIS`, `SUPABASE`) already cover routing — **no new kinds needed for v1**. |
| **KV / cache / realtime** | `StoreService`, `RedisService` | `store.proto`, `redis.proto` | Caching, presence, live message/notification fan-out. Reuse as-is. |

### What we add — `jobboard.proto`

Canonical source: **`packages/data/proto/jobboard/jobboard.proto`** (package `jobboard`, standalone, built via `prost`). It is not inlined here — that drifts; the proto is kept in sync with the SQL schema package (`packages/data/sql/schema/jobboard/`).

- **Id conventions**: entity ids are `bytes` = the 16-byte ULID-as-uuid (`public.gen_ulid()::uuid`); user refs are `bytes` = `auth.users(id)`; lookup ids (`Vertical`, `Taxonomy`) and the taxonomy/vertical id lists are `uint64` = `bigint` identity; timestamps are ISO `string`.
- **Messages mirror the tables**: added `ConversationParticipant`, `Report`, `AuditLog`; `Message` carries `sender_participant_id` (not a raw user id) and dropped `read_at` (read state is the participant cursor); `Conversation` dropped `participant_ids`; `ById` keys on `bytes`, `ByLookup` on `uint64`.
- Taxonomy/vertical id lists (`discipline_ids`/`tool_ids`/`skill_ids`/`tag_ids`/`vertical_ids`) stay `repeated uint64` — the API view of the junction tables; relational integrity (same-vertical, ownership) lives in SQL.

### Reuse summary

- **New file:** `jobboard.proto` (1 file, 1 package).
- **Reused as-is:** `JediEnvelope`/`MessageKind`/`PayloadFormat` (`jedi/jedi.proto`), `RedisService` (`jedi/redis.proto`). (Identity reuse — `Auth`/`User`/`Profile` etc. — happens at the DB/service layer, not via proto import, since `kbveproto.proto` has no package; see the reality-check note above.)
- **Reused as pattern (not copied):** `kbve.discordsh.DiscordServer` → `Gig`, `ServerTag` → `Vertical`/`Taxonomy`.
- **No new `MessageKind` values** — existing routing bits suffice for v1.
- **No hardcoded discipline enum** — disciplines/tools/skills are data-driven taxonomy scoped by vertical, so new verticals require no proto change.

* * *

## Trust & safety

- Vetting on both sides is the primary trust mechanism.
- Reporting + admin takedown for gigs, profiles, messages.
- Off-platform payment disclaimer + safety guidance (no escrow yet — set expectations clearly).
- Audit log for admin actions.

* * *

## Key risks / open questions

1. **Disintermediation / leakage** — with payments off-platform, members can match once and transact off-platform forever. *Mitigations:* keep reviews/reputation valuable enough to bring people back; consider gating contact details until a stage; plan the monetization switch before leakage becomes habit.
2. **Vetting throughput** — manual approval is the quality bar *and* a growth bottleneck. Needs a written rubric (per vertical) + a fast admin UI.
3. **Cold-start liquidity** — curated + both-vetted = slowest to fill. Likely need to hand-seed one side first, in one vertical first. Game dev launches first; which side to seed?
4. **"Sanctioned" criteria undefined** — what objectively qualifies a poster vs a taker, per vertical?
5. **Vertical expansion sequencing** — the model supports many verticals, but each needs taxonomy seeding, a vetting rubric, and liquidity. Which vertical follows game dev, and on what trigger?
6. **Proto include paths** — sharing `MediaAttachment`/identity across packages needs a common protoc include root; decide whether to relocate shared protos or vendor.

* * *

## Phased build plan

| Phase | Scope | Outcome |
|---|---|---|
| **0 — Foundations** | Axum + `sqlx` + Postgres; migrations; verticals + taxonomy seed (game dev first); first-party auth (register/login/session/logout) + CORS; wire `jobboard.proto` into the build | API boots, auth works, DB ready |
| **1 — Identity & vetting** | Membership application endpoints, admin vetting queue, capability grants (per vertical) | Members can be sanctioned |
| **2 — Profiles & portfolio** | Talent/client profiles, portfolio CRUD + R2 media upload | Public profiles exist |
| **3 — Gigs** | Post gig, gig moderation, browse + filter (vertical/discipline/tool), gig detail | Work is discoverable |
| **4 — Applications & selection** | Apply, applicant management, accept → engagement | Matching works end-to-end |
| **5 — Messaging** | Conversations + threads + attachments | Parties can talk |
| **6 — Engagements & reviews** | Mark complete, two-sided reviews, reputation display | Trust accrues |
| **7 — Frontend client** | Choose framework; build the UI against the API | Usable product |
| **8 — Discovery & notifications** | Search polish, saved items, in-app notifications | Retention loops |
| **9 — Monetization hooks** | Wire entitlements to a chosen model (sub/featured/credits) via reused `Invoice`/`Setting` | Revenue switch ready |
| **10 — Second vertical** | Seed a new vertical (taxonomy + rubric); validate the model expands without schema change | Multi-vertical proven |

* * *

## Decisions

**Locked:** curated, both-sides vetted · gig→apply mechanic · lead-gen v1 (off-platform payments) · monetization-agnostic hooks · **game dev as the launch vertical, vertical-agnostic data model** (verticals + data-driven taxonomy, no hardcoded discipline enum) · decoupled architecture · Rust/Axum API · **Supabase auth** (verify JWT, `sub` = `auth.users.id`; all jobboard rows FK `auth.users`) — first-party auth was a wrong turn, removing it · **jedi `PgCluster` (tokio-postgres + bb8) + dbmate migrations** against the KBVE cluster · standalone `jobboard.proto` (one package, standalone for Phase 0).

**Still open:**
- **Frontend framework** (Astro+React / Next.js frontend-only / React SPA) — deferred to Phase 7.
- Sanctioning rubric for posters and takers (per vertical).
- Which side to seed first for liquidity (in the game-dev vertical).
- Which vertical follows game dev, and on what trigger.
- When/whether to gate contact info to reduce leakage.
- Eventual monetization model (subscription / featured / credits).
- cookie-only vs cookie+bearer; OAuth providers (Discord/GitHub/Steam) for v1.
- Proto include-path strategy (shared root vs vendor).

* * *

## FAQ

**What is the KBVE Job Board?**
It is a curated, both-sides-vetted freelance platform where sanctioned members post
gigs and other sanctioned members take them up. It launches in the game-dev vertical
but is architected so additional service verticals can be added as data, without
schema or code changes.

**What is the Job Board's technical architecture?**
It is a decoupled Rust/Axum REST API served to a separate frontend client. Auth is
Supabase (verifying the JWT `sub` as `auth.users.id`), DB access is via jedi
`PgCluster` over Postgres, migrations use dbmate, and the wire format is protobuf
over the jedi envelope.

**How does the Job Board add new verticals without schema changes?**
Disciplines, tools, and skills all live in a taxonomy table scoped by `vertical_id`
rather than a hardcoded enum, and gigs and profiles reference taxonomy ids. Launching
a new vertical is a seed-data operation, not a schema or code change.

* * *

## Related

- [rows](/project/rows/) — the KBVE multi-tenant Rust/Axum service whose auth and PgCluster patterns the Job Board reuses.

---
# KASM Void — Custom KASM Discord + CloakBrowser Workspace

> KASM Void is a custom KASM workspace image bundling Discord and CloakBrowser in one supervised container for in-session Discord screen-share of the browser.

Source: https://kbve.com/project/kasm-void/

## Overview

`kasm-void` is the production workspace image used by the `kasm-vpn`
Deployment in `apps/kube/kasm/`. It extends `kasmweb/discord` with
[CloakBrowser](https://github.com/CloakHQ/CloakBrowser) so the KASM session
exposes both Discord and a browser side-by-side. The browser is the canonical
screen-share target inside Discord — the operator opens any URL in the bundled
Chromium build and streams the window through Discord's video feature.

## Why a custom image

- The stock `kasmweb/discord` image ships only Discord; closing it leaves an
  empty desktop with no way to recover.
- We need a known, reproducible browser binary inside the workspace so the
  Discord stream picks up consistent fonts/codecs across sessions.
- Resource targets are higher than the stock image's defaults — bundling lets
  us own the `requests/limits` against a single artifact instead of patching
  a vendor tag.

## Crash recovery

`/dockerstartup/custom_startup.sh` spawns three background supervisors:

| Loop | Process matched (`pgrep -f`) | Action |
|------|------------------------------|--------|
| `cloak_loop` | `cloakbrowser` | Relaunches `/opt/cloakbrowser/cloakbrowser $CLOAK_APP_ARGS $START_URL` |
| `discord_loop` | `discord|electron` | Relaunches the upstream `discord_startup.sh` |
| `nav_shim_loop` | `nav_shim.py` | Relaunches `python3 /dockerstartup/nav_shim.py` |

Each loop polls every 3–5 seconds. Closing the Discord window or the browser
window from the desktop triggers a respawn — no manual KASM session restart
needed.

The original `kasmweb/discord` startup script is preserved as
`/dockerstartup/discord_startup.sh` so its arg-handling, profile setup, and
maximize logic continue to work unchanged.

## Runtime env

| Variable             | Default              | Notes                                          |
| -------------------- | -------------------- | ---------------------------------------------- |
| `START_URL`          | `https://kbve.com`   | Launch URL for the cloakbrowser instance       |
| `CLOAK_APP_ARGS`     | (chromium defaults)  | Override the full cloakbrowser arg list        |
| `LAUNCH_DISCORD`     | `1`                  | Set to `0` to disable the Discord supervisor   |
| `LAUNCH_CLOAK`       | `1`                  | Set to `0` to disable the browser supervisor   |
| `LAUNCH_NAV_SHIM`    | `1`                  | Set to `0` to disable the URL launcher shim    |
| `NAV_SHIM_PORT`      | `9998`               | Shim listens on this port (0.0.0.0)            |
| `CDP_PORT`           | `9222`               | Cloakbrowser CDP port (bound to 127.0.0.1)     |
| `URL_LAUNCHER_TOKEN` | (k8s secret)         | Reuses `kasm-vnc-pw` value as bearer token     |
| `VNC_PW`             | (k8s secret)         | Provided by the kasm `Deployment`              |
| `APP_ARGS`           | (inherited)          | Discord-side Electron args, consumed upstream  |

## Desktop shortcuts + helper scripts (v0.0.5)

The Desktop ships with launcher icons so the operator does not have to
remember paths. Each `.desktop` entry is built into the image at
`/home/kasm-user/Desktop/` and the underlying scripts live in
`/home/kasm-user/scripts/`.

| Icon | Action |
|------|--------|
| Terminal | Opens `xfce4-terminal` (the package is now installed) |
| Discord | Direct launcher for `/usr/share/discord/Discord` (host-update skipped) |
| CloakBrowser | Direct launcher for the bundled Chromium fork |
| Open URL in Browser | `zenity` prompt → posts to the local `nav_shim` (falls back to a fresh `cloakbrowser --new-window` if the shim is down) |
| Reload CloakBrowser | Kills `cloakbrowser`, clears the `Singleton*` locks; the supervisor respawns it in ~3s |
| Reset Discord | Stops Discord, clears `Cache/`/`Code Cache/`/`GPUCache/`/`Shared Dictionary/`, re-seeds `SKIP_HOST_UPDATE` |

### Discord host-update gate

`scripts/seed-discord-config.sh` writes `SKIP_HOST_UPDATE: true` to
`~/.config/discord/settings.json` before every Discord launch. The
upstream Discord-on-Linux build otherwise attempts a self-update on each
boot, which fails inside the gluetun-tunneled namespace and leaves the
desktop without a Discord window.

### CloakBrowser stability

`cloak_loop` now passes
`--user-data-dir=/home/kasm-user/.config/cloakbrowser
--disable-software-rasterizer` and clears stale `SingletonLock`/`SingletonSocket`
files before each respawn. The loop also tracks an exponential backoff
when the binary exits in under 2 seconds and tails the last few lines of
`/tmp/cloakbrowser.log` so the failure is visible from `kubectl logs`.

## URL launcher (`nav_shim`)

The bundled browser opens whatever `START_URL` was at session start. To
swap it without restarting the pod, the dashboard `POST`s a JSON body to
`/dashboard/kasm/launch-url/{workspace}` (axum-kbve). axum forwards to the
in-pod `nav_shim.py` over an internal `kasm-vpn-service:9998` route.

The shim is a thin HTTP front for [CDP](https://chromedevtools.github.io/devtools-protocol/)
`Page.navigate` and **only** exposes that one method. Defense in depth:

| Layer | Mitigation |
|-------|------------|
| Cloakbrowser CDP | Bound to `127.0.0.1` inside the workspace container only |
| Shim API surface | Only `POST /open {url}` and `GET /healthz` are routed; everything else 404s |
| Bearer auth | Every request must carry the `URL_LAUNCHER_TOKEN` (= rotated `kasm-vnc-pw`) |
| Cilium NetworkPolicy | Port 9998 is only reachable from the `kbve` namespace |
| URL policy | Scheme allowlist (http/https), no embedded creds, no loopback/private/link-local hosts, no `.cluster.local`/`.svc` |
| Audit | Each launch request and shim response is captured via the existing Vector → ClickHouse `project_logs` pipeline |

## Resources

The `workspace` container in `apps/kube/kasm/manifest/deployment.yaml` is
sized for Discord + a browser tab + a screenshare encoder running in parallel:

| | CPU | Memory |
|---|---|---|
| `requests` | `2` | `4Gi` |
| `limits` | `4` | `8Gi` |

The Gluetun sidecar keeps its own modest profile (`100m`/`128Mi` request,
`500m`/`384Mi` limit) — bumping it does not buy noticeable latency since
the VPN tunnel is bandwidth-, not CPU-bound.

## Build

```sh
npx nx run kasm-void:container
npx nx run kasm-void:test
```

Published tags land at `ghcr.io/kbve/kasm-void:<version>`; the post-publish
chore workflow syncs the Deployment image pin to match `version.toml`.

## FAQ

**What is the KASM Void image?**
`kasm-void` is the production workspace image used by the `kasm-vpn` Deployment. It extends `kasmweb/discord` with CloakBrowser so the KASM session exposes both Discord and a browser side-by-side, with the browser as the canonical Discord screen-share target.

**Why bundle Discord and a browser instead of using the stock image?**
The stock `kasmweb/discord` ships only Discord and leaves an empty desktop when closed. Bundling gives a known reproducible browser binary for consistent stream fonts and codecs and lets KBVE own resource requests and limits against a single artifact.

**How does KASM Void keep the desktop populated after a crash?**
A custom startup script spawns three supervisor loops (`cloak_loop`, `discord_loop`, `nav_shim_loop`) that poll every 3 to 5 seconds via `pgrep` and relaunch CloakBrowser, Discord, or the `nav_shim` if they exit, so no manual KASM session restart is needed.

## Related

- [DiscordSH Bot](/project/discordsh-bot) — Discord gateway bot in the same Discord tooling group.

---
# kbve — Axum + Diesel Backend Boilerplate Crate

> KBVE core Rust crate — an Axum and Diesel boilerplate for building backend APIs and micro-services, with auth, Supabase, and gate features.

Source: https://kbve.com/project/kbve-crate/

## Overview

`kbve` is the KBVE core Rust crate — an [Axum](https://github.com/tokio-rs/axum)
and [Diesel](https://diesel.rs/) boilerplate that provides shared building
blocks for producing backend APIs and micro-services. It bundles authentication,
markdown, wallet, referral, and gate modules behind Cargo feature flags so each
service links only what it needs.

## Key facts

| | |
|---|---|
| **Package** | `kbve` |
| **Version** | 0.1.26 |
| **Language** | Rust (Axum + Diesel) |
| **License** | MIT |
| **Source** | [`packages/rust/kbve`](https://github.com/KBVE/kbve/tree/main/packages/rust/kbve) |
| **Edition** | 2021 |

## Features

- **Axum + Diesel base** — HTTP routing plus async Diesel (diesel-async, bb8 pool) for backend micro-services.
- **Authentication** — Argon2 password hashing and JWT (`jsonwebtoken`) handling.
- **`supabase` / `kv`** — Supabase integration and a Valkey-backed key-value layer via `jedi`.
- **`gate` / `gate-auth`** — an auth-proxy WebSocket surface (the kbve-gate sidecar) fronting services like n8n, Grafana, and Studio.
- **`image-gen`, `wallet`, `referral`, `markdown`, `lot`** — additional optional modules for the KBVE platform.
- **`legacy-sync-db`** — the older synchronous Diesel modules (guild, models, runes, schema, spellbook).

## FAQ

**What is the kbve crate?**
It is the KBVE core Rust crate — an Axum and Diesel boilerplate that provides
shared building blocks for producing backend APIs and micro-services across the
KBVE ecosystem.

**What features does the kbve crate expose?**
Cargo feature flags gate optional capabilities including `supabase`, `kv`
(Valkey-backed), `image-gen`, `wallet`, `gate-auth`, and `gate` (an auth-proxy
WebSocket surface), plus a `legacy-sync-db` path for the older Diesel
synchronous modules.

**What is the kbve gate feature for?**
The `gate` and `gate-auth` features provide an authentication-proxy surface
built on Axum WebSockets and reqwest streaming, used as the kbve-gate sidecar
that fronts services such as n8n, Grafana, and Studio.

## Related

- [KBVE Gate](/docs/project/kbve-gate) — the auth-proxy sidecar built on this crate's gate feature.
- [Q Crate](/docs/project/q-crate) — another core Rust crate powering KBVE games.

---
# KBVE Gate — Supabase JWT Auth Reverse-Proxy Sidecar

> KBVE Gate is a reusable auth reverse-proxy sidecar that validates a Supabase JWT plus an authz policy, then proxies HTTP and WebSocket to internal upstreams.

Source: https://kbve.com/project/kbve-gate/

import { Aside, Steps } from '@astrojs/starlight/components';

## KBVE Gate

`kbve-gate` is a thin authentication reverse-proxy built on the `kbve` crate's
feature-gated `gate` module. It runs as a sidecar in front of an internal
service so the upstream binds localhost and only the gate is exposed.

## Key facts

| | |
|---|---|
| **App** | `kbve-gate` |
| **Version** | 0.1.7 |
| **Built on** | `kbve` crate `gate` feature module (Rust) |
| **Image** | `kbve/kbve-gate` |
| **Deploy shapes** | sidecar or standalone Deployment + Service + HTTPRoute |
| **Fronts** | n8n, Grafana, Longhorn, ArgoCD, Forgejo, Supabase Studio |
| **Source** | [`apps/kbve/kbve-gate`](https://github.com/KBVE/kbve/tree/main/apps/kbve/kbve-gate) |

### Auth

The gate accepts a Supabase JWT from an `Authorization: Bearer` header, an
`sb-access-token` / `kbve_gate` cookie, or an `?access_token=` query param.
After the JWT validates it applies an authz policy:

- `jwt-only` — any valid Supabase JWT passes.
- `is_staff` — `forum.is_staff(sub)` must return true. The gate mints a
  short-lived `service_role` JWT from `SUPABASE_JWT_SECRET` to call PostgREST,
  so the stale stored service-key is never used.

### Configuration

| Env | Default | Purpose |
| --- | --- | --- |
| `GATE_LISTEN` | `0.0.0.0:5678` | bind address |
| `GATE_UPSTREAM` | `http://127.0.0.1:5679` | upstream base URL |
| `GATE_UPSTREAM_PREFIX` | — | path prefix prepended to every upstream request (Grafana sub-path) |
| `GATE_UPSTREAM_CA_CERT_PATH` | — | CA bundle to trust an HTTPS upstream (ArgoCD TLS) |
| `GATE_AUTHZ` | `is_staff` | `is_staff` or `jwt-only` |
| `GATE_STAFF_SCHEMA` | `forum` | Postgres schema holding `is_staff` |
| `GATE_UPSTREAM_BASIC` | — | `Basic <b64>` injected downstream |
| `GATE_UPSTREAM_BEARER` | — | `Authorization: Bearer <token>` injected downstream (ArgoCD apiKey) |
| `GATE_FORWARD_USER_HEADER` / `GATE_FORWARD_USER_VALUE` | — | trusted identity header injected downstream (Grafana auth-proxy) |
| `GATE_LOGIN_REDIRECT` | — | 302 target for unauthed browser navigations |
| `GATE_COOKIE_DOMAIN` | — | domain scope for the minted session cookie (e.g. `.kbve.com`) |
| `SUPABASE_JWT_SECRET` | — | required |
| `SUPABASE_URL` | — | required for `is_staff` (direct PostgREST) |

### Login bounce

The KBVE session lives in the browser (IndexedDB), so a cross-subdomain
navigation carries no token. The gate completes auth with a bounce:

<Steps>

1. Unauthed navigation to a gated host → `302` to
   `GATE_LOGIN_REDIRECT?redirect_to=<original URL>`.
2. The login page, once a session exists, returns the browser to
   `redirect_to?access_token=<jwt>`.
3. The gate validates the token, sets a `kbve_gate` cookie scoped to
   `GATE_COOKIE_DOMAIN`, and `302`s to a clean URL. Subsequent requests carry
   the cookie.

</Steps>

The login page only honours `redirect_to` targets on `*.kbve.com` over https,
so the token can never be handed to a foreign origin.

### Deployment shapes

Two shapes depending on whether the upstream is in the same pod:

- **Sidecar** — the gate shares a pod with the upstream, which binds
  `127.0.0.1`. Used when the workload is ours to edit (n8n).
- **Standalone** — the gate is its own `Deployment` + `Service` + `HTTPRoute`
  and proxies a separate in-cluster `Service`. Used for Helm- or
  operator-managed upstreams we don't own (Grafana, Longhorn, ArgoCD).

### n8n (sidecar)

The first consumer fronts n8n: n8n moves to `127.0.0.1:5681`, the gate owns the
Service port `5678`, and `n8n.kbve.com` routes through it so the panel stays
staff-only.

### Grafana (standalone)

`grafana.kbve.com` → standalone gate in `monitoring` → `monitoring-grafana:80`.
`GATE_UPSTREAM_PREFIX=/dashboard/grafana/proxy` matches Grafana's sub-path
`root_url`. Grafana's own login is bypassed with its auth-proxy:
`GATE_FORWARD_USER_HEADER=X-WEBAUTH-USER` / `GATE_FORWARD_USER_VALUE=kbve-staff`,
so the gate-authed staff user is trusted downstream.

### Longhorn (standalone)

`longhorn.kbve.com` → standalone gate in `longhorn-system` →
`longhorn-frontend:80`. No prefix (the UI roots at `/`) and no upstream login —
the gate's `is_staff` is the only auth in front of the panel.

### ArgoCD (standalone)

`argo.kbve.com` → standalone gate in `argocd` → `argocd-server:443` over HTTPS
(`GATE_UPSTREAM_CA_CERT_PATH` trusts the `argocd-server-tls` CA). ArgoCD keeps
its own login, so the gate injects an admin apiKey as `GATE_UPSTREAM_BEARER`
(synced by ESO from the `argocd-auth` secret) on every request — the SPA then
authenticates as that account instead of redirecting to ArgoCD's login.

### Forgejo (standalone)

`forgejo.kbve.com` → standalone gate in `forgejo` → `forgejo-http:3000`.
The gate enforces `is_staff` authz while API and git operations (e.g., `/api/`,
`/v2/`, `/KBVE/`) bypass the gate for token-based auth. Forgejo is configured
with OAuth/OIDC to use Supabase as the identity provider, enabling automatic
account creation and login for authenticated staff users.

## FAQ

**What is KBVE Gate?**
KBVE Gate is a thin authentication reverse-proxy built on the `kbve` crate's
feature-gated `gate` module. It runs as a sidecar in front of an internal service so
the upstream binds localhost and only the gate is exposed, fronting tools like n8n,
Grafana, Longhorn, ArgoCD, Forgejo, and Supabase Studio.

**How does KBVE Gate authenticate requests?**
The gate accepts a Supabase JWT from an `Authorization: Bearer` header, an
`sb-access-token` / `kbve_gate` cookie, or an `?access_token=` query param. After the
JWT validates it applies an authz policy — `jwt-only` lets any valid JWT pass, while
`is_staff` requires `forum.is_staff(sub)` to return true.

**How does KBVE Gate handle cross-subdomain login?**
Because the KBVE session lives in the browser's IndexedDB, a cross-subdomain
navigation carries no token, so the gate does a login bounce — it `302`s unauthed
navigations to `GATE_LOGIN_REDIRECT`, the login page returns with `access_token`, and
the gate validates it and sets a `kbve_gate` cookie scoped to `GATE_COOKIE_DOMAIN`.

## Related

- [Edge](/docs/project/edge) — KBVE edge service tier.
- [API](/docs/project/api) — the KBVE core API the gate protects access patterns around.

---
# KBVEAgones — Unreal Agones-to-ROWS Server Bridge Plugin

> Server-only Unreal plugin bridging the Agones SDK and KBVE ROWS, registering a dedicated-server instance with ROWS once Agones reports its GameServer identity.

Source: https://kbve.com/project/kbveagones/

## Overview

KBVEAgones is a server-only glue plugin for Unreal Engine dedicated servers. Agones owns the GameServer lifecycle (Ready / Health); `UKBVEAgonesBridgeSubsystem` listens for the Agones `ConnectedDelegate` and registers the instance with KBVE ROWS via `UROWSInstanceSubsystem::RegisterLauncher(Address, Port, MaxInstances)` using the address and port Agones reports. This wires an Agones-fleeted UE dedicated server into the ROWS backend without leaking any of it into client or editor builds.

## Key facts

| | |
|---|---|
| **Plugin** | KBVEAgones |
| **Version** | 0.0.1 |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Platforms** | Linux |
| **Depends on** | [Agones](./agones), [KBVEROWS](./kbverows) |
| **Source** | [`packages/unreal/KBVEAgones`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEAgones) |

## Features

- **Agones → ROWS bridge** — `UKBVEAgonesBridgeSubsystem` reacts to the Agones `ConnectedDelegate` and registers the instance with ROWS.
- **Launcher registration** — calls `UROWSInstanceSubsystem::RegisterLauncher(Address, Port, MaxInstances)` with the Agones-reported endpoint.
- **Server-only** — module is `TargetAllowList: ["Server"]` and the subsystem gates on `IsRunningDedicatedServer()`, keeping it out of client/editor builds.
- **Clean separation** — depends on Agones for lifecycle and KBVEROWS for REST; KBVEROWS stays a pure REST plugin.

## FAQ

**What does the KBVEAgones plugin do?**
It is a server-only glue plugin. `UKBVEAgonesBridgeSubsystem` listens for the Agones `ConnectedDelegate` and registers the dedicated-server instance with KBVE ROWS via `RegisterLauncher`, using the address and port Agones reports.

**Does KBVEAgones run in client or editor builds?**
No. The module is `TargetAllowList: ["Server"]` and the subsystem gates on `IsRunningDedicatedServer()`, so it stays out of client and editor builds.

**What does KBVEAgones depend on?**
It depends on the Agones plugin for the GameServer lifecycle and KBVEROWS for the ROWS REST client. KBVEROWS itself remains a pure REST plugin.

## Related

- [ROWS](./rows) — the Rust game backend the instance registers with.
- [KBVEROWS](./kbverows) — the Unreal REST client plugin KBVEAgones depends on.
- [Agones](./agones) — the GameServer fleet manager driving the lifecycle.

---
# KBVECombat — Server-Authoritative Combat Plugin for Unreal

> KBVECombat is a shared Unreal Engine combat domain with server-authoritative damage, teams, and death built on KBVEGameplay stat and effect primitives.

Source: https://kbve.com/project/kbvecombat/

## Overview

`KBVECombat` is the shared combat domain — server-authoritative damage, teams/factions, and death — built on **KBVEGameplay** primitives (stats + effects). It depends on KBVEGameplay, never the reverse: combat consumes the primitives, it doesn't define them. Backend-agnostic — Mover pawns, CMC characters, and Mass NPC proxies all fight through one interface.

## Pieces

- **`UKBVECombatComponent`** — resolves damage against the owner's Health stat via `IKBVEStatTarget`, tracks team + replicated dead state, fires `OnDamaged` / `OnDeath`. Implements `IKBVECombatant`.
- **`IKBVECombatant`** — `GetTeamId` / `IsAlive` / `ApplyDamage`; uniform participation regardless of movement backend.
- **`FKBVEDamageEvent`** — amount, `EKBVEDamageElement`, instigator, hit info.
- **`UKBVECombatStatics`** — `ApplyDamage` / `IsAlive` / `GetTeamId` / `AreHostile`, resolving a combatant on any actor.

## Usage

```cpp
FKBVEDamageEvent Dmg;
Dmg.Amount = 25.f;
Dmg.Element = EKBVEDamageElement::Fire;
Dmg.Instigator = Attacker;
UKBVECombatStatics::ApplyDamage(Target, Dmg); // authority-only
```

Add `UKBVECombatComponent` to any actor implementing `IKBVEStatTarget` with a `Health` stat (e.g. `AKBVEMoverPawn`, `AchuckCoreCharacter`). Damage flows through the stat, composing with KBVEGameplay effects and replicating via the owner's transport (Iris / KBVENet).

## Roadmap

- Element resist/weakness scaling, attack/ability driver (windups/cooldowns/hitboxes), threat/aggro + death loot hooks, combat-event feed for UI.

## FAQ

**What is the KBVECombat plugin?**
KBVECombat is the shared combat domain for KBVE Unreal Engine games —
server-authoritative damage, teams and factions, and death — built on
KBVEGameplay stat and effect primitives. It depends on KBVEGameplay and never
the reverse.

**Which movement backends does KBVECombat support?**
It is backend-agnostic. Mover pawns, CMC characters, and Mass NPC proxies all
fight through the same `IKBVECombatant` interface, so combat participation is
uniform regardless of the movement backend.

**How is damage applied in KBVECombat?**
Damage is authority-only. `UKBVECombatStatics::ApplyDamage` resolves a combatant
on any actor and applies an `FKBVEDamageEvent` against the owner's Health stat
via `IKBVEStatTarget`, composing with KBVEGameplay effects and replicating
through the owner's transport.

## Related

- [KBVEGameplay](/docs/project/kbvegameplay) — the stats and effects primitives KBVECombat builds on.
- [KBVEMover](/docs/project/kbvemover) — one of the movement backends whose pawns fight through KBVECombat.

---
# KBVEEvents — Typed UE Event Bus Plugin

> Lightweight typed publish/subscribe event bus for Unreal Engine — compile-time-typed channels, pooled payloads, and lock-free SPSC worker-to-game handoff.

Source: https://kbve.com/project/kbveevents/

## Overview

`KBVEEvents` is a lightweight typed publish/subscribe event bus for KBVE Unreal
Engine games. It provides compile-time-typed channels (`TKBVEChannel<TPayload>`),
pooled payloads, and a lock-free SPSC handoff for moving Mass worker-thread
events onto the game thread. It is a companion to UE's `GameplayMessageRouter` —
use GMR for Blueprint-friendly tag-based messaging, and KBVEEvents when
performance or compile-time typing matters.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEEvents` |
| **Version** | 0.1.0 |
| **Language** | C++ (Unreal Engine) |
| **Min engine** | UE 5.4 |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVEEvents`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEEvents) |
| **Platforms** | Win64, Linux, Mac |

## Features

- **Compile-time-typed channels** — `TKBVEChannel<TPayload>` dispatches strongly
  typed payloads with no tag lookups or boxing.
- **Handle-based subscriptions** — `Subscribe` returns an `FKBVEEventHandle`;
  cancel via `Unsubscribe` or let the owning `UObject` GC, since channels prune
  stale weak refs before each dispatch.
- **Synchronous game-thread dispatch** — `Publish` invokes callbacks on the
  calling thread under an `FCriticalSection` so the channel itself never tears.
- **Lock-free cross-thread path** — an MPSC queue lets a worker enqueue POD
  payloads that a game-thread bridge drains and publishes safely.

## Usage

```cpp
TKBVEChannel<FMyPayload> Channel;

FKBVEEventHandle Handle = Channel.Subscribe(Owner,
    [](const FMyPayload& Payload) { /* game-thread callback */ });

Channel.Publish(FMyPayload{ /* ... */ });
Channel.Unsubscribe(Handle);
```

## FAQ

**What is KBVEEvents?**
It is a lightweight typed publish/subscribe event bus for Unreal Engine games,
using compile-time-typed channels (`FKBVEChannel`), pooled payloads, and a
lock-free SPSC queue for worker-to-game-thread events.

**When should I use KBVEEvents instead of GameplayMessageRouter?**
Use UE's `GameplayMessageRouter` for Blueprint-friendly tag-based messaging;
reach for KBVEEvents when performance or compile-time typing matters.

**Is it safe to publish from a worker thread?**
`Publish` invokes callbacks synchronously on the calling thread, so it is
game-thread by default. For cross-thread events, a worker enqueues a POD payload
on the MPSC queue and a game-thread bridge drains it and publishes safely.

## Related

- [KBVEWorld](/docs/project/kbveworld) — procedural world toolkit that pairs with the event bus.
- [KBVEPostShader](/docs/project/kbvepostshader) — sibling KBVE Unreal plugin.

---
# KBVEGameplay — Consumable & Effect Framework

> KBVEGameplay is a game-agnostic Unreal consumable and effect framework — restores, over-time regen/DoT, stat buffs, statuses, cooldowns, and melee combat.

Source: https://kbve.com/project/kbvegameplay/

## Overview

Game-agnostic consumable + effect framework. A game implements `IKBVEStatTarget`
(map its stats to FName ids) and attaches `UKBVEEffectComponent`; the plugin owns
the effect lifecycle from a data-driven `FKBVEEffectSpec`:

- **Restores** — instant stat deltas (heal HP, restore mana/energy).
- **Regens** — over-time HoT / DoT (`RatePerSecond` × `Duration`).
- **Buffs** — temporary additive / multiplicative stat modifiers (auto-removed on expiry).
- **Statuses** — named condition tags (poison / regen / blessed) with stacks + duration.
- **Cooldown** — per-`SourceKey` gate (`TryApplyEffect` rejects while hot).
- **AnimationRef** — carried on the spec for the game to drive a montage.

Tick auto-disables when no effects or cooldowns are active. Effect DATA lives in
the shared itemdb; the game builds an `FKBVEEffectSpec` from its item definition.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEGameplay` |
| **Version** | 0.1.0 (beta) |
| **Engine** | Unreal Engine 5.4+ |
| **Platforms** | Win64, Linux, Mac |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVEGameplay`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEGameplay) |

## Features

- **Data-driven effects** — restores, regens/DoT, buffs, and statuses from `FKBVEEffectSpec`.
- **Cooldown gating** — per-`SourceKey` gate rejects re-application while hot.
- **Auto-disabling tick** — the component stops ticking when no effects or cooldowns are live.

## Stats + combat

Also holds the agnostic gameplay-stat layer (the effect target it feeds):

- **`FKBVEStatBlock`** — health / mana / stamina with regen rates + stamina
  thresholds; `HealthFraction` / `ManaFraction` / `StaminaFraction`.
- **`EKBVEMovementState`** — movement flag set (`OnGround`/`Moving`/`Sprinting`/…) +
  `KBVEMove` helpers; gates stamina drain/regen.
- **`FKBVEStatFragment`** + **`UKBVEStatRegenProcessor`** — Mass fragment + parallel
  regen processor (health/mana regen, stamina drain on sprint, low-stamina + empty
  penalty). Worker-thread, cache-coherent.
- **`IKBVECombatDamageable` / `IKBVECombatAttacker`** — combat interfaces
  (apply damage/heal/death/danger; attack-trace / combo / charged hooks).
- **`UKBVEMeleeComponent`** — generic melee sweep: forward sphere trace from a
  mesh socket, hits `IKBVECombatDamageable`, applies damage + knockback/launch
  impulse, fires `OnMeleeHit`; per-swing dedupe (`BeginSwing`/`EndSwing`).

`UKBVEEffectComponent` applies effects through `IKBVEStatTarget`; a game's stat
owner maps those onto its `FKBVEStatBlock` / `FKBVEStatFragment`.

## Event payloads (`KBVEGameplayEvents.h`)

Shared cross-game vocabulary for stat/combat signals — plain POD structs a game
and reusable UI agree on: `FKBVEHealthChangedPayload` / `FKBVEManaChangedPayload`
/ `FKBVEStaminaChangedPayload` (current/max + stamina regen delay),
`FKBVEDamageReceivedPayload` (amount + damage-bit), and the Mass-sim
`FKBVECombatHitPayload` / `FKBVEEntityKilledPayload` (entity handles). Transport
stays the game's — these are only the contract; chuck pipes them through its own
`TKBVEChannel` hubs. Game-specific payloads (inventory-dirty, tooltip,
item-consumed, pickup, auth, chat, ui-flags) stay in the game.

## FAQ

**What does KBVEGameplay provide?**
A game-agnostic consumable and effect framework for Unreal — data-driven restores,
over-time regen/DoT, stat buffs, status conditions, and cooldowns applied through
the `IKBVEStatTarget` interface.

**How does a game integrate KBVEGameplay?**
A game implements `IKBVEStatTarget` to map its stats to FName ids and attaches
`UKBVEEffectComponent`; the plugin then owns the effect lifecycle from a
data-driven `FKBVEEffectSpec`.

**Does KBVEGameplay include combat?**
Yes. It ships an agnostic stat block, a Mass parallel regen processor, combat
damageable/attacker interfaces, and a generic `UKBVEMeleeComponent` sweep with
knockback and per-swing dedupe.

## Related

- [KBVECombat](/docs/project/kbvecombat) — combat systems that pair with these stats.
- [KBVEItemDB](/docs/project/kbveitemdb) — item database that supplies effect data.
- [KBVEMover](/docs/project/kbvemover) — movement layer that reads movement state.

---
# KBVEHexWorld — Hex-Grid World Topology Module for Unreal

> KBVEHexWorld is the hex-grid topology module of the KBVEWorld Unreal plugin, providing deterministic seeds, noise terrain, and a Blueprint hex cell registry.

Source: https://kbve.com/project/kbvehexworld/

import { Aside } from '@astrojs/starlight/components';

<Aside type="note">
KBVEHexWorld is now a module of the **KBVEWorld** plugin, not a standalone
plugin. Enable `KBVEWorld` to get both the square-chunk world and the hex
topology modules.
</Aside>

## Overview

`KBVEHexWorld` is the hex-grid world topology module of the **KBVEWorld** Unreal
plugin. It provides deterministic world seeds, noise-driven terrain, and a
foundation for PCG streaming. The `UHexWorldSubsystem` maintains a master map of
hex cells with Blueprint-callable registration and query functions.

## Key facts

| | |
|---|---|
| **Module** | `KBVEHexWorld` (in `KBVEWorld` plugin) |
| **Version** | 0.1.0 |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVEWorld/Source/KBVEHexWorld`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEWorld/Source/KBVEHexWorld) |
| **Depends on** | MassGameplay, KBVESQLite, ProceduralMeshComponent, KBVEPerf |

## Features

- **Hex topology** — hex-grid coordinates (`FHexCoord`) and cell records
  (`FHexCellRecord`) with neighbor queries.
- **Deterministic seeds** — `HexWorldSeedSubsystem` for reproducible world
  generation.
- **Noise terrain** — `HexNoiseSubsystem` and `HexEnvironmentSubsystem` drive
  procedural terrain and environment.
- **Blueprint-callable map** — `UHexWorldSubsystem` (a `GameInstanceSubsystem`)
  registers, unregisters, looks up, and enumerates hex cells.

## FAQ

**What is KBVEHexWorld?**
`KBVEHexWorld` is the hex-grid world topology module of the KBVEWorld Unreal
plugin. It provides deterministic world seeds, noise-driven terrain, and a
foundation for PCG streaming, exposing a Blueprint-callable master map of hex
cells.

**Is KBVEHexWorld a standalone plugin?**
No. It is now a module inside the KBVEWorld plugin rather than a standalone
plugin. Enable `KBVEWorld` to get both the square-chunk world module and the hex
topology module together.

**How do you query the hex world?**
The `UHexWorldSubsystem` is a `GameInstanceSubsystem` that maintains a master hex
map. It exposes Blueprint-callable functions to register and unregister cells by
`FHexCoord`, look up a cell record, list all coordinates, and query a cell's
neighbors.

## Related

- [KBVEROWS](/docs/project/kbverows) — sibling KBVE Unreal backend integration plugin.

---
# KBVEItemDB — Item Database & Inventory Plugin for Unreal

> KBVEItemDB is a game-agnostic Unreal Engine item database, inventory model, and dropped-item Mass fragment that loads the shared itemdb artifact.

Source: https://kbve.com/project/kbveitemdb/

## Overview

Game-agnostic item database + inventory + Mass bridge. The data/inventory half
to [KBVEGameplay](/project/kbvegameplay)'s effect half:

- **`FKBVEItemDef` / `FKBVEItemFood`** — runtime item def: identity, type flags,
  rarity, stacking, prices, tags, and consumable/food effect fields
  (heals / restoreMana / restoreEnergy / regenPerSecond / regenDuration / cooldown
  / animationRef) — aligned to `FKBVEEffectSpec` so a game maps item → effect.
- **`UKBVEItemDatabase`** (GameInstance subsystem) — loads `Content/Data/itemdb-data.json`
  via UE Json; lookup by key / ref. Mirrors the `chuckItemDB` pattern.
- **`FKBVEInventory` / `FKBVEInventoryBag` / `FKBVEInventoryStack`** + `UKBVEInventoryLibrary`
  (`TryAdd` / `CountItem` / `FindFirstSlot`) — generic inventory model.
- **`FKBVEDroppedItemFragment` / `FKBVEDroppedItemTag`** — Mass fragment for
  world-dropped items (key, count, rarity, lifetime, magnet/pickup radius).

Item DATA stays in the shared itemdb MDX. KBVEItemDB carries it + the inventory
model; KBVEGameplay applies the consumable effects (atlas/icon rendering deferred).

### Consumables (type- + data-driven)

`type_flags` classify the consumable — FOOD (`0x08`) / DRINK (`0x10`) / POTION
(`0x20`) — and the `food:` block carries the numbers: `heals` / `restore_mana` /
`restore_energy` (instant), `regen_per_second` + `regen_duration` (heal-over-time),
plus top-level `cooldown`. A consumer builds an `FKBVEEffectSpec` from these
(instant `Restores` + `Regens`, cooldown-gated) and applies it through
KBVEGameplay's `UKBVEEffectComponent` → `IKBVEStatTarget`. Type picks the regen
target (food → health, drink → mana/stamina); the data fills the magnitudes. An
item with a `food:` block or a food/drink/potion type bit is consumable without
needing an explicit `consumable: true`.

## Dropped items (`AKBVEDroppedItemActor` / `UKBVEDroppedItemPool`)

Pooled, billboarded world-drop system — extracted from chuck's
`chuckDroppedItemActor` / `chuckDroppedItemPool` and made game-agnostic.

- **`AKBVEDroppedItemActor`** — sphere overlap root + icon/halo `UMaterialBillboardComponent`
  + rarity `UPointLightComponent`. Idle bob, then pawn-overlap triggers a homing
  ease toward the picker; on complete it calls back into the pool. No game types.
- **`UKBVEDroppedItemPool`** (world subsystem) — preallocates `InitialPoolSize` (64)
  actors, free-list `SpawnDrop` / `ReleaseDrop`, fires `OnItemPickedUp(Picker, ItemKey, Count)`
  on homing-complete so the game owns auth + inventory add.
- **`IKBVEDroppedItemVisualProvider`** (icon-provider seam) — game implements
  `GetDroppedItemVisual(ItemKey, FKBVEDroppedItemVisual&)` to supply per-item
  `IconMID` / `HaloMID` / `RarityColor`; registered via `SetVisualProvider`. Keeps
  atlas/MID generation game-side while the pool stays generic.

The chuck-specific `Cast<AchuckCoreCharacter>` + `ServerAddItemByKey` pickup path
becomes: provider feeds visuals, `OnItemPickedUp` delegate feeds the inventory.

chuck now consumes this directly — `UchuckItemDB` implements
`IKBVEDroppedItemVisualProvider` (maps key → atlas icon MID + rarity halo) and
hosts the `OnItemPickedUp` handler (`HandleDroppedItemPickedUp` → authority-gated
`ServerAddItemByKey`); `AchuckCoreCharacter::BeginPlay` registers the DB as the
pool's provider + pickup sink once, and `ServerDropSlot` just calls
`SpawnDrop(ItemKey, Count, Loc)`. chuck's old `chuckDroppedItemActor` /
`chuckDroppedItemPool` are deleted.

## Generated proto types (`gen-itemdb-uecpp.mjs`)

The same `itemdb.binpb` descriptor that feeds the zod generator also feeds a UE
C++ emitter (`packages/data/codegen/gen-itemdb-uecpp.mjs`, run via
`nx run astro-kbve:sync:itemdb-uecpp`). It writes, into `Public/Generated/`:

- **`KBVEItemDBProtoTypes.h`** — one `USTRUCT` per item-package proto message
  (`FKBVEGenItem`, `FKBVEGenFoodInfo`, `FKBVEGenUseEffect`, …), topo-ordered so
  definitions precede use; scalars/enums/nested/`repeated` map to UE types.
- **`KBVEItemDBProtoParse.h`** — `KBVEItemDBProto::Populate(FStruct&, yyjson_val*)`
  per message, reading the camelCase JSON keys the data codegen emits.

So a new proto field regenerates both the struct and its JSON reader — no
hand-written parser to drift (the class of bug that silently dropped consumable
data). The mirror of the zod generator, emitting UE-native `USTRUCT`s instead of
`google::Message` (no libprotobuf runtime).

**One item type, one parser, one map.** Both loaders run
`KBVEItemDBProto::Populate(FKBVEGenItem, …)` then the single shared map
`KBVEItemMap::FromGen` → the curated `FKBVEItemDef`:

- **plugin** `UKBVEItemDatabase` and **chuck** `UchuckItemDB` both store + return
  `FKBVEItemDef` (chuck retired its `FchuckItemDef` / `FchuckItemFood` /
  `EchuckItemRarity` / `chuckItem::RarityColor` — deleted `chuckItemTypes.h`).
- `FKBVEItemDef` absorbed chuck's needs: `IsFood/IsDrink/IsPotion`, `ConsumeStatuses`
  + `ConsumeBuffDuration`, and `KBVEItem::RarityColor`. chuck consumers (consume,
  inventory slot, item info, drop visuals) read it directly.
- `key` + `has_img` are now proto fields (`itemdb.proto`) so the generated type is a
  true superset — the proto is the single source of truth, no engine-only injected
  fields. The old hand-written `FJsonObject` / yyjson key-reads in both loaders are
  gone; a new proto field flows everywhere by regenerating, no loader edits.

`UchuckItemDB` still owns chuck's atlas / icon-MID / rarity-halo rendering on top of
the shared `FKBVEItemDef`.

## Persistence (`FKBVEInventoryStore` / `UKBVEInventoryStoreSubsystem`)

Durable local inventory via the **KBVESQLite** plugin — row-per-slot
(`player_inventory(player_id, bag_ref, slot_idx, item_key, count, durability, flags)`,
WAL), save/load/count/clear by player id, opened at `Saved/KBVE/inventory.db`.

**Two boundaries to respect:**

1. **SQLite ⟂ Mass.** SQLite is a persistence boundary, not a per-tick datasource:
   load → seed Mass fragments at spawn/login, mutate fragments on worker threads,
   flush fragments → SQLite at intervals/logout (game thread / async). A single
   `sqlite3*` is not thread-safe; never query it inside the Mass processor loop.
2. **KBVESQLite ⟂ UE SQLiteCore.** KBVESQLite is the single sqlite provider for
   KBVE code (its own vendored `sqlite3`). Do not also link the engine's
   `SQLiteCore` in the same module — duplicate `sqlite3_*` symbols crash the build/run.
   Plugins depending on KBVESQLite declare `dependency_plugins: packages/unreal/KBVESQLite`.

## FAQ

**What is the KBVEItemDB plugin?**
KBVEItemDB is a game-agnostic Unreal Engine plugin providing an item database
loader, a generic inventory model, and a dropped-item Mass fragment. It loads the
shared itemdb artifact into runtime item defs and looks them up by key or ref.

**How does KBVEItemDB relate to KBVEGameplay?**
KBVEItemDB is the data and inventory half; KBVEGameplay is the effect half. Item
defs carry consumable/food fields aligned to `FKBVEEffectSpec`, so a consumer
builds an effect spec from an item and applies it through KBVEGameplay's
`UKBVEEffectComponent`.

**How are consumables modeled in KBVEItemDB?**
`type_flags` classify items as FOOD, DRINK, or POTION, and a `food` block carries
the numbers such as `heals`, `restore_mana`, `restore_energy`,
`regen_per_second`, `regen_duration`, and `cooldown`. An item with a `food` block
or a food/drink/potion type bit is consumable without an explicit `consumable`
flag.

## Related

- [KBVESQLite](/docs/project/kbvesqlite) — the SQLite provider KBVEItemDB uses for durable inventory persistence.
- [KBVEZstd](/docs/project/kbvezstd) — compression plugin in the same Unreal plugin family.

---
# KBVELibGit — libgit2 Git Plugin Installer for UE5

> KBVELibGit is an editor-only Unreal Engine 5 plugin that uses libgit2 to clone, fetch, and manage public GitHub repositories as local UE plugins.

Source: https://kbve.com/project/kbvelibgit/

## Overview

`KBVELibGit` is an **editor-only** Unreal Engine 5 plugin that uses
[libgit2](https://libgit2.org) to clone, fetch, and manage public GitHub
repositories as local UE plugins — directly from an in-editor installer panel. It
loads at `PostEngineInit`, contains no runtime content, and is currently a beta,
experimental plugin.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVELibGit` |
| **Version** | 0.1.0 |
| **Type** | Editor module (`PostEngineInit`) |
| **Engine** | UE 5.4+ |
| **Platforms** | Win64, Linux, Mac |
| **Backend** | libgit2 (ThirdParty) |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVELibGit`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVELibGit) |

## Features

- **Clone / fetch over libgit2** — a fresh clone for new repos, a fetch-latest for
  ones already on disk, all driven by the bundled libgit2 ThirdParty library.
- **Remote HEAD resolution** — resolves a registry HEAD over the wire via
  `ls-remote` without a full clone when no local copy exists.
- **Git Plugin Installer panel** — an editor UI (`SGitInstallerPanel`) that adds a
  "Git Plugin Installer" entry for browsing and installing repos as plugins.
- **Plugin registry + validation** — a plugin registry, validator, and lock guard
  keep installed plugins consistent.

## FAQ

**What does KBVELibGit do?**
KBVELibGit is an editor-only Unreal Engine 5 plugin that uses the libgit2 library to
clone, fetch, and manage public GitHub repositories as local Unreal plugins from
inside the editor.

**Which engine versions and platforms does KBVELibGit support?**
It targets Unreal Engine 5.4 and newer, and supports Win64, Linux, and Mac. It is an
editor module that loads at the `PostEngineInit` phase and is currently a beta,
experimental plugin.

**How does KBVELibGit fetch repositories?**
It uses libgit2 directly to clone a fresh repo or fetch the latest for an
already-cloned one, and can resolve a registry HEAD over the wire with `ls-remote`
when no local clone exists, all through an in-editor Git Plugin Installer panel.

## Related

- [KBVESupabase](/project/kbvesupabase/) — a KBVE Unreal Engine 5 plugin for Supabase auth and data.

---
# KBVEMapDB — Unreal World/Map Database + Mass Plugin

> KBVEMapDB is a game-agnostic Unreal plugin that loads the shared mapdb artifact into runtime world-object defs with ref lookup and a Mass fragment bridge.

Source: https://kbve.com/project/kbvemapdb/

## Overview

KBVEMapDB is a game-agnostic Unreal Engine plugin providing world/map data plus a Mass bridge. `UKBVEMapDatabase` (a GameInstance subsystem) loads `Content/Data/mapdb-data.json` into `FKBVEWorldObjectDef` records — resource nodes, containers, and stations with harvest yield/amount/time and spawn weights — and exposes ref lookup. `FKBVEWorldObjectFragment` and `FKBVEWorldObjectTag` carry a placed object's identity and harvest state into Mass for harvestable world entities.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEMapDB` |
| **Version** | 0.1.0 |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Status** | beta |
| **Platforms** | Win64, Linux, Mac |
| **Source** | [`packages/unreal/KBVEMapDB`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEMapDB) |

## Features

- **Game-agnostic loader** — `UKBVEMapDatabase` GameInstance subsystem reads the shared `mapdb-data.json` artifact at runtime.
- **World-object defs** — `FKBVEWorldObjectDef` records model resource nodes, containers, and stations with harvest yield, amount, time, and spawn weights.
- **Ref lookup** — resolve placed objects back to their canonical definition by reference.
- **Mass bridge** — `FKBVEWorldObjectFragment` and `FKBVEWorldObjectTag` carry object identity and harvest state into Mass for harvestable entities.

## FAQ

**What is the KBVEMapDB plugin?**
KBVEMapDB is a game-agnostic Unreal Engine plugin providing world/map data plus a Mass bridge. The `UKBVEMapDatabase` GameInstance subsystem loads the shared `mapdb-data.json` artifact into `FKBVEWorldObjectDef` records and exposes ref lookup.

**What world-object data does KBVEMapDB load?**
It loads `FKBVEWorldObjectDef` records for resource nodes, containers, and stations, including harvest yield, amount, and time plus spawn weights, from `Content/Data/mapdb-data.json`.

**How does KBVEMapDB integrate with Mass?**
`FKBVEWorldObjectFragment` and `FKBVEWorldObjectTag` carry a placed object's identity and harvest state into Mass, so harvestable world entities are driven by the same shared definitions.

## Related

- [KBVETinyBVH](/project/kbvetinybvh) — sibling Unreal plugin from the KBVE package group.
- [Unreal Chuck Dev](/project/unreal-chuck-dev) — UE5 game client that consumes KBVE Unreal plugins.

---
# KBVEMover — Networked UE5 Mover Control Character

> Shared UE5 Mover control character for KBVE games — a networked, data-driven pawn that is client-predicted and server-authoritative.

Source: https://kbve.com/project/kbvemover/

## Overview

`KBVEMover` is the shared control-character layer built on UE5's **Mover** plugin — a networked, data-driven pawn that replaces the legacy `CharacterMovementComponent`. Server-authoritative with client prediction, so it works standalone, listen-server, and on the dedicated server.

## AKBVEMoverPawn

`APawn` with a capsule root, skeletal mesh, third-person camera, and a `UCharacterMoverComponent` (default Walking / Falling / Flying modes). Implements `IMoverInputProducerInterface` and sets itself as the component's `InputProducer`. Enhanced Input accumulates intent; `ProduceInput` translates it into the Mover sim's `FCharacterDefaultInputs` (camera-relative move, orientation intent, jump).

## Usage

Enable the plugin (pulls in `Mover` + `EnhancedInput`), derive a BP from `AKBVEMoverPawn`, assign the mesh + input assets, and set it as the `DefaultPawnClass`. Networking is automatic. It runs parallel to the legacy CMC `AchuckCoreCharacter` — opt in per game.

## Roadmap

- Locomotion animation layer.
- Custom movement modes (sprint / dash / swim).
- Port stats/inventory onto the Mover pawn.

## FAQ

**What is KBVEMover?**
KBVEMover is the shared control-character layer for KBVE games, built on UE5's
Mover plugin. It is a networked, data-driven pawn that replaces the legacy
`CharacterMovementComponent`, working standalone, on a listen-server, and on a
dedicated server.

**What is AKBVEMoverPawn?**
`AKBVEMoverPawn` is an `APawn` with a capsule root, skeletal mesh, third-person
camera, and a `UCharacterMoverComponent` (Walking, Falling, Flying modes). It
implements `IMoverInputProducerInterface` and translates Enhanced Input into the
Mover sim's `FCharacterDefaultInputs`.

**How do I use KBVEMover in a game?**
Enable the plugin (it pulls in `Mover` and `EnhancedInput`), derive a Blueprint
from `AKBVEMoverPawn`, assign the mesh and input assets, and set it as the
`DefaultPawnClass`. Networking is automatic and it runs parallel to the legacy
CMC character, so games opt in per game.

## Related

- [KBVEGameplay](/docs/project/kbvegameplay) — the gameplay plugin KBVEMover depends on.
- [KBVEUI](/docs/project/kbveui) — the shared Slate UI component library for KBVE Unreal games.

---
# KBVENet — Iris-Ready Entity Replication Plugin for Unreal 5

> KBVENet is a shared Unreal Engine 5 networking plugin — a delta-compressed entity-snapshot replicator streaming server-authoritative Mass ECS sims to clients.

Source: https://kbve.com/project/kbvenet/

## Overview

`KBVENet` is the shared networking layer for KBVE games. It provides Iris-ready replication primitives for streaming a server-authoritative simulation (Mass ECS swarms, etc.) to clients that render it locally.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVENet` |
| **Version** | 0.1.0 |
| **Engine** | Unreal Engine 5.7+ |
| **License** | KBVE |
| **Platforms** | Win64, Linux, Mac |
| **Depends on** | KBVESupabase, KBVEWorld, KBVEGameplay |
| **Source** | [`packages/unreal/KBVENet`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVENet) |

## Entity-snapshot replicator

`UKBVENetEntityReplicator` holds a delta-compressed `FFastArraySerializer` of lean per-entity snapshots — `Id`, quantized `Location`, packed `YawQ`, `Frame`, and a `StateByte`. FastArrays are transported by **Iris** when the ReplicationSystem is on, by the classic NetDriver otherwise — the consumer writes no Iris-specific code.

```cpp
// server
Rep->ServerUpsert(EntityId, WorldPos, MoveYawDeg, Frame, bMoving ? 1 : 0);
// client
for (const FKBVENetEntitySnapshot& S : Rep->GetSnapshots()) { /* render */ }
```

## Enabling Iris

Per game: `bUseIris = true;` in each `*.Target.cs`, and `Net.Iris.UseIrisReplication=1` under `[ConsoleVariables]` in `Config/DefaultEngine.ini`.

## Consumers

- **chuck slime swarm** — server runs the Mass sim and pushes each slime's position/yaw/frame; clients render the swarm from snapshots into a local ISM. Direction row + billboard are computed per-client from the local camera so facing stays view-correct.

## Roadmap

- Push-model dirty tracking on the replicated array.
- Per-entity Iris NetObjects (replacing the single-actor FastArray) for very large swarms.
- Relevancy / spatial culling so clients only receive nearby entities.

## FAQ

**What does the KBVENet plugin do?**
KBVENet is a shared Unreal Engine 5 networking layer that streams a
server-authoritative simulation, such as a Mass ECS swarm, to clients using a
delta-compressed entity-snapshot replicator so clients render the sim locally.

**How does KBVENet replicate entities?**
`UKBVENetEntityReplicator` holds a delta-compressed `FFastArraySerializer` of lean
per-entity snapshots — `Id`, quantized `Location`, packed yaw, animation `Frame`,
and a `StateByte`. FastArrays ride Iris when the ReplicationSystem is on and the
classic NetDriver otherwise, so consumers write no Iris-specific code.

**How do you enable Iris replication with KBVENet?**
Per game, set `bUseIris = true;` in each `*.Target.cs` and add
`Net.Iris.UseIrisReplication=1` under `[ConsoleVariables]` in
`Config/DefaultEngine.ini`. KBVENet supplies the replication primitives; turning
Iris on stays a per-target configuration choice.

## Related

- [KBVEULID](/docs/project/kbveulid) — ULID generator that supplies stable IDs for replicated events.
- [Unreal RentEarth](/docs/project/unreal-rentearth) — a KBVE UE5 game client that consumes shared plugins like KBVENet.

---
# KBVENPCDB — Unreal NPC Database and Mass Bridge

> Game-agnostic Unreal plugin that loads the shared npcdb artifact into runtime NPC defs, exposes ref lookup, and spawns Mass entities from db data.

Source: https://kbve.com/project/kbvenpcdb/

## Overview

Game-agnostic NPC database + Mass Entity bridge. Mirrors the itemdb loader
pattern but ships as a reusable plugin:

## Key facts

| | |
|---|---|
| **Plugin** | KBVENPCDB |
| **Version** | 0.1.0 |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Platforms** | Win64, Linux, Mac |
| **Depends on** | KBVEYYJson |
| **Source** | [`packages/unreal/KBVENPCDB`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVENPCDB) |

## Details

- **`UKBVENpcDatabase`** (GameInstance subsystem) — loads `Content/Data/npcdb-data.json`
  (the shared npcdb codegen artifact) into `FKBVENpcDef` records; lookup by `ref`.
- **`FKBVENpcDef` / `FKBVENpcStats`** — runtime NPC def (identity, stats, level,
  faction, abilities, tags, aggro, first-strike).
- **`FKBVENpcFragment` / `FKBVENpcTag`** — Mass fragment + tag carrying the
  NPC's db identity into the entity world.
- **`UKBVENpcSpawner`** (World subsystem) — `SpawnNpcEntity(Def)` creates a Mass
  entity with the NPC fragment; the game adds its own fragments (stats, transform).

NPC DATA stays in the shared npcdb MDX; the plugin owns the load + Mass bridge.
ChuckRPG calls it to spawn data-driven NPC entities.

## KBVENPCSprite module

The plugin also ships a `KBVENPCSprite` render module for billboarded pixel-art NPC
sprites in the 3D world (data/Mass stay in the `KBVENPCDB` module; this only draws):

- **`UKBVENpcSpriteDef`** — UDataAsset: atlas + sprite material + grid (columns =
  animation frames, rows = view directions front/side/back), fps, world size, pivot.
- **`UKBVENpcSpriteRenderSubsystem`** — `Spawn/Update/Despawn` sprite handles; one HISM
  per def, CPU Y-locked camera billboard, atlas cell driven by per-instance custom data
  (offset/scale UV; right view is the side row mirrored via negative U scale).

P1 is standalone (assign a `UKBVENpcSpriteDef`); later it keys off the npcdb `Ref`. The
sprite material is authored in-editor — see the module README for the custom-data contract.

## FAQ

**What does the KBVENPCDB plugin do?**
It loads the shared npcdb codegen artifact (`npcdb-data.json`) into `FKBVENpcDef` records via the `UKBVENpcDatabase` subsystem, offers lookup by `ref`, and spawns Mass entities carrying `FKBVENpcFragment` from that db data.

**Where does NPC data come from?**
NPC data stays in the shared npcdb MDX and is codegen'd to `npcdb-data.json`. The plugin owns only the load and Mass bridge; it does not author NPC data itself.

**What is the KBVENPCSprite module?**
A render module that draws billboarded pixel-art NPC sprites in the 3D world. `UKBVENpcSpriteDef` defines the atlas and grid, and `UKBVENpcSpriteRenderSubsystem` spawns, updates, and despawns sprite handles with one HISM per def.

## Related

- [KBVEItemDB](./kbveitemdb) — the itemdb loader this plugin's pattern mirrors.
- [ROWS](./rows) — the KBVE game backend the NPC entities live alongside.

---
# KBVEPerf — Runtime Performance Instrumentation for UE5

> KBVEPerf is runtime-toggleable UE5 performance instrumentation with scoped timers, counters, log and overlay sinks, and a live HTTP /perf JSON readout.

Source: https://kbve.com/project/kbveperf/

## Overview

`KBVEPerf` is a lightweight, runtime-toggleable performance instrumentation layer. Scoped timers and counters feed per-name aggregates that drain to three sinks — the log, an on-screen overlay, and a live HTTP `/perf` JSON readout — so any KBVE plugin can be profiled by flipping a CVar, and the results read live by external tooling instead of relaying `stat unit` numbers by hand.

It compiles out of Shipping builds (`KBVEPERF_ENABLED=0`); when compiled in but disabled at runtime it costs a single atomic load + branch per scope.

## Macros

```cpp
#include "KBVEPerf.h"

void UMyThing::HotPath()
{
    KBVEPERF_SCOPE("Grass.AddChunk");          // RAII scoped timer
    KBVEPERF_COUNT("Grass.Instances", 72627);  // counter / gauge sample
}
```

The name prefix before the first `.` is the **category** (`Grass.AddChunk` → `Grass`). Add `KBVEPerf` to your module's `PrivateDependencyModuleNames` and the plugin to your `.uplugin` `Plugins` list.

## CVars

| CVar | Default | Purpose |
|------|---------|---------|
| `kbve.perf` | `0` | Master switch — `1` turns collection + `/perf` on. |
| `kbve.perf.categories` | `""` | Comma-separated allow-list, e.g. `"Grass,Terrain"`. Empty = all. |
| `kbve.perf.port` | `8099` | Port for the HTTP `/perf` endpoint. |
| `kbve.perf.overlay` | `0` | On-screen overlay of the worst ops this frame. |
| `kbve.perf.threshold` | `3.0` | Log-sink threshold (ms). |

## HTTP readout

```bash
kbve.perf 1
curl http://localhost:8099/perf
```

```json
{
  "frame": 12345,
  "fps": 58.2,
  "ops": [
    { "name": "Grass.AddChunk", "count": 412, "lastMs": 3.1, "maxMs": 10.9, "avgMs": 3.4, "p95Ms": 7.2 },
    { "name": "Terrain.GenerateMeshData", "count": 380, "lastMs": 0.6, "maxMs": 1.1, "avgMs": 0.7, "p95Ms": 0.9 }
  ],
  "counts": [
    { "name": "Grass.ResidentChunks", "value": 25 },
    { "name": "Grass.Instances", "value": 72627 }
  ]
}
```

## Integration

`KBVEWorld` (terrain chunks + grass render subsystem) is the first consumer: the bespoke `FKBVEHitchLog` scoped timers were replaced with `KBVEPERF_SCOPE`, and the grass subsystem publishes `KBVEPERF_COUNT` gauges for resident chunks, registered chunks, HISM count, and total instances.

## FAQ

**What is the KBVEPerf plugin?**
KBVEPerf is a lightweight, runtime-toggleable performance instrumentation layer
for UE5. Scoped timers and counters feed per-name aggregates that drain to three
sinks — the log, an on-screen overlay, and a live HTTP `/perf` JSON readout — so
any KBVE plugin can be profiled by flipping a CVar.

**What is the runtime cost of KBVEPerf?**
It compiles out of Shipping builds via `KBVEPERF_ENABLED=0`. When compiled in but
disabled at runtime it costs a single atomic load plus a branch per scope, and it
can be toggled live with the `kbve.perf` CVar.

**How do you read KBVEPerf results externally?**
Set `kbve.perf 1` to enable collection and the HTTP endpoint, then `curl
http://localhost:8099/perf` for a JSON readout of per-op timings (count, last,
max, avg, p95) and counter gauges, instead of relaying `stat unit` numbers by
hand.

## Related

- [KBVEWorld](/docs/project/kbveworld) — the terrain and grass subsystem that is KBVEPerf's first consumer.
- [KBVEPostShader](/docs/project/kbvepostshader) — sibling UE5 rendering plugin in the KBVE stack.

---
# KBVEPostShader — Stylized UE5 Post-Process

> Stylized Unreal Engine 5 post-process — anisotropic Kuwahara oil-paint smear, cel banding, and depth-driven ink outlines for a Breath of the Wild / Ghibli look.

Source: https://kbve.com/project/kbvepostshader/

## Overview

`KBVEPostShader` is a stylized post-process pipeline targeting a **Breath of the Wild / Studio Ghibli** painterly look: anisotropic Kuwahara oil-paint smear, cel luminance banding, and depth-driven ink outlines. It runs as chained RDG passes from a `FSceneViewExtension`, inserted after the tonemapper, gated by CVars and off by default.

## Pipeline

1. **Structure tensor** — RGB Sobel resolved into a local flow tangent + anisotropy.
2. **Anisotropic Kuwahara** — 8-sector generalized Kuwahara over a flow-oriented ellipse → oil-paint base.
3. **Composite** — ink outlines from scene **depth** + painted-luma discontinuities, cel banding (hue preserved), warm saturation, darkened by the ink mask.

## CVars

| CVar | Default | Purpose |
|------|---------|---------|
| `r.KBVEPost.Enable` | `0` | Master on/off. |
| `r.KBVEPost.Radius` | `6` | Kuwahara sample radius. |
| `r.KBVEPost.OilStrength` | `0.85` | Blend original → Kuwahara. |
| `r.KBVEPost.Bands` | `5` | Cel luminance bands. |
| `r.KBVEPost.EdgeStrength` | `1.4` | Ink outline darkening. |
| `r.KBVEPost.EdgeThreshold` | `0.15` | Discontinuity threshold. |
| `r.KBVEPost.Saturation` | `1.15` | Painterly saturation. |

Defaults also live in **Project Settings → KBVE → KBVE Post Shader**.

```bash
r.KBVEPost.Enable 1
r.KBVEPost.Radius 8
```

## Status

P1: the core trio (structure tensor + anisotropic Kuwahara + cel/ink composite), BotW-tuned defaults, desktop SM5+. P2 will add GBuffer-normal outlines, a warm palette LUT, canvas overlay, flow warp, and Ghibli/BotW presets.

## FAQ

**What look does KBVEPostShader produce?**
A painterly Breath of the Wild / Studio Ghibli style — anisotropic Kuwahara
oil-paint smear, cel luminance banding, and depth-driven ink outlines.

**How is the effect rendered?**
It runs as chained RDG passes from an `FSceneViewExtension` inserted after the
tonemapper, gated by CVars and off by default.

**How do I enable and tune it?**
Set `r.KBVEPost.Enable` to `1` and adjust CVars like `r.KBVEPost.Radius` and
`r.KBVEPost.OilStrength`; the same defaults are exposed under **Project Settings
→ KBVE → KBVE Post Shader**.

## Related

- [KBVEWorld](/docs/project/kbveworld) — procedural world toolkit whose scenes this post-process styles.
- [KBVEEvents](/docs/project/kbveevents) — typed event bus used across KBVE Unreal plugins.

---
# KBVEQuestDB — Quest Database Loader for Unreal

> Game-agnostic Unreal quest database loader reading the shared questdb artifact into runtime quest defs — objectives, rewards, prerequisites, and chains.

Source: https://kbve.com/project/kbvequestdb/

## Overview

Game-agnostic quest catalog. `UKBVEQuestDatabase` (a GameInstance subsystem) loads
`Content/Data/questdb-data.json` into `FKBVEQuestDef` records (objectives, rewards,
category, chain) with ref lookup. Quest progress and state stay game-side. It
mirrors the itemdb/npcdb loader pattern and depends on **KBVEYYJson** for parsing.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEQuestDB` |
| **Version** | 0.1.0 (beta) |
| **Engine** | Unreal Engine 5.4+ |
| **Platforms** | Win64, Linux, Mac |
| **License** | KBVE |
| **Depends on** | KBVEYYJson |
| **Source** | [`packages/unreal/KBVEQuestDB`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEQuestDB) |

## Features

- **GameInstance subsystem** — `UKBVEQuestDatabase` loads at game-instance scope.
- **Data-driven defs** — parses `questdb-data.json` into `FKBVEQuestDef` records.
- **Rich quest shape** — objectives, rewards, category, and chain per quest.
- **Ref lookup** — resolve quest definitions by reference.
- **Consistent pattern** — mirrors the itemdb / npcdb loaders.

## Usage

Enable `KBVEQuestDB` (and its KBVEYYJson dependency) in your `.uproject`, ship the
questdb artifact to `Content/Data/questdb-data.json`, then query the
`UKBVEQuestDatabase` subsystem for quest defs by ref. Progress is tracked by the game.

## FAQ

**What does KBVEQuestDB do?**
It is a game-agnostic quest catalog loader that reads the shared
`questdb-data.json` artifact into `FKBVEQuestDef` records — objectives, rewards,
category, and chain — with ref lookup.

**Does KBVEQuestDB track quest progress?**
No. It loads static quest definitions only; quest progress and state stay
game-side. It mirrors the itemdb and npcdb loader pattern.

**What are its dependencies and requirements?**
It depends on KBVEYYJson for JSON parsing and targets Unreal Engine 5.4+ on
Win64, Linux, and Mac.

## Related

- [KBVEYYJson](/docs/project/kbveyyjson) — JSON parsing dependency.
- [KBVENpcDB](/docs/project/kbvenpcdb) — sibling NPC database loader.
- [KBVEItemDB](/docs/project/kbveitemdb) — sibling item database loader.

---
# KBVEROWS — Rust Open World Server Backend Plugin for UE5

> KBVEROWS is a unified Unreal Engine 5 backend plugin for the Rust Open World Server — auth, instance management, and character persistence over ROWS REST.

Source: https://kbve.com/project/kbverows/

## Overview

`KBVEROWS` is a unified Unreal Engine 5 backend integration plugin for the **Rust
Open World Server (ROWS)**. It provides auth, instance management, character
persistence, and global data subsystems that communicate with the ROWS REST API,
so an Unreal client can sign in, manage character data, and join server
instances through a single plugin.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEROWS` (module `ROWS`) |
| **Version** | 1.0 (beta) |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVEROWS`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEROWS) |
| **Platforms** | Win64, Linux, Mac |

## Features

- **Auth** — `ROWSAuthSubsystem` with login widgets (`ROWSLoginWidget`,
  `ROWSLoadingWidget`) and a `ROWSLoginController`.
- **Character persistence** — `ROWSCharacterSubsystem` for character data.
- **Instance management** — `ROWSInstanceSubsystem` to allocate and join server
  instances.
- **Pluggable transport** — `ROWSTransport` with `ROWSHttpTransport` and
  `ROWSGrpcTransport` backends.

## FAQ

**What is KBVEROWS?**
`KBVEROWS` is a unified Unreal Engine 5 backend integration plugin for the Rust
Open World Server (ROWS). It provides auth, instance management, character
persistence, and global data subsystems that talk to the ROWS REST API.

**What subsystems does KBVEROWS provide?**
The `ROWS` module ships subsystems including `ROWSSubsystem`, `ROWSAuthSubsystem`,
`ROWSCharacterSubsystem`, and `ROWSInstanceSubsystem`, plus login UI widgets and
a controller. Transport is pluggable via `ROWSTransport` with HTTP and gRPC
implementations.

**Which platforms and engine versions does KBVEROWS support?**
KBVEROWS targets Unreal Engine 5.4 and later on Win64, Linux, and Mac. It is
enabled by default and is currently a beta plugin.

## Related

- [Agones](/docs/project/agones) — server lifecycle SDK used alongside ROWS-backed dedicated servers.
- [KBVEYYJson](/docs/project/kbveyyjson) — fast JSON plugin used across the KBVE Unreal stack.

---
# KBVESQLite — Embedded SQLite Database Plugin for Unreal

> KBVESQLite is an embedded SQLite database plugin for Unreal Engine, vendoring the sqlite3 amalgamation with an RAII connection, statement, and key/value store.

Source: https://kbve.com/project/kbvesqlite/

## Overview

KBVESQLite wraps SQLite as an embedded database plugin for Unreal Engine — a
vendored `sqlite3` amalgamation plus a thin RAII wrapper so consumers never
touch raw `sqlite3_*` calls.

## Access seam

- **`FKBVESQLiteConnection`** — RAII connection: `Open(path, bUseWAL)` / `Close` /
  `Exec` / `Prepare` / `Begin` / `Commit` / `Rollback`.
- **`FKBVESQLiteStatement`** — RAII prepared statement: `Bind*`, `Step` / `Execute`
  / `Reset`, `Column*` accessors.
- **`FKBVESettingsStore`** — scoped key/value prefs on a connection
  (`kv_settings(scope, key, value)`, UPSERT): typed `Set/Get String|Int|Float|Bool`,
  `RemoveKey`, `LoadScope`. Agnostic settings persistence — UI is KBVEUI's job.

Add `KBVESQLite` to your module's `PrivateDependencyModuleNames` and
`dependency_plugins: packages/unreal/KBVESQLite` to your ci-registry entry so the
CI plugin build stages it.

## Rules

- **Single sqlite provider** — never link the engine's `SQLiteCore` in the same
  module; duplicate `sqlite3_*` symbols crash the build/run.
- **Persistence boundary, not a Mass hot-loop datasource** — one connection is not
  thread-safe; WAL gives many readers + one writer across separate connections.
  Load at boundaries, keep the working set in memory/Mass fragments, flush async.

Consumers: `FKBVEWorldChunkCache` (KBVEWorld), `FKBVEInventoryStore` +
`FKBVEItemCatalogStore` (KBVEItemDB), `FKBVESettingsStore` (chuck `UchuckSettings`
window geometry, `Saved/KBVE/settings.db`).

## FAQ

**What is the KBVESQLite plugin?**
KBVESQLite wraps SQLite as an embedded database plugin for Unreal Engine, bundling
a vendored `sqlite3` amalgamation with a thin RAII wrapper so consumers never touch
raw `sqlite3_*` calls. It exposes `FKBVESQLiteConnection`, `FKBVESQLiteStatement`,
and a scoped key/value `FKBVESettingsStore`.

**Why must KBVESQLite be the single SQLite provider?**
Consumers must never also link the engine's `SQLiteCore` in the same module,
because duplicate `sqlite3_*` symbols crash the build and run. KBVESQLite is the
one sqlite provider for KBVE code.

**How should KBVESQLite be used in a Mass game loop?**
It is a persistence boundary, not a Mass hot-loop datasource. A single connection
is not thread-safe; WAL allows many readers and one writer across separate
connections, so you load at boundaries, keep the working set in memory or Mass
fragments, and flush asynchronously.

## Related

- [KBVEItemDB](/docs/project/kbveitemdb) — item database and inventory plugin that persists through KBVESQLite.
- [KBVEZstd](/docs/project/kbvezstd) — compression plugin in the same Unreal plugin family.

---
# KBVESupabase — Supabase Auth and Data Plugin for UE5

> KBVESupabase is an Unreal Engine 5 plugin for Supabase — GoTrue auth, JWT storage with auto-refresh, PostgREST, storage, edge functions, and realtime chat.

Source: https://kbve.com/project/kbvesupabase/

## Overview

`KBVESupabase` is a Supabase integration plugin for Unreal Engine 5 — a **drop-in
account layer for KBVE games**. It provides GoTrue authentication, JWT storage with
auto-refresh, PostgREST database helpers, storage, edge functions, and a realtime
chat client, all Blueprint-friendly. It depends on the `KBVEROWS` plugin.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVESupabase` |
| **Version** | 0.1.0 |
| **Depends on** | `KBVEROWS` |
| **Engine** | UE 5.4+ |
| **Platforms** | Win64, Linux, Mac |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVESupabase`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVESupabase) |

## Features

- **Auth** — email/password, anonymous sign-in, magic-link OTP (email + SMS), password
  recovery, and full OAuth (Google/GitHub/Discord/Twitch/Apple/Azure) via PKCE and an
  RFC 8252 loopback flow.
- **Session management** — refresh-token timer (`RefreshLeadSeconds` before expiry),
  persistent per-project disk session, and automatic refresh + retry on HTTP 401.
- **JWT** — client-side claims decode with `kbve_username` hoisted from user/app
  metadata to match the `kbve.com` GoTrue Custom Access Token hook.
- **Storage** — `UKBVESupabaseStorage` for upload, download, list, sign URL, remove,
  move, copy, and public URL helpers.
- **Database (PostgREST)** — `DbSelect` / `DbInsert` / `DbUpdate` / `DbDelete` /
  `DbUpsert` / `DbRpc` plus raw `RestRequest`.
- **Edge Functions** — `InvokeFunction(name, body)` against `/functions/v1/<name>`.
- **Chat** — `UKBVESupabaseChat` WebSocket client for the KBVE irc-gateway
  (`chat.kbve.com/ws`) with JWT-on-upgrade and backoff reconnect.
- **Blueprint-friendly** — all public methods are `BlueprintCallable`, delegates
  `BlueprintAssignable`, configured via Project Settings.

## Usage

```cpp
#include "KBVESupabaseSubsystem.h"

UKBVESupabaseSubsystem* Sb = GetGameInstance()->GetSubsystem<UKBVESupabaseSubsystem>();
Sb->OnSignedIn.AddDynamic(this, &UMyClass::HandleSignedIn);
Sb->OnAuthError.AddDynamic(this, &UMyClass::HandleAuthError);

Sb->SignInWithPassword(TEXT("user@example.com"), TEXT("hunter2"));
```

## FAQ

**What does the KBVESupabase plugin do?**
KBVESupabase is a drop-in Supabase account layer for Unreal Engine 5 games, providing
GoTrue authentication, JWT storage with automatic refresh, PostgREST database helpers,
storage, edge function invocation, and a realtime chat client.

**What authentication methods does KBVESupabase support?**
It supports email and password sign-in and sign-up, anonymous sign-in, magic-link OTP
over email and SMS, password recovery, and full OAuth for Google, GitHub, Discord,
Twitch, Apple, and Azure via PKCE with an RFC 8252 loopback flow.

**Is KBVESupabase usable from Blueprints?**
Yes. Every public method is a `BlueprintCallable` `UFUNCTION` and delegates are
`BlueprintAssignable`, so auth, database, storage, and chat can be wired up entirely
in Blueprints as well as C++.

## Related

- [KBVELibGit](/project/kbvelibgit/) — an editor-only KBVE Unreal plugin for installing Git-hosted plugins.

---
# KBVETinyBVH — Unreal TinyBVH Ray Tracing Plugin

> KBVETinyBVH is an Unreal Engine wrapper for TinyBVH 1.6.7, the single-header BVH construction and traversal library for ray tracing, as a runtime plugin.

Source: https://kbve.com/project/kbvetinybvh/

## Overview

KBVETinyBVH is an Unreal Engine wrapper for [TinyBVH](https://github.com/jbikker/tinybvh) 1.6.7 — a single-header BVH (bounding volume hierarchy) construction and traversal library for ray tracing. It packages the upstream `tiny_bvh.h` header, along with OpenCL and compute traversal kernels, as a runtime third-party plugin for the KBVE Unreal stack.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVETinyBVH` |
| **Version** | 1.6.7 |
| **Wraps** | TinyBVH 1.6.7 |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Platforms** | Win64, Linux, Mac |
| **Source** | [`packages/unreal/KBVETinyBVH`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVETinyBVH) |

## Features

- **Single-header BVH** — wraps the upstream `tiny_bvh.h` library for compact BVH construction and traversal.
- **Ray-tracing ready** — bundles OpenCL (`.cl`) and compute (`.comp`) traversal kernels for BVH2, BVH4, CWBVH, TLAS, and wavefront paths.
- **Runtime third-party module** — categorized as a Third Party plugin, loaded at the Default phase and not enabled by default.
- **Cross-platform** — builds for Win64, Linux, and Mac on Unreal Engine 5.4 and newer.

## FAQ

**What is the KBVETinyBVH plugin?**
KBVETinyBVH is an Unreal Engine wrapper for TinyBVH 1.6.7, a single-header BVH (bounding volume hierarchy) construction and traversal library used for ray tracing. It ships as a runtime third-party plugin.

**What version of TinyBVH does it wrap?**
The plugin wraps TinyBVH 1.6.7, matching the plugin `VersionName`, and bundles the `tiny_bvh.h` single-header library along with OpenCL and compute traversal kernels.

**Which Unreal versions and platforms are supported?**
KBVETinyBVH targets Unreal Engine 5.4 and newer and builds for Win64, Linux, and Mac. It is a runtime module and is not enabled by default.

## Related

- [KBVEMapDB](/project/kbvemapdb) — sibling Unreal plugin from the KBVE package group.
- [Unreal Chuck Dev](/project/unreal-chuck-dev) — UE5 game client that consumes KBVE Unreal plugins.

---
# KBVEUI — Shared Slate UI Component Library for Unreal

> Shared Slate UI component library for KBVE Unreal games — movable frames, settings rows, hotbar, slots, tooltips, info panels, and a dev overlay.

Source: https://kbve.com/project/kbveui/

## Overview

Shared Slate UI component library for KBVE Unreal games — game-agnostic visual
primitives (Core + Slate only): movable frames, the settings frame + reusable
settings rows (toggle / slider / combo), hotbar, slots, tooltips, info panels,
the `SKBVEEquipmentPanel` paper-doll (11 generic equip slots via `EKBVEEquipSlot`),
the `SKBVELoadingPanel` full-screen loader (`InitialMessage` + `UnitLabel` args,
`SetProgress`/`SetMessage`), and the **`SKBVEDevOverlay`** debug HUD (self-computed
FPS/ms; entity-count and ping fed via `FKBVEDevOverlayIntProvider` delegates so the
widget needs no Engine or Mass dep — the game supplies the numbers).

Also holds **UI state** — `FKBVEUIState` (panel-flag set + cursor/movement/camera
policy masks + `Has`/`Set`/`Diff`/`NeedsCursor`/`BlocksMovement` helpers) and
`KBVEUIFlag` common flag bits — so a controller tracks which panels are open and
derives input/cursor mode without re-rolling the bitfield. Stays Core+Slate;
domain-aware UI (item-aware inventory, Supabase auth/chat) composes on top.

### Modules

- **`KBVEUI`** — base library, Core + Slate only. The agnostic visual primitives
  and UI state above.
- **`KBVEUIAuth`** — Supabase auth surface (`SKBVELoginWidget` email/password +
  Discord/GitHub/Google OAuth + guest, `SKBVEAccountPanel` nick/avatar/sign-out).
  Drives `UKBVESupabaseSubsystem`; status/profile pushed in via setters so the
  game owns the auth event wiring. Login title is a `SLATE_ARGUMENT`. This module
  pulls in Engine + HTTP + KBVESupabase, so the base `KBVEUI` module stays pure —
  link `KBVEUIAuth` only when a game wants the Supabase UI. Hence
  `dependency_plugins: packages/unreal/KBVESupabase`.
- **`KBVEUIChat`** — irc-gateway chat window (`SKBVEChatPanel`): movable frame,
  channel tabs, scrollback, slash commands, input history. Dispatches through
  `UKBVESupabaseSubsystem`'s chat object; inbound lines/state are pushed in via
  `OnChatLine(FKBVEChatLineView)` / `OnChatStateChanged(bool)` so the game owns
  the event-bus wiring, and geometry persistence is delegated out
  (`OnSaveGeometry`/`OnLoadGeometry`) — no game settings type leaks in. Shares the
  same `KBVESupabase` dependency as `KBVEUIAuth`.

Plugin source ships via its own PR; this entry wires it into the build/release
pipeline alongside the other UE plugins.

## FAQ

**What is KBVEUI?**
KBVEUI is a shared Slate UI component library for KBVE Unreal games, providing
game-agnostic Core + Slate visual primitives — movable frames, settings frame
and rows, hotbar, slots, tooltips, info panels, an equipment paper-doll, a
loading panel, and a dev overlay HUD.

**What modules does KBVEUI ship?**
It ships `KBVEUI` (the pure Core + Slate base library and UI state), `KBVEUIAuth`
(a Supabase auth surface with login and account widgets), and `KBVEUIChat` (an
irc-gateway chat window), keeping the base module free of Engine and HTTP
dependencies.

**Why is KBVEUI kept to Core and Slate only?**
Keeping the base module Core + Slate makes the primitives game-agnostic and
dependency-light. Domain-aware UI such as Supabase auth or chat composes on top
via `KBVEUIAuth` and `KBVEUIChat`, which pull in Engine, HTTP, and KBVESupabase
only when a game links them.

## Related

- [KBVESupabase](/docs/project/kbvesupabase) — the Supabase subsystem KBVEUIAuth and KBVEUIChat drive.
- [KBVEROWS](/docs/project/kbverows) — a dependency plugin used by the UI stack.

---
# KBVEULID — ULID Generator Plugin for Unreal Engine 5

> KBVEULID is an Unreal Engine 5 plugin that generates 128-bit ULIDs — lexicographically sortable Crockford Base32 identifiers for DB, save, and event IDs.

Source: https://kbve.com/project/kbveulid/

## Overview

`KBVEULID` is an Unreal Engine 5 runtime plugin that generates **ULIDs** —
Universally Lexicographically Sortable Identifiers. Each ID is 128 bits (a 48-bit
millisecond timestamp plus 80 bits of `FGuid`-derived entropy) encoded as a
26-character Crockford Base32 string. Because the timestamp leads, ULIDs sort by
creation time, which makes them well suited to database IDs, replicated event IDs,
save records, and marketplace lots.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEULID` |
| **Version** | 0.1.0 |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Platforms** | Win64, Linux, Mac |
| **Source** | [`packages/unreal/KBVEULID`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEULID) |

## Features

- **128-bit ULIDs** — 48-bit millisecond timestamp + 80-bit `FGuid` entropy.
- **Crockford Base32** — 26-character string encoding via `FKBVEUlid::ToString()`.
- **Lexicographic sortability** — the timestamp prefix orders IDs by creation time.
- **Lean runtime module** — a single `FKBVEUlid` struct plus `KBVEULID::Generate()`,
  loaded in the Default phase with no content dependencies.

## Usage

```cpp
#include "KBVEULID.h"

FKBVEUlid Id = FKBVEUlid::New();
FString IdStr = Id.ToString();

FString Quick = KBVEULID::Generate();
```

## FAQ

**What does the KBVEULID plugin do?**
KBVEULID is an Unreal Engine 5 runtime plugin that generates ULIDs — 128-bit
Universally Lexicographically Sortable Identifiers encoded as 26-character Crockford
Base32 strings, suitable for database IDs, replicated event IDs, save records, and
marketplace lots.

**How is a KBVEULID identifier structured?**
Each ULID is 128 bits — a 48-bit millisecond timestamp plus 80 bits of
`FGuid`-derived entropy — stored as 16 bytes in `FKBVEUlid` and encoded to a
26-character Crockford Base32 string. The timestamp prefix keeps IDs
lexicographically sortable by creation time.

**Which engine versions and platforms does KBVEULID support?**
KBVEULID targets Unreal Engine 5.4 and newer and builds for Win64, Linux, and Mac.
It ships as a Runtime module loaded in the Default phase.

## Related

- [KBVENet](/docs/project/kbvenet) — KBVE's Unreal networking plugin, which can carry ULID-keyed event IDs.

---
# KBVEWASM — WebAssembly Runtime Plugin for Unreal

> KBVEWASM is an Unreal Engine plugin wrapping the WebAssembly Micro Runtime (WAMR) 2.2.0 to run sandboxed WebAssembly modules inside UE on Win64, Linux, and Mac.

Source: https://kbve.com/project/kbvewasm/

## Overview

KBVEWASM wraps the WebAssembly Micro Runtime (WAMR) 2.2.0 for Unreal Engine, letting UE projects load and execute sandboxed WebAssembly modules from inside the engine. It embeds WAMR — a lightweight, portable WebAssembly runtime — so game and tooling logic authored in any Wasm-targeting language can run within UE across Win64, Linux, and Mac.

## Key facts

| | |
|---|---|
| **Plugin** | KBVEWASM |
| **Runtime** | WAMR (WebAssembly Micro Runtime) 2.2.0 |
| **Version** | 2.2.0 |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE |
| **Platforms** | Win64, Linux, Mac |
| **Source** | [`packages/unreal/KBVEWASM`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEWASM) |

## Features

- **WAMR-backed runtime** — embeds WebAssembly Micro Runtime 2.2.0 for executing Wasm modules in-engine.
- **Sandboxed execution** — runs WebAssembly modules in an isolated runtime rather than native UE code.
- **Cross-platform** — supported on Win64, Linux, and Mac under Unreal Engine 5.4+.

## FAQ

**What does the KBVEWASM plugin do?**
KBVEWASM wraps the WebAssembly Micro Runtime (WAMR) 2.2.0 for Unreal Engine, letting UE projects load and run sandboxed WebAssembly modules from inside the engine.

**Which runtime does KBVEWASM use?**
It uses WAMR (WebAssembly Micro Runtime) version 2.2.0, a lightweight embeddable WebAssembly runtime, matching the plugin version.

**Which platforms and engine versions does KBVEWASM support?**
KBVEWASM targets Unreal Engine 5.4 and later on Win64, Linux, and Mac.

## Related

- [KBVENPCDB](./kbvenpcdb) — another KBVE Unreal Engine plugin in the same collection.
- [KBVEAgones](./kbveagones) — server-side KBVE Unreal plugin bridging Agones and ROWS.

---
# KBVEWebSurface — Web Content on 3D Surfaces for Unreal

> KBVEWebSurface is a game-agnostic Unreal Engine plugin that renders interactive web content onto 3D surfaces — billboards, terminals, kiosks, and holograms.

Source: https://kbve.com/project/kbvewebsurface/

## Overview

`KBVEWebSurface` renders interactive web content onto Unreal world surfaces. The plugin is game-agnostic and targets reuse across `chuckrpg`, future KBVE titles, and external Fab distribution.

### Surface kinds

- **Flat panel** — `UKBVEWebSurfaceComponent` wraps a `UWidgetComponent` with an embedded UMG `WebBrowser`.
- **Curved / holographic** — `UKBVEWebRenderSurfaceComponent` pipes the browser through a render target onto an arbitrary mesh + material.
- **Actor** — `AKBVEWebSurfaceActor` ships as a drop-in for terminals and kiosks.

### Input

`UKBVEWebInputRouter` maps player line traces to widget-pixel coordinates. Hit UVs come from `FindCollisionUV`, so `Support UV From Hit Results` must be enabled on the project.

### Bridge

`UKBVEWebBridge` exposes a typed message bus between embedded JS and Blueprint/C++. Pages call `window.kbveBridge.send(channel, payload)`; the bridge re-broadcasts via `OnMessage`.

### Performance

CEF is expensive. The plugin ships a per-surface frame-rate cap, offscreen pause, snapshot fallback at distance, and a `UKBVEWebSurfacePool` LRU cap on concurrent live surfaces.

### Backend

The default backend wraps Unreal's stock `UWebBrowser` (CEF). Alternate backends (Ultralight, WebUI) plug in via `IKBVEWebBackend` and ship as separate plugins.

### Use cases

- Marketplace / auction house
- Account, guild, social screens
- Admin and debug terminals
- Patch notes, news boards
- In-world interactive billboards and kiosks

### Anti-use cases

- Combat HUD, health bars, minimap — use Slate/UMG.
- Per-NPC labels, shop signs, hundreds of world objects — too expensive per surface.

## FAQ

**What is the KBVEWebSurface plugin?**
KBVEWebSurface is a game-agnostic Unreal Engine plugin that renders interactive
web content onto world surfaces — flat panels, curved or holographic meshes, and
drop-in terminal or kiosk actors — for reuse across `chuckrpg`, future KBVE
titles, and external Fab distribution.

**How does input work on a web surface?**
`UKBVEWebInputRouter` maps player line traces to widget-pixel coordinates. Hit
UVs come from `FindCollisionUV`, so the project must have `Support UV From Hit
Results` enabled.

**When should you not use KBVEWebSurface?**
Avoid it for combat HUDs, health bars, and minimaps — use Slate or UMG instead —
and for per-NPC labels, shop signs, or hundreds of world objects, where a CEF
surface per object is too expensive.

## Related

- [KBVEUI](/docs/project/kbveui) — the Slate/UMG component library for HUD and in-game UI.
- [Marketplace](/docs/project/marketplace) — an auction-house surface KBVEWebSurface can render.

---
# KBVEWorld — Procedural World UE Plugin

> Unreal Engine procedural world toolkit — noise-driven terrain chunks, SQLite chunk cache, async grass and foliage placement, plus hex-world subsystems.

Source: https://kbve.com/project/kbveworld/

## Overview

`KBVEWorld` is a game-agnostic procedural world toolkit for Unreal Engine. It
generates noise-driven terrain chunks, caches them in SQLite, places grass and
foliage asynchronously, and supplies sky plus post-process defaults. It also
ships a hex-world module for hex-grid worlds.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEWorld` |
| **Version** | 0.1.0 |
| **Language** | C++ (Unreal Engine) |
| **Min engine** | UE 5.4 |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVEWorld`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEWorld) |
| **Depends on** | KBVESQLite, KBVEPerf, MassGameplay, ProceduralMeshComponent |
| **Platforms** | Win64, Linux, Mac |

## Features

- **Noise-driven terrain** — `KBVEWorldCore` provides seeds and noise; terrain
  chunk actors build meshes from the sampled heightfield.
- **SQLite chunk cache** — generated chunks are persisted and rehydrated through
  the KBVESQLite-backed chunk cache and blob format.
- **Async grass and foliage** — HISM-based grass and foliage placement with GPU
  compute-shader placement and render subsystems, kept off the game thread.
- **Hex world** — `KBVEHexWorld` adds hex-grid noise, seed, terrain, and
  environment subsystems for hex-tile worlds.

## FAQ

**What is KBVEWorld?**
It is a game-agnostic procedural world toolkit for Unreal Engine — noise-driven
terrain chunks, an SQLite chunk cache, async grass and foliage placement, and
sky plus post-process defaults.

**What are the KBVEWorld modules?**
It ships three runtime modules — `KBVEWorldCore` (noise and seed), `KBVEWorld`
(terrain, grass, foliage, chunk cache), and `KBVEHexWorld` (hex-grid world
subsystems).

**What plugins does KBVEWorld depend on?**
It depends on `MassGameplay`, `ProceduralMeshComponent`, and the in-repo
`KBVESQLite` and `KBVEPerf` plugins.

## Related

- [KBVEPostShader](/docs/project/kbvepostshader) — stylized post-process that complements the world sky defaults.
- [KBVEEvents](/docs/project/kbveevents) — typed event bus used across KBVE Unreal plugins.

---
# KBVEXXHash — Fast Hashing Plugin for Unreal

> KBVEXXHash is an Unreal Engine plugin wrapping xxHash 0.8.3, an extremely fast non-cryptographic hash algorithm, for high-throughput hashing in UE 5.4+ games.

Source: https://kbve.com/project/kbvexxhash/

## Overview

`KBVEXXHash` is an Unreal Engine plugin that wraps
[xxHash](https://github.com/Cyan4973/xxHash) 0.8.3, an **extremely fast
non-cryptographic hash algorithm**. It ships as a runtime module for UE 5.4+ on
Win64, Linux, and Mac, giving KBVE Unreal games a high-throughput hash for
checksums, hash-table keys, and change detection.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEXXHash` |
| **Version** | 0.8.3 |
| **Engine** | Unreal Engine 5.4+ |
| **Platforms** | Win64, Linux, Mac |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVEXXHash`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEXXHash) |
| **Upstream** | [Cyan4973/xxHash](https://github.com/Cyan4973/xxHash) |

## Features

- **xxHash 0.8.3 wrapper** — bundles the upstream library as a UE third-party dependency.
- **Runtime module** — loads in the Default phase for use during gameplay.
- **Non-cryptographic speed** — optimized for throughput on checksums and lookups.
- **Cross-platform** — builds for Win64, Linux, and Mac.

## Usage

Enable the `KBVEXXHash` plugin in your `.uproject` and add the `KBVEXXHash`
module to your build dependencies to call into the wrapped hashing API from C++.

## FAQ

**What does KBVEXXHash provide?**
It wraps the xxHash 0.8.3 library as an Unreal Engine runtime module, giving UE
games an extremely fast non-cryptographic hash for checksums and lookups.

**Is xxHash suitable for cryptographic use?**
No. xxHash is a non-cryptographic hash optimized for speed, meant for checksums,
hash tables, and change detection — not for security.

**Which engine versions and platforms are supported?**
KBVEXXHash targets Unreal Engine 5.4 and later on Win64, Linux, and Mac as a
runtime module.

## Related

- [KBVEZstd](/docs/project/kbvezstd) — Zstandard compression plugin for Unreal.
- [KBVEYYJson](/docs/project/kbveyyjson) — fast JSON parsing plugin for Unreal.
- [UEDevOps](/docs/project/uedevops) — DevOps toolkit that depends on KBVEXXHash.

---
# KBVEYYJson — High-Performance yyjson JSON Plugin for Unreal

> KBVEYYJson is an Unreal Engine 5 plugin wrapping the yyjson 0.12.0 high-performance JSON library for fast parsing and serialization on Win64, Linux, and Mac.

Source: https://kbve.com/project/kbveyyjson/

## Overview

`KBVEYYJson` is an Unreal Engine 5 plugin that wraps
[yyjson](https://github.com/ibireme/yyjson) 0.12.0, a high-performance C JSON
library. It gives KBVE Unreal projects low-overhead JSON parsing and
serialization through a single runtime module, replacing the slower built-in
engine JSON utilities for high-volume payloads.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEYYJson` |
| **Version** | 0.12.0 (tracks yyjson) |
| **Engine** | Unreal Engine 5.4+ |
| **License** | KBVE (yyjson upstream MIT) |
| **Source** | [`packages/unreal/KBVEYYJson`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEYYJson) |
| **Platforms** | Win64, Linux, Mac |

## Features

- **yyjson-backed** — wraps the yyjson 0.12.0 C library for fast JSON parsing and
  serialization.
- **Runtime module** — a single `KBVEYYJson` runtime module loaded in the default
  phase.
- **Cross-platform** — builds on Win64, Linux, and Mac under UE 5.4+.
- **Opt-in** — third-party category, not enabled by default, so projects pull it
  in only where fast JSON matters.

## FAQ

**What is KBVEYYJson?**
`KBVEYYJson` is an Unreal Engine 5 plugin that wraps yyjson 0.12.0, a
high-performance C JSON library, so Unreal projects can parse and serialize JSON
far faster than the engine's built-in JSON utilities.

**Why use yyjson instead of Unreal's built-in JSON?**
yyjson is one of the fastest C JSON libraries available. Wrapping it as a runtime
module gives KBVE Unreal projects low-overhead JSON parsing and serialization,
which matters for high-volume data such as ROWS backend payloads and codegen
databases.

**Which platforms and engine versions does KBVEYYJson support?**
KBVEYYJson targets Unreal Engine 5.4 and later on Win64, Linux, and Mac. It is a
third-party runtime module and is not enabled by default.

## Related

- [KBVEROWS](/docs/project/kbverows) — ROWS backend plugin that serializes REST payloads.
- [KBVEHexWorld](/docs/project/kbvehexworld) — sibling KBVE Unreal world module.

---
# KBVEZstd — Zstandard Compression Plugin for Unreal

> KBVEZstd is an Unreal Engine plugin wrapping Facebook's Zstandard (zstd) 1.5.7 library for fast, real-time lossless compression on Win64, Linux, and Mac.

Source: https://kbve.com/project/kbvezstd/

## Overview

`KBVEZstd` is an Unreal Engine plugin that wraps Facebook's
[Zstandard](https://github.com/facebook/zstd) (zstd) 1.5.7 library, bringing fast
real-time lossless compression into Unreal projects. It ships as a Third Party
runtime module (`FKBVEZstdModule`) that vendors the `zstd.h` third-party headers
so consumers link a single zstd provider.

## Key facts

| | |
|---|---|
| **Plugin** | `KBVEZstd` |
| **zstd version** | 1.5.7 |
| **Min engine** | UE 5.4 |
| **Platforms** | Win64, Linux, Mac |
| **License** | KBVE |
| **Source** | [`packages/unreal/KBVEZstd`](https://github.com/KBVE/kbve/tree/main/packages/unreal/KBVEZstd) |

## Features

- **Vendored zstd 1.5.7** — the Facebook Zstandard amalgamation is included as a
  Third Party dependency, so projects link one zstd provider.
- **Runtime module** — `FKBVEZstdModule` loads at the Default phase; not enabled
  by default, opt in per project.
- **Cross-platform** — builds for Win64, Linux, and Mac.
- **Real-time friendly** — Zstandard's ratio-to-speed trade-off suits save data,
  world chunks, and network payloads.

## FAQ

**What is the KBVEZstd plugin?**
KBVEZstd is an Unreal Engine runtime plugin that wraps Facebook's Zstandard (zstd)
1.5.7 compression library, exposing fast real-time lossless compression to Unreal
projects on Win64, Linux, and Mac.

**Which Unreal Engine versions does KBVEZstd support?**
KBVEZstd targets a minimum engine version of 5.4 and ships for the Win64, Linux,
and Mac platforms. It is a Runtime module loaded at the Default loading phase.

**Why use Zstandard in an Unreal project?**
Zstandard offers a strong compression-ratio to speed trade-off suited to real-time
workloads, making it well matched to compressing save data, world chunks, and
network payloads in a game.

## Related

- [KBVESQLite](/docs/project/kbvesqlite) — embedded SQLite database plugin that pairs with compression for persistence.
- [KBVEItemDB](/docs/project/kbveitemdb) — item database plugin in the same Unreal plugin family.

---
# KhashVault — Browser Cryptography and Secure Storage

> KhashVault is a browser-side cryptography and secure-storage npm library using the Web Crypto API and OpenPGP for AES-GCM, hashing, PBKDF2, and secure storage.

Source: https://kbve.com/project/khashvault/

## Overview

`@kbve/khashvault` is a browser-side cryptography and secure-storage library built
on the **Web Crypto API** and **OpenPGP**. It bundles symmetric encryption, hashing,
key derivation, PGP key management, and encrypted persistence behind a small
TypeScript API, with optional Web Worker offloading for heavy operations.

## Key facts

| | |
|---|---|
| **Package** | `@kbve/khashvault` |
| **Version** | 1.0.12 |
| **Language** | TypeScript (ESM) |
| **Foundations** | Web Crypto API, OpenPGP |
| **License** | MIT |
| **Source** | [`packages/npm/khashvault`](https://github.com/KBVE/kbve/tree/main/packages/npm/khashvault) |

## Features

- **AES-GCM encryption** — `aesEncrypt` / `aesDecrypt` plus password-based variants.
- **Hashing** — `sha256`, `sha512`, and generic `hash` / `hashBytes`.
- **Key derivation** — `deriveKey` and `deriveRawBits` (PBKDF2).
- **Key management** — `generateAesKey`, `exportKey`, `importKey`, `randomBytes`.
- **PGP** — `pgpGenerateKeyPair`, `pgpEncrypt`, `pgpDecrypt` via OpenPGP.
- **Secure storage** — `SecureLocalStorage` and `SecureIndexedDB` for encrypted
  browser persistence.
- **Web Worker offload** — `KhashVaultWorkerClient` with SharedArrayBuffer helpers
  for cross-origin-isolated contexts.

## FAQ

**What is KhashVault?**
KhashVault is a browser-side cryptography and secure-storage npm library built on
the Web Crypto API and OpenPGP, offering AES-GCM encryption, SHA-256/512 hashing,
PBKDF2 key derivation, PGP key pairs, and encrypted local and IndexedDB storage.

**What cryptographic primitives does KhashVault provide?**
It provides AES-GCM encryption and decryption (including password-based), SHA-256
and SHA-512 hashing, PBKDF2 key derivation, AES key generation and import/export,
and PGP key generation, encryption, and decryption via OpenPGP.

**Does KhashVault support Web Workers?**
Yes. It ships a `KhashVaultWorkerClient` plus SharedArrayBuffer helpers for
cross-origin-isolated contexts so heavy crypto can run off the main thread.

## Related

- [DevOps](/project/devops/) — a companion KBVE npm helper library for CI/CD and codegen.

---
# Kilobase — Custom Supabase Postgres Image with pgrx

> Kilobase is KBVE's custom Supabase-based Postgres image built with a pgrx Rust extension and pg_failover_slots, extending PostgreSQL 17 with jedi regex helpers.

Source: https://kbve.com/project/kilobase/

## Overview

Kilobase is KBVE's custom Supabase-based PostgreSQL image. It builds a pgrx Rust extension plus `pg_failover_slots` against PostgreSQL 17 and bakes them into a Supabase-compatible Postgres container, letting KBVE ship extra SQL functions (backed by the jedi library) without maintaining a fork of the upstream database.

## Key facts

| | |
|---|---|
| **App** | `kilobase` |
| **Version** | 17.6.1 |
| **Image** | `ghcr.io/kbve/kilobase` |
| **Base** | Supabase Postgres (PostgreSQL 17) |
| **Extension toolchain** | `cargo-pgrx` 0.16.1 |
| **License** | KBVE |
| **Source** | [`apps/kbve/kilobase`](https://github.com/KBVE/kbve/tree/main/apps/kbve/kilobase) |

## Features

- **Custom pgrx extension** — the `kilobase` extension compiles Rust into a Postgres `cdylib`, exposing immutable, parallel-safe functions like `pgrx_extract_email` and `pgrx_extract_github_username`.
- **jedi integration** — the extension reuses zero-copy regex helpers from the jedi library so extraction runs directly inside Postgres.
- **Failover slots** — `pg_failover_slots` is built and layered in for replication slot failover.
- **Supabase-compatible** — extends the upstream Supabase Postgres image rather than forking it, tagged after the base version.

## FAQ

**What is Kilobase?**
Kilobase is KBVE's custom Supabase-based PostgreSQL image. It builds a pgrx Rust extension plus `pg_failover_slots` against PostgreSQL 17 and bakes them into a Supabase-compatible Postgres container.

**What does the Kilobase pgrx extension add?**
The `kilobase` extension exposes pgrx functions such as `pgrx_extract_email` and `pgrx_extract_github_username` that reuse jedi library zero-copy regex helpers as immutable, parallel-safe SQL functions.

**What Postgres version does Kilobase target?**
Kilobase builds against PostgreSQL 17 (pgdg dev-17) with the `pg17` feature by default, using `cargo-pgrx` 0.16.1, and tags its image after the underlying supabase/postgres version.

## Related

- [bevy_supa](/project/bevy-supa-crate) — Supabase/PostgREST client crate that can target this database.
- [ARC Runner](/project/arc-runner) — CI runner that bakes the `dbmate` migrator used against Kilobase.

---
# KBVE Kubectl — Alpine musl kubectl Image with Rust CLI

> Alpine + musl kubectl container image with Rust CLI extensions for KubeVirt VM lifecycle management and Agones GameServer rotation.

Source: https://kbve.com/project/kubectl/

## Overview

Alpine-based kubectl image with a static musl Rust CLI wrapper for KubeVirt VM management. Replaces the distroless `registry.k8s.io/kubectl` image which lacks `/bin/sh` and breaks Kubernetes Job scripts. Built end-to-end on `rust:alpine` so the binary has zero glibc dependencies.

### CLI Subcommands

| Command | Description |
|---------|-------------|
| `kbve-kubectl info` | Print version and check available tools |
| `kbve-kubectl run <script>` | Execute a shell script (passthrough to `/bin/sh`) |
| `kbve-kubectl guest-exec --vm <name> --command <cmd>` | Run a command inside a KubeVirt VM via QEMU Guest Agent |
| `kbve-kubectl rotate-gameserver --namespace <ns> --gameserver <name>` | Roll an Agones GameServer when its desired image drifts from the running pod image (delete-only; ArgoCD recreates) |

### Bundled Tools

| Tool | Purpose |
|------|---------|
| `kubectl` | Kubernetes API access (static binary) |
| `curl` | HTTP requests |
| `jq` | JSON processing |
| `/bin/sh` | Shell script execution (Alpine ash) |
| `kbve-kubectl` | Static musl Rust CLI |

### Usage in Jobs

```yaml
containers:
    - name: task
      image: ghcr.io/kbve/kubectl:0.1.0
      command: ['/bin/sh', '/scripts/my-script.sh']
```

### Where it ships

The image is pinned across every manifest in the `deployment_yamls` field above, all kept in sync on each publish. A representative sample:

| Manifest | Job | Pattern |
|---|---|---|
| `apps/kube/kubevirt/autologon/job.yaml` | KubeVirt Windows autologon setup | One-shot Job, kubectl + virtctl |
| `apps/kube/kubevirt/runner/job.yaml` | KubeVirt runner orchestration | One-shot Job, kubectl + virtctl |
| `apps/kube/agones/factorio/manifests/rotation-cronjob.yaml` | Factorio GameServer rotator + watchdog | CronJob every 2 min, invokes `kbve-kubectl rotate-gameserver` to (a) compare `gs.spec.image` vs `pod.spec.image` and delete the GameServer on drift, and (b) detect `state=Unhealthy` with a missing pod and delete the stuck GameServer so ArgoCD selfHeal recreates from the spec |

When a new behavior needs to land across all rotator and KubeVirt jobs (RCON-aware save-flush probes, Agones SDK Health calls, retry-with-backoff, ConfigMap-driven rotation policy), extend the Rust CLI in `apps/vm/kubectl/src/`, bump `version.toml`, and every manifest above auto-bumps via the post-publish sync.

Or using the Rust CLI directly:

```yaml
containers:
    - name: task
      image: ghcr.io/kbve/kubectl:0.1.0
      command: ['kbve-kubectl', 'guest-exec']
      args: ['--vm', 'windows-builder', '--command', 'powershell.exe']
```

GameServer rotator using the Rust CLI directly:

```yaml
containers:
    - name: rotator
      image: ghcr.io/kbve/kubectl:0.1.2
      command:
          - kbve-kubectl
          - rotate-gameserver
          - --namespace=factorio
          - --gameserver=factorio
          - --container=factorio
          - --delete-timeout=180
```

## FAQ

**What is the KBVE kubectl image?**
It is an Alpine-based kubectl image with a static musl Rust CLI wrapper for
KubeVirt VM management. It replaces the distroless `registry.k8s.io/kubectl`
image, which lacks `/bin/sh` and breaks Kubernetes Job scripts.

**What can the kbve-kubectl CLI do?**
The Rust CLI offers `info` to print versions and check tools, `run` to execute
shell scripts, `guest-exec` to run commands inside a KubeVirt VM via the QEMU
Guest Agent, and `rotate-gameserver` to roll an Agones GameServer when its
desired image drifts from the running pod.

**How is the kubectl image kept in sync across manifests?**
The image tag is pinned across every manifest listed in the `deployment_yamls`
frontmatter field, and all of them auto-bump on each publish via the
post-publish version sync.

## Related

- [Aria2 Proxy](/docs/project/aria2-proxy) — download-proxy image used alongside kubectl in KubeVirt provisioning.

---
# Laser — Phaser + React Three Fiber Integration for React 19

> Laser is a lightweight TypeScript layer that embeds Phaser games and React Three Fiber scenes in React 19 apps via hooks, components, and a shared event bus.

Source: https://kbve.com/project/laser/

## Overview

`@kbve/laser` is a lightweight integration layer for **Phaser** and **React Three
Fiber (R3F)** in React 19 applications. It provides React hooks and components for
embedding Phaser games and R3F scenes with a shared event bus, making it easy to
build hybrid 2D/3D game UIs. Laser is used across KBVE's browser games as the glue
between the game canvas and the React tree.

## Key facts

| | |
|---|---|
| **Package** | `@kbve/laser` |
| **Version** | 0.1.5 |
| **Language** | TypeScript |
| **License** | MIT |
| **Source** | [`packages/npm/laser`](https://github.com/KBVE/kbve/tree/main/packages/npm/laser) |
| **Registry** | npm |

## Features

- **Phaser integration** — `<PhaserGame>` component with ref-based access, a
  `usePhaserGame` context hook, and `usePhaserEvent` for subscribing to Phaser
  events.
- **React Three Fiber integration** — `<Stage>` component and a `useGameLoop` hook
  for frame-synced game logic.
- **Shared event bus** — `LaserEventBus` for decoupled communication between the
  Phaser and R3F layers.
- **TypeScript-first** — full type definitions with exported types for configs,
  events, and geometry primitives.

## Usage

```bash
npm install @kbve/laser
```

```tsx
import {
	PhaserGame,
	usePhaserEvent,
	Stage,
	useGameLoop,
	laserEvents,
} from '@kbve/laser';
```

## FAQ

**What is the Laser package?**
Laser is a lightweight integration layer that embeds Phaser games and React Three
Fiber (R3F) scenes inside React 19 applications, providing hooks, components, and a
shared event bus for building hybrid 2D/3D game UIs.

**What does Laser provide for Phaser and R3F?**
For Phaser it exposes a `PhaserGame` component with ref access, a `usePhaserGame`
context hook, and `usePhaserEvent` for event subscriptions. For R3F it provides a
`Stage` component and a `useGameLoop` hook for frame-synced game logic.

**What peer dependencies does Laser need?**
Laser needs `react` and `react-dom` (>= 18). Phaser (>= 3.80) is optional for
Phaser features, and `three` (>= 0.160) with `@react-three/fiber` and
`@react-three/drei` is optional for R3F features — install only the ones you use.

## Related

- [Droid](/docs/project/droid) — sibling KBVE npm package managing web, shared, and service workers.

---
# LofiFocus — AI Lo-Fi Music Generator Chrome Extension

> LofiFocus is a Chrome extension that auto-generates AI lo-fi music from the page you are reading, using a MusicGen model, an N8N workflow, and a Flask API.

Source: https://kbve.com/project/lofifocus/

import AdsterraAds from '@/components/kbve/AdsterraAds.astro';

---

Demo: https://lofifocus.kbve.com/#

Chrome Extension Repo: https://github.com/KBVE/lofifocus-chrome-extension

Download Chrome Extension: https://github.com/KBVE/lofifocus-chrome-extension/releases/latest

Custom Trained LoFi Model: https://storageapi.webenclave.com/hackathon/lm_final.pt

AI Voice Generation via ElevenLabs: https://storageapi.webenclave.com/hackathon/ElevenLabs_2023-08-29T22_11_24_Charlotte_pre_s50_sb75_b_m1.mp3

Songs Generated using facebook/musicgen-small:

https://storageapi.webenclave.com/hackathon/77896957728656.wav

https://storageapi.webenclave.com/hackathon/89748590695969.wav

https://storageapi.webenclave.com/hackathon/32174022274771.wav

Custom Model with Multi-Band Diffusion:

https://storageapi.webenclave.com/hackathon/1693443008707.wav

https://storageapi.webenclave.com/hackathon/1693446342975.wav

https://storageapi.webenclave.com/hackathon/1693446441558.wav

---
# Video 
Youtube video: https://www.youtube.com/embed/szN4w4cd02s?si=cd0fz-zlLhpL_sYR

---

# Lofi Focus

- [Video](#video)
- [Lofi Focus](#lofi-focus)
  - [Overview](#overview)
  - [Benefits of LoFi Music](#benefits-of-lofi-music)
  - [Audiocraft to the Rescue](#audiocraft-to-the-rescue)
  - [Why Download Our Chrome Extension](#why-download-our-chrome-extension)
  - [How to Install Our Chrome Extension](#how-to-install-our-chrome-extension)
  - [Features](#features)
  - [Implementation](#implementation)
  - [Our Custom Model](#our-custom-model)
  - [Goals](#goals)
  - [Technologies Used](#technologies-used)
  - [High Level Design](#high-level-design)
- [API Documentation](#api-documentation)
  - [Flask API](#flask-api)
  - [N8N API](#n8n-api)
- [Contributions](#contributions)
- [Citations](#citations)

## Overview

Lofi Focus is a chrome extension that automatically generates lo-fi music when browsing articles, blogs, and other sites. The ambient, chilled-out sounds create an enjoyable atmosphere to help users focus while reading.

Lofi music, as explored in Justin Wang's study "Lofi hip-hop radio: Beats to relax/study to" offers a therapeutic escape for its listeners. The genre serves as a coping mechanism for stress and anxiety, with research suggesting that such music impacts the autonomic nervous system, potentially reducing subconscious stress levels (wang2020lofi, Page 5). Additionally, lofi provides solace during personal losses, with its comforting visuals and tones resonating with the emotions of its audience (wang2020lofi, Page 12). Many also use lofi as calming background music for various tasks, from studying to relaxation (wang2020lofi, Page 12). Furthermore, its nostalgic connection to late '90s and early 2000s anime offers a unique blend of soothing genres, providing listeners with a familiar yet calming auditory experience (wang2020lofi, Page 4).

## Benefits of LoFi Music

- Improves focus and concentration - The chill, repetitive beats help tune out distractions and keep you in a flow state. The lack of jarring changes also avoids breaking focus.
- Reduces stress and anxiety - The ambient sounds lower heart rate and have a calming effect on the mind and body.
- Enhances productivity - By helping you focus and relax, lo-fi enables you to work and study more efficiently for longer periods.
- Sets a peaceful mood - The mellow, nostalgic sounds induce feelings of tranquility and relaxation.
- Provides unobtrusive background music - As there are no attention-grabbing vocals, it subtly enhances an environment without being distracting.
- Inspires creativity - The simple compositions are unintimidating and let your mind wander productively.
- Helps with sleep and relaxation - The soothing tracks are great for relaxing the body and quieting the mind before sleep.
- Fosters pleasant memories and nostalgia - For many, it evokes nostalgia from times spent studying or relaxing to music.

## Audiocraft to the Rescue

With Audiocraft we can:

- Create fully AI-generated LoFi tracks tailored to specific use-cases
- Produce High-quality audio
- Create endless unique music
- Train new models tailored to LoFi

<AdsterraAds label="Sponsored" />

## Why Download Our Chrome Extension

- Improve focus and concentration when reading
- Make reading more enjoyable and relaxing
- Boost productivity
- Avoid listening fatigue
- Portability
- Ease of use
- Less anxiety
- Nostalgia

## How to Install Our Chrome Extension

1. Download the extension files here: https://github.com/KBVE/lofifocus-chrome-extension/releases/latest
   - You will need to download the files that make up the chrome extension, usually as a zip folder from the developer. This includes the manifest.json file, HTML/CSS/JS assets, and any images or resources.
2. Unzip the folder containing the extension source files to a location on your computer. You should now have a folder that contains a popup.html, manfiest.json, and several other files.
3. Open Google Chrome and navigate to `chrome://extensions` in the address bar.
4. Enable Developer Mode.
5. Click the "Load Unpacked" button and select the folder containing your extracted extension files. This will install the extension in developer mode.
6. For easy access, click the puzzle icon for your extensions and pin your newly installed extension. This will make it appear as an icon in your browser toolbar.

## Features

- Analyzes webpage content
- Generates a unique, customized lofi track for that page using AI music generation
- Allows users to adjust volume, pause, start, play, re-generate Lo-Fi Music

## Implementation

- Built as a Chrome browser extension for ease of use
- Uses JavaScript content scripts to analyze webpages and play lofi audio
- Leverages AudioCraft's MusicGen AI model to generate the lofi tracks
- Polished UI allows easy control over the music generation

## Our Custom Model
We collected a dataset of original non-copyright lofi music. This gave us access to a large corpus of high-quality training data without any copyright issues.

We split the lofi songs into 30 second audio clips and paired each clip with a text prompt describing the mood, instruments, tempo and other qualities of that segment. Examples include "slow chill hip hop beat with mellow piano and vinyl crackle" and "upbeat lofi with energetic drums and warm bassline".

We formatted this dataset into the required .wav and .txt file pairs that musicgen_trainer expects. The text prompts would guide the model to learn the nuances of lofi hip hop.

We then ran musicgen_trainer on this dataset, configuring it to use the small architecture for optimization purposes. We trained for 100 epochs with a learning rate of 1e-5 and batch size of 4.

During training, musicgen_trainer used the audio/text pairs to fine-tune MusicGen on lofi music. The pre-trained weights were specialized to generate high quality lofi given descriptive prompts.

After training finished, we saved the best performing model checkpoint. We now have a MusicGen variant skilled at generating original lofi tunes according to textual descriptions.

## Goals

- Help people focus and be more productive when reading on the web
- Provide an ambient audio environment that blocks distracting sounds
- Make reading more enjoyable and relaxed through chill tunes
- Give users more options to customize their browsing experience

## Technologies Used

- Audiocraft Music Generation
- Audiocraft Multi-Band Diffusion
- Audiocraft Audio Write
- ChatGPT 3.5-turbo
- JsonLink
- Local Tunnel
- ElevenLabs AI Voice Generation
- Min.io S3 Storage
- Python - Poetry - Flask API
- Node.js - Yarn
- HTML, CSS (Tailwind)
- Plasmo Browser Extension Framework
- Appwrite Backend as a Service
- Docker - Portainer - Coolify
- Github Actions (CI/CD)
- N8N Workflow Automation Tool

## High Level Design

- [x] User visits webpage

- [x] User opens extension

- [x] Browser extension loads ElevenLabs voice clip and says "Please wait patiently while your LoFi track is loading... We are fetching the contents of the page, generating the necessary prompts, and guiding Audiocraft to generate you ambient and chilled-out LoFi music to create an enjoyable atmosphere to help you focus while reading. Sit back... Relax... and focus on your breathing for next several seconds..."

- [x] Lofi Focus sends current URL to N8N workflow

- [x] N8N calls JsonLink API to extract URL metadata

- [x] JsonLink returns page metadata to N8N

- [x] N8N sends metadata to ChatGPT API

- [x] ChatGPT generates personalized lofi music prompts

- [x] N8N parses the prompts

- [x] N8N sets generation parameters (prompt, sampling, top_k, MBD, etc)

- [x] N8N calls custom AudioCraft REST API (Python Flask)

- [x] Flask app runs locally and exposes API via LocalTunnel

- [x] Flask app receives inputs and invokes AudioCraft generation

- [x] AudioCraft generates track using MusicGen + RTX 4090 GPU (CUDA)

- [x] Flask API returns .wav file to N8N

- [x] N8N uploads .wav to S3 storage (Min.io)

- [x] N8N sends audio URL to Lofi Focus

- [x] Lofi Focus plays the generated track

# API Documentation

## Flask API

POST - `https://.../generate_music`

```json
{
  "model_name": "facebook/musicgen-small",
  "duration": 15,
  "prompt": "LoFi Hip-Hop",
  "strategy": "loudness",
  "sampling": true,
  "top_k": 0,
  "top_p": 0.9,
  "temperature": 0.9,
  "use_diffusion": false
}
```

## N8N API

POST - `https://.../generate-music`

```json
{
	"url": "https://medium.com/@KimWitten/stop-trying-to-manage-your-time-a07b6e45cec8",
  "use_custom": true, /* optional */
	"use_diffusion": true, /* optional */
  "duration": 15 /* optional */
}
```

# Contributions

https://github.com/h0lybyte - Docker, Portainer, Appwrite

https://github.com/BChip - Audiocraft, Flask API, N8N Workflow, Eleven
Labs Voice AI, Documentation

https://github.com/Ziggy9263 - Chrome Extension

https://github.com/ZachHandley - Custom Audiocraft Model for LoFi

https://github.com/8gratitude8 - Presentation, Static Site, Prompt Engineering

https://github.com/ernivani - Chrome Extension

# Citations

```
https://ojs.stanford.edu/ojs/index.php/theword/article/view/1705/1326
@article{wang2020lofi,
  title={Lofi hip-hop radio: Beats to relax/study to},
  author={Wang, Justin},
  journal={The Word: Tha Stanford Journal of Student Hiphop Research},
  volume={1},
  number={1},
  pages={10--23},
  year={2020}
}

```

```
@article{copet2023simple,
      title={Simple and Controllable Music Generation},
      author={Jade Copet and Felix Kreuk and Itai Gat and Tal Remez and David Kant and Gabriel Synnaeve and Yossi Adi and Alexandre Défossez},
      year={2023},
      journal={arXiv preprint arXiv:2306.05284},
}
```

## FAQ

**What is LofiFocus?**
LofiFocus is a Chrome extension that automatically generates lo-fi music while you browse articles, blogs, and other sites, creating an ambient atmosphere to help you focus while reading.

**How does LofiFocus generate music?**
The extension sends the current URL to an N8N workflow that extracts page metadata, uses ChatGPT to build music prompts, then calls a custom AudioCraft MusicGen model via a Python Flask API on an RTX 4090 GPU; the resulting track is stored in S3 and played back in the browser.

**Does LofiFocus use a custom model?**
Yes. The team fine-tuned Facebook's MusicGen small model on a dataset of non-copyright lo-fi clips paired with descriptive text prompts, training for 100 epochs to specialize it for generating lo-fi hip-hop from text.

## Related

- [Charles](/docs/project/charles) — the KBVE GPU machine-learning build behind model training.

---
# Asset Marketplace

> Open marketplace for game assets — 3D, 2D, audio, VFX, tools, and complete projects — on a decoupled Rust/Axum API sharing KBVE identity with the Job Board.

Source: https://kbve.com/project/marketplace/

## Asset Marketplace

> Status: **Spec / architecture** — no app code yet. This is the document to review/edit before building.
> Sibling product to the [Job Board](/docs/project/jobboard) — the Job Board sells *services*, the Asset Marketplace sells *digital goods*. They share identity, media, transport, and technical vocabulary.

An **open marketplace for game assets** — think Fab / itch.io / CraftPix / GameDevMarket, scoped strictly to **game assets**: 3D models, 2D art, audio, VFX, shaders, tools/plugins, and complete projects. Creators list assets; buyers discover them. v1 is a **lead-gen catalog** (browse, storefronts, license terms, wishlists, external buy links); on-platform **checkout with per-sale commission** and downloadable delivery ships in a later phase.

**Strictly game assets.** Unlike a generalist digital-goods store, the category tree, tagging (engines/tools/formats), and previews are built for games — engine compatibility, poly counts, rig types, tilemap formats, loopable audio, license suitability for shipped games. That focus is the wedge.

**Architecture is decoupled:** a standalone **Rust/Axum REST API** (own DB access, own first-party auth — no third-party auth SaaS) serving a **separate frontend client** (framework TBD) over HTTP.

### Positioning / moat
- **Game-native catalog.** Categories and facets speak game dev (engine version, render pipeline, tris/verts, humanoid rig, atlas size, sample rate) — not generic "graphics/audio."
- **Open supply, curated trust.** Anyone can list (volume), but verification badges, ratings, and moderation surface quality. Trust is earned and displayed, not gatekept at the door.
- **Shared ecosystem.** One KBVE account, one identity, one engine/tool vocabulary across the Job Board and the Asset Marketplace — a freelancer can both take gigs *and* sell assets.

* * *

## Personas & roles

| Persona | What they do | Gating |
|---|---|---|
| **Seller** | Creates a storefront, lists assets, sets prices + license tiers, uploads files. | Open (sign up → list); optional verification tier |
| **Buyer** | Browses, wishlists, reviews; purchases + downloads (checkout phase). | Open |
| **Admin** | Manages categories, moderates listings, handles DMCA/abuse reports, reviews verification + AI-disclosure. | Internal |

- One account can be both **seller** and **buyer**, and is the *same* KBVE account used on the Job Board (capabilities tracked as a bitmask on the existing `User.role`).
- **Open marketplace:** no pre-approval to list. Quality is managed post-hoc via moderation, reports, ratings, and an optional **verified seller** badge.

* * *

## Asset taxonomy

Two facets, both controlled (no free text) so filtering works:

1. **Category tree** (asset-store specific, hierarchical) — *what the asset is*.
2. **Engine/tool/format tags** (shared with the Job Board) — *what it works with*.

### Category tree (hierarchical, admin-managed)
- **3D** — Characters, Creatures, Environments, Props, Vehicles, Weapons, Modular Kits
- **2D** — Sprites, Tilesets, Characters, Backgrounds, UI/GUI, Icons
- **Textures & Materials** — PBR materials, Substance, decals, skyboxes
- **Audio** — Music (loops/tracks), SFX, Ambience, Voice/VO
- **VFX & Shaders** — particle FX, shader packs, post-processing
- **Tools & Code** — plugins, editor tools, scripts, systems
- **Complete Projects / Templates** — game templates, starter kits, demos
- **Fonts** — game-ready/display fonts

### Engine/tool/format tags (reuse Job Board vocabulary)
Unity, Unreal, Godot, GameMaker, Bevy; Blender, Maya, ZBrush, Substance, Photoshop, Spine, FMOD, Wwise; formats: `fbx`, `gltf`, `obj`, `png`, `wav`, `ogg`, `unitypackage`, `uasset`. These already exist as `Taxonomy` rows — reuse them, don't duplicate.

> Categories live in a new hierarchical `AssetCategory`; engine/tool/format tags reuse the shared `Taxonomy` (see protobuf section).

* * *

## Core flows

### A. Seller onboarding (open)
1. Sign up (first-party auth — shared KBVE account).
2. Create a **storefront** (slug, name, tagline, logo/banner).
3. (Optional) apply for **verified seller** badge later.

### B. List an asset
1. Create asset — title, category, engine/tool/format tags, description.
2. Upload file bundle as an **AssetVersion** (changelog + source files → **private** R2). The pipeline then **auto-generates watermarked, degraded previews** (turntable/low-poly viewer, downscaled images, low-bitrate audio clips) — the seller picks which to feature. *(Checkout phase; in lead-gen v1 a seller may instead point paid assets to an `external_url`.)*
3. Set **license offerings** — Standard and/or Extended price, or mark the asset **free** (see Licensing).
4. Declare **AI-content disclosure**.
5. Publish → `PUBLISHED` (or `PENDING_REVIEW` if moderation gate is on).

### C. Buyer discovers
1. Browse / search / filter by category, engine, format, price, rating, license.
2. View asset detail — previews, files/specs, license terms, version history, reviews.
3. **Wishlist** / add to a **collection**; follow sellers/storefronts.

### D. Purchase & delivery *(checkout phase)*
1. Buyer selects a license tier → checkout (Stripe).
2. Payment captured → **Order** recorded (reuses `Invoice`) → platform takes **commission**.
3. **LicenseGrant** issued → time-limited signed **download URL** to the AssetVersion files (R2).
4. Buyer can re-download owned versions + receive update notifications.
5. Verified-purchase **review** unlocked.

### E. Payouts & moderation *(cross-cutting)*
- Seller payouts via Stripe Connect (checkout phase).
- Admin: category management, listing moderation, **DMCA/abuse** workflow, malware-scan review, AI-disclosure enforcement, audit log.

* * *

## Licensing

> **Default model: royalty-free Standard + Extended tiers** (industry norm — Fab, GameDevMarket, Unity Asset Store). Marked as the one open decision; collapsing to a single tier later is trivial, the reverse is a migration.

- **Standard** — royalty-free; buyer may use the asset in an unlimited number of *their own* shipped games/products. Restrictions: no redistribution/resale of the raw files, no asset-flip products, optional per-title revenue or team-seat cap.
- **Extended** — higher price; lifts caps. Permits use where the asset is a *core resold component* (templates, stock libraries, merch/print-on-demand), higher revenue thresholds, more seats, optional sublicensing.

Licenses are modeled as platform-provided **`LicenseTemplate`** rows (tier + human-readable terms + machine-readable caps), and each asset attaches one or more **`LicenseOffering`** (template + price). In **lead-gen v1**, licensing is *terms display + metadata*; enforcement (receipts, `LicenseGrant`, download tokens) activates with checkout. Alternatives considered: single royalty-free license (simpler, less upsell) and seller-defined licenses (flexible, fragmenting) — see Decisions.

* * *

## Revenue

**Commission per sale.** The platform takes a percentage of each transaction; the seller keeps the remainder. Because v1 is lead-gen (no on-platform checkout), **commission activates in the checkout phase** — v1 builds the catalog, storefronts, and demand. The percentage and any verified-seller rate breaks live in reused `Setting`/`Global` so they're tunable without a migration. (Subscription-library access, à la CraftPix, can be layered later via the same hooks.)

* * *

## Preview protection & download gating

**The buyer never sees or receives the real asset before they're entitled to it.** What a listing shows is a **derived, watermarked, intentionally-degraded preview generated server-side from the source** — never the deliverable file. Downloads of the source are gated on a `LicenseGrant` (paid) or the asset being free.

### Two distinct artifact classes
- **Source files (`AssetFile`)** — the real, full-quality deliverable. Stored in **private** R2; **no public URL, ever**. Served only as a short-lived signed URL *after* the download route verifies a `LicenseGrant`.
- **Previews (`status.MediaAttachment`)** — public/CDN, watermarked + degraded, **auto-generated by the upload pipeline** from the source. Safe to index, hotlink, and show to anyone — they are not usable as the real asset.

### Per-type preview generation
| Asset type | Source (gated, private) | Generated preview (public, watermarked) |
|---|---|---|
| 3D model | fbx/gltf, textures, rig | Watermarked turntable video + a **decimated/low-poly** WebGL viewer (no downloadable mesh) — never the source geometry |
| 2D art / textures | full-res PNG/PSD, PBR maps | Down-scaled, watermark-overlaid JPG/WebP; flattened (no layers) |
| Audio / music | full-length WAV / stems | Short, **lower-bitrate** clip with an embedded audio watermark (tone/voice tag) |
| VFX / shader | project files | Watermarked demo video / animated GIF |
| Code / tools | source archive | README + screenshots + **redacted** snippets only |
| Complete project | full project | Gameplay video + screenshots; **no** project files |

### Download gating
- **Paid asset** → download requires a `LicenseGrant`, which only exists after a successful Stripe payment (checkout phase). `/downloads/:grantId` validates the grant, then mints a signed R2 URL valid for minutes.
- **Free asset** (`Asset.is_free`) → a `LicenseGrant` is **auto-issued** on request (still recorded, so download counts, version updates, and notifications work), then the same signed-URL path applies.
- **Lead-gen v1 caveat:** until checkout ships, *paid* assets expose previews + an `external_url` (the transaction happens off-platform), while *free* assets can already deliver on-platform. **No source file is ever reachable without a grant.**

> Invariant: a `LicenseGrant` (or `is_free`) is the **only** key to a source file, and the only thing the public ever sees is a watermarked derivative.

* * *

## Data model (Postgres)

Accessed via **`sqlx`** (async, compile-time-checked; migrations via `sqlx migrate`). Each table maps to a protobuf message; reused entities map to existing protos, new ones to the `assetstore` package.

| Table | Source proto |
|---|---|
| `users` | **reuse** `User` + `Auth` (kbveproto) |
| `sessions`, `oauth_accounts` | shared with Job Board (new) |
| `profiles` (base) | **reuse** `Profile` (kbveproto) |
| `storefronts` | new `assetstore.Storefront` |
| `asset_categories` (hierarchical) | new `assetstore.AssetCategory` |
| `engine/tool/format tags` | **reuse** `jobboard.Taxonomy` (shared vocabulary) |
| `assets` | new `assetstore.Asset` (+ reuse `MediaAttachment` for previews) |
| `asset_versions` | new `assetstore.AssetVersion` |
| `asset_files` | new `assetstore.AssetFile` (R2 blob keys, private) |
| `license_templates` | new `assetstore.LicenseTemplate` |
| `license_offerings` | new `assetstore.LicenseOffering` |
| `asset_reviews` | new `assetstore.AssetReview` |
| `wishlists`, `collections` | new `assetstore.Wishlist` / `Collection` |
| `orders` (purchase records) | **reuse** `Invoice` (kbveproto) |
| `license_grants` (entitlements) | new `assetstore.LicenseGrant` |
| `payouts` | new `assetstore.Payout` (Stripe Connect) |
| `reports`, `dmca_claims`, `audit_log` | new (admin / trust & safety) |
| `settings`, `globals` (commission %, flags) | **reuse** `Setting`, `Global` (kbveproto) |

* * *

## Tech architecture (decoupled)

### Backend — Rust API service
| Concern | Choice | Why |
|---|---|---|
| Framework | **Axum** (Tokio) | Fast, ergonomic, tower middleware ecosystem |
| Auth | **First-party** — `axum-login` + `tower-sessions` (Postgres store), `argon2`, optional `oauth2` (Discord/GitHub/Steam) | Shared KBVE identity; no auth SaaS |
| DB access | `sqlx` (async, compile-time-checked) | Type-safe SQL; `sqlx migrate` |
| DB | Postgres (Supabase / Neon) | Relational fits catalog/orders/licenses |
| Wire format | `prost`/`tonic` protobuf over `jedi.JediEnvelope` | Reuses KBVE proto/envelope transport |
| Object storage | S3-compatible (Cloudflare R2) | **Private** source files (no public URL); **time-limited signed download URLs** gated on a grant. Separate **public** bucket/CDN for watermarked previews |
| File pipeline | malware scan + **watermarked/degraded preview generation** per asset type (turntable renders, low-poly viewers, downscaled images, low-bitrate audio) | Source never gets a public URL; only derived previews are exposed |
| Search | Postgres FTS (v1) → Meilisearch later | Faceted catalog search; Rust-native upgrade |
| Payments | **Stripe + Stripe Connect** (checkout phase) | Collect, commission, pay out sellers |
| Notifications | In-app (DB) v1; email later | Order receipts, asset updates |

### Frontend — TBD (decided in a later phase)
- Pure HTTP client of the API. Candidates: Astro + React (KBVE-native), Next.js (frontend-only), or React SPA.
- Asset detail / storefront pages are SEO-critical → favors SSR/SSG (Astro or Next).

### Deployment
- **API:** containerized Axum on Kubernetes (KBVE-native) / Fly.io / Railway (stateful — not serverless).
- **DB:** Supabase/Neon Postgres. **Object storage + CDN:** Cloudflare R2 (signed URLs for paid files; public CDN for previews).

**Authorization model:** Axum middleware authenticates session/token; route guards check the `Capability` bitmask on `User.role`; ownership checks for storefront/asset edits; **download routes verify a `LicenseGrant`** before issuing a signed URL.

* * *

## REST API surface (Axum)

All mutations go through the API; the frontend is a pure client. Auth via session cookie or `Authorization: Bearer`. Versioned under `/api/v1`.

```
# Auth (shared with Job Board)
POST   /auth/register | /auth/login | /auth/logout
GET    /auth/me
GET    /auth/oauth/:provider | /auth/oauth/:provider/cb

# Categories & tags
GET    /categories                       asset category tree
GET    /tags                             engine/tool/format tags (shared taxonomy)
POST   /admin/categories                 [admin] create/edit category
POST   /admin/tags                       [admin] add tag

# Storefronts
POST   /storefronts                      create my storefront
GET    /storefronts/:slug                public storefront + assets
PATCH  /storefronts/:slug                [owner]

# Assets (catalog)
GET    /assets                           browse/filter (category, engine, format, price, rating)
POST   /assets                           [seller] create listing
GET    /assets/:slug                     detail (previews, specs, license terms, versions, reviews)
PATCH  /assets/:slug                     [seller, owner]
POST   /assets/:slug/publish             [seller, owner]

# Versions & files
POST   /assets/:slug/versions            [seller] new version (changelog)
POST   /assets/:slug/versions/:v/files   [seller] upload file -> R2 (+ scan)
PATCH  /assets/:slug/offerings           [seller] set Standard/Extended pricing

# Engagement
POST   /me/wishlist/:assetId             add/remove wishlist
GET/POST/PATCH /me/collections[/:id]     curated lists
POST   /assets/:slug/reviews             [buyer] review (verified-purchase in checkout phase)

# Acquire & deliver
POST   /assets/:slug/claim               FREE asset -> auto-issue LicenseGrant (no payment)
POST   /checkout                         PAID -> create order (Stripe) for selected offerings   (checkout phase)
POST   /webhooks/stripe                  payment confirmation -> Order(Invoice) + LicenseGrant   (checkout phase)
GET    /me/library                       owned assets (LicenseGrants)
GET    /downloads/:grantId               -> time-limited signed R2 URL (verifies grant; free or paid)
GET    /me/payouts                       [seller] payout history (Stripe Connect)   (checkout phase)

# Trust & safety
POST   /reports                          report a listing
POST   /dmca                             submit a DMCA/copyright claim
GET    /admin/reports | /admin/dmca | /admin/moderation   [admin]
```

* * *

## Protocol Buffers

Reuses the existing KBVE proto collection (`packages/rust/jedi/proto/*`, `packages/kbve/src/kbveproto.proto`) **and the Job Board's shared vocabulary**. **Rule: reuse first, extend second, add last.** We add one new file — `assetstore.proto` (package `assetstore`).

### What we reuse (do not recreate)

| Need | Reused proto | Where | Notes |
|---|---|---|---|
| **Auth / credentials** | `Auth` | `kbveproto.proto` | First-party auth model — use as-is (shared with Job Board). |
| **User identity** | `User` | `kbveproto.proto` | `role` bitmask carries seller/buyer/admin capability; `reputation` aggregates seller rating. |
| **Base profile** | `Profile` | `kbveproto.proto` | Seller bio/socials; storefront extends via `Storefront`. |
| **Bearer tokens** | `Apikey` | `kbveproto.proto` | Non-browser clients. |
| **Orders / receipts** | `Invoice` | `kbveproto.proto` | Purchase records reuse `Invoice` (`items`, `total`, `paid`, `status`, `external`). |
| **Commission %, flags** | `Setting`, `Global` | `kbveproto.proto` | Tunable commission + feature flags without migration. |
| **Preview media** | `MediaAttachment` | `status.proto` | `url, media_type (bitmask), caption` — asset previews. |
| **Engine/tool/format tags** | `Taxonomy` | `jobboard.proto` | **Shared vocabulary** — an asset tagged "Unity" uses the same id as a gig tagged "Unity". (Candidate to promote into a `common.proto` later; see risks.) |
| **Listing pattern** | `DiscordServer`, `DiscordTag` | `disoxide.proto` | Template (not copied): bitmask `status`, inline SQL CHECK comments, URL regex, `updated_at`. `Asset`/`Storefront` follow it. |
| **Transport envelope** | `JediEnvelope`, `MessageKind` | `jedi.proto` | Payloads ride inside `JediEnvelope`; existing routing bits suffice — **no new kinds**. |
| **KV / cache / realtime** | `StoreService`, `RedisService` | `store.proto`, `redis.proto` | Catalog cache, download-token cache, update fan-out. |

### What we add — `assetstore.proto`

> Suggested location: `packages/rust/jedi/proto/assetstore.proto`, package `assetstore`, built via `prost`/`tonic`. Reuses `status.proto` (MediaAttachment) and `jobboard.proto` (Taxonomy) — both must be on the protoc include path.

```proto
syntax = "proto3";
package assetstore;

// Reuse — on the protoc include path:
import "status.proto";      // MediaAttachment
import "jobboard.proto";    // Taxonomy (shared engine/tool/format tags)
// Identity & money reused from kbveproto.proto: Auth, User, Profile, Apikey, Invoice, Setting, Global
// Transport: payloads ride inside jedi.JediEnvelope (jedi.proto)

// ─────────────────────────── Enums (bitflags where noted) ───────────────────────────

// Stored in the EXISTING User.role bitmask — no new capability table.
enum Capability {
  CAP_NONE   = 0;
  CAP_BUYER  = 1;
  CAP_SELLER = 2;
  CAP_ADMIN  = 4;
}

// Asset lifecycle — bitmask (mirrors disoxide status convention).
enum AssetStatus {
  ASSET_DRAFT          = 0;
  ASSET_PENDING_REVIEW = 1;
  ASSET_PUBLISHED      = 2;
  ASSET_SUSPENDED      = 4;   // moderation/DMCA
  ASSET_ARCHIVED       = 8;
}

enum LicenseTier {
  LICENSE_UNSPECIFIED = 0;
  LICENSE_STANDARD    = 1;
  LICENSE_EXTENDED    = 2;
  LICENSE_CUSTOM      = 3;    // reserved for seller-defined templates
}

// AI-content disclosure (Fab-style requirement).
enum AiDisclosure {
  AI_NONE        = 0;   // no generative AI used
  AI_ASSISTED    = 1;   // AI-assisted (e.g. upscaling, denoise)
  AI_GENERATED   = 2;   // substantially AI-generated
}

// File moderation state.
enum ScanStatus {
  SCAN_PENDING = 0;
  SCAN_CLEAN   = 1;
  SCAN_FLAGGED = 2;
}

// ─────────────────────────── Storefront ───────────────────────────

message Storefront {
  // ? id BIGSERIAL PRIMARY KEY
  uint64 id = 1;
  // ? owner_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE
  bytes  owner_id = 2;
  // ? slug TEXT NOT NULL UNIQUE CHECK (slug ~ '^[a-z0-9-]+$')
  string slug = 3;
  string name = 4;
  string tagline = 5;
  string bio = 6;
  string logo_url = 7;
  string banner_url = 8;
  // Bitwise status (active / verified / suspended).
  int32  status = 9;
  string created_at = 10;
  string updated_at = 11;
}

// ─────────────────────────── Category tree (hierarchical) ───────────────────────────

message AssetCategory {
  // ? id BIGSERIAL PRIMARY KEY
  uint64 id = 1;
  // ? parent_id BIGINT REFERENCES asset_categories(id)  (NULL = top level)
  uint64 parent_id = 2;
  // ? slug TEXT NOT NULL UNIQUE CHECK (slug ~ '^[a-z0-9-]+$')  e.g. "3d-characters"
  string slug = 3;
  string label = 4;
  string icon = 5;
  // Bitwise status (active/featured).
  int32  status = 6;
  int32  sort_order = 7;
}

// ─────────────────────────── Licensing ───────────────────────────

message LicenseTemplate {
  uint64 id = 1;
  LicenseTier tier = 2;
  string name = 3;
  // Human-readable terms (markdown).
  string terms_md = 4;
  // Machine-readable caps:
  bool   allow_commercial      = 5;
  bool   allow_redistribution  = 6;   // resell/redistribute raw files
  bool   allow_resale_in_product = 7; // asset as a core resold component
  bool   allow_sublicense      = 8;
  int32  seat_cap     = 9;            // 0 = unlimited
  int64  revenue_cap  = 10;           // 0 = unlimited (per-title revenue cap)
  string updated_at = 11;
}

// Per-asset price for a license template (e.g. Standard $X, Extended $Y).
message LicenseOffering {
  uint64 id = 1;
  uint64 asset_id = 2;
  uint64 license_template_id = 3;
  int64  price = 4;        // minor units
  string currency = 5;
  bool   active = 6;
}

// ─────────────────────────── Asset (pattern from disoxide.DiscordServer) ───────────────────────────

message Asset {
  // ? id BIGSERIAL PRIMARY KEY
  uint64 id = 1;
  // ? seller_id UUID NOT NULL REFERENCES auth.users(id)
  bytes  seller_id = 2;
  uint64 storefront_id = 3;
  // ? slug TEXT NOT NULL UNIQUE CHECK (slug ~ '^[a-z0-9-]+$')
  string slug = 4;
  // ? title VARCHAR(140) NOT NULL
  string title = 5;
  // ? summary VARCHAR(200)
  string summary = 6;
  // ? description TEXT (markdown)
  string description = 7;
  // ? category_id BIGINT NOT NULL REFERENCES asset_categories(id)
  uint64 category_id = 8;
  // Shared taxonomy ids: engines / tools / formats (jobboard.Taxonomy).
  repeated uint64 tag_ids = 9;
  // PUBLIC, watermarked + degraded previews auto-generated from the source
  // (turntable/low-poly viewer, downscaled images, low-bitrate audio) —
  // NEVER the deliverable source files (those are private AssetFiles).
  repeated status.MediaAttachment previews = 10;   // ← reused
  AiDisclosure ai_disclosure = 11;
  // AssetStatus bitmask.
  int32  status = 12;
  uint64 current_version_id = 13;
  // Lowest active license price, denormalized for listing/sort.
  int64  price_from = 14;
  string currency = 15;
  // Free assets auto-issue a LicenseGrant on download (no payment required).
  bool   is_free = 24;
  // Lead-gen v1: external buy link until on-platform checkout ships.
  string external_url = 16;
  // Denormalized stats.
  uint32 downloads = 17;
  uint32 sales = 18;
  uint32 rating_count = 19;
  float  rating_avg = 20;
  string published_at = 21;
  string created_at = 22;
  string updated_at = 23;
}

// ─────────────────────────── Versions & files ───────────────────────────

message AssetVersion {
  uint64 id = 1;
  uint64 asset_id = 2;
  // ? version TEXT NOT NULL  e.g. "1.2.0"
  string version = 3;
  string changelog = 4;
  string created_at = 5;
}

message AssetFile {
  uint64 id = 1;
  uint64 version_id = 2;
  string filename = 3;
  // fbx / gltf / png / wav / unitypackage / uasset / zip …
  string format = 4;
  int64  size_bytes = 5;
  // R2 object key (private; never returned raw — served via signed URL).
  string blob_key = 6;
  string checksum = 7;
  ScanStatus scan = 8;
  string created_at = 9;
}

// ─────────────────────────── Reviews & collections ───────────────────────────

message AssetReview {
  uint64 id = 1;
  uint64 asset_id = 2;
  bytes  buyer_id = 3;
  // 1..5
  int32  rating = 4;
  string body = 5;
  // True once verified-purchase gating is live (checkout phase).
  bool   verified_purchase = 6;
  string created_at = 7;
}

message Wishlist {
  bytes  user_id = 1;
  repeated uint64 asset_ids = 2;
  string updated_at = 3;
}

message Collection {
  uint64 id = 1;
  bytes  user_id = 2;
  string name = 3;
  bool   is_public = 4;
  repeated uint64 asset_ids = 5;
  string created_at = 6;
}

// ─────────────────────────── Checkout, entitlements & payouts (checkout phase) ───────────────────────────
// Order/receipt reuses kbveproto.Invoice. Entitlement + payout are new.

message LicenseGrant {
  uint64 id = 1;
  // References the reused Invoice (order) that paid for it.
  uint64 invoice_id = 2;
  uint64 asset_id = 3;
  uint64 asset_version_id = 4;
  uint64 license_template_id = 5;
  bytes  buyer_id = 6;
  // Opaque token resolved to a time-limited signed R2 URL at download time.
  string download_token = 7;
  string granted_at = 8;
}

message Payout {
  uint64 id = 1;
  bytes  seller_id = 2;
  int64  amount = 3;       // minor units, net of commission
  string currency = 4;
  // 0 pending, 1 paid, 2 failed
  int32  status = 5;
  // Stripe Connect transfer/payout reference.
  string external_ref = 6;
  string period_start = 7;
  string period_end = 8;
  string created_at = 9;
}

// ─────────────────────────── Trust & safety ───────────────────────────

message DmcaClaim {
  uint64 id = 1;
  bytes  claimant_id = 2;
  uint64 asset_id = 3;
  string description = 4;
  string evidence_url = 5;
  // 0 received, 1 upheld (asset suspended), 2 rejected, 3 counter-noticed
  int32  status = 6;
  string created_at = 7;
}

// ─────────────────────────── Service (pattern from kbveproto.MessageRpc / store.StoreService) ───────────────────────────

message ById   { uint64 id = 1; }
message BySlug { string slug = 1; }
message ByUser { bytes  user_id = 1; }
message Ack    { bool success = 1; string message = 2; }

service AssetStoreRpc {
  // Catalog admin
  rpc UpsertCategory (AssetCategory) returns (Ack);     // admin
  rpc UpsertLicenseTemplate (LicenseTemplate) returns (Ack);  // admin

  // Storefront & listings
  rpc CreateStorefront (Storefront) returns (Ack);
  rpc CreateAsset (Asset) returns (Ack);
  rpc GetAsset (BySlug) returns (Asset);
  rpc PublishAsset (ById) returns (Ack);
  rpc AddAssetVersion (AssetVersion) returns (Ack);
  rpc AddAssetFile (AssetFile) returns (Ack);
  rpc SetLicenseOffering (LicenseOffering) returns (Ack);

  // Engagement
  rpc ToggleWishlist (ById) returns (Ack);
  rpc SubmitReview (AssetReview) returns (Ack);

  // Checkout & delivery (checkout phase)
  rpc IssueLicenseGrant (LicenseGrant) returns (Ack);   // after Stripe webhook
  rpc ResolveDownload (ById) returns (Ack);             // grant id -> signed URL in message

  // Trust & safety
  rpc SubmitDmca (DmcaClaim) returns (Ack);
}
```

### Reuse summary

- **New file:** `assetstore.proto` (1 file, 1 package).
- **Reused as-is:** `Auth`, `User`, `Profile`, `Apikey`, **`Invoice` (orders)**, `Setting`, `Global`, `MediaAttachment`, **`jobboard.Taxonomy` (engine/tool/format tags)**, `JediEnvelope`/`MessageKind`, `StoreService`, `RedisService`.
- **Reused as pattern (not copied):** `DiscordServer` → `Asset`/`Storefront`, `DiscordTag` → `AssetCategory`, `MessageRpc`/`StoreService` → `AssetStoreRpc`.
- **New domain only:** storefronts, hierarchical categories, licensing (templates/offerings/grants), versions/files, reviews/collections, payouts, DMCA.
- **No new `MessageKind` values** — existing routing bits suffice.

* * *

## Trust & safety

Open supply makes moderation load-bearing:
- **DMCA / copyright** — formal claim → review → suspend workflow (`DmcaClaim`). Stolen assets are the #1 risk for open asset marketplaces.
- **Malware scanning** — every uploaded `AssetFile` is scanned (`ScanStatus`) before it can be sold/downloaded.
- **AI-content disclosure** — required `AiDisclosure` per asset; surfaced on listings; misdeclaration is a takedown reason.
- **Quality / asset-flip moderation** — reports + ratings + optional verified-seller badge.
- **Refunds & chargebacks** (checkout phase) — policy for digital goods; fraud monitoring.
- **Private source, watermarked previews** — source files live in private R2 with no public URL, served only via short-lived signed URLs gated on a `LicenseGrant` (or `is_free`). The public ever only sees **derived, watermarked, degraded** previews — never the deliverable. See [Preview protection & download gating](#preview-protection--download-gating).
- Audit log for all admin actions.

* * *

## Key risks / open questions

1. **Stolen / pirated assets** — open listing invites IP theft. Needs the DMCA workflow + possibly perceptual-hash/duplicate detection on upload. How aggressive at launch?
2. **AI-content policy** — disclosure is modeled, but the *policy* (allowed? labeled-only? banned in some categories?) is a product decision.
3. **Lead-gen for digital goods is unusual** — in v1 buyers leave via `external_url`, so **no commission is collected until checkout ships**. Confirm v1 is acceptable as a pure discovery catalog, or accelerate checkout.
4. **File hosting & egress costs** — large bundles + free previews can get expensive; R2 has no egress fees (good fit), but storage tiers/limits per seller need a policy.
5. **Refund policy** for instant-delivery digital goods (checkout phase).
6. **Shared `Taxonomy` coupling** — reusing `jobboard.Taxonomy` couples this package to `jobboard`. Cleaner long-term: promote `Taxonomy` (+ `MediaAttachment`) into a shared `common.proto`. Decide now vs later.
7. **Relationship to Job Board** — confirm single shared identity/account across both products (assumed), and whether storefront + talent profile are unified surfaces.

* * *

## Phased build plan

| Phase | Scope | Outcome |
|---|---|---|
| **0 — Foundations** | Axum + `sqlx` + Postgres; migrations; seed category tree + reuse shared tags; first-party auth (shared KBVE identity); wire `assetstore.proto` | API boots, auth works, DB ready |
| **1 — Storefronts** | Create/manage storefront; seller profile | Sellers have a home |
| **2 — Listings (catalog)** | Create asset, categories/tags, preview media, license offerings, AI disclosure; lead-gen `external_url` | Assets are listed |
| **3 — Discovery** | Browse/search/faceted filter; asset detail; license-terms display | Catalog is usable |
| **4 — Engagement** | Wishlists, collections, follows, reviews | Demand-side retention |
| **5 — Checkout & delivery** | Stripe checkout; Order(`Invoice`); commission; `LicenseGrant`; R2 signed downloads; library | **Real store + revenue** |
| **6 — Payouts** | Stripe Connect onboarding; seller `Payout` | Sellers get paid |
| **7 — File pipeline & T&S** | Malware scan, preview/thumbnail generation, DMCA workflow, verified-purchase reviews | Trust hardened |
| **8 — Frontend client** | Choose framework (SEO-critical → SSR); build UI | Usable product |
| **9 — Discovery polish & monetization** | Meilisearch, recommendations, featured listings, optional subscription library | Scale + revenue surface |

* * *

## Decisions

**Locked:** strictly game assets · **open marketplace** (anyone lists; post-hoc moderation) · **lead-gen catalog v1**, on-platform checkout later · **commission per sale** (activates at checkout) · decoupled architecture · Rust/Axum API · first-party auth (shared KBVE identity, no auth SaaS) · `sqlx` + Postgres · R2 with signed downloads · **previews are server-generated, watermarked, degraded derivatives (never the source); source files are private + grant-gated; free assets auto-issue a grant** · protobuf reuses KBVE protos + `jobboard.Taxonomy` + one new `assetstore` package.

**Still open:**
- **Licensing model** — defaulted to **Standard + Extended**; confirm vs single royalty-free vs seller-defined.
- **AI-content policy** — allowed / labeled-only / restricted by category.
- **Anti-piracy aggressiveness** at launch (DMCA only vs duplicate detection).
- **Frontend framework** (Astro+React / Next.js frontend-only / React SPA) — Phase 8; SEO favors SSR.
- **Commission rate** + verified-seller rate breaks.
- **Shared `Taxonomy`/`MediaAttachment`** — keep coupling to `jobboard` vs promote to `common.proto`.
- **Preview-generation stack** — which renderer/encoder per type (e.g. headless Blender/Three.js for 3D turntables + decimation, ffmpeg for audio/video, image pipeline for watermarking), and the fidelity-vs-leak-resistance tradeoff (how degraded/watermarked).
- Seller storage limits/tiers; refund policy; subscription-library tier (later).

---
# Minecraft Server — Fabric on Agones

> Fabric Minecraft 1.21.11 dedicated server on Agones with performance mods, an Old Combat Mod, and a Rust JNI behavior-tree AI plugin, deployed on Kubernetes.

Source: https://kbve.com/project/mc/

## Overview

Fabric Minecraft 1.21.11 server deployed via Agones on Kubernetes. Multi-stage Docker build compiles a Rust JNI behavior tree mod and bundles it with performance mods from Modrinth.

## Key facts

| | |
|---|---|
| **Image** | `kbve/mc` |
| **Loader** | Fabric (Minecraft 1.21.11) |
| **Orchestration** | Agones Fleet on Kubernetes |
| **Base** | `itzg/minecraft-server:java21` |
| **License** | KBVE |
| **Source** | [`apps/mc`](https://github.com/KBVE/kbve/tree/main/apps/mc) |

## Features

- **Fabric performance stack** — C2ME, VMP, Lithium, FerriteCore, ServerCore, Chunky.
- **Old Combat Mod** — restores 1.8-style combat mechanics.
- **Rust JNI AI** — `behavior_statetree` NPC AI compiled to a cdylib and bundled via Loom.
- **Agones Fleet** — scheduled and scaled as an Agones GameServer fleet.

### Mod Stack

| Mod | Purpose |
|-----|---------|
| Fabric API | Required dependency |
| C2ME | Concurrent chunk management |
| VMP | Very many players optimization |
| Lithium | General server optimization |
| FerriteCore | Memory usage optimization |
| ServerCore | Server-side performance tweaks |
| Chunky | Chunk pre-generation |
| Old Combat Mod | 1.8-style combat mechanics |
| behavior_statetree | Rust/Tokio NPC AI via JNI |

### Architecture

```
Rust cdylib (behavior_statetree)
    └─► Gradle/Fabric Loom bundles .so into JAR
         └─► Docker multi-stage build
              └─► itzg/minecraft-server:java21
                   └─► Agones Fleet (arc-runners namespace)
```

## FAQ

**What is the KBVE Minecraft server?**
A Fabric Minecraft 1.21.11 dedicated server deployed via Agones on Kubernetes,
bundling performance mods, an Old Combat Mod, and a Rust JNI behavior-tree AI plugin.

**What is the behavior_statetree mod?**
A Rust/Tokio NPC AI mod compiled to a cdylib and bundled into the server JAR via
Gradle/Fabric Loom and a Docker multi-stage build, driving NPC behavior over JNI.

**Which performance mods are included?**
The stack includes Fabric API, C2ME, VMP, Lithium, FerriteCore, ServerCore, and
Chunky for chunk management, memory, and general server optimization.

## Related

- [Agones Factorio](/docs/project/agones-factorio) — sibling Agones dedicated server.
- [Agones](/docs/project/agones) — the game-server orchestration platform.
- [behavior_statetree](https://github.com/KBVE/kbve/tree/main/apps/mc/behavior_statetree) — Rust AI mod source.

---
# Minecraft Lobby — PaperMC Landing and Fallback Server

> PaperMC 1.21.11 lobby server — default landing target and fallback for the KBVE MC Velocity proxy, running a superflat peaceful world with minimal plugins.

Source: https://kbve.com/project/mc-lobby/

## Overview

PaperMC-based lobby server that sits alongside the [Fabric survival backend](/project/mc/) in the KBVE MC stack. It's the first server new players land on when they connect, and the fallback when the Fabric backend disconnects unexpectedly — instead of getting kicked, players get moved here until Fabric comes back.

The world is a vanilla **superflat** preset (bedrock + 2 dirt + grass, plains biome, no structures, no mob spawning) with `DIFFICULTY=peaceful` so there's zero combat. Nether and End dimensions are disabled (`ALLOW_NETHER=false`, `ALLOW_END=false`) — portals stay inert and `/execute in` commands targeting those dimensions fail, keeping all activity on the overworld. No custom spawn structures are baked in — admins build with WorldEdit after first boot, then lock the spawn point in with `/setspawn`.

### Plugin Stack

| Plugin | Purpose |
|---|---|
| LuckPerms | Cross-server permission sync via the pluginmsg channel (same wire format as Fabric + Velocity). |
| EssentialsX | Core `/sethome`, `/tpa`, `/back`, kit system. Required base dependency for every EssentialsX addon below. |
| EssentialsX-Spawn | `/spawn`, `/setspawn`, spawn-on-join. Separate addon JAR — the `/spawn` command lives here, not in the core EssentialsX jar. |
| EssentialsXAntiBuild | Blocks build/break/interact for non-permissioned players — grief-proofs the lobby by default. |
| WorldEdit | Admin building tool; same version line as Fabric for consistency. |
| AdvancedPortals | Physical portal regions that fire proxy commands on player entry. Lets us place decorative portals that teleport players to other backends via the [Velocity command plugin](/project/mc-velocity/). |

### Architecture

```
itzg/minecraft-server:java25
    └─► TYPE=PAPER, VERSION=1.21.11
         └─► Superflat peaceful world (LEVEL_TYPE=minecraft:flat)
              └─► Paper native Velocity forwarding (paper-global.yml secret)
                   └─► Kubernetes Deployment (1 replica, Recreate strategy)
                        └─► ClusterIP Service: mc-lobby-backend
                             └─► Registered with Velocity as `lobby`
```

### Velocity Integration

The Velocity proxy (see [mc-velocity](/project/mc-velocity/)) has the lobby as its default `try` target:

```toml
[servers]
lobby = "mc-lobby-backend.arc-runners.svc.cluster.local:25565"
mc = "mc-fabric-backend.arc-runners.svc.cluster.local:25565"
try = ["lobby", "mc"]
```

Combined with `failover-on-unexpected-server-disconnect = true` in the Velocity advanced section, this means players on `mc` who get disconnected (fleet restart, pod recycle, Fabric crash) are automatically sent back to the lobby instead of getting kicked to their client disconnect screen.

## FAQ

**What is the MC Lobby server?**
It is a PaperMC 1.21.11 lobby server in the KBVE Minecraft stack. It is the first
server new players land on and the fallback when the Fabric survival backend
disconnects, so players are moved here instead of being kicked until Fabric
returns.

**What kind of world does the lobby run?**
A vanilla superflat preset (bedrock plus two dirt and grass, plains biome, no
structures, no mob spawning) with `DIFFICULTY=peaceful` for zero combat. The
Nether and End are disabled, keeping all activity on the overworld.

**How does the lobby integrate with the Velocity proxy?**
The Velocity proxy lists the lobby as its default `try` target and uses
`failover-on-unexpected-server-disconnect`, so players disconnected from the `mc`
backend are automatically routed back to the lobby rather than kicked to the
disconnect screen.

## Related

- [mc (Fabric survival backend)](/project/mc/)
- [mc-velocity (custom Velocity proxy + command plugin)](/project/mc-velocity/)

---
# Minecraft Velocity Proxy — Kotlin Plugins

> Custom Velocity 3.4 proxy image with Kotlin plugins for cross-server teleport aliases, chat bridging, last-server persistence, and a Discord chat relay.

Source: https://kbve.com/project/mc-velocity/

## Overview

Custom Velocity proxy image that replaces the generic `itzg/bungeecord:latest` used previously. Same itzg runtime under the hood, but with two pre-baked Kotlin plugins built from source:

- **`kbve-velocity-commands`** (`apps/mc/velocity/plugin/`) — teleport aliases, cross-server chat bridge, last-server persistence.
- **`kbve-discord-relay`** (`apps/mc/velocity/plugin-discord/`) — Discord ↔ MC chat relay with prefix routing, reply context, and role-gated console commands.

The two plugins are independent (no source-level dependency, separate `@Plugin` IDs, separate version numbers) so they can be enabled, disabled, and rolled back independently. They ship together in the same image because they target the same Velocity proxy and need the same JDK/runtime stage.

### 1. Teleport command aliases

Brigadier commands that wrap `Player.createConnectionRequest(server).fireAndForget()`:

| Command | Target |
|---|---|
| `/lobby`, `/hub` | `lobby` backend (PaperMC lobby) |
| `/mc`, `/survival` | `mc` backend (Fabric survival) |

Hardcoded aliases for v1. A config file for dynamic aliases is v2 scope. No-permission — any player can use them in v1; LuckPerms nodes like `kbve.lobby` can be added later.

### 2. Cross-server chat bridge

Listens to `PlayerChatEvent` on Velocity. Per-player chat mode stored in an in-memory `ConcurrentHashMap<UUID, ChatMode>`, toggled via `/chat`:

| Command | Behavior |
|---|---|
| `/chat` | Shows current mode (default `global`) |
| `/chat local` | Messages stay on source server |
| `/chat global` | Messages broadcast to every backend with a server-tagged prefix |

**Local mode:** the plugin doesn't touch the event. Vanilla MC chat (`<player> message`) flows through with signed-chat verification + backend chat-filter pipeline intact, visible only to same-server players. The absence of a tag is the local indicator.

**Global mode:** the plugin denies the original `PlayerChatEvent` and re-emits a formatted `Component` to every player on every backend:

```
[Lobby] fudster: hi
[Survival] fudster: hi
```

- `[`, `]`, `:` → dark gray (visual gutter)
- `Lobby` → dark aqua, `Survival` → dark green (no yellow)
- Player name + body → white (default chat color)

Tradeoff: signed-chat verification is bypassed for global only — the message reaches recipients as a system component, not signed chat. Local chat keeps full signing.

Session-scoped — the chat-mode map resets when the Velocity pod restarts. Persistent storage is v2 scope.

### 3. Last-server persistence

Tracks the last server a player was connected to via `ServerConnectedEvent` and restores it on `PlayerChooseInitialServerEvent` when they reconnect. Falls back to Velocity's normal `try` list (which starts with lobby) if the stored server is missing or offline.

In-memory only for v1 — survives player disconnect/reconnect cycles within a single Velocity pod lifetime, not across pod restarts.

## `kbve-discord-relay`

Bridges in-game chat into a single Discord channel and routes Discord messages back into the network. Standalone Velocity plugin — no DiscordSRV, no source dependency on `kbve-velocity-commands`. JDA 5 is bundled directly into the plugin's fat jar.

**Outbound (MC → Discord):** every player chat message — `LOCAL` or `GLOBAL` — is posted to a webhook the bot self-provisions on startup (`kbve-mc-relay`, created via `MANAGE_WEBHOOKS`). The webhook `username` is set to `<player> [L]` or `<player> [S]` so each message renders as the player and Discord readers can see which backend it came from. Mode-independent on purpose: `/chat local` still appears in Discord with the `[L]`/`[S]` tag — the mode only affects whether the in-game cross-server bridge in `kbve-velocity-commands` fires.

**Inbound (Discord → MC):** the bot listens to the configured channel and parses prefixes:

| Discord input | In-game effect |
|---|---|
| `hi everyone` | Broadcast to all servers |
| `>lobby hello` / `>hub hello` | Lobby only |
| `>mc hello` / `>survival hello` | Survival only |
| reply to a `[L]` webhook message | Lobby only (server inferred from the referenced message's author tag) |
| reply to an `[S]` webhook message | Survival only |

**Public commands** (no role gate): `>who` / `>list`, `>servers`, `>help`.

**Staff commands** (gated by Discord role IDs `733334418747555918` or `647866541790068746`, override via `DISCORD_CMD_ROLES`): `>cmd <command>` runs on the Velocity console; `>kick <player> [reason]`, `>ban`, `>mute` are sugar over `>cmd`; `>tell <player> <msg>` DMs a single player; `>say <msg>` posts a network-wide staff announcement. Unauthorized callers are silently dropped (no reaction, no reply) so unprivileged users can't enumerate the gated command set, with every attempt audit-logged at INFO.

**Configuration:**

| Env var | Purpose |
|---|---|
| `DISCORD_BOT_TOKEN` | JDA bot login (sealed in `mc-discord-relay` Secret) |
| `DISCORD_CHANNEL_ID` | Channel the bot listens to and posts into (default `1501071171804991651`) |
| `DISCORD_CMD_ROLES` | Optional CSV override of authorized role IDs |

If `DISCORD_BOT_TOKEN` is unset (e.g. the e2e container test) the plugin logs a single line and stays inert; `kbve-velocity-commands` continues working.

## Build

Multi-stage Dockerfile:

```
Stage 1: gradle:jdk21
    └─► Gradle shadowJar → kbve-velocity-commands-<version>.jar
Stage 2: gradle:jdk21
    └─► Gradle shadowJar → kbve-discord-relay-<version>.jar (bundles JDA 5)
Stage 3: itzg/bungeecord:latest
    └─► COPY both JARs into /plugins/
         └─► itzg auto-loads everything in /plugins/ at Velocity boot
              └─► LuckPerms-Velocity also downloaded via PLUGINS env var
```

Both plugins use Velocity API 3.4.0-SNAPSHOT, Kotlin 2.0.21, KAPT for `@Plugin` annotation processing, and JDK 21.

## FAQ

**What is the KBVE Minecraft Velocity proxy?**
A custom Velocity 3.4 proxy image that replaces the generic `itzg/bungeecord`
base and ships two pre-baked Kotlin plugins — `kbve-velocity-commands` and
`kbve-discord-relay` — built from source.

**What do the two plugins do?**
`kbve-velocity-commands` adds teleport aliases, a cross-server chat bridge, and
last-server persistence, while `kbve-discord-relay` bridges in-game chat to and
from a Discord channel with role-gated console commands.

**Are the plugins coupled?**
No. They have separate `@Plugin` IDs, versions, and no source dependency, so they
can be enabled, disabled, and rolled back independently even though they ship in
the same image.

## Related

- [mc (Fabric survival backend)](/docs/project/mc)
- [mc-lobby (PaperMC lobby)](/docs/project/mc-lobby)
- [kbve-velocity-commands source](https://github.com/KBVE/kbve/tree/main/apps/mc/velocity/plugin)
- [kbve-discord-relay source](https://github.com/KBVE/kbve/tree/main/apps/mc/velocity/plugin-discord)

---
# Memes — meme.sh Axum + Astro Web Service on Kubernetes

> Memes is the KBVE web service behind meme.sh, built from an axum + Askama Rust backend and an Astro static frontend, packaged as kbve/memes on a Cilium gateway.

Source: https://kbve.com/project/memes/

## Overview

Memes application service serving [meme.sh](https://meme.sh) and `www.meme.sh`. Built from `apps/memes/axum-memes` (Rust backend + Askama templates) plus the `apps/memes/astro-memes` static frontend, packaged into the `kbve/memes` image. Deployment lives at [apps/kube/memes/manifest/](apps/kube/memes/manifest/).

## Routing

Public traffic enters via Cloudflare → CNAME to `gateway.kbve.com` → `142.132.206.71` (Cilium gateway LB) → [`kbve-gateway`](apps/kube/kbve/manifest/kbve-gateway.yaml) `https-memes` listener (hostname `meme.sh`, cert `memes-tls` covers both `meme.sh` and `www.meme.sh` via SAN) → [`memes-route`](apps/kube/memes/manifest/httproute.yaml) (spec.hostnames = `[meme.sh, www.meme.sh]`) → `memes-service:4321`.

The cert lives in `memes/memes-tls` and is consumed cross-namespace by `kbve-gateway` via [`memes-tls-from-kbve-gateway` ReferenceGrant](apps/kube/memes/manifest/memes-refgrant.yaml).

## TLS / certificate

[`memes-cert`](apps/kube/memes/manifest/memes-cert.yaml) is **RSA 2048**, issued by the `letsencrypt-http` ClusterIssuer (HTTP-01). The algorithm matches the cert already in `memes-tls`; do not change to ECDSA without first verifying that the ACME HTTP-01 challenge path on Cilium gateway is healthy (see runbook below) — otherwise cert-manager flags `IncorrectCertificate` and queues a reissue that can never complete.

## Cilium gateway gotcha — never split apex + www across listeners with one cert

The original setup had two listeners (`https-memes` for `meme.sh`, `https-memes-www` for `www.meme.sh`) both pointing at the same `memes-tls` Secret. Cilium derives the Envoy filter chain SNI list from the **cert SAN** (not the listener `hostname`), so each listener emitted a filter chain with the same SNI array `[meme.sh, www.meme.sh]`. Envoy rejects duplicate filter chain match → falls through to the default 404 handler → 73 days of `meme.sh` returning nginx-style 404s while `kubectl get gateway` reported `Programmed=True / Accepted=True / ResolvedRefs=True` and the `memes-service` cluster sat healthy with zero `cx_total`.

A second-order victim was ACME HTTP-01 — `cm-acme-http-solver-*` HTTPRoutes share the same listener, so the cert reissue loop also couldn't complete (`Ready=False, Reason=IncorrectCertificate`).

**Rule for this gateway:** if one cert covers multiple SANs, use **one listener** with the apex hostname and let the HTTPRoute `spec.hostnames` enumerate every hostname the route serves. If you need per-host listeners, issue one cert per hostname so the SNI lists don't collide.

## Runbook — meme.sh returns 404

1. Confirm origin is the actual culprit (not Cloudflare): `curl -s https://meme.sh/ | head` — an `nginx`-flavored 404 body means the request reached origin and the gateway returned it.
2. Compare against a sibling host on the same gateway, e.g. `curl -sk --resolve kbve.com:443:142.132.206.71 -H 'Host: kbve.com' https://kbve.com/` — if that's 200, the gateway is healthy and the breakage is memes-specific.
3. Dump the Envoy filter chains and look for two with overlapping SNI arrays: `kubectl exec -n kube-system <cilium-pod> -- cilium-dbg envoy admin config | jq '.. | objects | select(.filter_chains) | .filter_chains[] | select(.filter_chain_match.server_names[]? | contains("meme")) | .filter_chain_match.server_names'` — if you see the SAN list duplicated across two chains, the listener split is the bug.
4. Collapse to one listener (this PR's fix), reapply via ArgoCD, and `kubectl rollout restart -n kube-system ds/cilium-envoy` to flush the stale filter chains.
5. The stuck `cm-acme-http-solver-*` HTTPRoutes drain automatically once the cert can validate; if they don't, `kubectl delete httproute -l acme.cert-manager.io/http01-solver -n memes` to force cert-manager to recreate fresh ones.
6. Re-curl `meme.sh` — should return 200.

## FAQ

**What is the Memes application?**
Memes is the KBVE web service serving meme.sh and www.meme.sh. It is built from
`apps/memes/axum-memes` (a Rust backend with Askama templates) plus the
`apps/memes/astro-memes` static frontend, packaged into the `kbve/memes` image.

**How does traffic reach the Memes service?**
Public traffic enters via Cloudflare, CNAMEs to `gateway.kbve.com`, hits the
Cilium gateway LB, then the `kbve-gateway` `https-memes` listener (cert
`memes-tls` covering meme.sh and www.meme.sh), routes through `memes-route`, and
lands on `memes-service:4321`.

**Why should apex and www not be split across gateway listeners?**
Cilium derives the Envoy filter chain SNI list from the cert SAN, not the
listener hostname. Two listeners sharing one multi-SAN cert emit duplicate filter
chain matches, which Envoy rejects, causing a fall-through 404. Use one listener
with the apex hostname and let the HTTPRoute enumerate every hostname.

## Related

- [Firecracker Node Web](/docs/project/firecracker-node-web) — sibling Docker-pipeline service in the KBVE stack.

---
# Metrics — In-House Observability & Telemetry Platform

> Metrics is KBVE's in-house observability platform, a Rust/axum service ingesting client telemetry into a self-hosted ClickHouse database.

Source: https://kbve.com/project/metrics/

## Metrics — in-house observability

`apps/metrics` is a scoped Rust/Axum service that ingests client telemetry into a
self-hosted ClickHouse `telemetry` database. It replaces SaaS error/metrics tooling
(Sentry / Datadog / PostHog) with one pipeline that exposes three lenses — errors,
performance, and product — over a single wide table correlated by `session_id`.

### Pipeline

```
@kbve/observ (browser SDK)
   → POST metrics.kbve.com/api/v1/ingest/errors
      → apps/metrics (axum, port 5500)
         → jedi ClickHouseConfig::execute_insert (JSONEachRow, batched)
            → telemetry.errors_distributed
```

The ingest path reuses the shared `jedi` ClickHouse client — no new database
plumbing. A background tokio mpsc flusher batches rows by size and interval.
Requests are CORS-allowlisted, per-IP rate-limited, body-capped, and run through a
noise/PII sanitizer. Error grouping uses a `sha256(project + error_type + top-5
stack frames)` fingerprint. `/readiness` checks ClickHouse so a degraded backend
sheds load instead of silently 503ing.

### Client-agnostic

The `platform` field (`web` / `unreal` / `unity` / …) lets every client feed the
same pipe, so the errors lens shipped for the frontend extends to game clients
without schema changes.

### Deployment

Runs in the `kbve` namespace behind the Cilium Gateway at `metrics.kbve.com`,
reusing the existing `clickhouse-credentials` ExternalSecret. Schema setup is a
job in the `vector` namespace that creates the `telemetry` database, the
`errors_raw` / `errors_distributed` tables, and the `error_groups` view.

## FAQ

**What is the Metrics service?**
Metrics (`apps/metrics`) is KBVE's in-house observability platform, a scoped
Rust/axum service that ingests client telemetry into a self-hosted ClickHouse
`telemetry` database. It replaces SaaS tooling like Sentry, Datadog, and PostHog
with one pipeline exposing errors, performance, and product lenses over a single
wide table correlated by `session_id`.

**How does the Metrics ingest pipeline work?**
The browser SDK `@kbve/observ` POSTs to `metrics.kbve.com/api/v1/ingest`, the axum
service on port 5500 reuses the shared `jedi` ClickHouse client to batch
JSONEachRow inserts via a tokio mpsc flusher, and rows land in
`telemetry.errors_distributed`. Requests are CORS-allowlisted, rate-limited,
body-capped, and PII-sanitized.

**How is Metrics client-agnostic across web and game clients?**
A `platform` field (`web`, `unreal`, `unity`, and more) lets every client feed the
same pipe, so the errors lens built for the frontend extends to Unreal and Unity
game clients with no schema changes.

## Related

- [Jedi](/docs/project/jedi-crate) — the shared crate whose ClickHouse client Metrics reuses for inserts.
- [Unity RareIcon](/docs/project/unity-rareicon) — a game client that feeds telemetry into Metrics.

---
# Pirate Game Jam — KBVE Jam 17 and Jam 16 DevLog Notes

> KBVE Pirate Game Jam project notes — team structure, GDD format, assets, and devlog across Pirate Jam 17 planning and the Pirate Jam 16 Godot entry.

Source: https://kbve.com/project/pirate/

## Pirate 17

### Preamble

    The time has arrived for the next major gamejam!
    We can start the team structure and prepare the 5 man squad, ideally with a solid gameplan too.
    Before the jam starts, I think we should make sure everything is operational, including the GDD format and markdown components.

### UIUX

    Since we dont have a theme yet, this can be skipped for now.

#### Colors

    Just a placeholder for that part.

### Assets

    We will most likely use Azure to hold the assets but I am sure there might be a better way to handle this.

### DevLog

    The Pirate 17 devlog, oh boi.


## Pirate 16

### Preamble 16

    The Pirate 16 Game Jam theme is “You Are The Weapon” and now we are the gods.
    Turns out we had a bit of a different gameplan, ended up switching from Unity to Godot, so most of this turned out to be useless for this jam.

---

### UIUX 16

    Mock Buttons - [Rock Buttons From void1gaming](https://void1gaming.itch.io/pixel-buttons-2-rock-buttons)

#### Colors 16

    Main Green - `#00bf63`
    Main Brown - `#916a4f`

---

### Assets 16

    We will be using the [Corgi Engine with Unity](/application/unity/#corgi).

    For the base UI assets, we will grab some examples from [Itch](https://itch.io/game-assets/free/tag-unity/tag-user-interface).

    Trees were added from [Stylized Nature Mega Kit](https://quaternius.itch.io/stylized-nature-megakit)
    
    Note: We removed this -> Now going to try and add the [Ultimate Platformer Pack](https://quaternius.itch.io/ultimate-platformer-pack)

#### Environment 16

    End of the Game Portal from [the Gateway](https://painartio.itch.io/the-gateway).
    Might as well grab some kenny assets, the first will be the [survival kit](https://kenney.nl/assets/survival-kit)

---

### DevLog 16

    The Dev cycle of webgl and unity is always a pain!
    There are still some issues with the auto graphics that I will have to resolve on the macbook.
    01/18/2025 - 06:08AM - Updating the build configurations.
    01/18/2025 - 07:35AM - Still need to figure out the joysticks.

## FAQ

**What is the KBVE Pirate Game Jam project?**
It is the planning and devlog page for KBVE's Pirate game jams, covering team
structure, the GDD format, asset sourcing, and development logs. Pirate Jam 17 is in
preparation and Pirate Jam 16 was an entry themed "You Are The Weapon".

**Which engine did the Pirate Jam 16 entry use?**
Pirate Jam 16 switched from Unity to Godot mid-jam, so most of the earlier
Unity-based planning for that jam went unused.

## Related

- [AR](/project/ar/) — another KBVE interactive-media research project.

---
# Python KBVE — Async API Layer for HTTP, WebSocket, and gRPC

> The kbve Python library is an API layer for async HTTP, WebSocket, gRPC, and broadcasting, with optional sprite, OSRS, and SEO tooling extras.

Source: https://kbve.com/project/python-kbve/

## Overview

The `kbve` Python library is an API layer and complexity handler for async HTTP, WebSocket, gRPC, and broadcasting. It provides the shared core that other KBVE Python packages (such as Fudster) build on, plus opt-in tooling for ARPG sprite baking, OSRS item-corpus analysis, and whole-site SEO/SEM auditing.

## Key facts

| | |
|---|---|
| **Package** | `python-kbve` (PyPI `kbve`) |
| **Version** | 1.0.13 |
| **Language** | Python `>=3.12,<3.14` |
| **License** | MIT |
| **Source** | [`packages/python/kbve`](https://github.com/KBVE/kbve/tree/main/packages/python/kbve) |
| **Core deps** | pydantic, aiohttp, fastapi, uvicorn, grpcio, protobuf |

## Features

- **Async API core** — modules spanning `api`, `grpc`, `proto`, `server`, and `health` for HTTP, WebSocket, gRPC, and broadcasting.
- **Sprite toolchain** *(extra `sprite`)* — `kbve.sprite.*` scripts (skin-variant, sprite-postprocess, ship-footprint) for ARPG sprite baking; adds Pillow and numpy.
- **OSRS corpus tooling** *(extra `osrs`)* — `kbve.osrs.*` survey/audit/family scripts for the OSRS item pages, including canonical-page collapse and the axum-kbve 301 table.
- **SEO/SEM auditor** *(extra `seo`)* — `kbve.seo.*` static frontmatter and MDX analysis for the whole site.

## Usage

```bash
pip install kbve

# development inside the KBVE monorepo
pnpm nx test python-kbve
pnpm nx lint python-kbve
pnpm nx build python-kbve
```

## FAQ

**What is the kbve Python library?**
`kbve` is an API layer and complexity handler for async HTTP, WebSocket, gRPC, and broadcasting. It provides the core modules that packages like Fudster build on, spanning `api`, `grpc`, `proto`, `server`, and `health`.

**How do I install the kbve Python package?**
Install it from PyPI with `pip install kbve`. It requires Python 3.12 or newer and depends on pydantic, aiohttp, fastapi, uvicorn, grpcio, and protobuf.

**What optional extras does kbve provide?**
`kbve` ships opt-in extras kept off the core install — `sprite` for the ARPG sprite-baking toolchain (Pillow, numpy), `osrs` for OSRS item-corpus analysis, and `seo` for the whole-site SEO/SEM auditor — each enabled with `uv sync --extra`.

## Related

- [Fudster](/project/fudster) — composable ML library built on top of this `kbve` core.

---
# q — Godot GDExtension Game Crate with Server Flavor

> Q is a Rust crate powering KBVE games — a Godot GDExtension client with a tokio game manager, plus a bevy + axum + rapier2d server flavor.

Source: https://kbve.com/project/q-crate/

## Overview

`q` is a Rust crate powering KBVE games. Its default build is a
[Godot](https://godotengine.org/) GDExtension (`cdylib`) with a tokio-backed
game manager; feature flags expose a parallel server flavor built on
[Bevy](https://bevyengine.org/), [Axum](https://github.com/tokio-rs/axum), and
`rapier2d`, along with per-game bundles.

## Key facts

| | |
|---|---|
| **Package** | `q` |
| **Version** | 0.1.1 |
| **Language** | Rust (edition 2024) |
| **License** | MIT |
| **Source** | [`packages/rust/q`](https://github.com/KBVE/kbve/tree/main/packages/rust/q) |
| **Crate types** | `cdylib` (GDExtension), `rlib` (library) |

## Features

- **Client flavor** — Godot GDExtension with dashmap, crossbeam, bitflags, and a tokio runtime; the `default` build.
- **Server flavor** — headless Bevy ECS driven from a tokio task, mutually exclusive with `client`.
- **Protocol** — postcard wire format plus bincode snapshot framing (`proto-shared`, `proto-client`, `proto-server`).
- **Physics** — `rapier2d` for spatial queries (client) and authoritative sim step (server).
- **Networking** — WS client for the Godot extension, Axum for the server (`net-client` / `net-server`).
- **Supabase auth** — server-side HS256 JWT verification to admit players.
- **Game bundles** — `nexus-defense` / `nexus-defense-server` roll up the features per game.

## FAQ

**What is the q crate?**
Q is a Rust crate powering KBVE games. Its default build is a Godot GDExtension
(`cdylib`) with a tokio-backed game manager, and feature flags expose a parallel
server flavor built on bevy, axum, and rapier2d.

**Can q be built as both a client and a server?**
Yes, but not at once. The `client` and `server` features are mutually exclusive
— enforced by a `compile_error!` in `lib.rs` — so a build is either the Godot
GDExtension client or the headless server flavor.

**What game bundles does the q crate provide?**
Feature rollups such as `nexus-defense` and `nexus-defense-server` bundle
protocol, physics, networking, and (server-side) bevy ECS plus Supabase JWT auth
and shared mapdb/npc registries, so build pipelines can select a whole game
flavor with one feature.

## Related

- [KBVE Crate](/docs/project/kbve-crate) — the core Axum + Diesel backend crate.
- [Unity RareIcon](/docs/project/unity-rareicon) — a KBVE game project in the same ecosystem.

---
# RareIcon — 2D Sci-Fi Action-RPG Bullet-Hell Roguelite

> RareIcon is a 2D pixel-art sci-fi action RPG where you hunt AI-generated rare icons across galactic worlds, backed by an axum game API on Agones.

Source: https://kbve.com/project/rareicon/

## Introduction

Welcome to RareIcon.com - A Galactic Quest for the Digital Age

Embark on an extraordinary journey with **RareIcon.com**, a 2D RPG set in the vast expanse of the future universe.
Drawing inspiration from iconic classics like Zelda and Pokemon Red/Blue, RareIcon.com combines nostalgic pixel art with cutting-edge machine learning to deliver a unique gaming experience.
As a player, your mission is to traverse diverse galactic environments in search of rare icons, each crafted by the game's own AI.

## Key facts

| | |
|---|---|
| **Game API** | `axum-rareicon` |
| **Version** | 0.1.3 |
| **Genre** | 2D sci-fi action-RPG bullet-hell roguelite |
| **Client engine** | Unity (DOTS/ECS) |
| **Backend** | Rust (axum), image `kbve/rareicon` |
| **Deploy** | Agones stack |
| **Source** | [`apps/rareicon/axum-rareicon`](https://github.com/KBVE/kbve/tree/main/apps/rareicon/axum-rareicon) |

## Game Overview

### The Quest

In the future, icons are not just symbols; they are powerful artifacts that hold the keys to understanding forgotten digital realms.
These icons are scattered across the universe, hidden on distant planets and guarded by challenging puzzles and formidable foes.
Your quest is to collect these icons, unlocking the secrets of the universe as you go.

### Unique Worlds

Explore a variety of planets, each rendered in charming pixel art yet boasting its own distinct ecosystem, culture, and challenges.
From the frozen tundras of a remote ice planet to the lush jungles of an alien world teeming with life, the diversity of environments will provide endless exploration and excitement.

### Icon Generation

At the heart of RareIcon.com is its revolutionary use of machine learning to generate icons.
This technology ensures that no two icons are the same, offering a truly unique collectible in every gameplay session.
Players can influence icon attributes through their choices and interactions within the game, making each icon not just rare but also deeply personal.

## Game Features

-   **Pixelated Graphics**: Relive the glory of the Gameboy era with graphics that bring a sense of nostalgia and simplicity, allowing you to focus on strategy and storytelling.
-   **Machine Learning Integration**: Experience the thrill of discovering one-of-a-kind icons generated by sophisticated AI, making every game playthrough unique.
-   **Dynamic Storylines**: Your decisions matter. The choices you make will influence the game's narrative, leading to different endings and interactions with characters and environments.
-   **Multiplayer Elements**: Connect with other players to trade icons, share tips, and compete or cooperate in special multiplayer zones.
-   **Regular Updates**: The universe of RareIcon.com is ever-expanding, with regular updates that add new planets, icons, and story arcs to explore.

## Join the Adventure

RareIcon.com is more than a game; it's a community of adventurers drawn together by the allure of the unknown and the thrill of discovery.
Whether you're a veteran gamer nostalgic for the pixelated games of yesteryear or a newcomer excited by the possibilities of AI-generated content, RareIcon.com offers a universe of fun and exploration.

Prepare your spaceship, ready your equipment, and set course for the stars—the hunt for rare icons is about to begin!

_Embark on your quest at RareIcon.com — where every icon tells a story, and every story spans the galaxy._

## DevLog

#### v0.1

Preparing the healing but added Chip with basic animations!
Updating the title scene, most of these starter dev logs will be a bit useless because we are still learning.
Making sure that the new build is fine.


#### v0.2

Remember to double check the weapon flips when adding them into the game.

#### v0.3

Added AI brain state switching depending on weapon pick up.
Triggering another build to grab the worker url location.
Multi thread deployment did not work, now testing the shader loading and unloading.
Added blueprint build system and now testing the VContainer, next patch is ready to be tested.
Next build test with the new items + javascript bridge test, also making sure that the steamworks does not break the imports.
Build might have failed because of the link.xml that was added in my accident, lets just run it back without those files.
Added additional tags around the scripts, trying the build process again, windows works but webgl does not, trying to add more guards?
Okay, so the additional guards were not the issue, but maybe we need to have nested wrappers, that is my next move.
Still having that build failure, decided to split the extension for the steam, maybe that might help resolve it.

#### v0.4.0

This is a test build of the supabase integration, making sure that we can see the first failpoint during the remote build process.

#### v0.4.1

Upgraded the unity version to 6000.2.6f2, to resolve the unity cve issue.

## FAQ

**What is RareIcon?**
RareIcon is a 2D sci-fi action-RPG set in a future universe, drawing on classics
like Zelda and Pokemon Red/Blue. Players traverse pixel-art galactic worlds hunting
rare icons, each generated by the game's machine-learning system so no two are
alike.

**What makes RareIcon's icons unique?**
Icons are generated with machine learning, so every playthrough yields
one-of-a-kind collectibles. Player choices and interactions influence icon
attributes, making each icon both rare and personal.

**What technology powers RareIcon?**
The RareIcon game API is `axum-rareicon`, a Rust axum service shipped as the
`kbve/rareicon` image and deployed on the Agones stack. The Unity client uses
DOTS/ECS, with a Supabase integration and Steamworks in the build pipeline.

## Related

- [ARPG Server](/docs/project/arpg-server) — another KBVE Agones-hosted game backend.
- [Cryptothrone](/docs/project/cryptothrone) — a sibling KBVE isometric game project.

---
# ROWS — Single-Binary Rust Open World Server (REST + gRPC)

> ROWS (Rust OWS) is a single-binary Rust game backend combining REST and gRPC, replacing the multi-service .NET OWS stack with one multi-tenant service.

Source: https://kbve.com/project/rows/

import { Aside } from '@astrojs/starlight/components';

## ROWS — Rust Open World Server

ROWS is a single-binary Rust reimplementation of the OWS (Open World Server) game backend. It consolidates the five .NET microservices (PublicAPI, InstanceManagement, CharacterPersistence, GlobalData, Management) into one unified service with both REST and gRPC interfaces.

### Architecture

- **REST API** (Axum) — player-facing endpoints: login, registration, character CRUD, zone connections
- **gRPC** (Tonic) — internal service-to-service communication and UE5 dedicated server coordination
- **RabbitMQ** — async job queue for instance lifecycle events (spin-up, shutdown, health checks)
- **PostgreSQL** — persistent storage for accounts, characters, abilities, world state
- **ValKey** — session cache and ephemeral game state
- **Agones** — game server fleet management for UE5 dedicated server instances

### Endpoints

| Group | Path Prefix | Description |
|-------|------------|-------------|
| Auth | `/api/users/*` | Login, register, session management |
| Characters | `/api/characters/*` | Character CRUD, class selection |
| Zones | `/api/zones/*` | Zone listing, server-to-connect-to |
| Instance | `/api/instance/*` | Server instance lifecycle |
| Global | `/api/global/*` | Key/value world state |
| Health | `/health`, `/ready` | Liveness and readiness probes |
| gRPC | Port 4322 (multiplexed) | Internal service mesh |

<Aside type="tip" title="Production">
    ROWS is the production game backend. The legacy .NET OWS microservices have been fully
    removed — all ChuckRPG traffic routes exclusively to ROWS via the per-environment hosts
    `api-dev.chuckrpg.com`, `api-beta.chuckrpg.com`, and `api-prod.chuckrpg.com`.
</Aside>

### Deployment

ROWS deploys as a single Docker image (`ghcr.io/kbve/rows`). ArgoCD syncs the manifest from `apps/kube/rows/manifest/rows-deployment.yaml` with auto-prune and self-heal enabled.

The container exposes:
- **Port 4322** — REST + gRPC multiplexed (Axum + Tonic on a single port)

#### Per-tenant deployment

Each game + environment is a **separate ROWS deployment** pinned to its own tenant via env. The config is loaded and validated once at boot (`RowsConfig::from_env`):

| Env | Purpose | Notes |
|-----|---------|-------|
| `OWS_API_KEY` | Tenant `customer_guid` (UUID) | **Required** for `beta`/`release`; `dev` falls back to an ephemeral guid with a warning |
| `OWS_TENANT_SLUG` | Human label (e.g. `chuckrpg-dev`) | Surfaced in logs, `DeploymentInfo`, and the Prometheus `service` label (`rows-<slug>`) |
| `OWS_ENV` | `dev` \| `beta` \| `release` | Drives the required-env guards |
| `AGONES_FLEET` | Per-tenant Agones fleet | **Required** for `beta`/`release`; the GameServer watcher filters by `agones.dev/fleet=<fleet>` |
| `AGONES_NAMESPACE` | Agones namespace | **Required** for `beta`/`release` |
| `SUPABASE_JWT_SECRET` / `SUPABASE_SERVICE_KEY_HASH` | Player + trusted-server auth | Optional; ROWS boots in legacy mode without them |

`GET /api/System/DeploymentInfo` echoes the active `tenant_slug`, `environment`, and `customer_guid` for verification.

<Aside type="note" title="Related">
    - Unreal client glue: [KBVEROWS plugin](/project/kbverows/)
    - Live operations: [ROWS dashboard](/dashboard/gameops/rows/)
</Aside>

---

### Authentication & Identity

ROWS has three distinct identities. They are different axes — do not conflate them.

| Identity | What it is | Source | How ROWS reads it |
|----------|-----------|--------|-------------------|
| **Tenant** (`customer_guid`) | A *game + environment* — e.g. `chuckrpg-dev`, `chuckrpg-beta`, `xy-release`. One fixed value per deployment. | `OWS_API_KEY` env (per-tenant secret) | `X-CustomerGUID` header, **enforced equal to the process tenant** |
| **Player** (`userguid`) | A *person*. | Supabase UUID (`sub`) | Supabase JWT, or a session GUID minted from it |
| **Trusted server** | The UE dedicated server / Iris instances. | Service key | `x-service-key` header, argon2-verified against `SUPABASE_SERVICE_KEY_HASH` |

**The tenant is not the player.** `customer_guid` partitions every table (users, characters, zones, world servers, maps). Within one tenant, all players and all UE instances share that `customer_guid` so they inhabit the same world — multiple Iris instances are just rows in `worldservers` / `mapinstances` under that tenant. The player is identified by their Supabase UUID, which becomes the OWS `userguid`.

**Multi-tenant by deployment, single-tenant by process.** ROWS runs **one process per tenant** (game + environment); each deployment pins its `customer_guid` from `OWS_API_KEY` at boot. The Postgres DB is shared across tenants and isolated only by the `customerguid` column, so the `require_customer_guid` middleware rejects (`403`) any request whose `X-CustomerGUID` differs from the process tenant — a client cannot reach another game's rows by swapping the header. gRPC, WebSocket, MQ consumers, and background jobs always use the process tenant directly.

**Player login.** The client signs in via Supabase (GoTrue) and posts the JWT to `ExternalLoginAndCreateSession`. ROWS validates it (HS256, `SUPABASE_JWT_SECRET`), keys the OWS user on the Supabase `sub`, and returns a `UserSessionGUID`. The UE client glue lives in the `ROWSupabase` module of the `KBVESupabase` plugin.

**Gates.**
- **World IP** (`GetServerToConnectTo` / `JoinMap`) requires a confirmed login — a Supabase bearer JWT *or* a live session GUID — and verifies the caller owns the requested character before returning a server address.
- **Server-write endpoints** (position/stats/logout, zone status, launcher register, spin-up/down) require a valid **service key**; player credentials do not pass. The dedicated server loads the key from `OWS_SERVICE_KEY` only on `IsRunningDedicatedServer()`, so it never enters a client build, and talks to ROWS in-cluster over the ClusterIP — the key never crosses the public internet.

`SUPABASE_SERVICE_KEY_HASH` (rows) and the plaintext `OWS_SERVICE_KEY` (fleet) both derive from the one kilobase secret `supabase-service-key` (`hash` + `key`). The GoTrue `customer_guid` JWT claim is intentionally unused — tenant identity comes from the process config (`OWS_API_KEY`), never from the token.

kube:
    stack: application
    environment: beta
    tier: api
    owner: h0lybyte
    criticality: low
---

### Procedural World — Seed-Based Multi-Zone Architecture

<Aside type="caution" title="Roadmap">
    This section describes the planned seed-based procedural world system.
    Current deployment uses single-zone with `ServerDefaultMap=Lvl_ThirdPerson`.
</Aside>

#### Overview

Each game zone is a procedurally generated region driven by a deterministic **seed**. The same seed always produces identical terrain, foliage, and spawn layouts. This enables:

- **One map, many worlds** — a single `Lvl_Procedural` map generates different zones from different seeds
- **Elastic scaling** — any server pod can host any zone, just give it a seed
- **Crash recovery** — replace a dead server, give it the same seed, world is identical
- **Discovery** — new zones are just new seeds, no additional map packaging required

#### Data Model

The `maps` table gains a `seed` column:

```sql
ALTER TABLE ows.maps ADD COLUMN seed BIGINT DEFAULT 0;

-- Example zones
INSERT INTO maps (customerguid, mapname, zonename, seed) VALUES
  ('83d88046-...', 'Lvl_Procedural', 'Grassland',    0xA1B2C3D4),
  ('83d88046-...', 'Lvl_Procedural', 'Arctic',       0xDEAD0002),
  ('83d88046-...', 'Lvl_Procedural', 'Desert',       0xCAFE0003),
  ('83d88046-...', 'Lvl_Procedural', 'Marshlands',   0xBEEF0004),
  ('83d88046-...', 'Lvl_PvPArena',   'PvPArena',     0);  -- static map, no seed
```

#### ROWS Flow

```
1. Player → GetServerToConnectTo(zoneName: "Arctic")
2. ROWS → Agones allocate → server starts on Entry
3. ROWS → GetZoneAssignment returns:
   {
     "assigned": true,
     "mapName": "Lvl_Procedural",
     "zoneName": "Arctic",
     "seed": 3735552002,
     "zoneInstanceId": 42
   }
4. Server → ServerTravel("/Game/Procedural/Lvl_Procedural?listen?seed=3735552002")
5. Lvl_Procedural BeginPlay → reads seed → PCG generates Arctic biome
6. Server reports ready → players connect to deterministic world
```

#### UE5 Integration

**PCG (Procedural Content Generation) Framework:**

| Layer | Driven By | Examples |
|-------|-----------|----------|
| Terrain heightmap | Seed + biome type | Mountain ranges, valleys, coastlines |
| Biome selection | Seed bits [0:7] | Grassland, Arctic, Desert, Marshland, Tropic |
| Foliage placement | Seed + density rules | Trees, bushes, grass patches |
| Resource nodes | Seed + spawn tables | Ore veins, herb clusters, fishing spots |
| Mob spawns | Seed + difficulty curve | Creature type, patrol routes, density |
| Landmarks | Fixed coordinates | Towns, dungeons, POIs (handcrafted, placed at deterministic positions) |
| Weather | Seed + time-of-day | Rain cycles, fog density, wind patterns |

**Hybrid approach:**
- **Handcrafted landmarks** are pre-built actors placed at coordinates derived from the seed
- **Procedural fill** generates the terrain and natural environment between landmarks
- **Biome blending** uses seed-derived Voronoi regions for smooth transitions

**GameMode seed consumption:**
```cpp
// In Lvl_Procedural's GameMode BeginPlay
FString SeedStr = UGameplayStatics::ParseOption(OptionsString, TEXT("seed"));
int64 Seed = FCString::Atoi64(*SeedStr);
FRandomStream WorldRNG(Seed);

// Feed to PCG subsystem
UPCGSubsystem* PCG = GetWorld()->GetSubsystem<UPCGSubsystem>();
PCG->SetGlobalSeed(Seed);
```

#### Zone Travel

Players move between zones via **zone portals** or **world map travel**:

```
Player enters Arctic→Desert portal
  → Client calls SetSelectedCharacterAndGetUserSession
  → Client calls GetServerToConnectTo(zoneName: "Desert")
  → ROWS finds/allocates Desert server (seed: 0xCAFE0003)
  → Client disconnects from Arctic, connects to Desert
  → Character position saved on Arctic, loaded on Desert
```

#### Seed Registry

Seeds can be:
- **Static** — admin-created zones with curated seeds (main world regions)
- **Dynamic** — player-triggered instanced content (dungeons, events) with random seeds
- **Seasonal** — time-limited zones that rotate seeds periodically

```
GET /api/System/SeedRegistry
{
  "zones": [
    { "zoneName": "Grassland",  "seed": 2712847316, "type": "static",  "biome": "grassland" },
    { "zoneName": "Arctic",     "seed": 3735552002, "type": "static",  "biome": "arctic" },
    { "zoneName": "Dungeon_42", "seed": 8827361024, "type": "dynamic", "biome": "cave",  "expires": "2026-04-01T00:00:00Z" }
  ]
}
```

#### Implementation Phases

| Phase | Scope | Dependencies |
|-------|-------|-------------|
| **Phase 1** | Add `seed` column to maps table, include in `GetZoneAssignment` response | dbmate migration |
| **Phase 2** | `Lvl_Procedural` map with basic PCG — terrain heightmap from seed | UE5 PCG framework |
| **Phase 3** | Biome system — seed bits select biome, PCG generates appropriate flora/fauna | Biome data tables |
| **Phase 4** | Handcrafted landmarks — POI actors placed at seed-derived coordinates | Level design |
| **Phase 5** | Zone portals — client-side travel between seed-based zones | OWS travel flow |
| **Phase 6** | Dynamic instances — player-triggered dungeons with random seeds | Instance lifecycle |
| **Phase 7** | Seed registry API — admin tools for zone management | Dashboard integration |

## FAQ

**What is ROWS?**
ROWS (Rust Open World Server) is a single-binary Rust reimplementation of the OWS game backend. It consolidates the five .NET microservices (PublicAPI, InstanceManagement, CharacterPersistence, GlobalData, Management) into one service exposing both REST (Axum) and gRPC (Tonic) on a single multiplexed port.

**How is ROWS multi-tenant?**
ROWS is multi-tenant by deployment but single-tenant by process — one process per game plus environment, pinning its `customer_guid` from `OWS_API_KEY` at boot. A shared Postgres DB is isolated by the `customerguid` column, and middleware rejects requests whose `X-CustomerGUID` differs from the process tenant.

**How does authentication work in ROWS?**
ROWS has three identities — tenant (`customer_guid` from `OWS_API_KEY`), player (Supabase UUID via a validated HS256 JWT), and trusted server (a service key argon2-verified against `SUPABASE_SERVICE_KEY_HASH`). Server-write endpoints require the service key; world-IP requests require a confirmed player login.

## Related

- [KBVEROWS](/docs/project/kbverows) — the Unreal Engine REST client plugin for ROWS.
- [KBVEAgones](/docs/project/kbveagones) — registers UE dedicated-server instances with ROWS.

---
# Soul — KBVE Rust Utility Crate

> Soul is a Rust utility crate in the KBVE monorepo, published as part of the shared crates pipeline for reuse across KBVE Rust projects and services.

Source: https://kbve.com/project/soul-crate/

## Overview

`Soul` is a Rust utility crate in the KBVE monorepo. It is maintained under
`packages/rust/soul` and published through the shared **crates** pipeline so it
can be reused across KBVE Rust projects and services. Versioning is tracked in
`version.toml` and released alongside the other workspace crates.

## Key facts

| | |
|---|---|
| **Package** | `soul` |
| **Version** | 0.1.1 |
| **Language** | Rust |
| **License** | MIT |
| **Pipeline** | crates |
| **Source** | `packages/rust/soul` |

## Features

- **Workspace crate** — part of the KBVE Rust crates collection, versioned and
  released through the shared crates pipeline.
- **Reusable** — intended for reuse across KBVE Rust projects rather than a
  single application.
- **MIT licensed** — open for use alongside the other KBVE workspace crates.

## FAQ

**What is the Soul crate?**
Soul is a Rust utility crate maintained in the KBVE monorepo and shipped through
the shared crates pipeline for reuse across KBVE Rust projects.

**How is the Soul crate versioned and published?**
Soul follows the KBVE crates pipeline, with its version tracked in `version.toml`
under `packages/rust/soul` and released alongside the other workspace crates.

**What license does Soul use?**
Soul is released under the MIT license, like the other open Rust crates in the
KBVE workspace.

## Related

- [ERust Crate](/docs/project/erust-crate) — egui/eframe component crate in the same workspace.
- [KBVE Crate](/docs/project/kbve-crate) — core shared Rust crate.

---
# SteamCMD Ubuntu — Steam Upload Base Image

> Ubuntu 24.04 Docker base image with steamcmd preinstalled, used for local config.vdf capture and the CI Steam build upload step. No credentials baked in.

Source: https://kbve.com/project/steamcmd-ubuntu/

## Overview

Ubuntu 24.04 base with `steamcmd` preinstalled at `/opt/steamcmd/`, plus a `/usr/local/bin/steamcmd` shim for direct invocation.

Two consumers:

1. **Local** — interactive `docker run -it --rm -v ~/steam-export:/export ghcr.io/kbve/steamcmd-ubuntu:24.04 bash` to capture a Linux-flavored `config.vdf` for the `STEAM_CONFIG_VDF` GitHub secret. Steam Guard mobile auth runs once; the resulting machine token blob authenticates Linux runners on subsequent CI runs.
2. **CI** — `ci-unity.yml`'s `deploy_steam` job uses this image to run `steamcmd +run_app_build` against the demo / main `app_build_<label>.vdf` configs.

## Image hygiene

- No credentials baked in. Each consumer brings its own `config.vdf` (volume mount locally, secret restore in CI).
- Self-update runs at image build time so first invocation isn't paying the steamcmd bootstrap cost.
- `lib32gcc-s1` is the only non-obvious runtime dep — steamcmd is a 32-bit Linux binary.

## Local capture flow

```sh
mkdir -p ~/steam-export
docker run -it --rm -v ~/steam-export:/export ghcr.io/kbve/steamcmd-ubuntu:24.04 bash
# inside:
#   steamcmd +login h0lybyte    → password + Steam Guard mobile confirm
#   quit
#   cp /root/Steam/config/config.vdf /export/
#   exit

base64 -i ~/steam-export/config.vdf -o /tmp/steam_config.b64
gh secret set STEAM_CONFIG_VDF --repo kbve/kbve < /tmp/steam_config.b64
rm -rf /tmp/steam_config.b64 ~/steam-export
```

## Pipeline

`pipeline: docker` → manifest fan-out builds + pushes to `ghcr.io/kbve/steamcmd-ubuntu:24.04` whenever `version` here outpaces `version.toml`.

## FAQ

**What is the steamcmd-ubuntu image for?**
It is an Ubuntu 24.04 base image with `steamcmd` preinstalled, used for local
`config.vdf` capture and the CI Steam build upload step in `ci-unity.yml`.

**Are Steam credentials baked into the image?**
No. Each consumer brings its own `config.vdf` — a volume mount locally, or the
`STEAM_CONFIG_VDF` secret restored in CI.

**Why is lib32gcc-s1 installed?**
`steamcmd` is a 32-bit Linux binary, so `lib32gcc-s1` is the one non-obvious
runtime dependency the image needs.

---
# UEDevOps — Telemetry & DevOps Plugin for Unreal

> UEDevOps is an Unreal Engine telemetry and DevOps plugin — capturing player errors and gameplay events with GitHub integration via Blueprint nodes.

Source: https://kbve.com/project/uedevops/

## Overview

`UEDevOps` is a DevOps toolkit plugin for Unreal Engine that streamlines
**debugging, observability, and telemetry** directly inside a project. It captures
**player errors, runtime gameplay events, and editor diagnostics**, then ships
them to a backend, git, or analytics stack — sending structured POST logs and
auto-creating GitHub issues. Telemetry is exposed as **Blueprint nodes** and
**editor utilities** across runtime and editor.

## Key facts

| | |
|---|---|
| **Plugin** | `UEDevOps` |
| **Version** | 0.1.0 |
| **Engine** | Unreal Engine 5.4+ |
| **Platforms** | Win64, Linux, Mac |
| **License** | KBVE |
| **Modules** | Runtime (`UEDevOps`) + Editor (`UEDevOpsEditor`) |
| **Depends on** | KBVEYYJson, KBVEXXHash, KBVEZstd, EditorScriptingUtilities |
| **Source** | [`packages/unreal/UEDevOps`](https://github.com/KBVE/kbve/tree/main/packages/unreal/UEDevOps) |

## Features

- **Unified telemetry pipeline** — capture player errors, runtime events, and editor diagnostics.
- **Structured log shipping** — send POST logs to a backend or analytics stack.
- **GitHub integration** — auto-create issues from captured diagnostics.
- **Blueprint-powered** — capture and ship telemetry without writing C++.
- **Runtime + Editor modules** — works both in-game and inside the editor.

## Usage

Enable the `UEDevOps` plugin (and its KBVEYYJson / KBVEXXHash / KBVEZstd
dependencies) in your `.uproject`, then use the Blueprint telemetry nodes to
capture errors and gameplay events and forward them to your backend.

## FAQ

**What does the UEDevOps plugin do?**
It provides a telemetry pipeline for Unreal games — capturing player errors,
gameplay events, and editor diagnostics and shipping them to a backend, git, or
analytics stack via Blueprint nodes and editor tools.

**Can telemetry be used from Blueprints?**
Yes. UEDevOps exposes Blueprint-powered telemetry so you can capture errors and
gameplay events and send structured POST logs without writing C++.

**What plugins does UEDevOps depend on?**
It depends on KBVEYYJson, KBVEXXHash, and KBVEZstd, plus Unreal's
EditorScriptingUtilities, and ships both Runtime and Editor modules.

## Related

- [KBVEYYJson](/docs/project/kbveyyjson) — fast JSON parsing dependency.
- [KBVEXXHash](/docs/project/kbvexxhash) — fast hashing dependency.
- [KBVEZstd](/docs/project/kbvezstd) — Zstandard compression dependency.

---
# Uniti — C FFI Bridge from KBVE Bevy Crates to Unity

> Uniti is a Rust cdylib exposing KBVE Bevy game-logic crates (pathfinder, inventory, battle, skills) to the Unity runtime for RareIcon via csbindgen C# bindings.

Source: https://kbve.com/project/uniti/

## Overview

`uniti` is the C FFI bridge that exposes the KBVE Bevy game-logic crates to the Unity runtime used by [RareIcon](/project/rareicon/). It compiles as a `cdylib` and is loaded by Unity as a native plugin.

Bindings on the C# side are generated by [`csbindgen`](https://github.com/Cysharp/csbindgen) at build time and committed to the Unity project as `Uniti.g.cs`.

## Bundled Crates

| Crate | Purpose |
| --- | --- |
| `bevy_pathfinder` | Grid flow-field navigation + chokepoint detection |
| `bevy_inventory` | Item / slot persistence |
| `bevy_battle` | Combat resolution |
| `bevy_skills` | Skill / proc tables |

Plus two runtime helpers compiled into the dylib so Unity does not need them on the host:

- `rusqlite` with the `bundled` feature — save-archive persistence, no system `libsqlite3` dep.
- `zstd` with default features disabled — pure-Rust compression for save blobs.

## Build Targets

Each Nx target builds the release `cdylib` and copies it into the Unity `Plugins/` tree for the matching platform.

```sh
npx nx run uniti:build:macos
npx nx run uniti:build:windows
npx nx run uniti:build:linux
npx nx run uniti:build:all
```

On macOS the target also runs `xattr -cr` and an adhoc `codesign --force --deep --sign -` so the dylib loads through Gatekeeper without a quarantine prompt.

## Generated Bindings

`build.rs` invokes `csbindgen` and writes the C# wrapper to:

```
apps/rareicon/unity-rareicon/Assets/_RareIcon/Scripts/Native/Uniti.g.cs
```

Hand-written wrapper classes live alongside it under `Native/Wrappers/` (for example `NativeWorld`).

## CI

Tracked in the dispatch manifest under the `crates` pipeline. The standard test / lint nx targets are wired:

```sh
npx nx run uniti:test
npx nx run uniti:lint
```

## FAQ

**What is the uniti crate?**
`uniti` is the C FFI bridge that exposes the KBVE Bevy game-logic crates to the
Unity runtime used by RareIcon. It compiles as a `cdylib` and is loaded by Unity
as a native plugin, bundling `bevy_pathfinder`, `bevy_inventory`, `bevy_battle`,
and `bevy_skills`.

**How are the C# bindings generated?**
`build.rs` invokes `csbindgen` at build time to generate a C# wrapper
(`Uniti.g.cs`) that is committed into the Unity project under
`Assets/_RareIcon/Scripts/Native`. Hand-written wrapper classes such as
`NativeWorld` live alongside it under `Native/Wrappers`.

**Does uniti need system libraries on the host?**
No. It statically bundles `rusqlite` with the `bundled` feature (so no system
`libsqlite3` is required) and `zstd` with default features disabled for pure-Rust
save-blob compression, so Unity can load the dylib without host dependencies.

## Related

- [Isometric](/docs/project/isometric) — sibling KBVE Bevy game consuming the same shared crates.
- [bevy_behavior](/docs/project/bevy-behavior-crate) — game-agnostic Bevy behavior engine in the same crate family.

## License

MIT

---
# Unity RareIcon — DOTS Hex-World Game Client

> RareIcon is a Unity DOTS hex-world game client with a Burst-driven simulation, shipping to itch.io as Win/Linux/macOS standalone and to Steam as a demo.

Source: https://kbve.com/project/unity-rareicon/

## Overview

RareIcon Unity client. Source: `apps/rareicon/unity-rareicon`. ECS DOTS world (Hex / Items / Logistics / Buildings / Units / Combat / Professions / Quests).

## Pipeline

`pipeline: unity` → dispatched by `ci-main.yml` to `ci-unity.yml` whenever `version` here outpaces `version.toml`. Standard manifest-driven flow, no bespoke workflow.

## Build matrix

`engine.build_targets`:

- `StandaloneLinux64`
- `StandaloneWindows64`
- `StandaloneOSX`
- `Android` — APK / AAB (debug-signed for now; production keystore + Play upload pending)
- `iOS` — Unity exports the Xcode project; the `.ipa` step is gated on an Apple Developer account

WebGL deliberately omitted — DOTS hybrid renderer + Burst aren't WebGL-friendly.

Steam integration is locked to standalone via `RareIcon.Platform.asmdef` (`includePlatforms` excludes mobile / WebGL) plus `SteamPluginPlatformGate` editor hook (disables `com.rlabrecque.steamworks.net` native binaries on iOS / Android / WebGL importers). Mobile builds compile without seeing Steamworks types and ship without `libsteam_api.so` in the APK / IPA.

## External publish

Two destinations from one build:

**Itch** (`external_publish.itch_user` / `itch_game`):

- `kbve/rareicon:linux-x86_64`
- `kbve/rareicon:windows-x86_64`
- `kbve/rareicon:osx-universal`

Build runs with `DISABLESTEAMWORKS` scripting define so SteamManager auto-no-ops when launched outside Steam.

**Steam** (`external_publish.steam_apps[]`):

- AppID `3791950` — `label: demo` (the public demo, shipped first)
- AppID `2238370` — `label: main` (full game, queued for later)
- Build keeps `steam_appid.txt` + Steamworks.NET enabled (the AppID flips per build via the Editor postprocessor)

The same `ci-unity.yml` run can target either route — the workflow reads `external_publish` to pick which post-build deploy fires.

## Secrets required

- `UNITY_LICENSE` (Personal/Professional auth artifact, GameCI flow)
- `UNITY_EMAIL`, `UNITY_PASSWORD` (Personal license)
- `BUTLER_API_KEY` (itch.io upload)
- `STEAM_USERNAME`, `STEAM_CONFIG_VDF` (Steam Guard mobile auth, encoded)

## Trigger

Tag-driven via the standard manifest dispatch. Bump `version` here, run `npx nx run astro-kbve:sync:ci-manifest`, commit, the next push fans `ci-main.yml` → `ci-unity.yml` for this entry.

## FAQ

**What is Unity RareIcon?**
RareIcon is a KBVE game client built in Unity using the DOTS ECS. It runs a
Burst-driven hex-world simulation covering hex tiles, items, logistics, buildings,
units, combat, professions, and quests.

**Where does RareIcon ship?**
RareIcon ships to itch.io as a Windows, Linux, and macOS standalone build, and to
Steam, where it has a demo app (AppID 3791950) and a main app (AppID 2238370).

**How is RareIcon built in CI?**
It uses the `unity` pipeline; `ci-main.yml` dispatches to `ci-unity.yml` whenever
the MDX `version` outpaces `version.toml`. The engine build targets are
StandaloneLinux64, StandaloneWindows64, StandaloneOSX, Android, and iOS.

## Related

- [CryptoThrone.com](/docs/project/cryptothrone) — another KBVE game client.
- [Metrics](/docs/project/metrics) — observability pipeline that ingests telemetry from Unity clients.

---
# Unreal Chuck Beta — Chuck RPG UE5 Standalone Shipping Client

> Unreal Chuck Beta is the Chuck RPG UE5 standalone Shipping client — Win64, Linux, and Mac builds shipped to itch.io as kbve/chuckrpg via the ci-unreal pipeline.

Source: https://kbve.com/project/unreal-chuck-beta/

## Overview

Chuck RPG UE5 standalone game client — the **cooked, non-editor Shipping** release
(`-clientconfig=Shipping`, `-cook -pak`) of the `main` branch. Compiled from the external
game repo [`KBVE/chuck`](https://github.com/kbve/chuck) (default branch = `main`,
`.uproject` under `engine.project_path`, Content pulled from the chuck Forgejo LFS
endpoint) and shipped to itch.io under `kbve/chuckrpg`. The editor/Development counterpart
is [Unreal Chuck Dev](/project/unreal-chuck-dev).

## Pipeline

`pipeline: unreal_game` → `ci-main.yml` dispatches `ci-unreal.yml` (`task: game`)
→ `ci-unreal-build.yml` (`mode: game`) whenever the MDX `version:` here outpaces
`version.toml`, or `source_path` files change. `engine.external_repo_url` makes the
builder clone `KBVE/chuck` (default branch) instead of using the monorepo shell; the
version gate / `version_toml` tracker still lives in this monorepo.

## Build Matrix

`engine.build_targets`:

- `Win64` — native build on the `UE5-Win` KubeVirt VM (RunUAT.bat)
- `Linux` — `BuildCookRun` in the cached Epic UE Docker image on `arc-runner-ue`
- `Mac` — native build on the `[self-hosted, macOS, ARM64]` runner (MacBook Air, registered directly with GitHub)

Plus the bundled Linux **dedicated server** (`shell_path` → `task: server`): the
`chuckServerBeta` target (`server_config: Shipping`) is cooked from the monorepo shell
and archived to the OWS PVC at `/ows-server/chuckServerBeta/<version>`, where the
chuckrpg-beta Agones fleet reads it (`subPath: chuckServerBeta`). Same version gate as the
client (1:1).

## Distribution

Ships to itch.io `kbve/chuckrpg`, one channel per platform:
- `windows` - Windows builds
- `linux` - Linux builds
- `macos` - macOS builds

Version tracking via butler's `--userversion` parameter. Requires the `butler_api` secret.

## Release

Bump `version:` above `version.toml` (`apps/chuckrpg/unreal-chuck/version.toml`),
run `npx nx run astro-kbve:sync:ci-manifest`, commit. The next `ci-main` run fans
out the game build + itch upload for this entry.

## Source: external KBVE/chuck

Builds source from the external game repo
[`KBVE/chuck`](https://github.com/kbve/chuck) (default branch). The builder clones
it with the GitHub PAT, then materializes `engine.project_path` (`chuck/` — the dir
holding `Chuck.uproject`). Content blobs come from the chuck Forgejo LFS endpoint
(`git.kbve.com/KBVE/chuck.git`); the repo's own `.lfsconfig` points at the `ssh://`
Forgejo remote, which the builder normalizes to the authenticated HTTPS ingress
route at build time.

When `engine.external_repo_url` is empty the builder falls back to the monorepo
shell `apps/chuckrpg/unreal-chuck` (the lightweight plugin build/test loop in
`packages/unreal/`). Closes [#11828](https://github.com/KBVE/kbve/issues/11828).

## FAQ

**What is Unreal Chuck Beta?**
It is the cooked, non-editor Shipping release of the Chuck RPG UE5 client, compiled
from the external KBVE/chuck game repo and shipped to itch.io under `kbve/chuckrpg`.
The editor/Development counterpart is [Unreal Chuck Dev](/project/unreal-chuck-dev).

**Which platforms does Unreal Chuck Beta build for?**
It builds Win64 natively on the UE5-Win KubeVirt VM, Linux via `BuildCookRun` in the
Epic UE Docker image on `arc-runner-ue`, and Mac natively on a self-hosted macOS
ARM64 runner, plus a bundled Linux dedicated server for the chuckrpg-beta Agones fleet.

**How is a new Unreal Chuck Beta release triggered?**
Bump the MDX `version:` above `version.toml`, run the `astro-kbve:sync:ci-manifest`
target, and commit. The next `ci-main` run fans out the game build and itch.io upload
through the manifest-driven ci-unreal game pipeline.

## Related

- [Unreal Chuck Dev](/project/unreal-chuck-dev) — the editor/Development counterpart build of the Chuck RPG UE5 client.

---
# Unreal Chuck Dev — Chuck RPG UE5 Dev Client Build

> Unreal Chuck Dev is the Chuck RPG UE5 dev client built from the external KBVE/chuck repo and shipped to itch.io as kbve/chuckrpg beside Unreal Chuck Beta.

Source: https://kbve.com/project/unreal-chuck-dev/

## Overview

Chuck RPG UE5 dev client. Like the [Unreal Chuck Beta](/project/unreal-chuck-beta), it
builds from the external [`KBVE/chuck`](https://github.com/kbve/chuck) repo (default branch,
`.uproject` under `engine.project_path` = `chuck`), with Content pulled from the chuck Forgejo
LFS endpoint (`git.kbve.com/KBVE/chuck`, HTTPS) declared in the repo's own `.lfsconfig`. It
differs only in distribution: the build ships to itch.io under `kbve/chuckrpg` on the `demo`
channel.

## Pipeline

`pipeline: unreal_game` → `ci-main.yml` dispatches `ci-unreal.yml` whenever the MDX
`version:` here outpaces `version.toml`, or `source_path` files change. This entry is
the single version lever for the whole chuck demo bundle — one bump fans out, off the
same gate, to:

- `task: game` (`mode: game`) — Win64 + Linux clients.
- `task: server` (`mode: server`) — the Linux dedicated server, triggered because this
  entry carries a `shell_path`. The server reads `apps/chuckrpg/unreal-chuck/build.toml`
  for repo / `server_target` / UE image and archives to the OWS PVC at
  `/mnt/longhorn/ows-server/<server_target>/<version>`.

With `engine.external_repo_url` set, the builder clones `KBVE/chuck` (default branch) and
builds the `.uproject` under `engine.project_path` = `chuck` against the prebuilt UE5.7 on the
`UE5-Win` KubeVirt VM (`C:\Program Files\Epic Games\UE_5.7`); the Linux client + server build
in the cached `ghcr.io/epicgames/unreal-engine:dev-5.8.0` image on `arc-runner-ue`.

## Build Matrix

`engine.build_targets`:

- `Win64` — native build on the `UE5-Win` KubeVirt VM (RunUAT.bat, prebuilt UE5.7)
- `Linux` — `arc-runner-ue` in the Epic UE5.7 Docker image
- `Mac` — native build on the `[self-hosted, macOS, ARM64]` runner (MacBook Air, registered directly with GitHub)

Plus the bundled Linux dedicated server (`shell_path`, same version).

## Distribution

Client shipped to itch.io as `kbve/chuckrpg` (channel `demo`) when `deploy_to_itch` is set.
Dedicated server staged to the OWS InstanceLauncher PVC for rows integration. Client,
server, and the shared `version.toml` all advance together (1:1).

## FAQ

**What is Unreal Chuck Dev?**
Unreal Chuck Dev is the Chuck RPG UE5 dev client. Like the Unreal Chuck Beta, it builds from the external KBVE/chuck repo with Content pulled from the chuck Forgejo LFS endpoint, and ships to itch.io under `kbve/chuckrpg`.

**How is the Unreal Chuck Dev build triggered?**
The `unreal_game` pipeline has `ci-main.yml` dispatch `ci-unreal.yml` whenever the MDX `version:` here outpaces `version.toml` or `source_path` files change. One bump fans out to the Win64 and Linux clients plus the Linux dedicated server.

**What platforms does Unreal Chuck Dev build for?**
It builds Win64 natively on the `UE5-Win` KubeVirt VM, Linux in the Epic Unreal Engine Docker image on `arc-runner-ue`, and Mac on a self-hosted macOS ARM64 runner, plus a bundled Linux dedicated server.

## Related

- [KBVEMapDB](/project/kbvemapdb) — Unreal world/map plugin from the KBVE package group.
- [KBVETinyBVH](/project/kbvetinybvh) — Unreal ray-tracing plugin from the KBVE package group.

---
# Unreal RareIcon — UE5 Linux Dedicated Server Build

> RareIcon UE5 Linux dedicated server build — uses the stock Epic Games Unreal Engine Docker image on the arc-runner-ue Kubernetes runner for CI.

Source: https://kbve.com/project/unreal-rareicon/

## Overview

RareIcon dedicated server build managed via the `ci-unreal.yml` workflow (`task: server`).

Uses the cached `ghcr.io/epicgames/unreal-engine:dev-5.7.4` Docker image on the `arc-runner-ue` Kubernetes runner.

### Shell Project

The build configuration lives in the monorepo at `apps/rareicon/unreal-rareicon/`:

- `build.toml` — game repo, .uproject path, server target, UE image tag
- `version.toml` — current build version

### Dispatch

Trigger via GitHub Actions:

1. Go to **CI - Unreal Engine** workflow
2. Select task: `dedicated-server`
3. Set `shell_path`: `apps/rareicon/unreal-rareicon`

## FAQ

**What is the Unreal RareIcon build?**
It is the RareIcon UE5 Linux dedicated server build, managed via the
`ci-unreal.yml` workflow with `task: server` and run on the `arc-runner-ue`
Kubernetes runner.

**Which Unreal Engine image does RareIcon use?**
It uses the cached `ghcr.io/epicgames/unreal-engine:dev-5.7.4` stock Epic Games
Docker image, so no custom engine build is required for CI.

**How is a RareIcon server build triggered?**
Trigger the **CI - Unreal Engine** workflow in GitHub Actions, select the
`dedicated-server` task, and set `shell_path` to `apps/rareicon/unreal-rareicon`.
Build config lives in `build.toml` and `version.toml` under that path.

## Related

- [Unity RareIcon](/docs/project/unity-rareicon) — the RareIcon game's Unity DOTS project.
- [RareIcon](/docs/project/rareicon) — the RareIcon project overview.

---
# Unreal RentEarth — UE5.8 Game Client Built From the Monorepo

> RentEarth is a UE5.8 game client built from the monorepo shell at apps/rentearth/unreal-rentearth via the unreal_game pipeline, shipping to itch.io.

Source: https://kbve.com/project/unreal-rentearth/

## Overview

RentEarth UE5 game client — a separate Unreal project from [Chuck](/docs/project/unreal-chuck-dev).
It compiles the monorepo shell at `apps/rentearth/unreal-rentearth` directly (no external game
repo), the same way the early Chuck demo did, and is wired to the shared `unreal_game` pipeline.

## Key facts

| | |
|---|---|
| **App** | `rentearth` |
| **Engine** | Unreal Engine 5.8.0 |
| **Pipeline** | `unreal_game` |
| **Build targets** | Win64, Linux |
| **Runner** | `arc-runner-ue` |
| **Distribution** | itch.io (`kbve/rentearth`) |
| **Source** | [`apps/rentearth/unreal-rentearth`](https://github.com/KBVE/kbve/tree/main/apps/rentearth/unreal-rentearth) |

## Pipeline

`pipeline: unreal_game` → `ci-main.yml` dispatches `ci-unreal.yml` (`task: game`) when the MDX
`version:` here outpaces `version.toml`, or `source_path` files change. With no
`engine.external_repo_url`, the builder checks out the monorepo and builds the `.uproject` under
`engine.project_path` against the prebuilt UE5.8 on the `UE5-Win` KubeVirt VM
(`C:\Program Files\Epic Games\UE_5.8`); the Linux client builds in the cached
`ghcr.io/epicgames/unreal-engine:dev-5.8.0` image on `arc-runner-ue`.

## Build Matrix

`engine.build_targets`:

- `Win64` — native build on the `UE5-Win` KubeVirt VM (RunUAT.bat, prebuilt UE5.8)
- `Linux` — `arc-runner-ue` in the Epic UE5.8 Docker image

The dedicated server is not wired yet — add `shell_path` + a `build.toml` (`server_target`,
`repo`, UE image) under `apps/rentearth/unreal-rentearth` to fan the server build off this same
version gate, matching the Chuck setup, once the server target exists.

## Distribution

Client shipped to itch.io as `kbve/rentearth` when `deploy_to_itch` is set. Client and the
shared `version.toml` advance together.

## FAQ

**What is Unreal RentEarth?**
RentEarth is a UE5 game client built directly from the monorepo shell at
`apps/rentearth/unreal-rentearth` via the shared `unreal_game` pipeline. It is a
separate Unreal project from Chuck and targets Unreal Engine 5.8.

**How is RentEarth built in CI?**
The `unreal_game` pipeline has `ci-main.yml` dispatch `ci-unreal.yml` with
`task: game` when the MDX `version:` outpaces `version.toml` or `source_path` files
change. Win64 builds natively on the `UE5-Win` KubeVirt VM against prebuilt UE5.8;
Linux builds in the Epic UE5.8 Docker image on `arc-runner-ue`.

**Where is RentEarth distributed?**
The client ships to itch.io as `kbve/rentearth` when `deploy_to_itch` is set. The
client and the shared `version.toml` advance together. A dedicated server target is
not wired yet.

## Related

- [Unreal Chuck (dev)](/docs/project/unreal-chuck-dev) — the sibling UE5 game project RentEarth forked its shell from.
- [KBVENet](/docs/project/kbvenet) — shared UE5 networking plugin available to KBVE game clients.

---
# KBVE VIP — Premium Membership, Tools, and Early Access

> KBVE VIP is a premium membership offering exclusive tools, plugins, early beta access, and priority support, planned as a monthly or yearly subscription.

Source: https://kbve.com/project/vip/

## Welcome to KBVE VIP

In the digital cosmos of KBVE Projects, where innovation meets utility, we proudly introduce KBVE VIP—a prestigious extension tailored for those who seek the extraordinary. This exclusive membership program is designed to offer enhanced tools, advanced features, and premium plugins that amplify the capabilities of our vast software repository.

## Why Join KBVE VIP?

### Exclusive Access

As a VIP member, you gain immediate access to a suite of premium tools and features unavailable to the regular user base. These are meticulously crafted to provide enhanced functionality and superior performance, ensuring you stay ahead of the technological curve.

### Cutting-Edge Plugins

Explore a treasure trove of plugins that can transform your projects with new functionalities and optimizations. Our plugins are designed with precision and integrated seamlessly to elevate your development experience.

### Early Releases and Beta Tests

Participate in beta tests of upcoming features and tools. Your feedback will not only shape the development of these innovations but also ensure that they meet the high standards of our discerning VIP members.

## Membership Benefits

-   **Priority Support**: Get your questions answered with top-tier customer service. Our dedicated support team prioritizes VIP inquiries, ensuring you receive swift and effective assistance.
-   **Community and Networking**: Gain access to an exclusive community of like-minded developers, where you can share ideas, collaborate on projects, and build professional networks.
-   **Resource Library**: Unlock a comprehensive digital library filled with guides, tutorials, and case studies designed to help you maximize the use of our tools and features.
-   **Regular Updates**: Receive monthly updates about new tools, features, and exclusive content directly to your inbox.

## How to Join?

Joining KBVE VIP is straightforward:

1.  **Visit Our Signup Page**: Navigate to the KBVE VIP section on our website and choose the membership tier that best fits your needs.
2.  **Complete the Registration Form**: Provide the necessary information to create your account. Our secure process ensures your personal details are kept confidential.
3.  **Enjoy Immediate Access**: Once your membership is active, you can immediately dive into the world of premium features and exclusive tools.

## Conclusion

KBVE VIP is not just a membership—it is your gateway to premium digital craftsmanship. With advanced tools at your disposal and a community of innovative minds accompanying you, the potential for creating groundbreaking software is limitless. Join KBVE VIP today, and transform the way you interact with technology.

_Elevate your experience with KBVE VIP—because you deserve the best._

## Notes

The VIP rank will be for very important people of KBVE, I will try to extend out custom services that would normally not be for the public userbase.
Part of the VIP will include a monthly/yearly membership that they can buy via Pateron, Twitch, ect..

## FAQ

**What is KBVE VIP?**
KBVE VIP is a premium membership program that offers exclusive tools, advanced features, and premium plugins on top of the KBVE software repository, aimed at very important members of the KBVE community.

**What benefits does KBVE VIP include?**
VIP members get priority support, exclusive community and networking access, a resource library of guides and tutorials, regular updates, and early access to beta tests of upcoming features.

**How do you become a KBVE VIP member?**
You visit the KBVE VIP signup page, choose a membership tier, and complete registration. The VIP rank is planned as a monthly or yearly membership purchasable via services such as Patreon and Twitch.

## Related

- [LofiFocus](/docs/project/lofifocus) — a KBVE community project available to members.

---
# Yuki — Persistent VRM Concierge for kbve.com

> Yuki is a persistent kbve.com concierge in the corner dock — chat panel, optional VRM avatar, audio-driven lipsync, and SSE-streamed replies.

Source: https://kbve.com/project/yuki/

import Adsense from '@/components/astropad/adsense/Adsense.astro';

Yuki is the always-available concierge that ships inside the right-side
dock on every kbve.com page. Persistent across `<ClientRouter />`
navigation, deferred until the user opens her, and architected so the
heavy parts (VRM model, Three.js scene, AudioContext) only land in the
browser when the user opts in.

## At a glance

| Phase | Status | What ships |
|-------|--------|------------|
| **A** — Dock shell | ✅ merged (#11474) | Persistent FAB + collapsed panel, vanilla driver, lazy-mount contract, localStorage state, ESC-to-close, reduced-motion respect |
| **B** — VRM avatar | ✅ merged (#11475) | `@pixiv/three-vrm@^3.5.3` scene, idle/blink animation, `aa`/`ih`/`ou` lipsync via AnalyserNode tap, render-loop visibility + fps gates |
| **C** — SSE stream | ✅ merged (#11476) | `GET /api/v1/yuki/chat?q=<…>` returns `text/event-stream` chunks; panel streams tokens into the bubble + hands assembled text to `speak()` for lipsync |
| **D** — Organic + float | ✅ merged (#11492) | Manual rest pose (no T-pose), portrait camera framing, `vrm.lookAt` cursor tracking, spine/hips micro-sway, draggable float-detach layer that persists across `<ClientRouter />` swaps |
| **D.1** — Vtuber polish | ✅ merged (#11507) | Spring-bone reset + body-twist on extreme gaze; first-open wave, input-focus look, nod-on-send, happy-on-done, click-to-wave, blendshape lerp; idle FPS drop to 15, render pause when dock collapsed + not floating; page-wide cursor follow + autonomous wander when floating |
| **D.2** — Followups | 🚧 this PR | Strip browser SpeechSynthesis (sounded awful); swap deprecated `THREE.Clock` for `THREE.Timer`; cache humanoid bone refs once instead of per-tick lookup; dock script uses dynamic `import()` for ClientRouter robustness; Adsense components standardised on `data-astro-rerun` push so ads re-init on every nav swap |
| **E** — Real backend | 🗓 next | Swap the canned reply in `transport/yuki.rs` for a jedi/q-routed LLM call. Prompt template, conversation compaction, rate limit. Front-end unchanged. |
| **F** — Voice in | 🗓 later | Push-to-talk mic capture → on-device VAD → server STT → same SSE response path |
| **G** — Tools / actions | 🗓 later | Function-call schema so Yuki can navigate the site, open the wallet card, queue a forum post, etc. |

<Adsense />

## Architecture

```text
┌─────────────────────────────────────────────────────────────────┐
│ AstroYukiDock.astro                                             │
│   • transition:persist="kbve-yuki-dock"                         │
│   • static HTML/CSS — zero JS on first paint                    │
└───────────────┬─────────────────────────────────────────────────┘
                │   user clicks FAB → first time only
                ▼
┌─────────────────────────────────────────────────────────────────┐
│ yuki-dock.ts (vanilla)                                          │
│   • toggle + localStorage state                                 │
│   • dynamic import('./YukiPanel')                               │
└───────────────┬─────────────────────────────────────────────────┘
                │   panel mounts inside the dock body
                ▼
┌─────────────────────────────────────────────────────────────────┐
│ YukiPanel.ts                                                    │
│   • chat log + input                                            │
│   • "Show 3D Yuki" toggle → dynamic import('./YukiVRM')         │
│   • submit → EventSource('/api/v1/yuki/chat?q=…')               │
│   • SSE chunks stream into the bubble; on `done` → speak(text)  │
└─────────┬──────────────────────────────────┬────────────────────┘
          │                                  │
          ▼ (optional)                        ▼
┌──────────────────────────┐    ┌─────────────────────────────────┐
│ YukiVRM.ts               │    │ axum-kbve transport/yuki.rs     │
│  Three + three-vrm       │    │  GET /api/v1/yuki/chat          │
│  idle / blink / lipsync  │    │  text/event-stream, 15s keep-   │
│  destroy() releases all  │    │  alive, `event: done` terminator│
│  resources               │    └─────────────────────────────────┘
└──────────────────────────┘
```

### Why no React for the panel?

The chat layer needs to live inside a `transition:persist` node that
the rest of the dock shell wraps. React's reconciliation tree is
allergic to having its root DOM swap-mutated under it by Astro's
ClientRouter, so the safer move is vanilla DOM that owns its own state.
Bundle-wise we save the React + ReactDOM payload on first dock open —
and the VRM scene that *does* use Three.js never crosses into React's
tree either.

### Why no Mediapipe / webcam?

Yuki's pose data is either ours (canned animations, server-driven
flags) or audio-derived (lipsync from the speak source). We
deliberately don't ask the visitor for camera access — the avatar is
a concierge, not a mirror.

## Public surface

### Frontend

```ts
// Loaded only after first dock expand.
import { mountYukiPanel } from '@/components/jay/dock/YukiPanel';

// Lazily imported by the panel when "Show 3D Yuki" is on.
import { mountYukiVRM } from '@/components/jay/dock/YukiVRM';
//   const handle = await mountYukiVRM({ host });
//   handle.setState('happy');
//   handle.speak(audioElement);   // analyser tap → mouth blendshapes
//   handle.destroy();             // releases WebGL ctx + AudioContext
```

### Backend

```
GET /api/v1/yuki/chat?q=<utf8 prompt>

Content-Type: text/event-stream
:keepalive                 ← every 15s while idle
data: <chunk>              ← repeats per token / sentence fragment
data: <chunk>
event: done                ← terminator
data:
```

The handler trims and rejects empty prompts with a 400. There is no
authentication on the route in Phase C; Phase D will gate it on a
Supabase JWT once the real LLM call costs money to run.

## Storage

| Key | Purpose |
|-----|---------|
| `kbve:yuki-dock:state` | `'collapsed'` or `'expanded'` — restores last view across reloads |
| `kbve:yuki-dock:avatar-mode` | `'text'` or `'3d'` — restores 3D toggle |
| `kbve:yuki-dock:history` | Last 24 chat entries, `{role, text, ts}` |
| `kbve:yuki-dock:float-mode` | `'1'` or `'0'` — restores float-detach state across reloads |
| `kbve:yuki-dock:float-pos` | `{x, y}` viewport coords of the float layer — restores last drag position |
| `kbve:yuki-dock:greeted` | `'1'` once Yuki has fired her first-open wave + greet on this device |

All six are localStorage-only, never sent to the server.

## What's next

- **Phase E**: replace `compose_reply` in `apps/kbve/axum-kbve/src/transport/yuki.rs` with a real LLM call. Likely q-routed so we keep our existing tracing + Supabase JWT verification. Front-end stays identical.
- **Site-context**: feed the current page slug into the prompt so Yuki can answer "where am I?" without a tool call.
- **Tool calls**: small JSON-schema function set (`navigate`, `open_dock_card`, `compose_forum_post`) so Yuki can act on the page, not just talk about it.
- **Voice input** behind a push-to-talk gate, on-device VAD to keep the mic OFF except while the button is held.
- **Wander**: replace the static float layer with a slow drift loop so Yuki actually walks the viewport edges between turns.

If you have feedback, drop it in the [forum](/forum/) — the link is
literally what the Phase C stub tells you to do.

## FAQ

**What is Yuki on kbve.com?**
Yuki is an always-available concierge that ships inside the right-side dock on
every kbve.com page. She is persistent across `<ClientRouter />` navigation,
deferred until the user opens her, and architected so the heavy parts (VRM model,
Three.js scene, AudioContext) only load in the browser when the user opts in.

**How does Yuki stream chat replies?**
The panel submits to `GET /api/v1/yuki/chat?q=…` on axum-kbve, which returns a
`text/event-stream`. SSE chunks stream token fragments into the chat bubble, and
on the `done` event the assembled text is handed to `speak()` for lipsync.

**Why does Yuki avoid React and webcam access?**
The chat panel is vanilla DOM because it lives inside a `transition:persist` node
that Astro's ClientRouter swap-mutates, which breaks React's reconciliation, and
it saves the React payload on first open. Yuki also never requests camera access
— pose is canned or audio-derived from lipsync.

## Related

- [API](/docs/project/api) — the axum-kbve service that hosts Yuki's chat endpoint.
- [KBVE.com](/docs/project/index) — the site Yuki's concierge dock ships on.

---