test: add vitest infrastructure and initial test suite (97 tests)

Set up vitest as the monorepo test framework with workspace support
and turbo task integration. Added tests across all three packages:

- appview: route handler tests (health, forum, categories, topics,
posts, routing), config loading, and database schema assertions
- lexicon: contract tests validating YAML structure, lexicon IDs,
record key conventions, knownValues usage, and strongRef fields
- web: fetchApi client tests (URL construction, error handling)
and config loading tests

Tests also document two config gaps where ?? doesn't catch empty
strings, causing NaN ports and empty URLs.

https://claude.ai/code/session_01MffppURah8kTTYS3SUZu5e

apps/appview/package.json

···
     "dev": "tsx watch --env-file=../../.env src/index.ts",
     "start": "node dist/index.js",
     "lint": "tsc --noEmit",
+    "test": "vitest run",
     "clean": "rm -rf dist",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate"

apps/appview/src/lib/__tests__/config.test.ts

···
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+describe("loadConfig", () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  async function loadConfig() {
+    const mod = await import("../config.js");
+    return mod.loadConfig();
+  }
+
+  it("returns default port 3000 when PORT is undefined", async () => {
+    delete process.env.PORT;
+    const config = await loadConfig();
+    expect(config.port).toBe(3000);
+  });
+
+  it("parses PORT as an integer", async () => {
+    process.env.PORT = "4000";
+    const config = await loadConfig();
+    expect(config.port).toBe(4000);
+    expect(typeof config.port).toBe("number");
+  });
+
+  it("returns default PDS URL when PDS_URL is undefined", async () => {
+    delete process.env.PDS_URL;
+    const config = await loadConfig();
+    expect(config.pdsUrl).toBe("https://bsky.social");
+  });
+
+  it("uses provided environment variables", async () => {
+    process.env.PORT = "5000";
+    process.env.FORUM_DID = "did:plc:test123";
+    process.env.PDS_URL = "https://my-pds.example.com";
+    process.env.DATABASE_URL = "postgres://localhost/testdb";
+    const config = await loadConfig();
+    expect(config.port).toBe(5000);
+    expect(config.forumDid).toBe("did:plc:test123");
+    expect(config.pdsUrl).toBe("https://my-pds.example.com");
+    expect(config.databaseUrl).toBe("postgres://localhost/testdb");
+  });
+
+  it("returns empty string for forumDid when FORUM_DID is undefined", async () => {
+    delete process.env.FORUM_DID;
+    const config = await loadConfig();
+    expect(config.forumDid).toBe("");
+  });
+
+  it("returns empty string for databaseUrl when DATABASE_URL is undefined", async () => {
+    delete process.env.DATABASE_URL;
+    const config = await loadConfig();
+    expect(config.databaseUrl).toBe("");
+  });
+
+  it("returns NaN for port when PORT is empty string (?? does not catch empty strings)", async () => {
+    process.env.PORT = "";
+    const config = await loadConfig();
+    // Documents a gap: ?? only catches null/undefined, not ""
+    expect(config.port).toBeNaN();
+  });
+});

apps/appview/src/routes/__tests__/categories.test.ts

···
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { apiRoutes } from "../index.js";
+
+const app = new Hono().route("/api", apiRoutes);
+
+describe("GET /api/categories", () => {
+  it("returns 200", async () => {
+    const res = await app.request("/api/categories");
+    expect(res.status).toBe(200);
+  });
+
+  it("returns an object with a categories array", async () => {
+    const res = await app.request("/api/categories");
+    const body = await res.json();
+    expect(body).toHaveProperty("categories");
+    expect(Array.isArray(body.categories)).toBe(true);
+  });
+});
+
+describe("GET /api/categories/:id/topics", () => {
+  it("returns 200", async () => {
+    const res = await app.request("/api/categories/123/topics");
+    expect(res.status).toBe(200);
+  });
+
+  it("echoes the category id and returns a topics array", async () => {
+    const res = await app.request("/api/categories/42/topics");
+    const body = await res.json();
+    expect(body).toHaveProperty("categoryId", "42");
+    expect(body).toHaveProperty("topics");
+    expect(Array.isArray(body.topics)).toBe(true);
+  });
+});

apps/appview/src/routes/__tests__/forum.test.ts

···
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { apiRoutes } from "../index.js";
+
+const app = new Hono().route("/api", apiRoutes);
+
+describe("GET /api/forum", () => {
+  it("returns 200", async () => {
+    const res = await app.request("/api/forum");
+    expect(res.status).toBe(200);
+  });
+
+  it("returns forum metadata with expected shape", async () => {
+    const res = await app.request("/api/forum");
+    const body = await res.json();
+    expect(body).toHaveProperty("name");
+    expect(body).toHaveProperty("description");
+    expect(body).toHaveProperty("did");
+    expect(typeof body.name).toBe("string");
+    expect(typeof body.description).toBe("string");
+    expect(typeof body.did).toBe("string");
+  });
+});

apps/appview/src/routes/__tests__/health.test.ts

···
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { apiRoutes } from "../index.js";
+
+const app = new Hono().route("/api", apiRoutes);
+
+describe("GET /api/healthz", () => {
+  it("returns 200 with ok status", async () => {
+    const res = await app.request("/api/healthz");
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ status: "ok", version: "0.1.0" });
+  });
+
+  it("returns application/json content type", async () => {
+    const res = await app.request("/api/healthz");
+    expect(res.headers.get("content-type")).toContain("application/json");
+  });
+});
+
+describe("GET /api/healthz/ready", () => {
+  it("returns 200 with ready status", async () => {
+    const res = await app.request("/api/healthz/ready");
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ status: "ready" });
+  });
+});

apps/appview/src/routes/__tests__/posts.test.ts

···
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { apiRoutes } from "../index.js";
+
+const app = new Hono().route("/api", apiRoutes);
+
+describe("POST /api/posts", () => {
+  it("returns 501 not implemented", async () => {
+    const res = await app.request("/api/posts", { method: "POST" });
+    expect(res.status).toBe(501);
+  });
+
+  it("returns an error message", async () => {
+    const res = await app.request("/api/posts", { method: "POST" });
+    const body = await res.json();
+    expect(body).toHaveProperty("error", "not implemented");
+  });
+});

apps/appview/src/routes/__tests__/routing.test.ts

···
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { apiRoutes } from "../index.js";
+
+const app = new Hono().route("/api", apiRoutes);
+
+describe("API routing", () => {
+  it("returns 404 for unknown routes", async () => {
+    const res = await app.request("/api/nonexistent");
+    expect(res.status).toBe(404);
+  });
+
+  it("mounts all expected route prefixes", async () => {
+    const routes = [
+      "/api/healthz",
+      "/api/forum",
+      "/api/categories",
+    ];
+
+    for (const route of routes) {
+      const res = await app.request(route);
+      expect(res.status, `${route} should be reachable`).not.toBe(404);
+    }
+  });
+});

apps/appview/src/routes/__tests__/topics.test.ts

···
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { apiRoutes } from "../index.js";
+
+const app = new Hono().route("/api", apiRoutes);
+
+describe("GET /api/topics/:id", () => {
+  it("returns 200", async () => {
+    const res = await app.request("/api/topics/abc123");
+    expect(res.status).toBe(200);
+  });
+
+  it("echoes the topic id and returns expected shape", async () => {
+    const res = await app.request("/api/topics/abc123");
+    const body = await res.json();
+    expect(body).toHaveProperty("topicId", "abc123");
+    expect(body).toHaveProperty("post");
+    expect(body).toHaveProperty("replies");
+    expect(Array.isArray(body.replies)).toBe(true);
+  });
+});
+
+describe("POST /api/topics", () => {
+  it("returns 501 not implemented", async () => {
+    const res = await app.request("/api/topics", { method: "POST" });
+    expect(res.status).toBe(501);
+  });
+
+  it("returns an error message", async () => {
+    const res = await app.request("/api/topics", { method: "POST" });
+    const body = await res.json();
+    expect(body).toHaveProperty("error", "not implemented");
+  });
+});

apps/appview/vitest.config.ts

···
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+  },
+});

apps/web/package.json

···
     "dev": "tsx watch --env-file=../../.env src/index.ts",
     "start": "node dist/index.js",
     "lint": "tsc --noEmit",
+    "test": "vitest run",
     "clean": "rm -rf dist"
   },
   "dependencies": {

apps/web/src/lib/__tests__/api.test.ts

···
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+const mockFetch = vi.fn();
+
+describe("fetchApi", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", mockFetch);
+    vi.stubEnv("APPVIEW_URL", "http://localhost:3000");
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.unstubAllEnvs();
+    mockFetch.mockReset();
+  });
+
+  async function loadFetchApi() {
+    const mod = await import("../api.js");
+    return mod.fetchApi;
+  }
+
+  it("calls the correct URL", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ data: "test" }),
+    });
+
+    const fetchApi = await loadFetchApi();
+    await fetchApi("/categories");
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+    const calledUrl = mockFetch.mock.calls[0][0];
+    expect(calledUrl).toBe("http://localhost:3000/api/categories");
+  });
+
+  it("returns parsed JSON on success", async () => {
+    const expected = { categories: [{ id: 1, name: "General" }] };
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(expected),
+    });
+
+    const fetchApi = await loadFetchApi();
+    const result = await fetchApi("/categories");
+    expect(result).toEqual(expected);
+  });
+
+  it("throws on non-ok response", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      statusText: "Internal Server Error",
+    });
+
+    const fetchApi = await loadFetchApi();
+    await expect(fetchApi("/fail")).rejects.toThrow(
+      "AppView API error: 500 Internal Server Error"
+    );
+  });
+
+  it("throws on 404 response", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      statusText: "Not Found",
+    });
+
+    const fetchApi = await loadFetchApi();
+    await expect(fetchApi("/missing")).rejects.toThrow(
+      "AppView API error: 404 Not Found"
+    );
+  });
+});

apps/web/src/lib/__tests__/config.test.ts

···
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+describe("loadConfig", () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  async function loadConfig() {
+    const mod = await import("../config.js");
+    return mod.loadConfig();
+  }
+
+  it("returns default port 3001 when PORT is undefined", async () => {
+    delete process.env.PORT;
+    const config = await loadConfig();
+    expect(config.port).toBe(3001);
+  });
+
+  it("parses PORT as an integer", async () => {
+    process.env.PORT = "8080";
+    const config = await loadConfig();
+    expect(config.port).toBe(8080);
+    expect(typeof config.port).toBe("number");
+  });
+
+  it("returns default appview URL when APPVIEW_URL is undefined", async () => {
+    delete process.env.APPVIEW_URL;
+    const config = await loadConfig();
+    expect(config.appviewUrl).toBe("http://localhost:3000");
+  });
+
+  it("uses provided environment variables", async () => {
+    process.env.PORT = "9000";
+    process.env.APPVIEW_URL = "https://api.atbb.space";
+    const config = await loadConfig();
+    expect(config.port).toBe(9000);
+    expect(config.appviewUrl).toBe("https://api.atbb.space");
+  });
+
+  it("returns NaN for port when PORT is empty string (?? does not catch empty strings)", async () => {
+    process.env.PORT = "";
+    const config = await loadConfig();
+    // Documents a gap: ?? only catches null/undefined, not ""
+    expect(config.port).toBeNaN();
+  });
+
+  it("returns empty string for appviewUrl when APPVIEW_URL is empty string", async () => {
+    process.env.APPVIEW_URL = "";
+    const config = await loadConfig();
+    // Documents a gap: ?? only catches null/undefined, not ""
+    expect(config.appviewUrl).toBe("");
+  });
+});

apps/web/vitest.config.ts

···
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+  },
+});

package.json

···
     "build": "turbo run build",
     "dev": "turbo run dev",
     "lint": "turbo run lint",
-    "clean": "turbo run clean"
+    "clean": "turbo run clean",
+    "test": "turbo run test"
   },
   "devDependencies": {
     "turbo": "^2.4.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
   }
 }

packages/db/package.json

···
   "scripts": {
     "build": "tsc",
     "lint": "tsc --noEmit",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "test": "vitest run"
   },
   "dependencies": {
     "drizzle-orm": "^0.45.1",

packages/db/src/__tests__/schema.test.ts

···
+import { describe, it, expect } from "vitest";
+import { getTableName, getTableColumns } from "drizzle-orm";
+import {
+  forums,
+  categories,
+  users,
+  memberships,
+  posts,
+  modActions,
+} from "../schema.js";
+
+describe("database schema", () => {
+  describe("forums table", () => {
+    it("has the correct table name", () => {
+      expect(getTableName(forums)).toBe("forums");
+    });
+
+    it("has expected columns", () => {
+      const cols = getTableColumns(forums);
+      expect(cols).toHaveProperty("id");
+      expect(cols).toHaveProperty("did");
+      expect(cols).toHaveProperty("rkey");
+      expect(cols).toHaveProperty("cid");
+      expect(cols).toHaveProperty("name");
+      expect(cols).toHaveProperty("description");
+      expect(cols).toHaveProperty("indexedAt");
+    });
+
+    it("has did and rkey as not-null", () => {
+      const cols = getTableColumns(forums);
+      expect(cols.did.notNull).toBe(true);
+      expect(cols.rkey.notNull).toBe(true);
+    });
+  });
+
+  describe("categories table", () => {
+    it("has the correct table name", () => {
+      expect(getTableName(categories)).toBe("categories");
+    });
+
+    it("has expected columns", () => {
+      const cols = getTableColumns(categories);
+      expect(cols).toHaveProperty("id");
+      expect(cols).toHaveProperty("did");
+      expect(cols).toHaveProperty("rkey");
+      expect(cols).toHaveProperty("name");
+      expect(cols).toHaveProperty("slug");
+      expect(cols).toHaveProperty("sortOrder");
+      expect(cols).toHaveProperty("forumId");
+      expect(cols).toHaveProperty("createdAt");
+      expect(cols).toHaveProperty("indexedAt");
+    });
+  });
+
+  describe("users table", () => {
+    it("has the correct table name", () => {
+      expect(getTableName(users)).toBe("users");
+    });
+
+    it("uses did as primary key", () => {
+      const cols = getTableColumns(users);
+      expect(cols.did.primary).toBe(true);
+    });
+
+    it("has handle as optional", () => {
+      const cols = getTableColumns(users);
+      expect(cols.handle.notNull).toBe(false);
+    });
+  });
+
+  describe("memberships table", () => {
+    it("has the correct table name", () => {
+      expect(getTableName(memberships)).toBe("memberships");
+    });
+
+    it("has expected columns", () => {
+      const cols = getTableColumns(memberships);
+      expect(cols).toHaveProperty("id");
+      expect(cols).toHaveProperty("did");
+      expect(cols).toHaveProperty("rkey");
+      expect(cols).toHaveProperty("forumId");
+      expect(cols).toHaveProperty("forumUri");
+      expect(cols).toHaveProperty("role");
+      expect(cols).toHaveProperty("roleUri");
+      expect(cols).toHaveProperty("joinedAt");
+      expect(cols).toHaveProperty("createdAt");
+    });
+
+    it("has did and forumUri as not-null", () => {
+      const cols = getTableColumns(memberships);
+      expect(cols.did.notNull).toBe(true);
+      expect(cols.forumUri.notNull).toBe(true);
+    });
+  });
+
+  describe("posts table", () => {
+    it("has the correct table name", () => {
+      expect(getTableName(posts)).toBe("posts");
+    });
+
+    it("has expected columns for the unified post model", () => {
+      const cols = getTableColumns(posts);
+      expect(cols).toHaveProperty("id");
+      expect(cols).toHaveProperty("did");
+      expect(cols).toHaveProperty("rkey");
+      expect(cols).toHaveProperty("text");
+      expect(cols).toHaveProperty("rootPostId");
+      expect(cols).toHaveProperty("parentPostId");
+      expect(cols).toHaveProperty("rootUri");
+      expect(cols).toHaveProperty("parentUri");
+      expect(cols).toHaveProperty("deleted");
+      expect(cols).toHaveProperty("createdAt");
+    });
+
+    it("has text as not-null", () => {
+      const cols = getTableColumns(posts);
+      expect(cols.text.notNull).toBe(true);
+    });
+
+    it("has deleted defaulting to false", () => {
+      const cols = getTableColumns(posts);
+      expect(cols.deleted.notNull).toBe(true);
+      expect(cols.deleted.hasDefault).toBe(true);
+    });
+
+    it("has rootPostId and parentPostId as nullable (topics have no parent)", () => {
+      const cols = getTableColumns(posts);
+      expect(cols.rootPostId.notNull).toBe(false);
+      expect(cols.parentPostId.notNull).toBe(false);
+    });
+  });
+
+  describe("modActions table", () => {
+    it("has the correct table name", () => {
+      expect(getTableName(modActions)).toBe("mod_actions");
+    });
+
+    it("has expected columns", () => {
+      const cols = getTableColumns(modActions);
+      expect(cols).toHaveProperty("id");
+      expect(cols).toHaveProperty("did");
+      expect(cols).toHaveProperty("action");
+      expect(cols).toHaveProperty("subjectDid");
+      expect(cols).toHaveProperty("subjectPostUri");
+      expect(cols).toHaveProperty("reason");
+      expect(cols).toHaveProperty("createdBy");
+      expect(cols).toHaveProperty("expiresAt");
+    });
+
+    it("has action and createdBy as not-null", () => {
+      const cols = getTableColumns(modActions);
+      expect(cols.action.notNull).toBe(true);
+      expect(cols.createdBy.notNull).toBe(true);
+    });
+  });
+
+  describe("all tables export correctly", () => {
+    it("exports six tables", () => {
+      const tables = [forums, categories, users, memberships, posts, modActions];
+      expect(tables).toHaveLength(6);
+      tables.forEach((table) => {
+        expect(table).toBeDefined();
+      });
+    });
+  });
+});

packages/db/vitest.config.ts

···
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+  },
+});

packages/lexicon/__tests__/lexicons.test.ts

···
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { globSync } from "glob";
+
+const LEXICONS_DIR = join(import.meta.dirname, "..", "lexicons");
+const yamlFiles = globSync("**/*.yaml", { cwd: LEXICONS_DIR });
+
+describe("lexicon definitions", () => {
+  it("finds at least one lexicon file", () => {
+    expect(yamlFiles.length).toBeGreaterThan(0);
+  });
+
+  describe.each(yamlFiles)("%s", (file) => {
+    const content = readFileSync(join(LEXICONS_DIR, file), "utf-8");
+    const parsed = parseYaml(content);
+
+    it("has lexicon version 1", () => {
+      expect(parsed).toHaveProperty("lexicon", 1);
+    });
+
+    it("has an id field", () => {
+      expect(parsed).toHaveProperty("id");
+      expect(typeof parsed.id).toBe("string");
+    });
+
+    it("has a defs object", () => {
+      expect(parsed).toHaveProperty("defs");
+      expect(typeof parsed.defs).toBe("object");
+    });
+
+    it("has an id that matches the file path", () => {
+      // space/atbb/post.yaml -> space.atbb.post
+      const expectedId = file.replace(/\.yaml$/, "").replace(/\//g, ".");
+      expect(parsed.id).toBe(expectedId);
+    });
+  });
+});
+
+describe("lexicon uniqueness", () => {
+  it("has no duplicate lexicon ids", () => {
+    const ids = yamlFiles.map((file) => {
+      const content = readFileSync(join(LEXICONS_DIR, file), "utf-8");
+      return parseYaml(content).id;
+    });
+    const unique = new Set(ids);
+    expect(unique.size).toBe(ids.length);
+  });
+});
+
+describe("record key conventions", () => {
+  const recordLexicons = yamlFiles
+    .map((file) => {
+      const content = readFileSync(join(LEXICONS_DIR, file), "utf-8");
+      return { file, parsed: parseYaml(content) };
+    })
+    .filter(({ parsed }) => parsed.defs?.main?.type === "record");
+
+  it.each(recordLexicons.map(({ file, parsed }) => [file, parsed]))(
+    "%s has a valid record key type",
+    (_file, parsed) => {
+      const key = parsed.defs.main.key;
+      expect(["tid", "literal:self"]).toContain(key);
+    }
+  );
+});
+
+describe("extensible fields use knownValues", () => {
+  it("modAction.action uses knownValues, not enum", () => {
+    const content = readFileSync(
+      join(LEXICONS_DIR, "space/atbb/modAction.yaml"),
+      "utf-8"
+    );
+    const parsed = parseYaml(content);
+    const actionField =
+      parsed.defs.main.record?.properties?.action;
+    if (actionField) {
+      expect(actionField).not.toHaveProperty("enum");
+      expect(actionField).toHaveProperty("knownValues");
+    }
+  });
+});
+
+describe("strongRef definitions", () => {
+  it("strongRef has uri and cid fields", () => {
+    const content = readFileSync(
+      join(LEXICONS_DIR, "com/atproto/repo/strongRef.yaml"),
+      "utf-8"
+    );
+    const parsed = parseYaml(content);
+    const mainDef = parsed.defs.main;
+    expect(mainDef.properties).toHaveProperty("uri");
+    expect(mainDef.properties).toHaveProperty("cid");
+    expect(mainDef.required).toContain("uri");
+    expect(mainDef.required).toContain("cid");
+  });
+});

packages/lexicon/package.json

···
     "build": "pnpm run build:json && pnpm run build:types",
     "build:json": "tsx scripts/build.ts",
     "build:types": "bash -c 'shopt -s globstar && lex gen-api --yes ./dist/types ./dist/json/**/*.json'",
+    "test": "vitest run",
     "clean": "rm -rf dist"
   },
   "devDependencies": {

packages/lexicon/vitest.config.ts

···
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+  },
+});

pnpm-lock.yaml

···
       typescript:
         specifier: ^5.7.0
         version: 5.9.3
+      vitest:
+        specifier: ^4.0.18
+        version: 4.0.18(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2)
 
   apps/appview:
     dependencies:
···
     resolution: {integrity: sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==}
     engines: {node: '>=18'}
 
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
···
     resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
     engines: {node: '>= 8'}
 
+  '@rollup/rollup-android-arm-eabi@4.57.1':
+    resolution: {integrity: sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.57.1':
+    resolution: {integrity: sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.57.1':
+    resolution: {integrity: sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.57.1':
+    resolution: {integrity: sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-freebsd-arm64@4.57.1':
+    resolution: {integrity: sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/rollup-freebsd-x64@4.57.1':
+    resolution: {integrity: sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.57.1':
+    resolution: {integrity: sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.57.1':
+    resolution: {integrity: sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-gnu@4.57.1':
+    resolution: {integrity: sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-musl@4.57.1':
+    resolution: {integrity: sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-loong64-gnu@4.57.1':
+    resolution: {integrity: sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/rollup-linux-loong64-musl@4.57.1':
+    resolution: {integrity: sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/rollup-linux-ppc64-gnu@4.57.1':
+    resolution: {integrity: sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-ppc64-musl@4.57.1':
+    resolution: {integrity: sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.57.1':
+    resolution: {integrity: sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-musl@4.57.1':
+    resolution: {integrity: sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-s390x-gnu@4.57.1':
+    resolution: {integrity: sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-gnu@4.57.1':
+    resolution: {integrity: sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-musl@4.57.1':
+    resolution: {integrity: sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-openbsd-x64@4.57.1':
+    resolution: {integrity: sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@rollup/rollup-openharmony-arm64@4.57.1':
+    resolution: {integrity: sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rollup/rollup-win32-arm64-msvc@4.57.1':
+    resolution: {integrity: sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.57.1':
+    resolution: {integrity: sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-gnu@4.57.1':
+    resolution: {integrity: sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==}
+    cpu: [x64]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.57.1':
+    resolution: {integrity: sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==}
+    cpu: [x64]
+    os: [win32]
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
   '@ts-morph/common@0.17.0':
     resolution: {integrity: sha512-RMSSvSfs9kb0VzkvQ2NWobwnj7TxCA9vI/IjR9bDHqgAyVbu2T0DN4wiKVqomyDWqO7dPr/tErSfq7urQ1Q37g==}
 
+  '@types/chai@5.2.3':
+    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
+
+  '@types/deep-eql@4.0.2':
+    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
+
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
   '@types/node@22.19.9':
     resolution: {integrity: sha512-PD03/U8g1F9T9MI+1OBisaIARhSzeidsUjQaf51fOxrfjeiKN9bLVO06lHuHYjxdnqLWJijJHfqXPSJri2EM2A==}
 
+  '@vitest/expect@4.0.18':
+    resolution: {integrity: sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==}
+
+  '@vitest/mocker@4.0.18':
+    resolution: {integrity: sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^6.0.0 || ^7.0.0-0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
+  '@vitest/pretty-format@4.0.18':
+    resolution: {integrity: sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==}
+
+  '@vitest/runner@4.0.18':
+    resolution: {integrity: sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==}
+
+  '@vitest/snapshot@4.0.18':
+    resolution: {integrity: sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==}
+
+  '@vitest/spy@4.0.18':
+    resolution: {integrity: sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==}
+
+  '@vitest/utils@4.0.18':
+    resolution: {integrity: sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==}
+
   ansi-styles@4.3.0:
     resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
     engines: {node: '>=8'}
 
+  assertion-error@2.0.1:
+    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+    engines: {node: '>=12'}
+
   await-lock@2.2.2:
     resolution: {integrity: sha512-aDczADvlvTGajTDjcjpJMqRkOF6Qdz3YbPZm/PyW6tKPkx2hlYBzxMhEywM/tU72HrVZjgl5VCdRuMlA7pZ8Gw==}
 
···
 
   buffer-from@1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
+
+  chai@6.2.2:
+    resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
+    engines: {node: '>=18'}
 
   chalk@4.1.2:
     resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
···
       sqlite3:
         optional: true
 
+  es-module-lexer@1.7.0:
+    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
+
   esbuild-register@3.6.0:
     resolution: {integrity: sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg==}
     peerDependencies:
···
     resolution: {integrity: sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==}
     engines: {node: '>=18'}
     hasBin: true
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  expect-type@1.3.0:
+    resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
+    engines: {node: '>=12.0.0'}
 
   fast-glob@3.3.3:
     resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
···
   fastq@1.20.1:
     resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
 
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
   fill-range@7.1.1:
     resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
     engines: {node: '>=8'}
···
     resolution: {integrity: sha512-vFrFJkWtJvJnD5hg+hJvVE8Lh/TcMzKnTgCWmtBipwI5yLX/iX+5UB2tfuyODF5E7k9xEzMdYgGqaSb1c0c5Yw==}
     engines: {node: 20 || >=22}
 
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
   merge2@1.4.1:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
···
   multiformats@9.9.0:
     resolution: {integrity: sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==}
 
+  nanoid@3.3.11:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  obug@2.1.1:
+    resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
+
   package-json-from-dist@1.0.1:
     resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
 
···
     resolution: {integrity: sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==}
     engines: {node: 20 || >=22}
 
+  pathe@2.0.3:
+    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
   picomatch@2.3.1:
     resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
     engines: {node: '>=8.6'}
 
+  picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  postcss@8.5.6:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
   postgres@3.4.8:
     resolution: {integrity: sha512-d+JFcLM17njZaOLkv6SCev7uoLaBtfK86vMUXhW1Z4glPWh4jozno9APvW/XKFJ3CCxVoC7OL38BqRydtu5nGg==}
     engines: {node: '>=12'}
···
     resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
 
+  rollup@4.57.1:
+    resolution: {integrity: sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
   run-parallel@1.2.0:
     resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
 
···
     resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
     engines: {node: '>=8'}
 
+  siginfo@2.0.0:
+    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
   signal-exit@4.1.0:
     resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
     engines: {node: '>=14'}
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
 
   source-map-support@0.5.21:
     resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
···
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
+  stackback@0.0.2:
+    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
+  std-env@3.10.0:
+    resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
+
   supports-color@7.2.0:
     resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
     engines: {node: '>=8'}
+
+  tinybench@2.9.0:
+    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
+  tinyexec@1.0.2:
+    resolution: {integrity: sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==}
+    engines: {node: '>=18'}
+
+  tinyglobby@0.2.15:
+    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
+    engines: {node: '>=12.0.0'}
+
+  tinyrainbow@3.0.3:
+    resolution: {integrity: sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==}
+    engines: {node: '>=14.0.0'}
 
   tlds@1.261.0:
     resolution: {integrity: sha512-QXqwfEl9ddlGBaRFXIvNKK6OhipSiLXuRuLJX5DErz0o0Q0rYxulWLdFryTkV5PkdZct5iMInwYEGe/eR++1AA==}
···
   unicode-segmenter@0.14.5:
     resolution: {integrity: sha512-jHGmj2LUuqDcX3hqY12Ql+uhUTn8huuxNZGq7GvtF6bSybzH3aFgedYu/KTzQStEgt1Ra2F3HxadNXsNjb3m3g==}
 
+  vite@7.3.1:
+    resolution: {integrity: sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.19.0 || >=22.12.0
+      jiti: '>=1.21.0'
+      less: ^4.0.0
+      lightningcss: ^1.21.0
+      sass: ^1.70.0
+      sass-embedded: ^1.70.0
+      stylus: '>=0.54.8'
+      sugarss: ^5.0.0
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  vitest@4.0.18:
+    resolution: {integrity: sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==}
+    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@opentelemetry/api': ^1.9.0
+      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+      '@vitest/browser-playwright': 4.0.18
+      '@vitest/browser-preview': 4.0.18
+      '@vitest/browser-webdriverio': 4.0.18
+      '@vitest/ui': 4.0.18
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@opentelemetry/api':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser-playwright':
+        optional: true
+      '@vitest/browser-preview':
+        optional: true
+      '@vitest/browser-webdriverio':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
   which@2.0.2:
     resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
     engines: {node: '>= 8'}
+    hasBin: true
+
+  why-is-node-running@2.3.0:
+    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+    engines: {node: '>=8'}
     hasBin: true
 
   yaml@2.8.2:
···
 
   '@isaacs/cliui@9.0.0': {}
 
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
···
       '@nodelib/fs.scandir': 2.1.5
       fastq: 1.20.1
 
+  '@rollup/rollup-android-arm-eabi@4.57.1':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.57.1':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.57.1':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.57.1':
+    optional: true
+
+  '@rollup/rollup-freebsd-arm64@4.57.1':
+    optional: true
+
+  '@rollup/rollup-freebsd-x64@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-gnu@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-musl@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-gnu@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-musl@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-musl@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.57.1':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.57.1':
+    optional: true
+
+  '@rollup/rollup-openbsd-x64@4.57.1':
+    optional: true
+
+  '@rollup/rollup-openharmony-arm64@4.57.1':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.57.1':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.57.1':
+    optional: true
+
+  '@rollup/rollup-win32-x64-gnu@4.57.1':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.57.1':
+    optional: true
+
+  '@standard-schema/spec@1.1.0': {}
+
   '@ts-morph/common@0.17.0':
     dependencies:
       fast-glob: 3.3.3
···
       mkdirp: 1.0.4
       path-browserify: 1.0.1
 
+  '@types/chai@5.2.3':
+    dependencies:
+      '@types/deep-eql': 4.0.2
+      assertion-error: 2.0.1
+
+  '@types/deep-eql@4.0.2': {}
+
+  '@types/estree@1.0.8': {}
+
   '@types/node@22.19.9':
     dependencies:
       undici-types: 6.21.0
 
+  '@vitest/expect@4.0.18':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@types/chai': 5.2.3
+      '@vitest/spy': 4.0.18
+      '@vitest/utils': 4.0.18
+      chai: 6.2.2
+      tinyrainbow: 3.0.3
+
+  '@vitest/mocker@4.0.18(vite@7.3.1(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2))':
+    dependencies:
+      '@vitest/spy': 4.0.18
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.3.1(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2)
+
+  '@vitest/pretty-format@4.0.18':
+    dependencies:
+      tinyrainbow: 3.0.3
+
+  '@vitest/runner@4.0.18':
+    dependencies:
+      '@vitest/utils': 4.0.18
+      pathe: 2.0.3
+
+  '@vitest/snapshot@4.0.18':
+    dependencies:
+      '@vitest/pretty-format': 4.0.18
+      magic-string: 0.30.21
+      pathe: 2.0.3
+
+  '@vitest/spy@4.0.18': {}
+
+  '@vitest/utils@4.0.18':
+    dependencies:
+      '@vitest/pretty-format': 4.0.18
+      tinyrainbow: 3.0.3
+
   ansi-styles@4.3.0:
     dependencies:
       color-convert: 2.0.1
+
+  assertion-error@2.0.1: {}
 
   await-lock@2.2.2: {}
 
···
       fill-range: 7.1.1
 
   buffer-from@1.1.2: {}
+
+  chai@6.2.2: {}
 
   chalk@4.1.2:
     dependencies:
···
   drizzle-orm@0.45.1(postgres@3.4.8):
     optionalDependencies:
       postgres: 3.4.8
+
+  es-module-lexer@1.7.0: {}
 
   esbuild-register@3.6.0(esbuild@0.25.12):
     dependencies:
···
       '@esbuild/win32-ia32': 0.27.3
       '@esbuild/win32-x64': 0.27.3
 
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  expect-type@1.3.0: {}
+
   fast-glob@3.3.3:
     dependencies:
       '@nodelib/fs.stat': 2.0.5
···
   fastq@1.20.1:
     dependencies:
       reusify: 1.1.0
+
+  fdir@6.5.0(picomatch@4.0.3):
+    optionalDependencies:
+      picomatch: 4.0.3
 
   fill-range@7.1.1:
     dependencies:
···
       '@isaacs/cliui': 9.0.0
 
   lru-cache@11.2.5: {}
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
 
   merge2@1.4.1: {}
 
···
 
   multiformats@9.9.0: {}
 
+  nanoid@3.3.11: {}
+
+  obug@2.1.1: {}
+
   package-json-from-dist@1.0.1: {}
 
   path-browserify@1.0.1: {}
···
       lru-cache: 11.2.5
       minipass: 7.1.2
 
+  pathe@2.0.3: {}
+
+  picocolors@1.1.1: {}
+
   picomatch@2.3.1: {}
 
+  picomatch@4.0.3: {}
+
+  postcss@8.5.6:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
   postgres@3.4.8: {}
 
   prettier@3.8.1: {}
···
   resolve-pkg-maps@1.0.0: {}
 
   reusify@1.1.0: {}
+
+  rollup@4.57.1:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.57.1
+      '@rollup/rollup-android-arm64': 4.57.1
+      '@rollup/rollup-darwin-arm64': 4.57.1
+      '@rollup/rollup-darwin-x64': 4.57.1
+      '@rollup/rollup-freebsd-arm64': 4.57.1
+      '@rollup/rollup-freebsd-x64': 4.57.1
+      '@rollup/rollup-linux-arm-gnueabihf': 4.57.1
+      '@rollup/rollup-linux-arm-musleabihf': 4.57.1
+      '@rollup/rollup-linux-arm64-gnu': 4.57.1
+      '@rollup/rollup-linux-arm64-musl': 4.57.1
+      '@rollup/rollup-linux-loong64-gnu': 4.57.1
+      '@rollup/rollup-linux-loong64-musl': 4.57.1
+      '@rollup/rollup-linux-ppc64-gnu': 4.57.1
+      '@rollup/rollup-linux-ppc64-musl': 4.57.1
+      '@rollup/rollup-linux-riscv64-gnu': 4.57.1
+      '@rollup/rollup-linux-riscv64-musl': 4.57.1
+      '@rollup/rollup-linux-s390x-gnu': 4.57.1
+      '@rollup/rollup-linux-x64-gnu': 4.57.1
+      '@rollup/rollup-linux-x64-musl': 4.57.1
+      '@rollup/rollup-openbsd-x64': 4.57.1
+      '@rollup/rollup-openharmony-arm64': 4.57.1
+      '@rollup/rollup-win32-arm64-msvc': 4.57.1
+      '@rollup/rollup-win32-ia32-msvc': 4.57.1
+      '@rollup/rollup-win32-x64-gnu': 4.57.1
+      '@rollup/rollup-win32-x64-msvc': 4.57.1
+      fsevents: 2.3.3
 
   run-parallel@1.2.0:
     dependencies:
···
 
   shebang-regex@3.0.0: {}
 
+  siginfo@2.0.0: {}
+
   signal-exit@4.1.0: {}
+
+  source-map-js@1.2.1: {}
 
   source-map-support@0.5.21:
     dependencies:
···
 
   source-map@0.6.1: {}
 
+  stackback@0.0.2: {}
+
+  std-env@3.10.0: {}
+
   supports-color@7.2.0:
     dependencies:
       has-flag: 4.0.0
+
+  tinybench@2.9.0: {}
+
+  tinyexec@1.0.2: {}
+
+  tinyglobby@0.2.15:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+
+  tinyrainbow@3.0.3: {}
 
   tlds@1.261.0: {}
 
···
 
   unicode-segmenter@0.14.5: {}
 
+  vite@7.3.1(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2):
+    dependencies:
+      esbuild: 0.27.3
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.57.1
+      tinyglobby: 0.2.15
+    optionalDependencies:
+      '@types/node': 22.19.9
+      fsevents: 2.3.3
+      tsx: 4.21.0
+      yaml: 2.8.2
+
+  vitest@4.0.18(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2):
+    dependencies:
+      '@vitest/expect': 4.0.18
+      '@vitest/mocker': 4.0.18(vite@7.3.1(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2))
+      '@vitest/pretty-format': 4.0.18
+      '@vitest/runner': 4.0.18
+      '@vitest/snapshot': 4.0.18
+      '@vitest/spy': 4.0.18
+      '@vitest/utils': 4.0.18
+      es-module-lexer: 1.7.0
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      obug: 2.1.1
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 3.10.0
+      tinybench: 2.9.0
+      tinyexec: 1.0.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.0.3
+      vite: 7.3.1(@types/node@22.19.9)(tsx@4.21.0)(yaml@2.8.2)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 22.19.9
+    transitivePeerDependencies:
+      - jiti
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - terser
+      - tsx
+      - yaml
+
   which@2.0.2:
     dependencies:
       isexe: 2.0.0
+
+  why-is-node-running@2.3.0:
+    dependencies:
+      siginfo: 2.0.0
+      stackback: 0.0.2
 
   yaml@2.8.2: {}
 

turbo.json

···
     "lint": {
       "dependsOn": ["^build"]
     },
+    "test": {
+      "dependsOn": ["^build"]
+    },
     "clean": {
       "cache": false
     }

vitest.workspace.ts

···
+import { defineWorkspace } from "vitest/config";
+
+export default defineWorkspace([
+  "apps/appview",
+  "apps/web",
+  "packages/db",
+  "packages/lexicon",
+]);