updates

2026-09-06 11:29:23 -04:00
parent cb39431a11
commit 3e2fc920fb
43 changed files with 2124 additions and 128 deletions
@@ -57,7 +57,7 @@
    "typescript": "beta"
  },
  "dependencies": {
-    "@star-kitten/util": "link:@star-kitten/util",
+    "@star-kitten/util": "workspace:*",
    "@projectdysnomia/dysnomia": "github:projectdysnomia/dysnomia#dev",
    "date-fns": "^4.1.0",
    "fp-filters": "^0.5.4",
@@ -4,7 +4,7 @@ import { getCommandState } from './command-state';
 import { type ExecutableInteraction } from '../types/interaction.type';
 import type { CommandContext, CommandHandler, CommandOptions, PartialContext } from '../types';
 import { augmentInteraction, getCommandName } from './command-helpers';
-import { awaitMaybePromise } from '@star-kitten/util/promise';
+import { awaitMaybePromise } from '@star-kitten/util/promise.js';

 export async function handleCommands(
  interaction: ExecutableInteraction,
@@ -23,6 +23,8 @@ import {
  type ThumbnailComponent,
  type ModalSubmitInteractionData,
  type FileUploadComponent,
+  type InteractionModalContent,
+  type InteractionResponseModal,
 } from '@projectdysnomia/dysnomia';

 export type ActionRowItem = Button | StringSelectMenu | UserSelectMenu | RoleSelectMenu | MentionableSelectMenu | ChannelSelectMenu;
@@ -330,13 +332,15 @@ export const label = (options: LabelOptions, component: LabelComponent['componen
 });

 export const modal = (
-  options: { custom_id?: string; title?: string },
-  ...components: Array<LabelComponent | ActionRow | TextDisplayComponent>
-): ModalSubmitInteractionData =>
-  ({
-    type: 9 as any, // Modal type
-    custom_id: options.custom_id ?? '',
-    title: options.title ?? '',
+  custom_id: string,
+  title: string,
+  ...components: Array<((Omit<ActionRow, "components"> & {
+      components: TextInput[];
+    }) | LabelComponent | TextDisplayComponent)>
+): InteractionModalContent => ({
+    type: Constants.InteractionResponseTypes.MODAL,
+    custom_id ,
+    title,
    components: components.filter((c) => c),
  } as any);

@@ -1,9 +1,9 @@
 import { Client as DJSClient } from '@projectdysnomia/dysnomia';
 import kv, { asyncKV } from '@star-kitten/util/kv.js';
-import type { KVStore } from './kv-store.type.ts.ts';
-import type { Cache } from './cache.type.ts';
 import { registerCommands } from '../commands/handle-commands.ts';
+import type { Cache } from './cache.type.ts';
 import type { Client } from './client.ts';
+import type { KVStore } from './kv-store.type.ts.ts';

 export interface DiscordBotOptions {
  token?: string;
@@ -12,22 +12,22 @@ DOTENV_PUBLIC_KEY_DEVELOPMENT="02572da3d4f3a844588a944214c0e142a5a01deaa6551456a
 DOTENV_PUBLIC_KEY="02292a330aa041b5f7efc51504e0c208accba67a6877a217ab43cbb59c3c0c3e66"

 # .env
-DEBUG="encrypted:BL9a2Dle847wiqvjnB1ryC8L5vJy0pn/5BZJdEMSWBIzcxPN3MhXoHsQ4KQcRXW4xuWLpHq00aAH5kNda3Bu7kPPbnltvhcYoqQSz3giItL8th1T/qm4zc+gM7lNHl/+5G0xJFE="
-PORT="encrypted:BKVA322kVuBfcDbptjVrvp9O8+1w0iCNT7Sv777MfCuLHTdJdUZr5jZbcKBD8yxPGpkc6sNdB4j6n2flC5NwExHdO/mdGD1VEBpdcZQCcSO7MYOYt1j0pfLNkvEqpuHnD1tkxT8="
-NODE_ENV="encrypted:BLNNdnKOW0f8d614oe1ur73es5z/2MhyJIXmeMNvU/VlOBL1dg/mT4vHosXG908eCyM2Nx1v7GxAfXmdpVSzWltfODwJzPw/lPZV3JFB2yIt4f8zJIHvkHKPMFLupK9bDUUS2m63uvZ4IE0v"
-LOG_LEVEL="encrypted:BOZXADbkv9vkzwx7/JC/EcBC00W5li6rbluRVGwy5t0fIj2WaoWXkwlTmHf5NiczQLPCgB+HD6LJxAeef8uEMgN0hwDCBXVGl53HWwDjkmxmmDAdfBmOeldJhDQbFNXumyrmKIOu"
-BASE_URL="encrypted:BFjoUMvbNCwqcd8j74dNe+4MZn1STXKTVq8LoP+CPuunNfL9QQkjyR+ryH0rgOH0W0LVLQBszEEpEiFFOohq3/uZlN/UTsqkQXntINvBMvT2S2dTTTafB4jgSoNrS6VDSx3mipO15IzQZ/QlADQrqVI5Y+iB7Y2lAx7M"
-EVE_CLIENT_ID="encrypted:BPpft3gC8xuWAg5SzhnoG009FhlJ9K65Ku7QoRrjZFAm7VaR2WDbH7lPMXoXY1/tu2sFln2+iCA0J8VMwqnvmHgocQtE2qPmRHdZUUSuGph76uIU4CNaIRICpXyn3jOfPIjsyBXcsKrMwLEdfeEwkxazDJ8ZAw/r+WHre9xr+iwK"
-EVE_CLIENT_SECRET="encrypted:BNXhx7jO6z2IfGU0TLUxMnONUXYWlQvM+RxUYDuOb+Tsncr32aJ4j6pFMHMeUYcqrQIogads6GDNb73trhk9XvpPu8kBgrksdkCtErp47u5++6yRGLkqTmkdpZeja2KCaGx0Bcu4EfP5DS/H9Mc6nvb6+wctj8s/w2MguF6O5gg/2LNDNT3tbrI="
-EVE_CALLBACK_URL="encrypted:BPzYFYlfnfLhPQuwRyUZs3F3wxjy6TEHQKNjbu+XnztSS6rJh8eAuW0ThYxee8lBAzLSGgKmjIt1PkYljnTekrR2CKyp3hMhag6W08tzxJDs4qyAsi+X91mEHXrd+ekmr4d5iAZu+sr/rHiK9jkzAsVWA8e8ttAVtW5Us7sb6ovZ1bjWM20oXk+4e5Gg"
-ESI_USER_AGENT="encrypted:BI/g/h+eCwT468Io0A9DhVU+z1iWiJwOI75mNDqZMJB1LWyhd/+pneYlcEAJJEsAPP4+YN66qAZ/8PzgH6rVcXS5H27FqwC+/mJFsMfC9jAkFDl38nxDogpKJUAimpG53ERM7LegMMcxAsnr085JduloijL5ylCwEwpiewzWwN+xqOOcQrW6UcQgsgbyonIlqaYstN4NdplvdSC2zvrYN5OnToEoQ2YFiAtU7dTxSx0="
-DISCORD_APP_ID="encrypted:BIiCdiy6ypeM3LK9pvkqoNIn0Js7XS5rUQqBNzZcywm9eH21gSit2rb+cwYGBGzYmkv/xG6Zf/CnUA7STrtRFfOD57vF46DVam0now4IVrTWr7X3CZLgBa0TBJgph72rTSTg8HKz8OheH/y7u730uN0OLhw="
-DISCORD_APP_SECRET="encrypted:BHNfy9BO/85OpyEQgehnwAByFz0jyE3b/YiK69aVFFKotBjeh9rj/0eg2/LsJvPsAHW3NDHmSWIvo+0gqTMuFbbA52wyLk4HeZmX5yNV6sQfGLitwJVCiyfXWpW81dkwTWF4bPNu/zTDlN7hJVuOTz9o6QN5WRSlbCiuP3n7Ojk8"
-DISCORD_PUBLIC_KEY="encrypted:BMzCllTpNrIQy9DkWGqE6tW7XxIEdui58eV5PqmMtwizEptjZVGp+IRtin9SUXBOtugzUUn51KP4+8AQauyFP4/oiEpiCa04lPLy2OF0pTzF61zC6jBb+gGL6fbvA2DWORXkR98sK6IAO5+OaGXy1SnHU1qjM7J5GFBaAywdPmDdLpuD4zJLvXggpooepaHHKer4ViyBAev9QU2Zb9/Ants="
-DISCORD_BOT_TOKEN="encrypted:BKJPnAvriqdaKV5eirAAs6TgtmtJMj7ZMjf8Y8sbD+T3WK/tbh8mgNNlyPk+ztre5mQD46vuWMa9F9uYCZcBmlk3XcRiYFwtyIGeaUPw2hT5kswk+jcaj66HKTknF09KwOhjvg3O2394d9p0jNFsx6ioT1ddzoSEKcQkyeBuJAsOTGnPVQKkfUNCRCWXMf6C3pxqVmFP/azfFFQNy8yevXnhZU97Zk9Ohg=="
-DISCORD_TEST_GUILD_ID="encrypted:BP+e5/IUX1gJP+/ZtG1LxwWcLeYsYwhM6boSbJv1YDhg3FF/qDM6A3OXsneSBP3PTDwW7e14M5U0jRIMT9YemyuF9r7895fMgBnFbPfSY+WaRDruibFI6QW1RvEcTuFjoU2/kRT6s69C/I1frYEMja2rfw=="
-JANICE_KEY="encrypted:BIb85AGnz4hgENGxJYhDmtEE6rEPjfBKZBtJ4KuDNtAjyIEI4kRKQNkOudVxc4BXQ6MXIqhIPIuTE6DdCN03olEfk3Fo5/FmwOr1bWF6pYFbwMxdVgjc9Cj9Lie3+tAnr3MaOfT0y+P+zUiAMWRJELpLv0TzSNhmTAF1LS+9zjUV"
-PERPLEXITY_API_KEY="encrypted:BNy5gd/Ku1Dilcfc9VftzIJn5xxDCT0NapIw5i+4h1srz2nNVgDc8w6GvmdBBz/NiPut9x+7Wv5hKVuXh2N07HaO67bTugzZ7dwabQdDJGlRp8mo/TEJMIN9Pm1ztI5HZW4UGfMY4xNILHRJb+JRBNdI4GZSh13i6vyc8ym9BgOXLVTR3ZSCJwFqzeDTgR9R3NhIjUa3"
-STAR_KITTEN_KV_DB_PATH="encrypted:BPZyMGyF1A+mQQ+OKNtHJLM+EGyrgkfhO6hHs1YHaoifLsMbJz2NDZmOzDg+ubPTUyjOJ+XbjcVdEFLn23QoOqKtW/WSk6WPPNAgWnWrTl+5XJI7bfGKaaZ1LR1PaB4ftPyMLFyoWVZ2iPHBP1xv"
-POSTGRES_URL="encrypted:BLUN+6NZpCkc+8WvJkhB3v8sYoX88maPYzkBi2WXItAOtA2r/1a65yZThcumddnba7WzaaN7xPv0CUA6LZpszP8t59LJ2ewKNJJyi9Z5bHINoedLh57kwlu0TcGsoO/EUPS81V0FZAlxLnmuVvMn/xYxmXJWiTeQRCe4vxLSctMNWgvcWXuQivGrLFh6AMtgfi+FxtkaH5zYXIjDn1Q/U2gKTwyLxmPBrXxFnYx8aGI9Leios605d/4lugra"
-NEO4J_URL="encrypted:BGphrNITLIGqF5aVoY9F2IaDVP+IRXuPvtfTRKtNqL8u5JIqkbEBpRknfB3wA2XoYiDsQ2ADfwwSuw5uvj1IWU2/ZS9AEukGJGYa6RP1dI/R0XvRAqS7O9waOH8nuH3KPaTSiEfeLqd+c+3J8MAKgpaysNp1nKGsZa6RzjhYEWxsKw3Yp4LY5d3yRloqxWsAJsd3WnH8cJWvJi0gT04PEJ73gX4TyHlPuduH37uo6os="
+DEBUG="encrypted:BBjPKsy3TwEt7LGJLBmyCJNff9qfGA0dRCVku/po1lTadCeXIdexYCXfwK3X0D1SMxpDB3g6ej7wSrfq2ITBRi2KfaEp8aBbXNBIhJwa3Ym31PLYnAoPft2DzHeGFon8K+9JJlQ="
+PORT="encrypted:BAy5D8GuVeDZ6Bz5okT7Fy5hFTcBJkxZbR/j8aoZKTci3Bdv7YSttleE2JEqWEgDMlseytCEGEfeU6NcUBPwikjrmVJvLkbtk614JJDBszpk0dU2aVkSVbAPFAdxwAJok24Ismw="
+NODE_ENV="encrypted:BG/XExUKgq+icyDkoZFQ1AoFK/CbbdiccfZT/3rN3MyamvZypUYCL8dvMf0lXRJtxIb1wn8FC/hn4v+NJt3it2kXSAnOGN0GBmv034TvbXJ+XD7tE3Mwz50VSrM8ocZLTBv7x6AIMj0wdE/H"
+LOG_LEVEL="encrypted:BM+h6kEBCeuPSR3uav+AST/uT9g9dPswoc2fIOudcu5GCmqharkO+BbV64f8e0BaFDgwN0vY+PMHdr5goS8Mri3oQ/SSVSk5ZR+klJkrntpuiHMMhEx3BXmmxW4OVIbJcSzcZV3O"
+BASE_URL="encrypted:BMEGIrpZzsUuDaG9AhaNDvdLGS3KWt2YM9YREO50FgI3bfbJr/fEjJJnz/3BRgbuHni5bjg1fZLjM/vUs6svPPlWNTSQdwrBO70uCpZaka+YDV538gSOdTVELX7UzCQToyQTEzLerBnskO/7c47s2TGHhna8ABgZw01i"
+EVE_CLIENT_ID="encrypted:BAgCn96+EoOM5jWUrR3DFxQ8gfIHYYXZ66aDk2EhqTzODHVorfr61m+JCL5pnJFfyYkjJXHXG0JnWBFqOCo8WQsfzAZjYEksxY2LgeH5R0PTNhbNfrC9QDDvuG+0z6PNtWDFvTZ+HcDFud5/oUxwjPr5x1Lp4Zm2mGI4aCcbalN5"
+EVE_CLIENT_SECRET="encrypted:BPIJGc+XleimidhXp1f3DY117RAW5BNFbf9xbFIHc5rbGzHTq3RgBexes+wzakz9tiSaYUqPr7lb5lbRaxyL9+U/fcWeaz4pEZwIKWdBTubNpOEOpLdGbV4FptzX1kASZyoZ64Fv9o+hPAv5lUvlRsDLsO504oGziCvEtQi9shJMsQg5U7T7KXc="
+EVE_CALLBACK_URL="encrypted:BPisIY0QjTwEg8uxi6YQ+lLma2rVrmLpnGug1K2PrmrEIuXTDEq9byGX3/B/jGZ5jZb98G2x5OSf58oeEA1uXDYimn8xigF3lIyHkL3iE7GoQ4Y0HjgwHNFv7IhgnsCNrHfTZ51JXgPnDExwUAlSPvSf/gvdkDntrfgtFOjjuklOI0Pg/GvLZ3G6FX1A"
+ESI_USER_AGENT="encrypted:BFnlEhC3Az03vW3esOpNIyQoNDxb8R/Wf784xyv5fZXnozcKlvaDegU1tl/CFlaa2K9yRCl1U4DFjvPyl6iVTmFoLvbLFKduCIRGj6WA1i2J36nAg0qJxr3hybh3Jvw8YIFhRx6b+X3RdNvNkR1+Uqb3fE8T8B5Ht4ETuSthkfvEUuBTGlEDJKkoamLlM+HWOXoPJZ3/+kn7fasfWGY2y9+IxoSKutojs5PaFjzuOZg="
+DISCORD_APP_ID="encrypted:BK+Egs07IftGmBHj8d4oKpFL+rATGjwDKh0r+5vKdDN/CRPdmvECD3WOiwFhCNuHQdN6PKRheW4Y+uu0XeBaopzyRD3GMRdekaJu3raLUgQWTMnen5X3Wo7iiaGAenAX/B1Y95AWWAATHlU+ve2aC1ONtDI="
+DISCORD_APP_SECRET="encrypted:BHpKn5yQdO429k+Q7KK9Tw+ee05hxue9bBR7cp1EwdfeMj7ddKIVYgHYqMdXDYXQnWKTHB0yMxaGWiXrbnkHUdZXBsKBDpnR7hsng7/19EDur5qJcPGNLELl7b0t7L8YBPf+P3xQGUUMmYejp3aXdG7dCEHgQcrSMrBdkxr7IIkc"
+DISCORD_PUBLIC_KEY="encrypted:BBfqy2j0Ul1NzWKH2X/UteAnTiTjgDKkxb56yFSpkSQlUrNY2S+rwKPDOsPy7dLSQ4BsXqlM5cStgnQ2YZDPVyzPWJGhW6H8Z8Zn+A5Y75KHXaIBfeYy6OVnGO9cs6E1POAPASStccdjBDDzNdzdXAHV+oLEQ60AFwEvBxM33bXMazAsavQ7TFov0e6QcJwQR4AVSFC/yoqdk02jg/743Jc="
+DISCORD_BOT_TOKEN="encrypted:BNAm4l7gzrpaVK8zB1i98a76cTs1JiCq2hzUhBKP9ZpuXmf9PS8bbtllCEAmLJpGWzZDA7woNh5/aFWhhgQkap3kKinI2yrwSsgDMKz5IQj2V1bMJzJRFIZ8dZSukU6T18Ek1DeJCrr6mw8vO2zv0COGFGl2nG1lYp8svM3zOYcMyL2egSwqwhbXmZTTwFG+/XrglNlqCBSmw+M9c+h/+dCyoozKAzMsSQ=="
+DISCORD_TEST_GUILD_ID="encrypted:BChZnEJex/udxza8vQviXNOp+hhQuBt11jutq9qYB+Dbc1Io3wnbMBBpLBuOMEi5a7JVot0H4VXPcHVqWJ7VSSmQJmrVwUCVNQeYag7IrVUPSnre6nJLe84RKBdgK5B5f7OPx36+DRtKabOGkcWdZziWVg=="
+JANICE_KEY="encrypted:BADdNEE0JSVOy2UOAv4MdBi8aneIBw7NyeIm/50E4ils/sbZ/au1qIdxAuMbWwZrY+MIi2WgCTfDdlBiHaCFEf1HgFId7IXl7WKQBtELph8O6baheE00sApboQP4rZfh7T+iAiWwPcqRdPtW+JLZ/QGR1ij+McfGK1Kx8M4Wp3mU"
+PERPLEXITY_API_KEY="encrypted:BKDjGjY06yq511IN+7txHqTBdaBgkV0z/wQ2bff87/6pdMXyMAvAk+LAIgb2h3b45CsP1xOFj0x8d9GoRAjRo1Dqx7vzTjPKccM8b6lem3G1NIsQ1Ced96MyRPSjs2tpdxhj6lSDzwEmJ/QjtTy/bR6tdnebmHfNrGjLHSOATEKnJDN1ZdpFC/KWeSmTEiiscVIiSk5O"
+STAR_KITTEN_KV_DB_PATH="encrypted:BCMyBS11CwDjMyspOV4qNKcQbJ5KaPF68UVoGHKj3BM+rusSJ5SXGC/j7joi/dKMUES3VMlqe01RXgK0TdxFfzDtFNnLNjq7sxvqCf22BM6l1D9JBG5vRLl4NuSbME+A7gcu2ETGLkFVJrd612lx"
+POSTGRES_URL="encrypted:BHfQZ6Moa5cOMvf/1PRYouIwEQ1L3VoUaNBnsttlxsjoggmfk2JMLqM4BT/tAeXYnjQoc9pUBnpFfT0IT2ui/YuKJDTcJRU/N+aACLdehR/Oz+o9N7bKRMLp6tOa7uzXJI7hKTHrfAGW+Us76I4brn3MykkVApecObwFwN+CCNEdMgrhP1GMfocHfNo+AJ5Wq1kN/R0njSJ4CFfFokd07U8xRSt/y0VbqJSRC6UacLWfuHZ14fZB/t8WaRaR"
+NEO4J_URL="encrypted:BOZ8L/vwG/YUcG4SeX9cP+MpB9FL/lsqdArQiDLme6+qp0yhpPyuzsiSZk3adm7JWFFkL/Qd6vyA44Kd0XhgN4eWYlRc9u+p/LPwVsUCK0ZeVh0whDmh4FBqEnM9PB76q0/fdOofO/b7ZMRh74Yqi4pCFcImk1E6P87LMfKQ/3nnWzHK71ghZ7d2HmIss+aDZmxP6+uo9fI2T4Ke4GIWUEhEweThVVNAYDi86A=="
@@ -5,19 +5,19 @@
 DOTENV_PUBLIC_KEY_PRODUCTION="02f0469506f6722d8fcc179c199ff159ca32f082000c8e7a1465891adb50a4c031"

 # .env.production
-DEBUG="encrypted:BK1eaaKoyGmDyiuLd+fIdaEdCGyYgLyUv5tsNcXvZ8CTMMXi7SBcNSy0K5hI0VC0ptEIX7iO/sZQcQ1K0V9gBFCoNDpuTvO+c3bFKU2nKQ0BBULlXhJNDoETmZ2p9L7KLNDFYQ6d"
-PORT="encrypted:BOpbRvBpbB3ra5St/8dv2h/93aL1vu1rVbc9u/V0YZyvP6nJv88rToz2/zfyNDeqsjBA2IO4s3+v3ZtxSJ6XXwd3+or3++yGs7A8t7bGoxVRyzb0uluHh6hWx+DKdxZE7HIYAh0="
-NODE_ENV="encrypted:BORW/YY5Y5EV7Lh5L3fSOfKsbyH5/ZBtMH/iuurGnJZlvFhBsZTBm5ms02dLJgFN/F1HFYskR8xLyEnnCCndK3YpdzrPYbVYSPr5EuWsVeX6DbCROi7RY1Zd27kYBSA5QjxHJOxWCIL0djY="
-LOG_LEVEL="encrypted:BHAO8Gg4Y3bo9Cwi1+YOvtc0dSgYUS6+UWNTcHfWISsrv4XX1sj/T9wjEGb8Y6dCmenqPSSI0DaBaEoLXDG3S31mdhTPmMfNBWRQQFbIxrz17WtqIDN6MGiI7/6ki5qryzup6ME="
-BASE_URL="encrypted:BAAw6UxbwTW7snM4pjPLGsYtZGbyOSDR9BwIo2oPDGPernDYD5YS80ffc7N1cRpLt807Vg41YoDsuj5PnwjmU9Zg7rl6cUnFKnLcvuFHNWdiULcl7bPQjHgZq1/wXwmYRt8p1DOI1nAgZIaxf58hi/c/9pUy5IpE"
-DISCORD_APP_ID="encrypted:BEneta1lCVd+uZCdIEOCtilukJb8W/57BZRvSzg7a6MnFkNxqlT2CXiZH6kvO9k+s3qj8zCUdsb6vQP0BzLlmDmmFLQGMn6q/NOlYArn0WlIUz+81JvMOZnv1YH6uFnJczJugtPoBy8d9Jjvn1u6vT+6pfM="
-DISCORD_APP_SECRET="encrypted:BG4R0eH2AHda/W+EkwT82dhO1UAjQZAbrXfn0+vOeNT/E3EQZ3VH/o5N1Ed3Hjg/mf90jv+ey3HBimt747dN+IBgkzkYpbs44h/TVZukSPwN5wJR14nVRwtU+ZZYX9UUsb/wjWFn7n5DCCOIs2N5Z/bqbRw4mPruKwBzJ5SD8JgD"
-DISCORD_PUBLIC_KEY="encrypted:BBTLdwJa7/tbzH4bddef00+PpJN9ZKCnSKxIWLuc10oKkg5g5TRSt9cnTRZvAsWGeacKxrECyl2WjoPYYI0qqDPZv/OHRejQ1EwDpfEVJVVoL7Xdm3c5Ncs0Vog03al3gEMbc2Zs6X3Teyt4K96PybwZ/fyhqsoHwmJ0mSvafD+2ASYii3tP23TkFewtnOenlZTBblXGkLy5C9Vkvodu1Qg="
-DISCORD_BOT_TOKEN="encrypted:BKIDa8iPhX1BKarlpoJOd/qhn/wLz0LsSI3joaCKWcEWpRynWAU1e1lfAA85j1EzVsX2BE2AcUbDS+FDzuacRooOgXk1fcywf2RSA+skDqdSGwNXDUQvOlptTdGyb8Eq10MkQOtUCHn50npULOCFkoGVHunzHCOtLAKzq0n758X8SOswfdWgDLQP8vtB9BF6SfkCu93bDDeZU+gJvYU3x/GwLqlaaJdF0A=="
-EVE_CLIENT_ID="encrypted:BA6dxhE8M8b3pDjcXDFBPdMw8aIBd1CUlN+NqnzC9XCZUc5Y7g4n2le0NPk6BwlgbrM9iRRdxzNkfmXiopJ1C33N4t095F/qd2cHAmya05//XAEOnOjA8MYA889rA/Jn1TXY2dSrLfp8UAMFo2pdu7r8QDAXdRUWoefAW/CmD0vR"
-EVE_CLIENT_SECRET="encrypted:BP7JP9rGeAWdVBashqAcGmB9v2WstOu7jJiB72jyzEK8PtSXA8eZK4MdFjwkfilZJr9k0kQcIYH4E/koKEW6BANDr5Ph8pYRz+r/lS11fsoJ1HZhujPKyuKIaIVEHxGb94FU7bJb6tAE0ozEZPZzeEZFGKJe5x9dR8qbAuD3oRC9JbidH4Lu2kQ="
-EVE_CALLBACK_URL="encrypted:BBOyw5Un+FeDukVE387oHdUZ6k3rMn69WX0Wi8qVWhyW1koCKTAot5jgZA24tKq4JPI71kYb1/5Z7baZCNekfOSUQsVbuFH8g9I9KffWeIIW7AhKA0TWPZCVxGCEFIj/x54DqmXtCnd7YRxYxXaWaSVrCos7lZAR5mnoTN2hBEEQFCWOhA1cX4iP"
-ESI_USER_AGENT="encrypted:BADtioS3QPCdtq+RvA90WTk61cnHPadpaeTE4JJDEaWuFygvtbouvrcbPhp6MmkXTrVb1E6Fs6dS74ocCMP+4wSfE4UuJpDos2lTo5eHp/Y65ERqdByQbAUVPQ1tf1vuqrDqBYFiM3LfiQUnulASsmhGsDUgroxPTv0g4hv+4m5/DMR4mClgn5Cb+UoguJRRptWyZi5jCvXwxQzTtRQ1NYqr8WNNMA65oiGCkw=="
-AUTH_DB_PATH="encrypted:BOgXzNmmct1BCPLRgrKbrCtERDEUCxyv1gJPEQupSgVmxyjoDCZLu+7dgfMvB7AeDfy2BtelFDpT3geWg+zazyUZO2aN/EvEv56YShh6iTDFONXHWx6l+8uu+l7Dmj9saL8MCJRcTBv4AtYseu7Y4AErK4wbNAEF"
-JANICE_KEY="encrypted:BKdgDHUyDpAx5e72lhaOA33hszd6OTCz5p3cDk8AkkLK4JumLtKYJSelkKeHsl+jSSpYgLbwDgS42RL5bYBOJZUXmTCSn01PlxQguoseHzjtyd4HqdRtXtK3AucQOX27ZbY0tEZFzW467suq9NpDKie2cB3mdSJrfS/CJX58VgRi"
-PERPLEXITY_API_KEY="encrypted:BL8MWGlcOic+n/V0yWSWai2Pwo8lbYbjcRkD2N7uDf38ogp7dUUdye/1dNWYzjm+ICsWXi5SQNEDkSdysegsJmoUtxBtEnX0Y0GJrQZaY5MEFobSicV5sjSdlh2y1gDcRrGPmvgsDXL/ehs3PWzz2DI0J71BnsziR4CmumkzwSxqot/mtTQMJQaO3UKFXB0RL5bwCWwv"
+DEBUG="encrypted:BF6PvADokMt8oSk1Ds/RZ7dEnItXTOg0Uki6zTjQJEQoJRFf8hinyOG9+VDARuCPIZr7IsPZvfSezyxHamI+OP1AayiVAqEOeCBQuld3OGKQJIyulk3Q6nFQw0fBgtUvc9VGnQca"
+PORT="encrypted:BP8VaMu/Zo/nvIht/n8zQEm/ssHcbWXQyezmMV3/CiVYZbo8qiX3p0GgKxdX4Tkqe6DLlwlJZ/VoOiDFUqc8fMfmmDHjHh9yioNRjcRKslig7yp4iLdX5mhnJdRMSi+EilQyFjE="
+NODE_ENV="encrypted:BF2gW1Y8JWYcBbbWx6MK2sMlkegd2uQgFXxGxTRrOxgeaVxLi1AP/UQ7Ao7qWSYka3wDUjTLWX0In/dSjPYCvGIYUNEYH3lr2C8caMggGR0JmqLnNgOGYSYEDYCfisY13Nv3sib4AHj20EE="
+LOG_LEVEL="encrypted:BErRZbw6FiMgGQhHoAhfVrYBdJiKV3w9qSQjZ0Hvtd+M3TIeHLh09Ysh9mhbwsfMwlbdL/1DCsQanVHoT8PXQ9lyb0Zmc+4BL3xuP89C5VSKs87le6RCurWIZrMYJRxPvmzKkbI="
+BASE_URL="encrypted:BBai7w4VNQCcGG5j0ETyPfLqcmggfSd/lEMDz4W6S5IedPS2RA3p4XsCMIP2Todfvc7OZ1bwoTfI6mJWLogUagdb3XbHKNNN45XTOyNQuat1H1gbOSZ4Cty0uRSP/rkOTrZJ0j7vlvhUwRH0l7NFkO0LtJphCdDm"
+DISCORD_APP_ID="encrypted:BL+d85ZIkW+iEo5XaGs4x42FsN1Ep1/A+QY3DjY8/QLUn6+NAXQC2C5n2meJMlLqnRBmKavBJYnSlHykeZ7tnQxevnIyDDWzQnz2iv9sPeGQi4XeuhOQykG50a/5gQ02AYcwa+TA4/9pu8WtMsOD7kimq3A="
+DISCORD_APP_SECRET="encrypted:BOr71InqmbCeyQyg4mox0vIwicahQV/UoNc8bfhD+bUN0cyGQS+TTn1Yz8N9jsEdFgbU3bJOVb1SX9RYpOLY8gfw6xeRqjFhljpGSdBed6BSHbfqGqjqDXnEgMB55SzCyDllvhxdW6+kEAP9WrTLeSfrLTGBCya0eDRcLTBGpgUv"
+DISCORD_PUBLIC_KEY="encrypted:BKtpTFt6+JYYriiLz5O/AK+7zshnXIjYfxRxLtwQTQ5OOUseqayPCONnH1HZGFcE9oY0cFYT2dPmODeRj9li2A/Seo3kNMlyuTQ/kS2Zlx6k+OcmIfwU/xSFUKlwp85F4lqLuaWiGjMC9Nrj2ps6zwqoKYJavixOGawfyWaTLr39dBGoMpX4jBQagAbc3lNcBSRFbPfnef3WI3iLYDbdsCQ="
+DISCORD_BOT_TOKEN="encrypted:BK2KaxCK0DYK81HtZSSRYeEA/zgZfVYQNTHWegJyztI4FDHs3TkIlXuFuRbU50uK9ya5tCP/FgzueFdmS2Rp7PAVlgCblPc2obl9/fjrSpvaT3zN8AForAolTXV2Ry1VQ9CiQdEFoBaRC5RKkIfRiwBQDSxIwFsuUR0SnuloIZYQvR9qu/3GiKzOsWF+FLXCkWyQdbirjHo09U3/3Qc6pxiSC1gZ3kikRA=="
+EVE_CLIENT_ID="encrypted:BEN5my5q8yTJJnuMC/6YW8UdtFa4KszUUeZYp2gLi9BeJ/Mstk0GFDba+LekpumLX7KGy/tRXoFI9ltfuLvny/R9SL6TibZg6//7f+XjWUIZloxa/IqvDF7MnMUOOKLopg8ZMRsOrPsR808o9Rv8O8T4JVoBsqnM00yRAhyQsDWa"
+EVE_CLIENT_SECRET="encrypted:BEM+Sxt3n+bzRKek8n6J4dts1b8Yytp+kLszyOpE44E/yo7gajxyHXNoEKfuanL3Y9YBzgmB7le4fGut3YXu4lUHezQ1m00zzcLlt1bZPkiWlGYme0zrGEBVqOzJgw0vUQhlkm/4AO5+E1mG5kheF4WkzoQsbhMScCMUFfJAUkVVTJ8c9ZOt0fY="
+EVE_CALLBACK_URL="encrypted:BHmIETmqbpGT6QejOehx+LSXVidFGbiGFafEDsJEYyt4VmAqnCUo7rw7G1tdLzf+ynfop0oHCpWXqpmtsP3bCzpVWsif7jAcqTNf1oKWy5QvccPmWQQoKE2Ifiy5qR19JFBiOQGP5mTKM/Vc4b8BrpTCwZaQy5m4G4I9YAqA0Ep2R6J4bpBO4kcu"
+ESI_USER_AGENT="encrypted:BOC6xT8ZwROV/hqNmjZDMk752uDYkT46FNQ/bfJGAFq75/vw7Vu6W7Xz/kOtitexTnT6xMZkXNFjqDHQHjRU2hN/hs0PR6Hlr4rSwZRbmOntmMDCZpZ8TnqCstohn3CWjtuvvZuZluYTa5Nw9Iiep6wp1C283W1On4VXnZuucPmBsftFXW0bKbsvxfoRUtMqadzAhbl9UgmJ7ErzxdTdbrvKjWRqLK3VQrlVFQ=="
+AUTH_DB_PATH="encrypted:BBUzPUjOjm73tcws/dvjNxpzEoXoG9kxAHgO5hks4wyb5MEt31BkIhnhsgtMGuBML2OAgGeyPR7OsZb0OnnrTwFucg6h2+TPOsXOGEfaTeXd8j+gJQhw4UQxzaq3bJ4s60Q2nN1wAc5cjY2eEfRCvCcPHxjDgHgf"
+JANICE_KEY="encrypted:BOnItoM8FT8KCmIEnHgZcmMlMIy2uqz0xOe136GoPGKhZp7VSZFm7Fl+PXaYiS6lVIsTL7Gq3EK98+9yxKbWBYby9ubQkz7WLz9qqKhjVfdT45sEt6o9ABBXEew4KQ3VXtF/HzlUd699+0nQOmWqJ3Ym0IkBFoDIatfHkL15o1AJ"
+PERPLEXITY_API_KEY="encrypted:BJA5fdBCnPIuAS/M5MrQ1GR7lKzBmPzEo7Y3TgXthfZgi8LDyIbmqsNp5OTL1565/brlBqrhiWtA734EmfPcwgJ8OA5X4V07HTkpLTsOdocohNiZO8bpXPQQVBGhfoomDqOqDqU60gAraKrzFXi364wMvq6t1a+k8saTM8cUpoo2A6hQlvw9qBYWbt58GbzKNh+wOIHJ"
@@ -5,12 +5,14 @@
  "private": true,
  "devDependencies": {
    "@dotenvx/dotenvx": "^1.52.0",
-    "@types/bun": "^1.3.9"
+    "@types/bun": "^1.3.9",
+    "tsdown": "^0.20.3"
  },
  "peerDependencies": {
    "typescript": "^5"
  },
  "dependencies": {
+    "@star-kitten/util": "workspace:*",
    "@duckdb/node-api": "^1.4.4-r.1",
    "neo4j-driver": "^6.0.1",
    "pg": "^8.18.0",
@@ -24,6 +26,11 @@
    "dev": "bunx @dotenvx/dotenvx run -f .env.development -- bun run src/main.ts && tsdown --watch",
    "build": "bunx @dotenvx/dotenvx run -f .env.production -- bun src/main.ts && tsdown",
    "encrypt": "bunx dotenvx encrypt -f .env.development && bunx dotenvx encrypt -f .env.production",
-    "decrypt": "bunx dotenvx decrypt -f .env.development && bunx dotenvx decrypt -f .env.production"
+    "decrypt": "bunx dotenvx decrypt -f .env.development && bunx dotenvx decrypt -f .env.production",
+    "everef-api": "bunx openapi-typescript https://raw.githubusercontent.com/autonomouslogic/eve-ref/refs/heads/main/spec/eve-ref-api.yaml -o src/eve/everef/schema.d.ts",
+    "get-data": "bun run refresh:reference-data && bun run refresh:hoboleaks",
+    "refresh:reference-data": "bun run src/download-and-extract.ts https://data.everef.net/reference-data/reference-data-latest.tar.xz ./data/reference-data",
+    "refresh:hoboleaks": "bun run src/download-and-extract.ts https://data.everef.net/hoboleaks-sde/hoboleaks-sde-latest.tar.xz ./data/hoboleaks",
+    "static-export": "bun run src/export-solar-systems.ts"
  }
 }
@@ -0,0 +1,129 @@
+import { fetchIdsOfType, fetchReferenceData, RefDataType } from './fetch';
+import type { LocalizedString } from './shared-types';
+
+export interface Attribute {
+  readonly attribute_id: number;
+  readonly category_id: number;
+  readonly data_type: number;
+  readonly default_value: number;
+  readonly description: LocalizedString;
+  readonly high_is_good: boolean;
+  readonly icon_id?: number;
+  readonly name: string;
+  readonly published: boolean;
+  readonly stackable: boolean;
+  readonly unit_id?: number;
+  readonly display_name: LocalizedString;
+  readonly tooltip_title?: LocalizedString;
+  readonly tooltip_description?: LocalizedString;
+}
+
+export const getAttribute = async (id: number) => {
+  const data = await fetchReferenceData<Attribute>(id, RefDataType.ATTRIBUTE);
+  if (!data) throw new Error(`Attribute ID ${id} not found in reference data`);
+  return data;
+};
+
+export enum CommonAttribute {
+  // Structure
+  StructureHitpoints = 9,
+  CargoCapacity = 38,
+  DroneCapacity = 283,
+  DroneBandwidth = 1271,
+  Mass = 4,
+  Volume = 161,
+  InertiaModifier = 70,
+  StructureEMResistance = 113,
+  StructureThermalResistance = 110,
+  StructureKineticResistance = 109,
+  StructureExplosiveResistance = 111,
+
+  // Armor
+  ArmorHitpoints = 265,
+  ArmorEMResistance = 267,
+  ArmorThermalResistance = 270,
+  ArmorKineticResistance = 269,
+  ArmorExplosiveResistance = 268,
+
+  // Shield
+  ShieldCapacity = 263,
+  ShieldRechargeTime = 479,
+  ShieldEMResistance = 271,
+  ShieldThermalResistance = 274,
+  ShieldKineticResistance = 273,
+  ShieldExplosiveResistance = 272,
+
+  // Electronic Resistances
+  CapacitorWarfareResistance = 2045,
+  StasisWebifierResistance = 2115,
+  WeaponDisruptionResistance = 2113,
+
+  // Capacitor
+  CapacitorCapacity = 482,
+  CapacitorRechargeTime = 55,
+
+  // Targeting
+  MaxTargetRange = 76,
+  MaxLockedTargets = 192,
+  SignatureRadius = 552,
+  ScanResolution = 564,
+  RadarSensorStrength = 208,
+  MagnetometricSensorStrength = 210,
+  GravimetricSensorStrength = 211,
+  LadarSensorStrength = 209,
+
+  // Jump Drive Systems
+  HasJumpDrive = 861,
+  JumpDriveCapacitorNeed = 898,
+  MaxJumpRange = 867,
+  JumpDriveFuelNeed = 866,
+  JumpDriveConsumptionAmount = 868,
+  FuelBayCapacity = 1549,
+  ConduitJumpConsumptionAmount = 3131,
+  COnduitJumpPassengerCapacity = 3133,
+
+  // Propulsion
+  MaxVelocity = 37,
+  WarpSpeed = 600,
+
+  // FITTING
+
+  // Slots
+  HighSlots = 14,
+  MediumSlots = 13,
+  LowSlots = 12,
+
+  // Stats
+  PowergridOutput = 11,
+  CPUOutput = 48,
+  TurretHardpoints = 102,
+  LauncherHardpoints = 101,
+
+  // Rigging
+  RigSlots = 1137,
+  RigSize = 1547,
+  Calibration = 1132,
+
+  // Module
+  CPUUsage = 50,
+  PowergridUsage = 30,
+  ActivationCost = 6,
+
+  // EWAR
+  MaxVelocityBonus = 20,
+  WarpScrambleStrength = 105,
+  WarpDisruptionStrength = 2425,
+  WarpDisruptionRange = 103,
+
+  // Weapon
+  DamageMultiplier = 64,
+  AccuracyFalloff = 158,
+  OptimalRange = 54,
+  RateOfFire = 51,
+  TrackingSpeed = 160,
+  ReloadTime = 1795,
+  ActivationTime = 73,
+  UsedWithCharge1 = 604,
+  UsedWithCharge2 = 605,
+  ChargeSize = 128,
+}
@@ -0,0 +1,140 @@
+import { ActivityType, type TypeIDQuantity } from './shared-types';
+import type { Type } from './type';
+import { getType } from './type';
+import { dataSets, loadModels } from './loadModels';
+
+export interface Activity {
+  time: number;
+}
+
+export interface ManufacturingActivity extends Activity {
+  time: number;
+  materials: { [type_id: string]: TypeIDQuantity };
+  products: { [type_id: string]: TypeIDQuantity };
+}
+
+export interface InventionActivity extends Activity {
+  time: number;
+  materials: { [type_id: string]: TypeIDQuantity };
+  products: { [type_id: string]: TypeIDQuantity };
+  skills: { [skill_type_id: string]: number }; // skill_type_id : level
+}
+
+export interface TypeQuantity {
+  type: Type;
+  quantity: number;
+}
+
+export interface Blueprint {
+  readonly blueprint_type_id: number;
+  readonly max_production_limit: number;
+  readonly activities: {
+    [ActivityType.MANUFACTURING]?: ManufacturingActivity;
+    [ActivityType.RESEARCH_MATERIAL]?: Activity;
+    [ActivityType.RESEARCH_TIME]?: Activity;
+    [ActivityType.COPYING]?: Activity;
+    [ActivityType.INVENTION]?: InventionActivity;
+  };
+}
+
+export function getBlueprint(blueprint_type_id: number): Blueprint {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.blueprints[String(blueprint_type_id)];
+  if (!data) throw new Error(`Blueprint Type ID ${blueprint_type_id} not found in reference data`);
+  return data;
+}
+
+export function getManufacturingMaterials(blueprint: Blueprint):
+  | any[]
+  | Promise<
+      {
+        type: Type;
+        quantity: number;
+      }[]
+    > {
+  const manufacturing = blueprint.activities[ActivityType.MANUFACTURING];
+  if (!manufacturing) return [];
+
+  return Promise.all(
+    Object.entries(manufacturing.materials).map(([type_id, { quantity }]) => ({
+      type: getType(parseInt(type_id)),
+      quantity,
+    })),
+  );
+}
+
+export function getManufacturingProducts(blueprint: Blueprint):
+  | any[]
+  | Promise<
+      {
+        type: Type;
+        quantity: number;
+      }[]
+    > {
+  const manufacturing = blueprint.activities[ActivityType.MANUFACTURING];
+  if (!manufacturing) return [];
+
+  return Promise.all(
+    Object.entries(manufacturing.products).map(([type_id, { quantity }]) => ({
+      type: getType(parseInt(type_id)),
+      quantity,
+    })),
+  );
+}
+
+export function getInventionMaterials(blueprint: Blueprint):
+  | any[]
+  | Promise<
+      {
+        type: Type;
+        quantity: number;
+      }[]
+    > {
+  const invention = blueprint.activities[ActivityType.INVENTION];
+  if (!invention) return [];
+
+  return Promise.all(
+    Object.entries(invention.materials).map(([type_id, { quantity }]) => ({
+      type: getType(parseInt(type_id)),
+      quantity,
+    })),
+  );
+}
+
+export function getInventionProducts(blueprint: Blueprint):
+  | any[]
+  | Promise<
+      {
+        type: Type;
+        quantity: number;
+      }[]
+    > {
+  const invention = blueprint.activities[ActivityType.INVENTION];
+  if (!invention) return [];
+
+  return Promise.all(
+    Object.entries(invention.products).map(([type_id, { quantity }]) => ({
+      type: getType(parseInt(type_id)),
+      quantity,
+    })),
+  );
+}
+
+export function getInventionSkills(blueprint: Blueprint):
+  | any[]
+  | Promise<
+      {
+        type: Type;
+        level: number;
+      }[]
+    > {
+  const invention = blueprint.activities[ActivityType.INVENTION];
+  if (!invention) return [];
+
+  return Promise.all(
+    Object.entries(invention.skills).map(([skill_type_id, level]) => ({
+      type: getType(parseInt(skill_type_id)),
+      level,
+    })),
+  );
+}
@@ -0,0 +1,35 @@
+import type { LocalizedString } from './shared-types';
+import { dataSets, loadModels } from './loadModels';
+
+export enum CommonCategory {
+  CARGO = 5,
+  SHIP = 6,
+  MODULE = 7,
+  CHARGE = 8,
+  BLUEPRINT = 9,
+  SKILL = 16,
+  DRONE = 18,
+  IMPLANT = 20,
+  APPAREL = 30,
+  DEPLOYABLE = 22,
+  REACTION = 24,
+  SUBSYSTEM = 32,
+  STRUCTURE = 65,
+  STRUCTURE_MODULE = 66,
+  FIGHTER = 87,
+}
+
+export interface Category {
+  readonly category_id: number;
+  readonly name: LocalizedString;
+  readonly published: boolean;
+  readonly group_ids: number[];
+  readonly icon_id?: number;
+}
+
+export function getCategory(category_id: number): Category {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.categories[String(category_id)];
+  if (!data) throw new Error(`Category ID ${category_id} not found in reference data`);
+  return data;
+}
@@ -0,0 +1,65 @@
+import { getAttribute, type Attribute } from './attribute';
+import type { LocalizedString } from './shared-types';
+import { dataSets, loadModels } from './loadModels';
+
+interface Modifier {
+  domain: number;
+  func: number;
+  group_id?: number;
+  modified_attribute_id: number;
+  modifying_attribute_id: number;
+  skill_type_id?: number;
+  operator: number;
+}
+
+export interface Effect {
+  readonly effect_id: number;
+  readonly disallow_auto_repeat: boolean;
+  readonly discharge_attribute_id?: number;
+  readonly distribution?: number;
+  readonly duration_attribute_id?: number;
+  readonly effect_category: number;
+  readonly effect_name: string;
+  readonly electronic_chance: boolean;
+  readonly falloff_attribute_id?: number;
+  readonly guid: string;
+  readonly is_assistance: boolean;
+  readonly is_offensive: boolean;
+  readonly is_warp_safe: boolean;
+  readonly propulsion_chance: boolean;
+  readonly published: boolean;
+  readonly range_attribute_id?: number;
+  readonly range_chance: boolean;
+  readonly modifiers: Modifier[];
+  readonly tracking_speed_attribute_id?: number;
+  readonly description: LocalizedString;
+  readonly display_name: LocalizedString;
+  readonly name: string;
+}
+
+export function getEffect(effect_id: number): Effect {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.dogma_effects[String(effect_id)];
+  if (!data) throw new Error(`Effect ID ${effect_id} not found in reference data`);
+  return data;
+}
+
+export function getDischargeAttribute(effect: Effect): Attribute {
+  return effect.discharge_attribute_id && getAttribute(effect.discharge_attribute_id);
+}
+
+export function getFalloffAttribute(effect: Effect): Attribute {
+  return effect.falloff_attribute_id && getAttribute(effect.falloff_attribute_id);
+}
+
+export function getDurationAttribute(effect: Effect): Attribute {
+  return effect.duration_attribute_id && getAttribute(effect.duration_attribute_id);
+}
+
+export function getRangeAttribute(effect: Effect): Attribute {
+  return effect.range_attribute_id && getAttribute(effect.range_attribute_id);
+}
+
+export function getTrackingSpeedAttribute(effect: Effect): Attribute {
+  return effect.tracking_speed_attribute_id && getAttribute(effect.tracking_speed_attribute_id);
+}
@@ -0,0 +1,50 @@
+import { asyncKV } from "@star-kitten/util";
+
+export enum RefDataType {
+    BLUEPRINT = 'blueprints',
+    CATEGORY = 'cateogories',
+    ATTRIBUTE = 'dogma_attributes',
+    EFFECT = 'dogma_effects',
+    GROUP = 'groups',
+    ICON = 'icons',
+    MARKET_GROUP = 'market_groups',
+    META_GROUP = 'meta_groups',
+    MUTAPLASMID = 'mutaplasmids',
+    REGION = 'regions',
+    SCHEMATIC = 'schematics',
+    SKILL = 'skills',
+    TYPE = 'types',
+    UNIT = 'units',
+}
+
+const REF_DATA_BASE_URL = 'https://ref-data.everef.net';
+export async function fetchReferenceData<T>(id: number, type: RefDataType) {
+    const key = `${type}/${id}`;
+    if (await asyncKV.has(key)) {
+        return JSON.parse(await asyncKV.get(key)) as T;
+    }
+    let url = new URL(REF_DATA_BASE_URL);
+    url.pathname = `${type}/${id}`;
+    const result = await fetch(url);
+    if (result.ok) {
+        const text = await result.text();
+        await asyncKV.set(key, text);
+        return JSON.parse(text) as T;
+    }
+    throw new Error(`${type} id ${id} not found in reference data.`);
+}
+
+export async function fetchIdsOfType(type: RefDataType) {
+    let url = new URL(REF_DATA_BASE_URL);
+    url.pathname = type;
+    const result = await fetch(url);
+    if (result.ok) {
+        return (await result.json()) as number[];
+    }
+}
+
+export async function loadAll(type: RefDataType) {
+  const ids = await fetchIdsOfType(type);
+  const promises = ids.map(id => fetchReferenceData(id, type));
+  await Promise.all(promises);
+}
@@ -0,0 +1,29 @@
+import type { LocalizedString } from './shared-types';
+import { dataSets, loadModels } from './loadModels';
+
+export interface Group {
+  readonly group_id: number;
+  readonly category_id: number;
+  readonly name: LocalizedString;
+  readonly published: boolean;
+  readonly icon_id?: number;
+  readonly anchorable: boolean;
+  readonly anchored: boolean;
+  readonly fittable_non_singleton: boolean;
+  readonly use_base_price: boolean;
+  readonly type_ids?: number[];
+}
+export function getGroup(group_id: number): Group {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.groups[String(group_id)];
+  if (!data) throw new Error(`Group ID ${group_id} not found in reference data`);
+  return data;
+}
+
+export function groupEveRefLink(group_id: number) {
+  return `https://everef.net/groups/${group_id}`;
+}
+
+export function renderGroupEveRefLink(group: Group, locale: string = 'en') {
+  return `[${group.name[locale] ?? group.name.en}](${groupEveRefLink(group.group_id)})`;
+}
@@ -0,0 +1,37 @@
+import { dataSets, loadModels } from './loadModels';
+
+export enum IconSize {
+  SIZE_32 = 32,
+  SIZE_64 = 64,
+  SIZE_128 = 128,
+  SIZE_256 = 256,
+  SIZE_512 = 512,
+}
+
+export interface Icon {
+  readonly icon_id: number;
+  readonly description: string;
+  readonly file: string;
+}
+
+export function getIcon(icon_id: number): Icon {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.icons[String(icon_id)];
+  if (!data) throw new Error(`Icon ID ${icon_id} not found in reference data`);
+  return data;
+}
+
+export function getIconUrl(
+  icon_id: Icon,
+  {
+    size = IconSize.SIZE_64,
+    isBp = false,
+    isBpc = false,
+  }: {
+    size?: IconSize;
+    isBp?: boolean;
+    isBpc?: boolean;
+  } = {},
+): string {
+  return `https://images.evetech.net/types/${icon_id}/icon${isBp ? '/bp' : isBpc ? '/bpc' : ''}?size=${size}`;
+}
@@ -0,0 +1,14 @@
+export * from './attribute';
+export * from './blueprint';
+export * from './category';
+export * from './effect';
+export * from './group';
+export * from './icon';
+export * from './market-group';
+export * from './meta-group';
+export * from './region';
+export * from './schematic';
+export * from './skill';
+export * from './solar-system';
+export * from './type';
+export * from './unit';
@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import { join } from 'node:path';
+import type { Unit } from './unit';
+import type { SolarSystem } from './solar-system';
+import type { Attribute } from './attribute';
+import type { Blueprint } from './blueprint';
+import type { Category } from './category';
+import type { Effect } from './effect';
+import type { Group } from './group';
+import type { Icon } from './icon';
+import type { MarketGroup } from './market-group';
+import type { MetaGroup } from './meta-group';
+import type { Region } from './region';
+import type { Schematic } from './schematic';
+import type { Skill } from './skill';
+import type { Type } from './type';
+
+const dataSets = {
+  loaded: false,
+  dogma_attributes: {} as Record<string, Attribute>,
+  blueprints: {} as Record<string, Blueprint>,
+  categories: {} as Record<string, Category>,
+  dogma_effects: {} as Record<string, Effect>,
+  groups: {} as Record<string, Group>,
+  icons: {} as Record<string, Icon>,
+  market_groups: {} as Record<string, MarketGroup>,
+  meta_groups: {} as Record<string, MetaGroup>,
+  regions: {} as Record<string, Region>,
+  schematics: {} as Record<string, Schematic>,
+  skills: {} as Record<string, Skill>,
+  solar_systems: {} as Record<string, SolarSystem>,
+  types: {} as Record<string, Type>,
+  units: {} as Record<string, Unit>,
+};
+export async function loadModels(): Promise<void> {
+  dataSets.dogma_attributes = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/dogma_attributes.json')).toString());
+  dataSets.blueprints = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/blueprints.json')).toString());
+  dataSets.categories = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/categories.json')).toString());
+  dataSets.dogma_effects = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/dogma_effects.json')).toString());
+  dataSets.groups = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/groups.json')).toString());
+  dataSets.icons = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/icons.json')).toString());
+  dataSets.market_groups = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/market_groups.json')).toString());
+  dataSets.meta_groups = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/meta_groups.json')).toString());
+  dataSets.regions = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/regions.json')).toString());
+  dataSets.schematics = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/schematics.json')).toString());
+  dataSets.skills = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/skills.json')).toString());
+  dataSets.solar_systems = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/solar_systems.json')).toString());
+  dataSets.types = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/types.json')).toString());
+  dataSets.units = JSON.parse(fs.readFileSync(join(__dirname, './data/reference-data/units.json')).toString());
+  dataSets.loaded = true;
+}
+
+export { dataSets };
@@ -0,0 +1,24 @@
+import type { LocalizedString } from './shared-types';
+import { dataSets, loadModels } from './loadModels';
+
+export interface MarketGroup {
+  readonly market_group_id: number;
+  readonly parent_group_id: number;
+  readonly name: LocalizedString;
+  readonly description: LocalizedString;
+  readonly child_market_group_ids: number[];
+  readonly icon_id: number;
+  readonly has_types: boolean;
+}
+
+export function getMarketGroup(market_group_id: number): MarketGroup {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.market_groups[String(market_group_id)];
+  if (!data) throw new Error(`Market group ID ${market_group_id} not found in reference data`);
+  return data;
+}
+
+export async function getAllChildMarketGroups(marketGroup: MarketGroup): Promise<MarketGroup[]> {
+  const children = await Promise.all(marketGroup.child_market_group_ids.map((id) => getMarketGroup(id)));
+  return children.concat(...(await Promise.all(children.map((child) => getAllChildMarketGroups(child)))));
+}
@@ -0,0 +1,17 @@
+import type { LocalizedString } from './shared-types';
+import { dataSets, loadModels } from './loadModels';
+
+export interface MetaGroup {
+  readonly meta_group_id: number;
+  readonly name: LocalizedString;
+  readonly type_ids: number[];
+  readonly icon_id?: number;
+  readonly icon_suffix?: string;
+}
+
+export function getMetaGroup(meta_group_id: number): MetaGroup {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.meta_groups[String(meta_group_id)];
+  if (!data) throw new Error(`Meta group ID ${meta_group_id} not found in reference data`);
+  return data;
+}
@@ -0,0 +1,24 @@
+import type { LocalizedString, Position } from './shared-types';
+import { dataSets, loadModels } from './loadModels';
+
+export interface Region {
+  readonly region_id: number;
+  readonly center: Position;
+  readonly description_id: number;
+  readonly faction_id: number;
+  readonly max: Position;
+  readonly min: Position;
+  readonly name_id: number;
+  readonly wormhole_class_id?: number;
+  readonly nebula_id?: number;
+  readonly universe_id: string;
+  readonly description: LocalizedString;
+  readonly name: LocalizedString;
+}
+
+export function getRegion(region_id: number): Region {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.regions[String(region_id)];
+  if (!data) throw new Error(`Region ID ${region_id} not found in reference data`);
+  return data;
+}
@@ -0,0 +1,43 @@
+import type { LocalizedString, TypeIDQuantity } from './shared-types';
+import { getType, type Type } from './type';
+import { dataSets, loadModels } from './loadModels';
+
+export interface Schematic {
+  readonly schematic_id: number;
+  readonly cycle_time: number;
+  readonly name: LocalizedString;
+  readonly materials: { [type_id: string]: TypeIDQuantity };
+  readonly products: { [type_id: string]: TypeIDQuantity };
+  readonly pin_type_ids: number[];
+}
+
+export function getSchematic(schematic_id: number): Schematic {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.schematics[String(schematic_id)];
+  if (!data) throw new Error(`Schematic ID ${schematic_id} not found in reference data`);
+  return data;
+}
+
+export function getMaterialQuantities(schematic: Schematic): {
+  type: Type;
+  quantity: number;
+}[] {
+  return Object.entries(schematic.materials).map(([type_id, { quantity }]) => ({
+    type: getType(Number(type_id)),
+    quantity,
+  }));
+}
+
+export function getProductQuantities(schematic: Schematic): {
+  type: Type;
+  quantity: number;
+}[] {
+  return Object.entries(schematic.products).map(([type_id, { quantity }]) => ({
+    type: getType(Number(type_id)),
+    quantity,
+  }));
+}
+
+export function getPinTypes(schematic: Schematic): Type[] {
+  return schematic.pin_type_ids.map(getType);
+}
@@ -0,0 +1,56 @@
+import type { Type } from './type';
+
+export interface LocalizedString {
+  de?: string;
+  en?: string;
+  es?: string;
+  fr?: string;
+  ja?: string;
+  ko?: string;
+  ru?: string;
+  zh?: string;
+}
+
+export interface TypeIDQuantity {
+  type_id: number;
+  quantity: number;
+}
+
+export interface TypeQuantity {
+  type: Type;
+  quantity: number;
+}
+
+export interface AttributeIDValue {
+  attribute_id: number;
+  value: number;
+}
+
+export interface EffectIDDefault {
+  effect_id: number;
+  is_default: boolean;
+}
+
+export interface MaterialIDQuantity {
+  material_type_id: number;
+  quantity: number;
+}
+
+export interface BlueprintTypeIDActivity {
+  blueprint_type_id: number;
+  blueprint_activity: ActivityType;
+}
+
+export enum ActivityType {
+  MANUFACTURING = 'manufacturing',
+  RESEARCH_MATERIAL = 'research_material',
+  RESEARCH_TIME = 'research_time',
+  COPYING = 'copying',
+  INVENTION = 'invention',
+}
+
+export interface Position {
+  x: number;
+  y: number;
+  z: number;
+}
@@ -0,0 +1,55 @@
+import { type Attribute, getAttribute } from './attribute';
+import { dataSets, loadModels } from './loadModels';
+
+export interface Skill {
+  readonly type_id: number;
+  readonly primary_dogma_attribute_id: number;
+  readonly secondary_dogma_attribute_id: number;
+  readonly primary_character_attribute_id: number;
+  readonly secondary_character_attribute_id: number;
+  readonly training_time_multiplier: number;
+  readonly required_skills?: { [skill_type_id: string]: number }; // skill_type_id : level
+}
+
+export function getSkill(type_id: number): Skill {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.skills[String(type_id)];
+  if (!data) throw new Error(`Skill ID ${type_id} not found in reference data`);
+  return data;
+}
+
+export function getPrimaryDogmaAttribute(skill: Skill): Attribute {
+  return getAttribute(skill.primary_dogma_attribute_id);
+}
+
+export function getSecondaryDogmaAttribute(skill: Skill): Attribute {
+  return getAttribute(skill.secondary_dogma_attribute_id);
+}
+
+export function getPrimaryCharacterAttribute(skill: Skill): Attribute {
+  return getAttribute(skill.primary_character_attribute_id);
+}
+
+export function getSecondaryCharacterAttribute(skill: Skill): Attribute {
+  return getAttribute(skill.secondary_character_attribute_id);
+}
+
+export function getPrerequisites(skill: Skill): { skill: Skill; level: number }[] {
+  if (!skill.required_skills) return [];
+  return Object.entries(skill.required_skills).map(([skill_type_id, level]) => ({
+    skill: getSkill(parseInt(skill_type_id)),
+    level,
+  }));
+}
+
+export function skillpointsAtLevel(skill: Skill, level: number): number {
+  return Math.pow(2, 2.5 * (level - 1)) * 250 * skill.training_time_multiplier;
+}
+
+export function totalSkillpoints(skill: Skill, level: number): number {
+  let total = 0;
+  for (let i = 1; i <= level; i++) {
+    total += skillpointsAtLevel(skill, i);
+  }
+  return total;
+}
@@ -0,0 +1,42 @@
+import { dataSets, loadModels } from './loadModels';
+
+export interface SolarSystem {
+  readonly regionID: number;
+  readonly constellationID: number;
+  readonly solarSystemID: number;
+  readonly solarSystemName: string;
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly xMin: number;
+  readonly xMax: number;
+  readonly yMin: number;
+  readonly yMax: number;
+  readonly zMin: number;
+  readonly zMax: number;
+  readonly luminosity: number;
+  readonly border: boolean;
+  readonly fringe: boolean;
+  readonly corridor: boolean;
+  readonly hub: boolean;
+  readonly international: boolean;
+  readonly regional: boolean;
+  readonly security: number;
+  readonly factionID: number;
+  readonly radius: number;
+  readonly sunTypeID: number;
+  readonly securityClass: string;
+}
+
+export function getSolarSystem(solarSystemID: number): SolarSystem {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.solar_systems[String(solarSystemID)] as any;
+  if (!data) throw new Error(`Solar System ID ${solarSystemID} not found in reference data`);
+  return {
+    ...data,
+    security: parseFloat(data.security),
+    radius: parseFloat(data.radius),
+    sunTypeID: parseInt(data.sun_type_id, 10),
+    securityClass: data.security_class ?? 'nullsec', // Default to 'nullsec' if security_class is not present
+  };
+}
@@ -0,0 +1,224 @@
+import type {
+  ActivityType,
+  AttributeIDValue,
+  BlueprintTypeIDActivity,
+  EffectIDDefault,
+  LocalizedString,
+  MaterialIDQuantity,
+} from './shared-types';
+import { IconSize } from './icon';
+import { getUnit, type Unit } from './unit';
+import { CommonAttribute, getAttribute, type Attribute } from './attribute';
+import { getGroup, type Group } from './group';
+import { getMetaGroup, type MetaGroup } from './meta-group';
+import { dataSets, loadModels } from './loadModels';
+
+interface Masteries {
+  '0': number[];
+  '1': number[];
+  '2': number[];
+  '3': number[];
+  '4': number[];
+}
+
+interface Bonus {
+  bonus: number;
+  bonus_text: LocalizedString;
+  importance: number;
+  unit_id: number;
+}
+
+interface Traits {
+  misc_bonuses: { [level: string]: Bonus };
+  role_bonuses: { [level: string]: Bonus };
+  types: { [skill_type_id: string]: { [order: string]: Bonus } };
+}
+
+export interface Type {
+  readonly type_id: number;
+  readonly name: LocalizedString;
+  readonly description: LocalizedString;
+  readonly published: boolean;
+  readonly group_id?: number;
+  readonly base_price?: number;
+  readonly capacity?: number;
+  readonly faction_id?: number;
+  readonly graphic_id?: number;
+  readonly market_group_id?: number;
+  readonly mass?: number;
+  readonly masteries?: Masteries;
+  readonly meta_group_id?: number;
+  readonly portion_size?: number;
+  readonly race_id?: number;
+  readonly radius?: number;
+  readonly sof_faction_name?: string;
+  readonly sound_id?: number;
+  readonly traits?: Traits;
+  readonly volume?: number;
+  readonly dogma_attributes?: {
+    [attribute_id: string]: AttributeIDValue;
+  };
+  readonly dogma_effects?: { [effect_id: string]: EffectIDDefault };
+  readonly packaged_volume?: number;
+  readonly type_materials?: { [type_id: string]: MaterialIDQuantity };
+  readonly required_skills?: { [skill_type_id: string]: number }; // skill_type_id : level
+  readonly type_variations?: { [meta_group_id: string]: number[] }; // meta_group_id : type_ids[]
+  readonly produced_by_blueprints?: {
+    [blueprint_type_id: string]: BlueprintTypeIDActivity;
+  }; // blueprint_type_id : blueprint_activity
+  readonly buildable_pin_type_ids?: number[];
+  readonly is_ore?: boolean;
+  readonly ore_variations?: { [variant: string]: number }; // variant : type_id
+  readonly produced_by_schematic_ids?: number[];
+  readonly used_by_schematic_ids?: number[];
+  readonly is_blueprint?: boolean;
+}
+
+export function getType(type_id: number): Type {
+  if (!dataSets.loaded) loadModels();
+  const data = dataSets.types[String(type_id)];
+  if (!data) throw new Error(`Type ID ${type_id} not found in reference data`);
+  return data;
+}
+
+export function getTypeIconUrl(type: Type, size: IconSize = IconSize.SIZE_64) {
+  return `https://images.evetech.net/types/${type.type_id}/icon${type.is_blueprint ? '/bp' : ''}?size=${size}`;
+}
+
+export function getSkillBonuses(type: Type): {
+  skill: Type;
+  bonuses: {
+    bonus: number;
+    bonus_text: LocalizedString;
+    importance: number;
+    unit: Unit;
+  }[];
+}[] {
+  if (!type.traits) return [];
+  const skillBonuses: {
+    skill: Type;
+    bonuses: {
+      bonus: number;
+      bonus_text: LocalizedString;
+      importance: number;
+      unit: Unit;
+    }[];
+  }[] = [];
+  for (const skill_type_id in type.traits.types) {
+    skillBonuses.push({
+      skill: getType(Number(skill_type_id)),
+      bonuses: Object.keys(type.traits.types[skill_type_id]).map((order) => {
+        const bonus = type.traits!.types[skill_type_id][order];
+        return {
+          bonus: bonus.bonus,
+          bonus_text: bonus.bonus_text,
+          importance: bonus.importance,
+          unit: getUnit(bonus.unit_id),
+        };
+      }),
+    });
+  }
+  return skillBonuses;
+}
+
+export function getRoleBonuses(type: Type): {
+  bonus: number;
+  bonus_text: LocalizedString;
+  importance: number;
+  unit: Unit;
+}[] {
+  if (!type.traits || !type.traits.role_bonuses) return [];
+  return Object.values(type.traits.role_bonuses).map((bonus) => ({
+    bonus: bonus.bonus,
+    bonus_text: bonus.bonus_text,
+    importance: bonus.importance,
+    unit: bonus.unit_id ? getUnit(bonus.unit_id) : undefined,
+  }));
+}
+
+export function eveRefLink(type_id: number) {
+  return `https://everef.net/types/${type_id}`;
+}
+
+export function renderTypeEveRefLink(type: Type, locale: string = 'en') {
+  return `[${type.name[locale] ?? type.name.en}](${eveRefLink(type.type_id)})`;
+}
+
+export function eveTycoonLink(type_id: number) {
+  return `https://evetycoon.com/market/${type_id}`;
+}
+
+export function getTypeAttributes(type: Type): any[] {
+  if (!type.dogma_attributes) return [];
+  Object.keys(type.dogma_attributes).map((attribute_id) => ({
+    attribute: getAttribute(Number(attribute_id)),
+    value: type.dogma_attributes![attribute_id].value,
+  }));
+}
+
+export function typeHasAnyAttribute(type: Type, attribute_ids: CommonAttribute[]): boolean {
+  if (!type.dogma_attributes) return false;
+  for (const attribute_id of attribute_ids) {
+    if (type.dogma_attributes[attribute_id]) return true;
+  }
+  return false;
+}
+
+export function getTypeSkills(type: Type): {
+  skill: Type;
+  level: number;
+}[] {
+  if (!type.required_skills) return [];
+  return Object.keys(type.required_skills).map((skill_type_id) => ({
+    skill: getType(Number(skill_type_id)),
+    level: type.required_skills![skill_type_id],
+  }));
+}
+
+export function typeGetAttribute(
+  type: Type,
+  attribute_id: number,
+): {
+  attribute: Attribute;
+  value: number;
+} {
+  if (!type.dogma_attributes || !type.dogma_attributes[attribute_id]) return null;
+  return {
+    attribute: getAttribute(attribute_id),
+    value: type.dogma_attributes[attribute_id].value,
+  };
+}
+
+export function getTypeBlueprints(type: Type): {
+  blueprint: Type;
+  activity: ActivityType;
+}[] {
+  if (!type.produced_by_blueprints) return [];
+  return Object.values(type.produced_by_blueprints).map((blueprint) => ({
+    blueprint: getType(blueprint.blueprint_type_id),
+    activity: blueprint.blueprint_activity,
+  }));
+}
+
+export function getTypeSchematics(type: Type): Type[] {
+  return type.produced_by_schematic_ids?.map((schematic_id) => getType(schematic_id)) ?? [];
+}
+
+export function getTypeGroup(type: Type): Group {
+  if (!type.group_id) return null;
+  return getGroup(type.group_id);
+}
+
+export function getTypeVariants(type: Type): {
+  metaGroup: MetaGroup;
+  types: Type[];
+}[] {
+  return Object.entries(type.type_variations || {}).map(([meta_group_id, variant_ids]) => ({
+    metaGroup: getMetaGroup(Number(meta_group_id)),
+    types: variant_ids.map((type_id) => getType(type_id)),
+  }));
+}
+
+export function typeHasAttributes(type: Type): boolean {
+  return type.dogma_attributes && Object.keys(type.dogma_attributes).length > 0;
+}
@@ -0,0 +1,66 @@
+import { convertMillisecondsToTimeString, convertSecondsToTimeString } from '@/utils/markdown';
+import { getGroup, renderGroupEveRefLink } from './group';
+import type { LocalizedString } from './shared-types';
+import { getType, renderTypeEveRefLink } from './type';
+import { dataSets, loadModels } from './loadModels';
+
+const sizeMap = {
+  1: 'Small',
+  2: 'Medium',
+  3: 'Large',
+  4: 'X-Large',
+};
+
+export interface Unit {
+  readonly unit_id: number;
+  readonly display_name: string;
+  readonly description: LocalizedString;
+  readonly name: LocalizedString;
+}
+
+export function getUnit(unit_id: number): Unit {
+  if (!dataSets.loaded) loadModels();
+  const unit = dataSets.units[String(unit_id)];
+  if (!unit) throw new Error(`Unit ID ${unit_id} not found in reference data`);
+  return unit;
+}
+
+export function renderUnit(unit: Unit, value: number, locale: string = 'en'): string {
+  switch (unit.unit_id) {
+    case 108: // inverse percentage
+    case 111: // Inverse percentage
+      return [(1 - value).toFixed(2), unit.display_name ?? ''].join(' ');
+    case 3: // seconds
+      return `${convertSecondsToTimeString(value)}`;
+    case 101: // milliseconds
+      return `${convertMillisecondsToTimeString(value)}`;
+    case 117: // size class
+      return sizeMap[value] ?? 'Unknown';
+    case 141: // hardpoints
+      return value + '';
+    case 120: // calibration
+      return value + ' pts';
+    case 116: // typeID
+      return getType(value).name[locale] ?? 'Unknown';
+    case 10: // m/s
+      return `${value} m/s`;
+    case 11: // meters per second squared
+      return `${value} m/s²`;
+    case 9: // cubic meters
+      return `${value} m³`;
+    case 8: // square meters
+      return `${value} m²`;
+    case 12: // reciprocal meters
+      return `${value} m⁻¹`;
+    case 128: // megabits per second
+      return `${value} Mbps`;
+    case 115: // groupID
+      return renderGroupEveRefLink(getGroup(value), locale) ?? 'Unknown';
+    default:
+      return [value, unit.display_name ?? ''].join(' ');
+  }
+}
+
+export function isUnitInversePercentage(unit: Unit): boolean {
+  return unit.unit_id == 108 || unit.unit_id == 111;
+}
@@ -44,9 +44,9 @@
    "typescript": "beta"
  },
  "dependencies": {
-    "@star-kitten/util": "link:@star-kitten/util",
-    "@star-kitten/eve": "link:@star-kitten/eve",
-    "@star-kitten/discord": "link:@star-kitten/discord"
+    "@star-kitten/util": "workspace:*",
+    "@star-kitten/eve": "workspace:*",
+    "@star-kitten/discord": "workspace:*"
  },
  "scripts": {
    "build": "tsdown",
@@ -78,7 +78,7 @@
    "typescript": "beta"
  },
  "dependencies": {
-    "@star-kitten/util": "link:@star-kitten/util",
+    "@star-kitten/util": "workspace:*",
    "@orama/orama": "^3.1.13",
    "@oslojs/encoding": "^1.1.0",
    "cron-parser": "^5.3.1",
@@ -1,7 +1,7 @@
 /**
 * Simple caching for ESI fetches using bun sqlite key-value store.
 */
-import * as kv from '@star-kitten/util/kv';
+import * as kv from '@star-kitten/util/kv.js';

 export const defaultCacheDuration = 1000 * 60 * 30; // 30 minutes

@@ -3,7 +3,7 @@ import { chain } from 'stream-chain';
 import { parser } from 'stream-json';
 import { streamObject } from 'stream-json/streamers/StreamObject';
 import { create, insert, search } from '@orama/orama';
-import { normalize } from '@star-kitten/util/text';
+import { normalize } from '@star-kitten/util/text.js';
 import { getType, type Type } from '@/models/type';

 const db = create({
@@ -44,7 +44,7 @@
    "access": "public"
  },
  "devDependencies": {
-    "@types/bun": "^1.3.5",
+    "@types/bun": "^1.3.9",
    "@types/jsonwebtoken": "^9.0.10",
    "@types/jwk-to-pem": "^2.0.3",
    "@types/lodash": "^4.17.20",
@@ -0,0 +1,81 @@
+// Shared test utilities for OAuth module
+
+// Extend RequestInit to include Bun's preconnect property
+declare global {
+  interface RequestInit {
+    preconnect?: Array<string | URL> | undefined;
+  }
+}
+
+
+export const mockFetch = (
+  input: string | URL,
+  init?: RequestInit | undefined
+): Promise<Response> => {
+  // Check if this is a token endpoint request (contains /oauth/token)
+  if (typeof input === "string" && input.includes("/oauth/token")) {
+    let body: Record<string, string> = {};
+
+    // Handle both JSON and URL-encoded form data
+    const bodyStr = init?.body as string;
+    if (bodyStr) {
+      try {
+        // Try to parse as JSON first
+        body = JSON.parse(bodyStr);
+      } catch (e) {
+        // If not JSON, parse as URL-encoded form data
+        body = Object.fromEntries(
+          new URLSearchParams(bodyStr)
+        ) as Record<string, string>;
+      }
+    }
+
+    // Return success for valid requests, error for invalid
+    if (
+      (body.grant_type === "refresh_token" &&
+        body.refresh_token === "test-refresh-token") ||
+      (body.grant_type === "authorization_code" &&
+        body.code === "valid-auth-code-12345")
+    ) {
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            access_token: "new-access-token",
+            expires_in: 1200,
+          })
+        )
+      );
+    } else if (
+      (body.grant_type === "refresh_token" &&
+        body.refresh_token === "invalid-refresh-token") ||
+      (body.grant_type === "authorization_code" &&
+        body.code === "invalid-code")
+    ) {
+      // Throw an error for invalid credentials to match test expectations
+      const error = new Error("Invalid credentials");
+      return Promise.reject(error);
+    } else {
+      // For other cases, throw an error to simulate network/API failure
+      const error = new Error("Network request failed");
+      (error as any).response = { status: 500 };
+      return Promise.reject(error);
+    }
+  }
+
+  return Promise.resolve(new Response(JSON.stringify({})));
+}
+
+// Augment for Bun compatibility
+mockFetch.preconnect = (
+    url: string | URL,
+    options?: {
+      /** Preconnect to the DNS of the URL */
+      dns?: boolean;
+      /** Preconnect to the TCP connection of the URL */
+      tcp?: boolean;
+      /** Preconnect to the HTTP connection of the URL */
+      http?: boolean;
+      /** Preconnect to the HTTPS connection of the URL */
+      https?: boolean;
+    },
+  ) => {};
@@ -0,0 +1,101 @@
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { mockFetch } from './__mocks__.ts';
+import { createAuthorizationURL } from './authorization-url';
+
+describe('createAuthorizationURL', () => {
+  // Mock fetch globally for all tests in this file
+  beforeAll(() => {
+    globalThis.fetch = mockFetch;
+  });
+
+  afterAll(() => {
+    delete (globalThis as any).fetch;
+
+    // Ensure crypto is restored to its original state
+    if ((globalThis as any).originalCrypto) {
+      globalThis.crypto = (globalThis as any).originalCrypto;
+      delete (globalThis as any).originalCrypto;
+    }
+  });
+
+  it('should create a valid authorization URL with all required parameters', async () => {
+    const result = await createAuthorizationURL(
+      'https://login.eveonline.com/oauth/authorize',
+      'https://example.com/callback',
+      'test-client',
+      ['publicData', 'characterFitting:read'],
+    );
+
+    expect(result.url.toString()).toContain('response_type=code');
+    expect(result.url.toString()).toContain('client_id=test-client');
+    expect(result.url.toString()).toContain('scope=publicData+characterFitting%3Aread');
+    expect(result.url.toString()).toContain('redirect_uri=https%3A%2F%2Fexample.com%2Fcallback');
+  });
+
+  it('should generate a state parameter', async () => {
+    // Mock crypto for this specific test
+    const mockCrypto = {
+      getRandomValues: (array: Uint8Array): Uint8Array => {
+        // Fill with predictable values for testing
+        for (let i = 0; i < array.length; i++) {
+          array[i] = i % 256;
+        }
+        return array;
+      },
+    };
+
+    const originalCrypto = globalThis.crypto;
+    try {
+      globalThis.crypto = { getRandomValues: mockCrypto.getRandomValues } as any;
+
+      const result = await createAuthorizationURL(
+        'https://login.eveonline.com/oauth/authorize',
+        'https://example.com/callback',
+        'test-client',
+        'publicData',
+      );
+
+      expect(result.state).toBeDefined();
+    } finally {
+      // Restore original crypto to avoid polluting other tests
+      globalThis.crypto = originalCrypto;
+      delete (globalThis as any).originalCrypto;
+    }
+  });
+
+  it('should handle scope as a string', async () => {
+    const result = await createAuthorizationURL(
+      'https://login.eveonline.com/oauth/authorize',
+      'https://example.com/callback',
+      'test-client',
+      'publicData characterFitting:read',
+    );
+
+    expect(result.url.toString()).toContain('scope=publicData+characterFitting%3Aread');
+  });
+
+  it('should handle scope as an array', async () => {
+    const result = await createAuthorizationURL(
+      'https://login.eveonline.com/oauth/authorize',
+      'https://example.com/callback',
+      'test-client',
+      ['publicData', 'characterFitting:read'],
+    );
+
+    expect(result.url.toString()).toContain('scope=publicData+characterFitting%3Aread');
+  });
+
+  it('should include all required OAuth parameters', async () => {
+    const result = await createAuthorizationURL(
+      'https://login.eveonline.com/oauth/authorize',
+      'https://example.com/callback',
+      'test-client',
+      'publicData',
+    );
+
+    expect(result.url.toString()).toContain('response_type=code');
+    expect(result.url.toString()).toContain('client_id=test-client');
+    expect(result.url.toString()).toContain('scope=publicData');
+    expect(result.url.toString()).toContain('redirect_uri=https%3A%2F%2Fexample.com%2Fcallback');
+  });
+});
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "bun:test";
+import { mockFetch } from "./__mocks__.ts";
+import { refresh } from "./refresh";
+
+// Mock fetch globally for these tests
+globalThis.fetch = mockFetch;
+
+describe("refresh", () => {
+  it("should successfully refresh a token with valid credentials", async () => {
+    const result = await refresh(
+      "test-refresh-token",
+      {
+        clientId: "test-client",
+        url: "https://login.eveonline.com/oauth/token",
+      }
+    );
+
+    expect(result).toBeDefined();
+    expect(result.access_token).toBe("new-access-token");
+    expect(result.expires_in).toBe(1200);
+  });
+
+  it("should throw an error when refresh fails", async () => {
+    await expect(
+      refresh(
+        "invalid-refresh-token",
+        {
+          clientId: "invalid-client",
+          url: "https://login.eveonline.com/oauth/token",
+        }
+      )
+    ).rejects.toThrow();
+  });
+});
@@ -0,0 +1,15 @@
+// Test setup to ensure clean global state
+import { afterAll, beforeAll } from "bun:test";
+
+// Store original crypto before any tests run
+const originalCrypto = globalThis.crypto;
+
+beforeAll(() => {
+  // Ensure we have a clean crypto object
+  globalThis.crypto = originalCrypto;
+});
+
+afterAll(() => {
+  // Restore original crypto after all tests
+  globalThis.crypto = originalCrypto;
+});
@@ -0,0 +1,25 @@
+import { describe, expect, it } from "bun:test";
+import { generateState } from "./state";
+
+describe("generateState", () => {
+  it("should generate a state string of correct length", () => {
+    const state = generateState();
+    // The actual implementation uses base64 encoding which produces 44 chars
+    expect(state.length).toBeGreaterThan(0);
+  });
+
+  it("should generate a state containing only allowed characters", () => {
+    const state = generateState();
+    // Base64 encoded strings can contain + and / characters
+    const allowedChars = /^[a-zA-Z0-9\-_+/=]+$/;
+    expect(allowedChars.test(state)).toBe(true);
+  });
+
+  it("should generate different states on each call", () => {
+    const state1 = generateState();
+    const state2 = generateState();
+    // Since we're using crypto.getRandomValues, the states should be different
+    // We'll mock this to ensure consistent behavior
+    expect(state1).toBeDefined();
+  });
+});
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test";
+import { mockFetch } from "./__mocks__.ts";
+import { validateCode } from "./validate-code";
+
+// Mock fetch globally for these tests
+globalThis.fetch = mockFetch;
+
+describe("validateCode", () => {
+  it("should successfully validate a code with valid credentials", async () => {
+    const result = await validateCode(
+      "valid-auth-code-12345",
+      {
+        clientId: "test-client",
+        url: "https://login.eveonline.com/oauth/token",
+      }
+    );
+
+    expect(result).toBeDefined();
+    expect(result.access_token).toBe("new-access-token");
+  });
+
+  it("should throw an error when validation fails", async () => {
+    await expect(
+      validateCode(
+        "invalid-code",
+        {
+          clientId: "test-client",
+          url: "https://login.eveonline.com/oauth/token",
+        }
+      )
+    ).rejects.toThrow();
+  });
+});
@@ -0,0 +1,45 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { jwtModule, verify } from "./verify";
+
+// Mock the JWT library to avoid crypto issues
+const mockJwt = {
+  verify: (token: string, secretOrPublicKey: string) =>
+    Promise.resolve({ sub: "1234567890", name: "John Doe", iat: 1516239022 }),
+};
+
+// Replace jwtModule.verify with our mock
+const originalVerify = jwtModule.verify;
+beforeAll(() => {
+  jwtModule.verify = mockJwt.verify as any;
+});
+
+afterAll(() => {
+  jwtModule.verify = originalVerify;
+});
+
+describe("verify", () => {
+  it("should successfully verify a valid JWT token", async () => {
+    const result = await verify(
+      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
+      "secret-key"
+    );
+
+    expect(result).toBeDefined();
+    expect((result as any).name).toBe("John Doe");
+  });
+
+  it("should throw an error when verification fails", async () => {
+    // Mock a failing jwt.verify
+    jwtModule.verify = () => Promise.reject(new Error("invalid signature")) as any;
+
+    try {
+      await verify(
+        "invalid-token",
+        "secret-key"
+      );
+      expect().fail("Should have thrown an error");
+    } catch (error) {
+      expect(error.message).toContain("invalid signature");
+    }
+  });
+});
@@ -1,5 +1,8 @@
 import jwt from 'jsonwebtoken';

+// Export the jwt module for testing
+export const jwtModule = jwt;
+
 export function verify(token: string, publicKey: string) {
-  return jwt.verify(token, publicKey);
+  return jwtModule.verify(token, publicKey);
 }
@@ -0,0 +1,433 @@
+import { Database } from 'bun:sqlite';
+import { beforeEach, describe, expect, it } from 'bun:test';
+import type { QueryOptions } from './sqlite';
+import {
+  dynamicInsert,
+  dynamicUpdate,
+  remove,
+  select
+} from './sqlite';
+
+// Test interfaces
+interface TestUser {
+  id?: number;
+  name?: string;
+  age?: number;
+  email?: string;
+  isActive?: boolean;
+}
+
+describe('dynamicInsert', () => {
+  let db: Database;
+
+  beforeEach(() => {
+    // Create in-memory database for each test
+    db = new Database(':memory:');
+    db.exec(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        age INTEGER,
+        email TEXT,
+        isActive INTEGER DEFAULT 1
+      )
+    `);
+  });
+
+  it('should insert a basic record', () => {
+    const userId = dynamicInsert<TestUser>(db, 'users', {
+      name: 'Alice',
+      age: 30,
+      email: 'alice@example.com'
+    });
+
+    expect(userId).toBeGreaterThan(0);
+
+    const result = db.prepare('SELECT * FROM users WHERE id = ?').get(userId) as TestUser;
+    expect(result.name).toBe('Alice');
+    expect(result.age).toBe(30);
+    expect(result.email).toBe('alice@example.com');
+  });
+
+  it('should insert records with different data types', () => {
+    const user1Id = dynamicInsert<TestUser>(db, 'users', {
+      name: 'Bob',
+      age: 25,
+      email: 'bob@example.com',
+      isActive: true
+    });
+
+    const user2Id = dynamicInsert<TestUser>(db, 'users', {
+      name: 'Charlie',
+      age: 35,
+      email: 'charlie@example.com',
+      isActive: false
+    });
+
+    expect(user1Id).toBeGreaterThan(0);
+    expect(user2Id).toBeGreaterThan(0);
+
+    const user1 = db.prepare('SELECT * FROM users WHERE id = ?').get(user1Id) as TestUser;
+    const user2 = db.prepare('SELECT * FROM users WHERE id = ?').get(user2Id) as TestUser;
+
+    // SQLite stores booleans as 1/0, not true/false
+    expect(user1.isActive).toBe(1 as any);
+    expect(user2.isActive).toBe(0 as any);
+  });
+
+  it('should handle empty object', () => {
+    // This should work but won't insert any columns
+    const userId = dynamicInsert<TestUser>(db, 'users', { name: '', age: 0, email: '' } as TestUser);
+    expect(userId).toBeGreaterThan(0);
+
+    const result = db.prepare('SELECT * FROM users WHERE id = ?').get(userId) as TestUser;
+    expect(Number(result.id)).toBe(Number(userId));
+  });
+
+  it('should correctly use table name and columns', () => {
+    const userId = dynamicInsert<TestUser>(db, 'users', {
+      name: 'Diana',
+      age: 28,
+      email: 'diana@example.com'
+    });
+
+    expect(userId).toBeGreaterThan(0);
+
+    // Verify the correct table was used
+    const result = db.prepare('SELECT * FROM users WHERE id = ?').get(userId) as any;
+    expect(result.name).toBe('Diana');
+  });
+});
+
+describe('dynamicUpdate', () => {
+  let db: Database;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    db.exec(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        age INTEGER,
+        email TEXT,
+        isActive INTEGER DEFAULT 1
+      )
+    `);
+
+    // Insert test data
+    const aliceId = dynamicInsert<TestUser>(db, 'users', {
+      name: 'Alice',
+      age: 30,
+      email: 'alice@example.com'
+    });
+    const bobId = dynamicInsert<TestUser>(db, 'users', {
+      name: 'Bob',
+      age: 25,
+      email: 'bob@example.com'
+    });
+  });
+
+  it('should update a single field', () => {
+    const changes = dynamicUpdate<TestUser>(db, 'users', { age: 31 }, 'id', 1);
+
+    expect(changes).toBe(1);
+
+    const result = db.prepare('SELECT * FROM users WHERE id = ?').get(1) as TestUser;
+    expect(result.age).toBe(31);
+  });
+
+  it('should update multiple fields at once', () => {
+    const changes = dynamicUpdate<TestUser>(db, 'users', {
+      age: 26,
+      email: 'bob.updated@example.com'
+    }, 'id', 2);
+
+    expect(changes).toBe(1);
+
+    const result = db.prepare('SELECT * FROM users WHERE id = ?').get(2) as TestUser;
+    expect(result.age).toBe(26);
+    expect(result.email).toBe('bob.updated@example.com');
+  });
+
+  it('should update with different data types', () => {
+    const changes = dynamicUpdate<TestUser>(db, 'users', {
+      age: 32,
+      isActive: false
+    }, 'id', 1);
+
+    expect(changes).toBe(1);
+
+    const result = db.prepare('SELECT * FROM users WHERE id = ?').get(1) as TestUser;
+    expect(result.age).toBe(32);
+    // SQLite stores booleans as 1/0, not true/false
+    expect(result.isActive).toBe(0 as any);
+  });
+
+  it('should return correct number of changed rows', () => {
+    // Update existing record
+    const changes1 = dynamicUpdate<TestUser>(db, 'users', { age: 99 }, 'id', 1);
+    expect(changes1).toBe(1);
+
+    // Try to update non-existent record (where id doesn't match)
+    const changes2 = dynamicUpdate<TestUser>(db, 'users', { age: 99 }, 'id', 999);
+    expect(changes2).toBe(0);
+  });
+});
+
+describe('select', () => {
+  let db: Database;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    db.exec(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        age INTEGER,
+        email TEXT,
+        isActive INTEGER DEFAULT 1
+      )
+    `);
+
+    // Insert test data
+    dynamicInsert<TestUser>(db, 'users', {
+      name: 'Alice',
+      age: 30,
+      email: 'alice@example.com'
+    });
+    dynamicInsert<TestUser>(db, 'users', {
+      name: 'Bob',
+      age: 25,
+      email: 'bob@example.com'
+    });
+    dynamicInsert<TestUser>(db, 'users', {
+      name: 'Charlie',
+      age: 35,
+      email: 'charlie@example.com'
+    });
+    dynamicInsert<TestUser>(db, 'users', {
+      name: 'Diana',
+      age: 28,
+      email: 'diana@example.com'
+    });
+  });
+
+  it('should select all records with default options', () => {
+    const results = select<TestUser>(db, 'users');
+    expect(results.length).toBe(4);
+    expect(results[0].name).toBe('Alice');
+    expect(results[1].name).toBe('Bob');
+  });
+
+  it('should select specific columns', () => {
+    const results = select<TestUser>(db, 'users', {}, 'name, age') as Array<{ name: string; age: number }>;
+    expect(results.length).toBe(4);
+    expect(results[0].name).toBe('Alice');
+    expect(results[0].age).toBe(30);
+    // @ts-expect-error - email should not be present
+    expect(results[0].email).toBeUndefined();
+  });
+
+  it('should filter with WHERE conditions (AND logic)', () => {
+    const results = select<TestUser>(db, 'users', {}, '*', { age: 30 });
+    expect(results.length).toBe(1);
+    expect(results[0].name).toBe('Alice');
+  });
+
+  it('should filter with OR conditions', () => {
+    const results = select<TestUser>(db, 'users', {}, '*', { or: { name: 'Alice' } });
+    expect(results.length).toBe(1);
+    expect(results[0].name).toBe('Alice');
+  });
+
+  it('should combine AND and OR conditions', () => {
+    const results = select<TestUser>(db, 'users', undefined, '*', {
+      age: 30,
+      or: { name: 'Alice' }
+    });
+    // This should match Alice (age = 30) only
+    expect(results.length).toBe(1);
+    expect(results[0].name).toBe('Alice');
+  });
+
+  it('should paginate results with skip and limit', () => {
+    const options: QueryOptions<TestUser> = { skip: 1, limit: 2 };
+    const results = select<TestUser>(db, 'users', options);
+
+    expect(results.length).toBe(2);
+    expect(results[0].name).toBe('Bob');
+    expect(results[1].name).toBe('Charlie');
+  });
+
+  it('should order results by column ASC', () => {
+    const options: QueryOptions<TestUser> = { orderBy: { name: 'ASC' } };
+    const results = select<TestUser>(db, 'users', options);
+
+    expect(results.length).toBe(4);
+    expect(results[0].name).toBe('Alice');
+    expect(results[1].name).toBe('Bob');
+  });
+
+  it('should order results by column DESC', () => {
+    const options: QueryOptions<TestUser> = { orderBy: { name: 'DESC' } };
+    const results = select<TestUser>(db, 'users', options);
+
+    expect(results.length).toBe(4);
+    expect(results[0].name).toBe('Diana');
+    expect(results[1].name).toBe('Charlie');
+  });
+
+  it('should return empty array when no records match', () => {
+    const results = select<TestUser>(db, 'users', {}, '*', { age: 99 });
+    expect(results.length).toBe(0);
+  });
+
+  it('should handle complex query with all options', () => {
+    const options: QueryOptions<TestUser> = {
+      skip: 0,
+      limit: 2,
+      orderBy: { age: 'ASC' }
+    };
+    const results = select<TestUser>(db, 'users', options, '*', { isActive: true });
+
+    expect(results.length).toBe(2);
+    expect(results[0].age).toBeLessThanOrEqual(results[1].age);
+  });
+});
+
+describe('remove', () => {
+  let db: Database;
+  let aliceId: number;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    db.exec(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        age INTEGER,
+        email TEXT,
+        isActive INTEGER DEFAULT 1
+      )
+    `);
+
+    // Insert test data
+    aliceId = Number(dynamicInsert<TestUser>(db, 'users', {
+      name: 'Alice',
+      age: 30,
+      email: 'alice@example.com'
+    }));
+  });
+
+  it('should delete records with WHERE conditions', () => {
+    const changes = remove<TestUser>(db, 'users', { id: aliceId });
+    expect(changes).toBe(1);
+
+    const results = select<TestUser>(db, 'users');
+    expect(results.length).toBe(0);
+  });
+
+  it('should delete with AND logic', () => {
+    // Add another record to test AND logic
+    dynamicInsert<TestUser>(db, 'users', { name: 'Dave', age: 30, email: 'dave@example.com' });
+
+    const changes = remove<TestUser>(db, 'users', { age: 30 });
+    expect(changes).toBe(2); // Alice and Dave
+
+    const results = select<TestUser>(db, 'users');
+    expect(results.length).toBe(0);
+  });
+
+  it('should delete with OR logic', () => {
+    // Insert a fresh Alice record for this test (different email to distinguish)
+    dynamicInsert<TestUser>(db, 'users', { name: 'Alice', age: 30, email: 'alice2@example.com' });
+    const changes = remove<TestUser>(db, 'users', { or: { name: 'Alice' } });
+    expect(changes).toBe(2); // Both Alice records should be deleted
+
+    // Should have no records left
+    const results = select<TestUser>(db, 'users');
+    expect(results.length).toBe(0);
+  });
+
+  it('should return correct number of deleted rows', () => {
+    // Re-insert Alice for this test
+    const newAliceId = dynamicInsert<TestUser>(db, 'users', { name: 'Alice', age: 30, email: 'alice@example.com' });
+    // Delete existing record
+    const changes1 = remove<TestUser>(db, 'users', { id: newAliceId });
+    expect(changes1).toBe(1);
+
+    // Delete non-existent record
+    const changes2 = remove<TestUser>(db, 'users', { id: 999 });
+    expect(changes2).toBe(0);
+  });
+
+  it('should delete all records when no WHERE clause', () => {
+    dynamicInsert<TestUser>(db, 'users', { name: 'Bob', age: 25, email: 'bob@example.com' });
+    const changes = remove<TestUser>(db, 'users');
+    expect(changes).toBe(2);
+
+    const results = select<TestUser>(db, 'users');
+    expect(results.length).toBe(0);
+  });
+});
+
+describe('Edge Cases and SQL Injection Prevention', () => {
+  let db: Database;
+
+  beforeEach(() => {
+    db = new Database(':memory:');
+    db.exec(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        age INTEGER,
+        email TEXT
+      )
+    `);
+
+    dynamicInsert<TestUser>(db, 'users', {
+      name: 'Alice',
+      age: 30
+    });
+  });
+
+  it('should prevent SQL injection via parameterized queries', () => {
+    // Test with potential SQL injection patterns
+    const maliciousInput = "Robert'); DROP TABLE users;--";
+    const userId = dynamicInsert<TestUser>(db, 'users', {
+      name: maliciousInput,
+      age: 25
+    });
+
+    expect(userId).toBeGreaterThan(0);
+
+    // Verify the table still exists and data is intact
+    const results = select<TestUser>(db, 'users');
+    expect(results.length).toBe(2);
+    expect(results.some(u => u.name === maliciousInput)).toBe(true);
+  });
+
+  it('should handle special characters in data', () => {
+    const specialChars = "O'Brien & Co.";
+    const userId = dynamicInsert<TestUser>(db, 'users', {
+      name: specialChars,
+      age: 40
+    });
+
+    expect(userId).toBeGreaterThan(0);
+
+    const result = select<TestUser>(db, 'users', {}, '*', { id: userId });
+    expect(result.length).toBe(1);
+    expect(result[0].name).toBe(specialChars);
+  });
+
+  it('should handle null and undefined values gracefully', () => {
+    // This should work without throwing errors
+    const userId = dynamicInsert<TestUser>(db, 'users', {
+      name: 'Test',
+      age: 0
+    });
+
+    expect(userId).toBeGreaterThan(0);
+  });
+});
@@ -28,41 +28,52 @@ export function select<T extends {}>(db: Database, table: string, options?: Quer
  let query = `SELECT ${select} FROM ${table}\n`;
  const values = [];
  if (where) {
-    query += `WHERE `;
-
+    const orConditions: string[] = [];
    if (where.or) {
-      query += `${Object.keys(where.or)
-        .map((k) => {
-          values.push(where.or[k]);
-          return `${k} = ?\n`;
-        })
-        .join('OR ')}`;
+      where.or && Object.keys(where.or).forEach((k) => {
+        values.push(where.or[k]);
+        orConditions.push(`${k} = ?`);
+      });
      delete where.or;
    }

-    if (Object.keys(where).length > 0) {
-      query += `${Object.keys(where)
-        .map((k) => {
-          values.push(where[k]);
-          return `${k} = ?\n`;
-        })
-        .join('AND ')}`;
+    const andConditions: string[] = [];
+    Object.keys(where).forEach((k) => {
+      values.push(where[k]);
+      andConditions.push(`${k} = ?`);
+    });
+
+    if (orConditions.length > 0 || andConditions.length > 0) {
+      query += 'WHERE ';
+      const conditions: string[] = [];
+
+      if (orConditions.length > 0) {
+        conditions.push(`(${orConditions.join(' OR ')})`);
+      }
+
+      if (andConditions.length > 0) {
+        conditions.push(andConditions.join(' AND '));
+      }
+
+      query += conditions.join(' AND ');
    }
  }

  if (options?.orderBy) {
-    query += `ORDER BY\n${Object.keys(options.orderBy)
+    query += `ORDER BY ${Object.keys(options.orderBy)
      .map((k) => {
-        values.push(options.orderBy[k]);
-        return `${k} ?`;
+        return `${k} ${options.orderBy[k]}`;
      })
-      .join(',\n')}\n`;
+      .join(', ')}\n`;
  }

-  if (options?.skip) {
-    values.push(options.limit || -1);
-    values.push(options.skip);
-    query += `LIMIT ? OFFSET ?`;
+  if (options?.limit !== undefined) {
+    values.push(options.limit);
+    query += `LIMIT ?`;
+    if (options?.skip) {
+      values.push(options.skip);
+      query += ` OFFSET ?`;
+    }
  }

  return db.prepare(query).all(...values) as T[];
@@ -73,25 +84,34 @@ export function remove<T>(db: Database, table: string, where?: Where<T>) {

  const values = [];
  if (where) {
-    query += `WHERE `;
-
+    const orConditions: string[] = [];
    if (where.or) {
-      query += `${Object.keys(where.or)
-        .map((k) => {
-          values.push(where.or[k]);
-          return `${k} = ?\n`;
-        })
-        .join('OR ')}`;
+      where.or && Object.keys(where.or).forEach((k) => {
+        values.push(where.or[k]);
+        orConditions.push(`${k} = ?`);
+      });
      delete where.or;
    }

-    if (Object.keys(where).length > 0) {
-      query += `${Object.keys(where)
-        .map((k) => {
-          values.push(where[k]);
-          return `${k} = ?\n`;
-        })
-        .join('AND ')}`;
+    const andConditions: string[] = [];
+    Object.keys(where).forEach((k) => {
+      values.push(where[k]);
+      andConditions.push(`${k} = ?`);
+    });
+
+    if (orConditions.length > 0 || andConditions.length > 0) {
+      query += ' WHERE ';
+      const conditions: string[] = [];
+
+      if (orConditions.length > 0) {
+        conditions.push(`(${orConditions.join(' OR ')})`);
+      }
+
+      if (andConditions.length > 0) {
+        conditions.push(andConditions.join(' AND '));
+      }
+
+      query += conditions.join(' AND ');
    }
  }

@@ -5,6 +5,7 @@
    "strict": false,
    "noImplicitAny": false,
    "skipLibCheck": true,
+    "typeRoots": ["src/types", "node_modules/@types"],
    "emitDeclarationOnly": true,
    "noEmit": false,
    "noEmitOnError": false,
@@ -13,5 +14,5 @@
    "allowImportingTsExtensions": true
  },
  "include": ["src"],
-  "exclude": ["node_modules", "dist", "build", "**/*.test.ts"]
+  "exclude": ["node_modules", "dist", "build"]
 }