feat: geometry (hit testing/picking)

.gitignore

···
 dist
 *.log
 .DS_Store
+coverage

TODO.txt

···
 Goal: determine what the cursor is over.
 
 Geometry (/packages/core/src/geom):
-[ ] shapeBounds(shape) -> Box2
-[ ] pointInRect(p, rectShape) -> bool
-[ ] pointInEllipse(p, ellipseShape) -> bool
-[ ] pointNearSegment(p, a, b, tolerance) -> bool
-[ ] hitTestPoint(state, worldPoint) -> shapeId? (topmost wins)
+[x] shapeBounds(shape) -> Box2
+[x] pointInRect(p, rectShape) -> bool
+[x] pointInEllipse(p, ellipseShape) -> bool
+[x] pointNearSegment(p, a, b, tolerance) -> bool
+[x] hitTestPoint(state, worldPoint) -> shapeId? (topmost wins)
 
 Layering:
-[ ] Define draw order = page.shapeIds order
-[ ] hitTest uses reverse order for topmost selection
+[x] Define draw order = page.shapeIds order
+[x] hitTest uses reverse order for topmost selection
 
 Tests:
-[ ] hitTestPoint returns expected shapeId for overlapping shapes
-[ ] tolerance works for line/arrow selection
+[x] hitTestPoint returns expected shapeId for overlapping shapes
+[x] tolerance works for line/arrow selection
 
 (DoD):
 - You can hover shapes and log the hit shape id (no selection yet).
-
 
 ==============================================================================
 7. Milestone G: Input system (pointer + keyboard)                      *wb-G*

apps/web/.prettierignore

···
 
 # Miscellaneous
 /static/
+
+# TS covered by dprint
+**/*.ts
+**/*.js

apps/web/README.md

···
-# sv
-
-Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
-
-## Creating a project
-
-If you're seeing this, you've probably already done this step. Congrats!
-
-```sh
-# create a new project in the current directory
-npx sv create
-
-# create a new project in my-app
-npx sv create my-app
-```
-
-## Developing
-
-Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
-
-```sh
-npm run dev
-
-# or start the server and open the app in a new browser tab
-npm run dev -- --open
-```
-
-## Building
-
-To create a production version of your app:
-
-```sh
-npm run build
-```
-
-You can preview the production build with `npm run preview`.
-
-> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.

apps/web/eslint.config.js

···
-import prettier from 'eslint-config-prettier';
-import { fileURLToPath } from 'node:url';
-import { includeIgnoreFile } from '@eslint/compat';
-import js from '@eslint/js';
-import svelte from 'eslint-plugin-svelte';
-import { defineConfig } from 'eslint/config';
-import globals from 'globals';
-import ts from 'typescript-eslint';
-import svelteConfig from './svelte.config.js';
+import { includeIgnoreFile } from "@eslint/compat";
+import js from "@eslint/js";
+import prettier from "eslint-config-prettier";
+import svelte from "eslint-plugin-svelte";
+import { defineConfig } from "eslint/config";
+import globals from "globals";
+import { fileURLToPath } from "node:url";
+import ts from "typescript-eslint";
+import svelteConfig from "./svelte.config.js";
 
-const gitignorePath = fileURLToPath(new URL('./.gitignore', import.meta.url));
+const gitignorePath = fileURLToPath(new URL("./.gitignore", import.meta.url));
 
 export default defineConfig(
-	includeIgnoreFile(gitignorePath),
-	js.configs.recommended,
-	...ts.configs.recommended,
-	...svelte.configs.recommended,
-	prettier,
-	...svelte.configs.prettier,
-	{
-		languageOptions: { globals: { ...globals.browser, ...globals.node } },
-
-		rules: {
-			// typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects.
-			// see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors
-			"no-undef": 'off'
-		}
-	},
-	{
-		files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
+  includeIgnoreFile(gitignorePath),
+  js.configs.recommended,
+  ...ts.configs.recommended,
+  ...svelte.configs.recommended,
+  prettier,
+  ...svelte.configs.prettier,
+  {
+    languageOptions: { globals: { ...globals.browser, ...globals.node } },
 
-		languageOptions: {
-			parserOptions: {
-				projectService: true,
-				extraFileExtensions: ['.svelte'],
-				parser: ts.parser,
-				svelteConfig
-			}
-		}
-	}
+    rules: {
+      // typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects.
+      // see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors
+      "no-undef": "off",
+    },
+  },
+  {
+    files: ["**/*.svelte", "**/*.svelte.ts", "**/*.svelte.js"],
+    languageOptions: {
+      parserOptions: { projectService: true, extraFileExtensions: [".svelte"], parser: ts.parser, svelteConfig },
+    },
+  },
 );

apps/web/package.json

···
 {
-	"name": "web",
-	"private": true,
-	"version": "0.0.1",
-	"type": "module",
-	"scripts": {
-		"dev": "vite dev",
-		"build": "vite build",
-		"preview": "vite preview",
-		"prepare": "svelte-kit sync || echo ''",
-		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-		"lint": "eslint . && prettier --check .",
-		"test:unit": "vitest",
-		"test": "npm run test:unit -- --run",
-		"format": "prettier --write ."
-	},
-	"devDependencies": {
-		"@eslint/compat": "^1.4.0",
-		"@eslint/js": "^9.39.1",
-		"@sveltejs/adapter-static": "^3.0.10",
-		"@sveltejs/kit": "^2.49.1",
-		"@sveltejs/vite-plugin-svelte": "^6.2.1",
-		"@types/node": "^24",
-		"@vitest/browser-playwright": "^4.0.15",
-		"eslint": "^9.39.1",
-		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-svelte": "^3.13.1",
-		"globals": "^16.5.0",
-		"playwright": "^1.57.0",
-		"prettier": "^3.7.4",
-		"prettier-plugin-svelte": "^3.4.0",
-		"svelte": "^5.45.6",
-		"svelte-check": "^4.3.4",
-		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.48.1",
-		"vite": "^7.2.6",
-		"vite-plugin-devtools-json": "^1.0.0",
-		"vitest": "^4.0.15",
-		"vitest-browser-svelte": "^2.0.1"
-	}
+  "name": "inkfinite-web",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "preview": "vite preview",
+    "prepare": "svelte-kit sync || echo ''",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "lint": "eslint . && prettier --check .",
+    "test:unit": "vitest",
+    "test": "npm run test:unit -- --run",
+    "format": "prettier --write ."
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.4.0",
+    "@eslint/js": "^9.39.1",
+    "@sveltejs/adapter-static": "^3.0.10",
+    "@sveltejs/kit": "^2.49.1",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@types/node": "^24",
+    "@vitest/browser-playwright": "^4.0.15",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-svelte": "^3.13.1",
+    "globals": "^16.5.0",
+    "playwright": "^1.57.0",
+    "prettier": "^3.7.4",
+    "prettier-plugin-svelte": "^3.4.0",
+    "svelte": "^5.45.6",
+    "svelte-check": "^4.3.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.1",
+    "vite": "^7.2.6",
+    "vite-plugin-devtools-json": "^1.0.0",
+    "vitest": "^4.0.15",
+    "vitest-browser-svelte": "^2.0.1"
+  }
 }

apps/web/tsconfig.json

···
 {
-	"extends": "./.svelte-kit/tsconfig.json",
-	"compilerOptions": {
-		"rewriteRelativeImportExtensions": true,
-		"allowJs": true,
-		"checkJs": true,
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"sourceMap": true,
-		"strict": true,
-		"moduleResolution": "bundler"
-	}
-	// Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
-	// except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
-	//
-	// To make changes to top-level options such as include and exclude, we recommend extending
-	// the generated config; see https://svelte.dev/docs/kit/configuration#typescript
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "rewriteRelativeImportExtensions": true,
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "bundler"
+  }
+  // Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
+  // except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
+  //
+  // To make changes to top-level options such as include and exclude, we recommend extending
+  // the generated config; see https://svelte.dev/docs/kit/configuration#typescript
 }

package.json

···
   "version": "1.0.0",
   "private": true,
   "type": "module",
-  "workspaces": [
-    "packages/*"
-  ],
+  "workspaces": ["packages/*", "apps/*"],
   "scripts": {},
   "devDependencies": {
     "@eslint/js": "^9.39.2",
···
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.50.0"
   },
-  "engines": {
-    "node": ">=18.0.0",
-    "pnpm": ">=8.0.0"
-  },
+  "engines": { "node": ">=18.0.0", "pnpm": ">=8.0.0" },
   "packageManager": "pnpm@10.26.1"
 }

packages/core/package.json

···
   "author": "Author Name <[e-mail]>",
   "license": "MIT",
   "homepage": "https://github.com/author/library#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/author/library.git"
-  },
-  "bugs": {
-    "url": "https://github.com/author/library/issues"
-  },
-  "exports": {
-    ".": "./dist/index.mjs",
-    "./package.json": "./package.json"
-  },
+  "repository": { "type": "git", "url": "git+https://github.com/author/library.git" },
+  "bugs": { "url": "https://github.com/author/library/issues" },
+  "exports": { ".": "./dist/index.mjs", "./package.json": "./package.json" },
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
···
   },
   "devDependencies": {
     "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
     "bumpp": "^10.3.2",
     "tsdown": "^0.18.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   },
-  "dependencies": {
-    "rxjs": "^7.8.2",
-    "uuid": "^13.0.0"
-  }
+  "dependencies": { "rxjs": "^7.8.2", "uuid": "^13.0.0" }
 }

packages/core/src/geom.ts

···
+import type { Box2, Vec2 } from "./math";
+import { Box2 as Box2Ops, Vec2 as Vec2Ops } from "./math";
+import type { ArrowShape, EllipseShape, LineShape, RectShape, ShapeRecord, TextShape } from "./model";
+import type { EditorState } from "./reactivity";
+import { getShapesOnCurrentPage } from "./reactivity";
+
+/**
+ * Get the axis-aligned bounding box of a shape in world coordinates
+ *
+ * For shapes with rotation, this returns the bounding box of the rotated shape
+ * (not the minimal bounding box of the original shape)
+ *
+ * @param shape - The shape to get bounds for
+ * @returns Bounding box in world coordinates
+ */
+export function shapeBounds(shape: ShapeRecord): Box2 {
+  switch (shape.type) {
+    case "rect": {
+      return rectBounds(shape);
+    }
+    case "ellipse": {
+      return ellipseBounds(shape);
+    }
+    case "line": {
+      return lineBounds(shape);
+    }
+    case "arrow": {
+      return arrowBounds(shape);
+    }
+    case "text": {
+      return textBounds(shape);
+    }
+  }
+}
+
+/**
+ * Get bounds for a rectangle shape
+ */
+function rectBounds(shape: RectShape): Box2 {
+  const { w, h } = shape.props;
+  const { x, y, rot } = shape;
+
+  if (rot === 0) {
+    return Box2Ops.create(x, y, x + w, y + h);
+  }
+
+  const corners = [{ x: 0, y: 0 }, { x: w, y: 0 }, { x: w, y: h }, { x: 0, y: h }];
+  const rotatedCorners = corners.map((corner) => rotatePoint(corner, rot));
+  const translatedCorners = rotatedCorners.map((corner) => ({ x: corner.x + x, y: corner.y + y }));
+  return Box2Ops.fromPoints(translatedCorners);
+}
+
+/**
+ * Get bounds for an ellipse shape
+ */
+function ellipseBounds(shape: EllipseShape): Box2 {
+  const { w, h } = shape.props;
+  const { x, y, rot } = shape;
+
+  if (rot === 0) {
+    return Box2Ops.create(x, y, x + w, y + h);
+  }
+
+  const corners = [{ x: 0, y: 0 }, { x: w, y: 0 }, { x: w, y: h }, { x: 0, y: h }];
+  const rotatedCorners = corners.map((corner) => rotatePoint(corner, rot));
+  const translatedCorners = rotatedCorners.map((corner) => ({ x: corner.x + x, y: corner.y + y }));
+  return Box2Ops.fromPoints(translatedCorners);
+}
+
+/**
+ * Get bounds for a line shape
+ */
+function lineBounds(shape: LineShape): Box2 {
+  const { a, b } = shape.props;
+  const { x, y, rot } = shape;
+
+  const points = [a, b];
+
+  if (rot === 0) {
+    const translatedPoints = points.map((p) => ({ x: p.x + x, y: p.y + y }));
+    return Box2Ops.fromPoints(translatedPoints);
+  }
+
+  const rotatedPoints = points.map((p) => rotatePoint(p, rot));
+  const translatedPoints = rotatedPoints.map((p) => ({ x: p.x + x, y: p.y + y }));
+  return Box2Ops.fromPoints(translatedPoints);
+}
+
+/**
+ * Get bounds for an arrow shape
+ */
+function arrowBounds(shape: ArrowShape): Box2 {
+  const { a, b } = shape.props;
+  const { x, y, rot } = shape;
+
+  const points = [a, b];
+
+  if (rot === 0) {
+    const translatedPoints = points.map((p) => ({ x: p.x + x, y: p.y + y }));
+    return Box2Ops.fromPoints(translatedPoints);
+  }
+
+  const rotatedPoints = points.map((p) => rotatePoint(p, rot));
+  const translatedPoints = rotatedPoints.map((p) => ({ x: p.x + x, y: p.y + y }));
+  return Box2Ops.fromPoints(translatedPoints);
+}
+
+/**
+ * Get bounds for a text shape
+ */
+function textBounds(shape: TextShape): Box2 {
+  const { fontSize, w } = shape.props;
+  const { x, y, rot } = shape;
+
+  const width = w ?? fontSize * 10;
+  const height = fontSize * 1.2;
+
+  if (rot === 0) {
+    return Box2Ops.create(x, y, x + width, y + height);
+  }
+
+  const corners = [{ x: 0, y: 0 }, { x: width, y: 0 }, { x: width, y: height }, { x: 0, y: height }];
+
+  const rotatedCorners = corners.map((corner) => rotatePoint(corner, rot));
+  const translatedCorners = rotatedCorners.map((corner) => ({ x: corner.x + x, y: corner.y + y }));
+  return Box2Ops.fromPoints(translatedCorners);
+}
+
+/**
+ * Rotate a point around the origin
+ *
+ * @param p - Point to rotate
+ * @param theta - Rotation angle in radians
+ * @returns Rotated point
+ */
+function rotatePoint(p: Vec2, theta: number): Vec2 {
+  const cos = Math.cos(theta);
+  const sin = Math.sin(theta);
+  return { x: p.x * cos - p.y * sin, y: p.x * sin + p.y * cos };
+}
+
+/**
+ * Check if a point is inside a rectangle shape
+ *
+ * @param p - Point in world coordinates
+ * @param shape - Rectangle shape
+ * @returns True if point is inside the rectangle
+ */
+export function pointInRect(p: Vec2, shape: RectShape): boolean {
+  const { x, y, rot } = shape;
+  const { w, h } = shape.props;
+  const localP = worldToLocal(p, x, y, rot);
+  return localP.x >= 0 && localP.x <= w && localP.y >= 0 && localP.y <= h;
+}
+
+/**
+ * Check if a point is inside an ellipse shape
+ *
+ * @param p - Point in world coordinates
+ * @param shape - Ellipse shape
+ * @returns True if point is inside the ellipse
+ */
+export function pointInEllipse(p: Vec2, shape: EllipseShape): boolean {
+  const { x, y, rot } = shape;
+  const { w, h } = shape.props;
+
+  const localP = worldToLocal(p, x, y, rot);
+
+  const centerX = w / 2;
+  const centerY = h / 2;
+  const radiusX = w / 2;
+  const radiusY = h / 2;
+
+  const dx = localP.x - centerX;
+  const dy = localP.y - centerY;
+  return (dx * dx) / (radiusX * radiusX) + (dy * dy) / (radiusY * radiusY) <= 1;
+}
+
+/**
+ * Check if a point is near a line segment
+ *
+ * @param p - Point to test
+ * @param a - Start point of segment
+ * @param b - End point of segment
+ * @param tolerance - Maximum distance from segment to be considered "near"
+ * @returns True if point is within tolerance distance of the segment
+ */
+export function pointNearSegment(p: Vec2, a: Vec2, b: Vec2, tolerance: number): boolean {
+  const ab = Vec2Ops.sub(b, a);
+  const ap = Vec2Ops.sub(p, a);
+  const abLengthSq = Vec2Ops.lenSq(ab);
+
+  if (abLengthSq === 0) {
+    return Vec2Ops.dist(p, a) <= tolerance;
+  }
+
+  const t = Math.max(0, Math.min(1, Vec2Ops.dot(ap, ab) / abLengthSq));
+  const projection = Vec2Ops.add(a, Vec2Ops.mulScalar(ab, t));
+  const distance = Vec2Ops.dist(p, projection);
+  return distance <= tolerance;
+}
+
+/**
+ * Check if a point is near a line or arrow shape
+ *
+ * @param p - Point in world coordinates
+ * @param shape - Line or arrow shape
+ * @param tolerance - Maximum distance from line to be considered a hit
+ * @returns True if point is near the line
+ */
+export function pointNearLine(p: Vec2, shape: LineShape | ArrowShape, tolerance = 5): boolean {
+  const { x, y, rot } = shape;
+  const { a, b } = shape.props;
+  const localP = worldToLocal(p, x, y, rot);
+  return pointNearSegment(localP, a, b, tolerance);
+}
+
+/**
+ * Check if a point is inside a text shape
+ *
+ * @param p - Point in world coordinates
+ * @param shape - Text shape
+ * @returns True if point is inside the text bounds
+ */
+export function pointInText(p: Vec2, shape: TextShape): boolean {
+  const { x, y, rot } = shape;
+  const { fontSize, w } = shape.props;
+  const localP = worldToLocal(p, x, y, rot);
+  const width = w ?? fontSize * 10;
+  const height = fontSize * 1.2;
+  return localP.x >= 0 && localP.x <= width && localP.y >= 0 && localP.y <= height;
+}
+
+/**
+ * Transform a point from world coordinates to shape-local coordinates
+ *
+ * @param p - Point in world coordinates
+ * @param shapeX - Shape x position
+ * @param shapeY - Shape y position
+ * @param shapeRot - Shape rotation in radians
+ * @returns Point in shape-local coordinates
+ */
+function worldToLocal(p: Vec2, shapeX: number, shapeY: number, shapeRot: number): Vec2 {
+  const translated = { x: p.x - shapeX, y: p.y - shapeY };
+
+  if (shapeRot === 0) {
+    return translated;
+  }
+
+  return rotatePoint(translated, -shapeRot);
+}
+
+/**
+ * Perform hit testing to find which shape is under a point
+ *
+ * Uses reverse order (topmost shape wins) based on page.shapeIds order.
+ * Line and arrow shapes use a tolerance for easier selection.
+ *
+ * @param state - Editor state
+ * @param worldPoint - Point to test in world coordinates
+ * @param tolerance - Tolerance for line/arrow hit testing (default: 5)
+ * @returns Shape ID of the topmost shape under the point, or null if no hit
+ */
+export function hitTestPoint(state: EditorState, worldPoint: Vec2, tolerance = 5): string | null {
+  const shapes = getShapesOnCurrentPage(state);
+
+  for (let index = shapes.length - 1; index >= 0; index--) {
+    const shape = shapes[index];
+
+    switch (shape.type) {
+      case "rect": {
+        if (pointInRect(worldPoint, shape)) {
+          return shape.id;
+        }
+        break;
+      }
+      case "ellipse": {
+        if (pointInEllipse(worldPoint, shape)) {
+          return shape.id;
+        }
+        break;
+      }
+      case "line":
+      case "arrow": {
+        if (pointNearLine(worldPoint, shape, tolerance)) {
+          return shape.id;
+        }
+        break;
+      }
+      case "text": {
+        if (pointInText(worldPoint, shape)) {
+          return shape.id;
+        }
+        break;
+      }
+    }
+  }
+
+  return null;
+}

packages/core/src/index.ts

···
 export * from "./camera";
+export * from "./geom";
 export * from "./math";
 export * from "./model";
 export * from "./reactivity";

packages/core/tests/geom.test.ts

···
+import { describe, expect, it } from "vitest";
+import {
+  hitTestPoint,
+  PageRecord,
+  pointInEllipse,
+  pointInRect,
+  pointNearSegment,
+  shapeBounds,
+  ShapeRecord,
+  Store,
+} from "../src";
+
+describe("Geometry", () => {
+  describe("shapeBounds", () => {
+    it("should return correct bounds for rect without rotation", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 200, { w: 50, h: 30, fill: "", stroke: "", radius: 0 });
+
+      const bounds = shapeBounds(rect);
+
+      expect(bounds.min).toEqual({ x: 100, y: 200 });
+      expect(bounds.max).toEqual({ x: 150, y: 230 });
+    });
+
+    it("should return correct bounds for rect with rotation", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+      rect.rot = Math.PI / 4;
+
+      const bounds = shapeBounds(rect);
+
+      expect(bounds.min.x).toBeDefined();
+      expect(bounds.min.y).toBeDefined();
+      expect(bounds.max.x).toBeGreaterThan(bounds.min.x);
+      expect(bounds.max.y).toBeGreaterThan(bounds.min.y);
+    });
+
+    it("should return correct bounds for ellipse without rotation", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 50, 50, { w: 100, h: 80, fill: "", stroke: "" });
+
+      const bounds = shapeBounds(ellipse);
+
+      expect(bounds.min).toEqual({ x: 50, y: 50 });
+      expect(bounds.max).toEqual({ x: 150, y: 130 });
+    });
+
+    it("should return correct bounds for line", () => {
+      const line = ShapeRecord.createLine("page:1", 10, 10, {
+        a: { x: 0, y: 0 },
+        b: { x: 100, y: 50 },
+        stroke: "",
+        width: 2,
+      });
+
+      const bounds = shapeBounds(line);
+
+      expect(bounds.min).toEqual({ x: 10, y: 10 });
+      expect(bounds.max).toEqual({ x: 110, y: 60 });
+    });
+
+    it("should return correct bounds for arrow", () => {
+      const arrow = ShapeRecord.createArrow("page:1", 20, 30, {
+        a: { x: 10, y: 10 },
+        b: { x: 50, y: 60 },
+        stroke: "",
+        width: 2,
+      });
+
+      const bounds = shapeBounds(arrow);
+
+      expect(bounds.min).toEqual({ x: 30, y: 40 });
+      expect(bounds.max).toEqual({ x: 70, y: 90 });
+    });
+
+    it("should return correct bounds for text", () => {
+      const text = ShapeRecord.createText("page:1", 100, 100, {
+        text: "Hello",
+        fontSize: 16,
+        fontFamily: "Arial",
+        color: "#000",
+        w: 100,
+      });
+
+      const bounds = shapeBounds(text);
+
+      expect(bounds.min).toEqual({ x: 100, y: 100 });
+      expect(bounds.max.x).toBeCloseTo(200, 1);
+      expect(bounds.max.y).toBeCloseTo(119.2, 1);
+    });
+
+    it("should return correct bounds for text without explicit width", () => {
+      const text = ShapeRecord.createText("page:1", 100, 100, {
+        text: "Hello",
+        fontSize: 20,
+        fontFamily: "Arial",
+        color: "#000",
+      });
+
+      const bounds = shapeBounds(text);
+
+      expect(bounds.min).toEqual({ x: 100, y: 100 });
+      expect(bounds.max.x).toBeCloseTo(300, 1);
+      expect(bounds.max.y).toBeCloseTo(124, 1);
+    });
+  });
+
+  describe("pointInRect", () => {
+    it("should return true for point inside rect", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+
+      expect(pointInRect({ x: 150, y: 125 }, rect)).toBe(true);
+      expect(pointInRect({ x: 100, y: 100 }, rect)).toBe(true);
+      expect(pointInRect({ x: 200, y: 150 }, rect)).toBe(true);
+    });
+
+    it("should return false for point outside rect", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+
+      expect(pointInRect({ x: 99, y: 125 }, rect)).toBe(false);
+      expect(pointInRect({ x: 201, y: 125 }, rect)).toBe(false);
+      expect(pointInRect({ x: 150, y: 99 }, rect)).toBe(false);
+      expect(pointInRect({ x: 150, y: 151 }, rect)).toBe(false);
+    });
+
+    it("should handle rotated rectangles", () => {
+      const rect = ShapeRecord.createRect("page:1", 0, 0, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+      rect.rot = Math.PI / 4;
+
+      const centerInLocal = { x: 50, y: 25 };
+      const cos = Math.cos(Math.PI / 4);
+      const sin = Math.sin(Math.PI / 4);
+      const centerPoint = {
+        x: centerInLocal.x * cos - centerInLocal.y * sin,
+        y: centerInLocal.x * sin + centerInLocal.y * cos,
+      };
+      expect(pointInRect(centerPoint, rect)).toBe(true);
+
+      const farPoint = { x: 200, y: 200 };
+      expect(pointInRect(farPoint, rect)).toBe(false);
+    });
+  });
+
+  describe("pointInEllipse", () => {
+    it("should return true for point inside ellipse", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, { w: 100, h: 80, fill: "", stroke: "" });
+
+      expect(pointInEllipse({ x: 150, y: 140 }, ellipse)).toBe(true);
+    });
+
+    it("should return false for point outside ellipse", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, { w: 100, h: 80, fill: "", stroke: "" });
+
+      expect(pointInEllipse({ x: 100, y: 100 }, ellipse)).toBe(false);
+      expect(pointInEllipse({ x: 200, y: 180 }, ellipse)).toBe(false);
+    });
+
+    it("should handle point at center of ellipse", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, { w: 100, h: 80, fill: "", stroke: "" });
+
+      const center = { x: 150, y: 140 };
+      expect(pointInEllipse(center, ellipse)).toBe(true);
+    });
+
+    it("should handle rotated ellipses", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 0, 0, { w: 100, h: 50, fill: "", stroke: "" });
+      ellipse.rot = Math.PI / 2;
+
+      const centerInLocal = { x: 50, y: 25 };
+      const cos = Math.cos(Math.PI / 2);
+      const sin = Math.sin(Math.PI / 2);
+      const centerPoint = {
+        x: centerInLocal.x * cos - centerInLocal.y * sin,
+        y: centerInLocal.x * sin + centerInLocal.y * cos,
+      };
+      expect(pointInEllipse(centerPoint, ellipse)).toBe(true);
+    });
+  });
+
+  describe("pointNearSegment", () => {
+    it("should return true for point on segment", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 100, y: 0 };
+      const p = { x: 50, y: 0 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+    });
+
+    it("should return true for point near segment within tolerance", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 100, y: 0 };
+      const p = { x: 50, y: 3 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+    });
+
+    it("should return false for point far from segment", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 100, y: 0 };
+      const p = { x: 50, y: 10 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(false);
+    });
+
+    it("should handle diagonal segments", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 100, y: 100 };
+      const p = { x: 50, y: 50 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+    });
+
+    it("should handle points beyond segment endpoints", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 100, y: 0 };
+
+      const beforeStart = { x: -10, y: 0 };
+      expect(pointNearSegment(beforeStart, a, b, 15)).toBe(true);
+
+      const afterEnd = { x: 110, y: 0 };
+      expect(pointNearSegment(afterEnd, a, b, 15)).toBe(true);
+    });
+
+    it("should handle zero-length segments", () => {
+      const a = { x: 50, y: 50 };
+      const b = { x: 50, y: 50 };
+      const p = { x: 52, y: 52 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+    });
+  });
+
+  describe("pointNearSegment - edge cases", () => {
+    it("should handle very small tolerance", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 100, y: 0 };
+      const p = { x: 50, y: 0.1 };
+
+      expect(pointNearSegment(p, a, b, 0.05)).toBe(false);
+      expect(pointNearSegment(p, a, b, 0.2)).toBe(true);
+    });
+
+    it("should handle negative coordinates", () => {
+      const a = { x: -100, y: -100 };
+      const b = { x: -50, y: -50 };
+      const p = { x: -75, y: -75 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+    });
+
+    it("should handle vertical segments", () => {
+      const a = { x: 50, y: 0 };
+      const b = { x: 50, y: 100 };
+      const p = { x: 52, y: 50 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+      expect(pointNearSegment(p, a, b, 1)).toBe(false);
+    });
+
+    it("should handle horizontal segments", () => {
+      const a = { x: 0, y: 50 };
+      const b = { x: 100, y: 50 };
+      const p = { x: 50, y: 52 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+      expect(pointNearSegment(p, a, b, 1)).toBe(false);
+    });
+
+    it("should handle very long segments", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 10_000, y: 10_000 };
+      const p = { x: 5000, y: 5003 };
+
+      expect(pointNearSegment(p, a, b, 5)).toBe(true);
+    });
+
+    it("should handle point exactly at endpoint", () => {
+      const a = { x: 0, y: 0 };
+      const b = { x: 100, y: 100 };
+
+      expect(pointNearSegment(a, a, b, 0.1)).toBe(true);
+      expect(pointNearSegment(b, a, b, 0.1)).toBe(true);
+    });
+  });
+
+  describe("pointInRect - edge cases", () => {
+    it("should handle point exactly on rect boundary", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+
+      expect(pointInRect({ x: 100, y: 125 }, rect)).toBe(true);
+      expect(pointInRect({ x: 200, y: 125 }, rect)).toBe(true);
+      expect(pointInRect({ x: 150, y: 100 }, rect)).toBe(true);
+      expect(pointInRect({ x: 150, y: 150 }, rect)).toBe(true);
+    });
+
+    it("should handle zero-size rectangles", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 0, h: 0, fill: "", stroke: "", radius: 0 });
+
+      expect(pointInRect({ x: 100, y: 100 }, rect)).toBe(true);
+      expect(pointInRect({ x: 100.1, y: 100 }, rect)).toBe(false);
+    });
+
+    it("should handle negative coordinates", () => {
+      const rect = ShapeRecord.createRect("page:1", -100, -100, { w: 50, h: 50, fill: "", stroke: "", radius: 0 });
+
+      expect(pointInRect({ x: -75, y: -75 }, rect)).toBe(true);
+      expect(pointInRect({ x: -101, y: -75 }, rect)).toBe(false);
+    });
+
+    it("should handle very small rectangles", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 0.1, h: 0.1, fill: "", stroke: "", radius: 0 });
+
+      expect(pointInRect({ x: 100.05, y: 100.05 }, rect)).toBe(true);
+      expect(pointInRect({ x: 100.2, y: 100.05 }, rect)).toBe(false);
+    });
+
+    it("should handle 90 degree rotation", () => {
+      const rect = ShapeRecord.createRect("page:1", 0, 0, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+      rect.rot = Math.PI / 2;
+
+      const center = { x: -25, y: 50 };
+      expect(pointInRect(center, rect)).toBe(true);
+    });
+
+    it("should handle 180 degree rotation", () => {
+      const rect = ShapeRecord.createRect("page:1", 0, 0, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+      rect.rot = Math.PI;
+
+      const center = { x: -50, y: -25 };
+      expect(pointInRect(center, rect)).toBe(true);
+    });
+  });
+
+  describe("pointInEllipse - edge cases", () => {
+    it("should handle point exactly on ellipse boundary", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, { w: 100, h: 80, fill: "", stroke: "" });
+
+      const rightEdge = { x: 200, y: 140 };
+      expect(pointInEllipse(rightEdge, ellipse)).toBe(true);
+    });
+
+    it("should handle very small ellipse", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, { w: 0.2, h: 0.2, fill: "", stroke: "" });
+
+      expect(pointInEllipse({ x: 100.1, y: 100.1 }, ellipse)).toBe(true);
+      expect(pointInEllipse({ x: 100.2, y: 100.1 }, ellipse)).toBe(false);
+    });
+
+    it("should handle circle (equal width and height)", () => {
+      const circle = ShapeRecord.createEllipse("page:1", 100, 100, { w: 100, h: 100, fill: "", stroke: "" });
+
+      expect(pointInEllipse({ x: 150, y: 150 }, circle)).toBe(true);
+      expect(pointInEllipse({ x: 200, y: 150 }, circle)).toBe(true);
+    });
+
+    it("should handle negative coordinates", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", -100, -100, { w: 100, h: 80, fill: "", stroke: "" });
+
+      expect(pointInEllipse({ x: -50, y: -60 }, ellipse)).toBe(true);
+    });
+
+    it("should handle very flat ellipse", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, { w: 200, h: 10, fill: "", stroke: "" });
+
+      const center = { x: 200, y: 105 };
+      expect(pointInEllipse(center, ellipse)).toBe(true);
+
+      const farOutside = { x: 200, y: 120 };
+      expect(pointInEllipse(farOutside, ellipse)).toBe(false);
+    });
+
+    it("should handle very tall ellipse", () => {
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, { w: 10, h: 200, fill: "", stroke: "" });
+
+      const center = { x: 105, y: 200 };
+      expect(pointInEllipse(center, ellipse)).toBe(true);
+
+      const farOutside = { x: 120, y: 200 };
+      expect(pointInEllipse(farOutside, ellipse)).toBe(false);
+    });
+  });
+
+  describe("shapeBounds - edge cases", () => {
+    it("should handle negative width/height gracefully", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: -50, h: -30, fill: "", stroke: "", radius: 0 });
+
+      const bounds = shapeBounds(rect);
+      expect(bounds.min.x).toBeDefined();
+      expect(bounds.max.x).toBeDefined();
+      expect(bounds.min.y).toBeDefined();
+      expect(bounds.max.y).toBeDefined();
+    });
+
+    it("should handle zero-size shapes", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 0, h: 0, fill: "", stroke: "", radius: 0 });
+
+      const bounds = shapeBounds(rect);
+      expect(bounds.min).toEqual({ x: 100, y: 100 });
+      expect(bounds.max).toEqual({ x: 100, y: 100 });
+    });
+
+    it("should handle line with same start and end points", () => {
+      const line = ShapeRecord.createLine("page:1", 100, 100, {
+        a: { x: 0, y: 0 },
+        b: { x: 0, y: 0 },
+        stroke: "",
+        width: 2,
+      });
+
+      const bounds = shapeBounds(line);
+      expect(bounds.min).toEqual({ x: 100, y: 100 });
+      expect(bounds.max).toEqual({ x: 100, y: 100 });
+    });
+
+    it("should handle multiple rotations", () => {
+      const rect = ShapeRecord.createRect("page:1", 100, 100, { w: 100, h: 50, fill: "", stroke: "", radius: 0 });
+      rect.rot = Math.PI * 2;
+
+      const bounds = shapeBounds(rect);
+      expect(bounds.min.x).toBeCloseTo(100, 1);
+      expect(bounds.min.y).toBeCloseTo(100, 1);
+      expect(bounds.max.x).toBeCloseTo(200, 1);
+      expect(bounds.max.y).toBeCloseTo(150, 1);
+    });
+
+    it("should handle very large shapes", () => {
+      const rect = ShapeRecord.createRect("page:1", 0, 0, { w: 100_000, h: 100_000, fill: "", stroke: "", radius: 0 });
+
+      const bounds = shapeBounds(rect);
+      expect(bounds.max.x).toBe(100_000);
+      expect(bounds.max.y).toBe(100_000);
+    });
+
+    it("should handle line with rotation", () => {
+      const line = ShapeRecord.createLine("page:1", 100, 100, {
+        a: { x: 0, y: 0 },
+        b: { x: 100, y: 0 },
+        stroke: "",
+        width: 2,
+      });
+      line.rot = Math.PI / 2;
+
+      const bounds = shapeBounds(line);
+      expect(bounds.min.x).toBeCloseTo(100, 1);
+      expect(bounds.max.y).toBeCloseTo(200, 1);
+    });
+  });
+
+  describe("hitTestPoint", () => {
+    it("should return shape id for point inside rect", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const rect = ShapeRecord.createRect("page:1", 100, 100, {
+        w: 100,
+        h: 50,
+        fill: "#ff0000",
+        stroke: "#000000",
+        radius: 0,
+      }, "shape:1");
+
+      store.setState((state) => ({
+        ...state,
+        doc: { pages: { [page.id]: { ...page, shapeIds: [rect.id] } }, shapes: { [rect.id]: rect }, bindings: {} },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 150, y: 125 });
+
+      expect(hitId).toBe("shape:1");
+    });
+
+    it("should return null for point outside all shapes", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const rect = ShapeRecord.createRect("page:1", 100, 100, {
+        w: 100,
+        h: 50,
+        fill: "#ff0000",
+        stroke: "#000000",
+        radius: 0,
+      }, "shape:1");
+
+      store.setState((state) => ({
+        ...state,
+        doc: { pages: { [page.id]: { ...page, shapeIds: [rect.id] } }, shapes: { [rect.id]: rect }, bindings: {} },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 50, y: 50 });
+
+      expect(hitId).toBeNull();
+    });
+
+    it("should return topmost shape for overlapping shapes", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const rect1 = ShapeRecord.createRect("page:1", 100, 100, {
+        w: 200,
+        h: 200,
+        fill: "#ff0000",
+        stroke: "#000000",
+        radius: 0,
+      }, "shape:1");
+      const rect2 = ShapeRecord.createRect("page:1", 150, 150, {
+        w: 100,
+        h: 100,
+        fill: "#00ff00",
+        stroke: "#000000",
+        radius: 0,
+      }, "shape:2");
+
+      store.setState((state) => ({
+        ...state,
+        doc: {
+          pages: { [page.id]: { ...page, shapeIds: [rect1.id, rect2.id] } },
+          shapes: { [rect1.id]: rect1, [rect2.id]: rect2 },
+          bindings: {},
+        },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 200, y: 200 });
+
+      expect(hitId).toBe("shape:2");
+    });
+
+    it("should hit test ellipse shapes", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const ellipse = ShapeRecord.createEllipse("page:1", 100, 100, {
+        w: 100,
+        h: 80,
+        fill: "#00ff00",
+        stroke: "#000000",
+      }, "shape:1");
+
+      store.setState((state) => ({
+        ...state,
+        doc: {
+          pages: { [page.id]: { ...page, shapeIds: [ellipse.id] } },
+          shapes: { [ellipse.id]: ellipse },
+          bindings: {},
+        },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 150, y: 140 });
+
+      expect(hitId).toBe("shape:1");
+    });
+
+    it("should hit test line shapes with tolerance", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const line = ShapeRecord.createLine("page:1", 100, 100, {
+        a: { x: 0, y: 0 },
+        b: { x: 100, y: 100 },
+        stroke: "#000000",
+        width: 2,
+      }, "shape:1");
+
+      store.setState((state) => ({
+        ...state,
+        doc: { pages: { [page.id]: { ...page, shapeIds: [line.id] } }, shapes: { [line.id]: line }, bindings: {} },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 150, y: 152 }, 5);
+
+      expect(hitId).toBe("shape:1");
+    });
+
+    it("should hit test arrow shapes with tolerance", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const arrow = ShapeRecord.createArrow("page:1", 100, 100, {
+        a: { x: 0, y: 0 },
+        b: { x: 100, y: 0 },
+        stroke: "#000000",
+        width: 2,
+      }, "shape:1");
+
+      store.setState((state) => ({
+        ...state,
+        doc: { pages: { [page.id]: { ...page, shapeIds: [arrow.id] } }, shapes: { [arrow.id]: arrow }, bindings: {} },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 150, y: 103 }, 5);
+
+      expect(hitId).toBe("shape:1");
+    });
+
+    it("should hit test text shapes", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const text = ShapeRecord.createText("page:1", 100, 100, {
+        text: "Hello",
+        fontSize: 16,
+        fontFamily: "Arial",
+        color: "#000000",
+        w: 100,
+      }, "shape:1");
+
+      store.setState((state) => ({
+        ...state,
+        doc: { pages: { [page.id]: { ...page, shapeIds: [text.id] } }, shapes: { [text.id]: text }, bindings: {} },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 150, y: 110 });
+
+      expect(hitId).toBe("shape:1");
+    });
+
+    it("should respect tolerance parameter for lines", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const line = ShapeRecord.createLine("page:1", 0, 0, {
+        a: { x: 0, y: 0 },
+        b: { x: 100, y: 0 },
+        stroke: "#000000",
+        width: 2,
+      }, "shape:1");
+
+      store.setState((state) => ({
+        ...state,
+        doc: { pages: { [page.id]: { ...page, shapeIds: [line.id] } }, shapes: { [line.id]: line }, bindings: {} },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+
+      const hitWithin = hitTestPoint(state, { x: 50, y: 3 }, 5);
+      expect(hitWithin).toBe("shape:1");
+
+      const hitOutside = hitTestPoint(state, { x: 50, y: 8 }, 5);
+      expect(hitOutside).toBeNull();
+
+      const hitWithLargeTolerance = hitTestPoint(state, { x: 50, y: 8 }, 10);
+      expect(hitWithLargeTolerance).toBe("shape:1");
+    });
+
+    it("should return null when no page is selected", () => {
+      const store = new Store();
+      const state = store.getState();
+      const hitId = hitTestPoint(state, { x: 150, y: 125 });
+
+      expect(hitId).toBeNull();
+    });
+
+    it("should handle multiple shape types on same page", () => {
+      const store = new Store();
+      const page = PageRecord.create("Page 1", "page:1");
+      const rect = ShapeRecord.createRect("page:1", 0, 0, {
+        w: 100,
+        h: 100,
+        fill: "#ff0000",
+        stroke: "#000000",
+        radius: 0,
+      }, "shape:1");
+      const ellipse = ShapeRecord.createEllipse("page:1", 200, 0, {
+        w: 100,
+        h: 100,
+        fill: "#00ff00",
+        stroke: "#000000",
+      }, "shape:2");
+      const line = ShapeRecord.createLine("page:1", 0, 200, {
+        a: { x: 0, y: 0 },
+        b: { x: 100, y: 100 },
+        stroke: "#000000",
+        width: 2,
+      }, "shape:3");
+
+      store.setState((state) => ({
+        ...state,
+        doc: {
+          pages: { [page.id]: { ...page, shapeIds: [rect.id, ellipse.id, line.id] } },
+          shapes: { [rect.id]: rect, [ellipse.id]: ellipse, [line.id]: line },
+          bindings: {},
+        },
+        ui: { ...state.ui, currentPageId: page.id },
+      }));
+
+      const state = store.getState();
+
+      expect(hitTestPoint(state, { x: 50, y: 50 })).toBe("shape:1");
+      expect(hitTestPoint(state, { x: 250, y: 50 })).toBe("shape:2");
+      expect(hitTestPoint(state, { x: 50, y: 252 }, 5)).toBe("shape:3");
+    });
+  });
+});

packages/core/tests/index.test.ts

···
-import { expect, test } from 'vitest'
-import { fn } from '../src'
+import { describe, expect, it } from "vitest";
+import * as core from "../src";
+
+describe("Core exports", () => {
+  it("should export math types and functions", () => {
+    expect(core.Vec2).toBeDefined();
+    expect(core.Box2).toBeDefined();
+    expect(core.Mat3).toBeDefined();
+  });
+
+  it("should export camera functions", () => {
+    expect(core.Camera).toBeDefined();
+  });
+
+  it("should export model types and functions", () => {
+    expect(core.ShapeRecord).toBeDefined();
+    expect(core.PageRecord).toBeDefined();
+    expect(core.Document).toBeDefined();
+  });
 
-test('fn', () => {
-  expect(fn()).toBe('Hello, tsdown!')
-})
+  it("should export reactivity functions", () => {
+    expect(core.Store).toBeDefined();
+    expect(core.getShapesOnCurrentPage).toBeDefined();
+  });
+
+  it("should export geometry functions", () => {
+    expect(core.shapeBounds).toBeDefined();
+    expect(core.pointInRect).toBeDefined();
+    expect(core.pointInEllipse).toBeDefined();
+    expect(core.pointNearSegment).toBeDefined();
+    expect(core.hitTestPoint).toBeDefined();
+  });
+});

packages/core/vitest.config.ts

···
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    ui: false,
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html", "json"],
+      thresholds: { lines: 75, functions: 75, branches: 75, statements: 75 },
+      exclude: ["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/*.config.ts", "**/tests/**"],
+    },
+  },
+});

packages/renderer/vitest.config.ts

···
 import { defineConfig } from "vitest/config";
 
-export default defineConfig({ test: { environment: "jsdom", globals: true } });
+export default defineConfig({ test: { environment: "jsdom", globals: true, ui: false } });

pnpm-lock.yaml

···
         specifier: ^8.50.0
         version: 8.50.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
 
+  apps/web:
+    devDependencies:
+      '@eslint/compat':
+        specifier: ^1.4.0
+        version: 1.4.1(eslint@9.39.2(jiti@2.6.1))
+      '@eslint/js':
+        specifier: ^9.39.1
+        version: 9.39.2
+      '@sveltejs/adapter-static':
+        specifier: ^3.0.10
+        version: 3.0.10(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))
+      '@sveltejs/kit':
+        specifier: ^2.49.1
+        version: 2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      '@sveltejs/vite-plugin-svelte':
+        specifier: ^6.2.1
+        version: 6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      '@types/node':
+        specifier: ^24
+        version: 24.10.4
+      '@vitest/browser-playwright':
+        specifier: ^4.0.15
+        version: 4.0.16(playwright@1.57.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)
+      eslint:
+        specifier: ^9.39.1
+        version: 9.39.2(jiti@2.6.1)
+      eslint-config-prettier:
+        specifier: ^10.1.8
+        version: 10.1.8(eslint@9.39.2(jiti@2.6.1))
+      eslint-plugin-svelte:
+        specifier: ^3.13.1
+        version: 3.13.1(eslint@9.39.2(jiti@2.6.1))(svelte@5.46.0)
+      globals:
+        specifier: ^16.5.0
+        version: 16.5.0
+      playwright:
+        specifier: ^1.57.0
+        version: 1.57.0
+      prettier:
+        specifier: ^3.7.4
+        version: 3.7.4
+      prettier-plugin-svelte:
+        specifier: ^3.4.0
+        version: 3.4.1(prettier@3.7.4)(svelte@5.46.0)
+      svelte:
+        specifier: ^5.45.6
+        version: 5.46.0
+      svelte-check:
+        specifier: ^4.3.4
+        version: 4.3.5(picomatch@4.0.3)(svelte@5.46.0)(typescript@5.9.3)
+      typescript:
+        specifier: ^5.9.3
+        version: 5.9.3
+      typescript-eslint:
+        specifier: ^8.48.1
+        version: 8.50.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      vite:
+        specifier: ^7.2.6
+        version: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+      vite-plugin-devtools-json:
+        specifier: ^1.0.0
+        version: 1.0.0(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      vitest:
+        specifier: ^4.0.15
+        version: 4.0.16(@types/node@24.10.4)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+      vitest-browser-svelte:
+        specifier: ^2.0.1
+        version: 2.0.1(svelte@5.46.0)(vitest@4.0.16)
+
   packages/core:
     dependencies:
       rxjs:
···
       '@types/node':
         specifier: ^25.0.3
         version: 25.0.3
+      '@vitest/coverage-v8':
+        specifier: ^4.0.16
+        version: 4.0.16(@vitest/browser@4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16))(vitest@4.0.16)
       bumpp:
         specifier: ^10.3.2
-        version: 10.3.2
+        version: 10.3.2(magicast@0.5.1)
       tsdown:
         specifier: ^0.18.1
         version: 0.18.1(typescript@5.9.3)
···
         version: 5.9.3
       vitest:
         specifier: ^4.0.16
-        version: 4.0.16(@types/node@25.0.3)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+        version: 4.0.16(@types/node@25.0.3)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
 
   packages/renderer:
     dependencies:
···
         version: 25.0.3
       bumpp:
         specifier: ^10.3.2
-        version: 10.3.2
+        version: 10.3.2(magicast@0.5.1)
       jsdom:
         specifier: ^27.3.0
         version: 27.3.0
···
         version: 5.9.3
       vitest:
         specifier: ^4.0.16
-        version: 4.0.16(@types/node@25.0.3)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+        version: 4.0.16(@types/node@25.0.3)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
 
 packages:
 
···
     resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
     engines: {node: '>=6.9.0'}
 
+  '@bcoe/v8-coverage@1.0.2':
+    resolution: {integrity: sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==}
+    engines: {node: '>=18'}
+
   '@csstools/color-helpers@5.1.0':
     resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
     engines: {node: '>=18'}
···
     resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
 
+  '@eslint/compat@1.4.1':
+    resolution: {integrity: sha512-cfO82V9zxxGBxcQDr1lfaYB7wykTa0b00mGa36FrJl7iTFd0Z2cHfEYuxcBRP/iNijCsWsEkA+jzT8hGYmv33w==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.40 || 9
+    peerDependenciesMeta:
+      eslint:
+        optional: true
+
   '@eslint/config-array@0.21.1':
     resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
···
   '@jridgewell/gen-mapping@0.3.13':
     resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
 
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+
   '@jridgewell/resolve-uri@3.1.2':
     resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
     engines: {node: '>=6.0.0'}
···
 
   '@oxc-project/types@0.103.0':
     resolution: {integrity: sha512-bkiYX5kaXWwUessFRSoXFkGIQTmc6dLGdxuRTrC+h8PSnIdZyuXHHlLAeTmOue5Br/a0/a7dHH0Gca6eXn9MKg==}
+
+  '@polka/url@1.0.0-next.29':
+    resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
 
   '@quansync/fs@1.0.0':
     resolution: {integrity: sha512-4TJ3DFtlf1L5LDMaM6CanJ/0lckGNtJcMjQ1NAV6zDmA0tEHKZtxNKin8EgPaVX1YzljbxckyT2tJrpQKAtngQ==}
···
   '@standard-schema/spec@1.1.0':
     resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
 
+  '@sveltejs/acorn-typescript@1.0.8':
+    resolution: {integrity: sha512-esgN+54+q0NjB0Y/4BomT9samII7jGwNy/2a3wNZbT2A2RpmXsXwUt24LvLhx6jUq2gVk4cWEvcRO6MFQbOfNA==}
+    peerDependencies:
+      acorn: ^8.9.0
+
+  '@sveltejs/adapter-static@3.0.10':
+    resolution: {integrity: sha512-7D9lYFWJmB7zxZyTE/qxjksvMqzMuYrrsyh1f4AlZqeZeACPRySjbC3aFiY55wb1tWUaKOQG9PVbm74JcN2Iew==}
+    peerDependencies:
+      '@sveltejs/kit': ^2.0.0
+
+  '@sveltejs/kit@2.49.2':
+    resolution: {integrity: sha512-Vp3zX/qlwerQmHMP6x0Ry1oY7eKKRcOWGc2P59srOp4zcqyn+etJyQpELgOi4+ZSUgteX8Y387NuwruLgGXLUQ==}
+    engines: {node: '>=18.13'}
+    hasBin: true
+    peerDependencies:
+      '@opentelemetry/api': ^1.0.0
+      '@sveltejs/vite-plugin-svelte': ^3.0.0 || ^4.0.0-next.1 || ^5.0.0 || ^6.0.0-next.0
+      svelte: ^4.0.0 || ^5.0.0-next.0
+      vite: ^5.0.3 || ^6.0.0 || ^7.0.0-beta.0
+    peerDependenciesMeta:
+      '@opentelemetry/api':
+        optional: true
+
+  '@sveltejs/vite-plugin-svelte-inspector@5.0.1':
+    resolution: {integrity: sha512-ubWshlMk4bc8mkwWbg6vNvCeT7lGQojE3ijDh3QTR6Zr/R+GXxsGbyH4PExEPpiFmqPhYiVSVmHBjUcVc1JIrA==}
+    engines: {node: ^20.19 || ^22.12 || >=24}
+    peerDependencies:
+      '@sveltejs/vite-plugin-svelte': ^6.0.0-next.0
+      svelte: ^5.0.0
+      vite: ^6.3.0 || ^7.0.0
+
+  '@sveltejs/vite-plugin-svelte@6.2.1':
+    resolution: {integrity: sha512-YZs/OSKOQAQCnJvM/P+F1URotNnYNeU3P2s4oIpzm1uFaqUEqRxUB0g5ejMjEb5Gjb9/PiBI5Ktrq4rUUF8UVQ==}
+    engines: {node: ^20.19 || ^22.12 || >=24}
+    peerDependencies:
+      svelte: ^5.0.0
+      vite: ^6.3.0 || ^7.0.0
+
   '@tybys/wasm-util@0.10.1':
     resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
 
   '@types/chai@5.2.3':
     resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
 
+  '@types/cookie@0.6.0':
+    resolution: {integrity: sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==}
+
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
···
 
   '@types/json-schema@7.0.15':
     resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
+  '@types/node@24.10.4':
+    resolution: {integrity: sha512-vnDVpYPMzs4wunl27jHrfmwojOGKya0xyM3sH+UE5iv5uPS6vX7UIoh6m+vQc5LGBq52HBKPIn/zcSZVzeDEZg==}
 
   '@types/node@25.0.3':
     resolution: {integrity: sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA==}
···
     resolution: {integrity: sha512-Xzmnb58+Db78gT/CCj/PVCvK+zxbnsw6F+O1oheYszJbBSdEjVhQi3C/Xttzxgi/GLmpvOggRs1RFpiJ8+c34Q==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
+  '@vitest/browser-playwright@4.0.16':
+    resolution: {integrity: sha512-I2Fy/ANdphi1yI46d15o0M1M4M0UJrUiVKkH5oKeRZZCdPg0fw/cfTKZzv9Ge9eobtJYp4BGblMzXdXH0vcl5g==}
+    peerDependencies:
+      playwright: '*'
+      vitest: 4.0.16
+
+  '@vitest/browser@4.0.16':
+    resolution: {integrity: sha512-t4toy8X/YTnjYEPoY0pbDBg3EvDPg1elCDrfc+VupPHwoN/5/FNQ8Z+xBYIaEnOE2vVEyKwqYBzZ9h9rJtZVcg==}
+    peerDependencies:
+      vitest: 4.0.16
+
+  '@vitest/coverage-v8@4.0.16':
+    resolution: {integrity: sha512-2rNdjEIsPRzsdu6/9Eq0AYAzYdpP6Bx9cje9tL3FE5XzXRQF1fNU9pe/1yE8fCrS0HD+fBtt6gLPh6LI57tX7A==}
+    peerDependencies:
+      '@vitest/browser': 4.0.16
+      vitest: 4.0.16
+    peerDependenciesMeta:
+      '@vitest/browser':
+        optional: true
+
   '@vitest/expect@4.0.16':
     resolution: {integrity: sha512-eshqULT2It7McaJkQGLkPjPjNph+uevROGuIMJdG3V+0BSR2w9u6J9Lwu+E8cK5TETlfou8GRijhafIMhXsimA==}
 
···
   args-tokenizer@0.3.0:
     resolution: {integrity: sha512-xXAd7G2Mll5W8uo37GETpQ2VrE84M181Z7ugHFGQnJZ50M2mbOv0osSZ9VsSgPfJQ+LVG0prSi0th+ELMsno7Q==}
 
+  aria-query@5.3.2:
+    resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==}
+    engines: {node: '>= 0.4'}
+
   assertion-error@2.0.1:
     resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
     engines: {node: '>=12'}
···
     resolution: {integrity: sha512-m1Q/RaVOnTp9JxPX+F+Zn7IcLYMzM8kZofDImfsKZd8MbR+ikdOzTeztStWqfrqIxZnYWryyI9ePm3NGjnZgGw==}
     engines: {node: '>=20.19.0'}
 
+  ast-v8-to-istanbul@0.3.9:
+    resolution: {integrity: sha512-dSC6tJeOJxbZrPzPbv5mMd6CMiQ1ugaVXXPRad2fXUSsy1kstFn9XQWemV9VW7Y7kpxgQ/4WMoZfwdH8XSU48w==}
+
+  axobject-query@4.1.0:
+    resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==}
+    engines: {node: '>= 0.4'}
+
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
···
   change-case@5.4.4:
     resolution: {integrity: sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w==}
 
+  chokidar@4.0.3:
+    resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
+    engines: {node: '>= 14.16.0'}
+
   chokidar@5.0.0:
     resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==}
     engines: {node: '>= 20.19.0'}
···
     resolution: {integrity: sha512-GfisEZEJvzKrmGWkvfhgzcz/BllN1USeqD2V6tg14OAOgaCD2Z/PUEuxnAZ/nPvmaHRG7a8y77p1T/IRQ4D1Hw==}
     engines: {node: '>=4'}
 
+  clsx@2.1.1:
+    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
+    engines: {node: '>=6'}
+
   color-convert@2.0.1:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
···
     resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==}
     engines: {node: ^14.18.0 || >=16.10.0}
 
+  cookie@0.6.0:
+    resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==}
+    engines: {node: '>= 0.6'}
+
   core-js-compat@3.47.0:
     resolution: {integrity: sha512-IGfuznZ/n7Kp9+nypamBhvwdwLsW6KC8IOaURw2doAK5e98AG3acVLdh0woOnEqCfUtS+Vu882JE4k/DAm3ItQ==}
 
···
     resolution: {integrity: sha512-0eW44TGN5SQXU1mWSkKwFstI/22X2bG1nYzZTYMAWjylYURhse752YgbE4Cx46AC+bAvI+/dYTPRk1LqSUnu6w==}
     engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0}
 
+  cssesc@3.0.0:
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
   cssstyle@5.3.5:
     resolution: {integrity: sha512-GlsEptulso7Jg0VaOZ8BXQi3AkYM5BOJKEO/rjMidSCq70FkIC5y0eawrCXeYzxgt3OCf4Ls+eoxN+/05vN0Ag==}
     engines: {node: '>=20'}
···
   deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
+  deepmerge@4.3.1:
+    resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
+    engines: {node: '>=0.10.0'}
+
   defu@6.1.4:
     resolution: {integrity: sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==}
 
   destr@2.0.5:
     resolution: {integrity: sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA==}
+
+  devalue@5.6.1:
+    resolution: {integrity: sha512-jDwizj+IlEZBunHcOuuFVBnIMPAEHvTsJj0BcIp94xYguLRVBcXO853px/MyIJvbVzWdsGvrRweIUWJw8hBP7A==}
 
   dotenv@17.2.3:
     resolution: {integrity: sha512-JVUnt+DUIzu87TABbhPmNfVdBDt18BLOWjMUFJMSi/Qqg7NTYtabbvSNJGOJ7afbRuv9D/lngizHtP7QyLQ+9w==}
···
     resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
     engines: {node: '>=10'}
 
+  eslint-config-prettier@10.1.8:
+    resolution: {integrity: sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==}
+    hasBin: true
+    peerDependencies:
+      eslint: '>=7.0.0'
+
+  eslint-plugin-svelte@3.13.1:
+    resolution: {integrity: sha512-Ng+kV/qGS8P/isbNYVE3sJORtubB+yLEcYICMkUWNaDTb0SwZni/JhAYXh/Dz/q2eThUwWY0VMPZ//KYD1n3eQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.1 || ^9.0.0
+      svelte: ^3.37.0 || ^4.0.0 || ^5.0.0
+    peerDependenciesMeta:
+      svelte:
+        optional: true
+
   eslint-plugin-unicorn@62.0.0:
     resolution: {integrity: sha512-HIlIkGLkvf29YEiS/ImuDZQbP12gWyx5i3C6XrRxMvVdqMroCI9qoVYCoIl17ChN+U89pn9sVwLxhIWj5nEc7g==}
     engines: {node: ^20.10.0 || >=21.0.0}
···
       jiti:
         optional: true
 
+  esm-env@1.2.2:
+    resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==}
+
   espree@10.4.0:
     resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
···
   esquery@1.6.0:
     resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
     engines: {node: '>=0.10'}
+
+  esrap@2.2.1:
+    resolution: {integrity: sha512-GiYWG34AN/4CUyaWAgunGt0Rxvr1PTMlGC0vvEov/uOQYWne2bpN03Um+k8jT+q3op33mKouP2zeJ6OlM+qeUg==}
 
   esrecurse@4.3.0:
     resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
···
   flatted@3.3.3:
     resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
 
+  fsevents@2.3.2:
+    resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
   fsevents@2.3.3:
     resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
···
   html-encoding-sniffer@4.0.0:
     resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
     engines: {node: '>=18'}
+
+  html-escaper@2.0.2:
+    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
 
   http-proxy-agent@7.0.2:
     resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
···
   is-potential-custom-element-name@1.0.1:
     resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
 
+  is-reference@3.0.3:
+    resolution: {integrity: sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==}
+
   isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
+  istanbul-lib-coverage@3.2.2:
+    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
+    engines: {node: '>=8'}
+
+  istanbul-lib-report@3.0.1:
+    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
+    engines: {node: '>=10'}
+
+  istanbul-lib-source-maps@5.0.6:
+    resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==}
+    engines: {node: '>=10'}
+
+  istanbul-reports@3.2.0:
+    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
+    engines: {node: '>=8'}
+
   jiti@2.6.1:
     resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
     hasBin: true
+
+  js-tokens@9.0.1:
+    resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
 
   js-yaml@4.1.1:
     resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
···
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
+  kleur@4.1.5:
+    resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
+    engines: {node: '>=6'}
+
+  known-css-properties@0.37.0:
+    resolution: {integrity: sha512-JCDrsP4Z1Sb9JwG0aJ8Eo2r7k4Ou5MwmThS/6lcIe1ICyb7UBJKGRIUUdqc2ASdE/42lgz6zFUnzAIhtXnBVrQ==}
+
   levn@0.4.1:
     resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
     engines: {node: '>= 0.8.0'}
 
+  lilconfig@2.1.0:
+    resolution: {integrity: sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==}
+    engines: {node: '>=10'}
+
+  locate-character@3.0.0:
+    resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==}
+
   locate-path@6.0.0:
     resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
     engines: {node: '>=10'}
···
   magic-string@0.30.21:
     resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
 
+  magicast@0.5.1:
+    resolution: {integrity: sha512-xrHS24IxaLrvuo613F719wvOIv9xPHFWQHuvGUBmPnCA/3MQxKI3b+r7n1jAoDHmsbC5bRhTZYR77invLAxVnw==}
+
+  make-dir@4.0.0:
+    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
+    engines: {node: '>=10'}
+
   mdn-data@2.12.2:
     resolution: {integrity: sha512-IEn+pegP1aManZuckezWCO+XZQDplx1366JoVhTpMpBB1sPey/SbveZQUosKiKiGYjg1wH4pMlNgXbCiYgihQA==}
 
···
   minimatch@9.0.5:
     resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
     engines: {node: '>=16 || 14 >=14.17'}
+
+  mri@1.2.0:
+    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
+    engines: {node: '>=4'}
+
+  mrmime@2.0.1:
+    resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==}
+    engines: {node: '>=10'}
 
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
···
     resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
     engines: {node: '>=12'}
 
+  pixelmatch@7.1.0:
+    resolution: {integrity: sha512-1wrVzJ2STrpmONHKBy228LM1b84msXDUoAzVEl0R8Mz4Ce6EPr+IVtxm8+yvrqLYMHswREkjYFaMxnyGnaY3Ng==}
+    hasBin: true
+
   pkg-types@2.3.0:
     resolution: {integrity: sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==}
 
+  playwright-core@1.57.0:
+    resolution: {integrity: sha512-agTcKlMw/mjBWOnD6kFZttAAGHgi/Nw0CZ2o6JqWSbMlI219lAFLZZCyqByTsvVAJq5XA5H8cA6PrvBRpBWEuQ==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  playwright@1.57.0:
+    resolution: {integrity: sha512-ilYQj1s8sr2ppEJ2YVadYBN0Mb3mdo9J0wQ+UuDhzYqURwSoW4n1Xs5vs7ORwgDGmyEh33tRMeS8KhdkMoLXQw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   pluralize@8.0.0:
     resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
     engines: {node: '>=4'}
 
+  pngjs@7.0.0:
+    resolution: {integrity: sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==}
+    engines: {node: '>=14.19.0'}
+
+  postcss-load-config@3.1.4:
+    resolution: {integrity: sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg==}
+    engines: {node: '>= 10'}
+    peerDependencies:
+      postcss: '>=8.0.9'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      postcss:
+        optional: true
+      ts-node:
+        optional: true
+
+  postcss-safe-parser@7.0.1:
+    resolution: {integrity: sha512-0AioNCJZ2DPYz5ABT6bddIqlhgwhpHZ/l65YAYo0BCIn0xiDpsnTHz0gnoTGk0OXZW0JRs+cDwL8u/teRdz+8A==}
+    engines: {node: '>=18.0'}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-scss@4.0.9:
+    resolution: {integrity: sha512-AjKOeiwAitL/MXxQW2DliT28EKukvvbEWx3LBmJIRN8KfBGZbRTxNYW0kSqi1COiTZ57nZ9NW06S6ux//N1c9A==}
+    engines: {node: '>=12.0'}
+    peerDependencies:
+      postcss: ^8.4.29
+
+  postcss-selector-parser@7.1.1:
+    resolution: {integrity: sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==}
+    engines: {node: '>=4'}
+
   postcss@8.5.6:
     resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
     engines: {node: ^10 || ^12 || >=14}
···
   prelude-ls@1.2.1:
     resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
     engines: {node: '>= 0.8.0'}
+
+  prettier-plugin-svelte@3.4.1:
+    resolution: {integrity: sha512-xL49LCloMoZRvSwa6IEdN2GV6cq2IqpYGstYtMT+5wmml1/dClEoI0MZR78MiVPpu6BdQFfN0/y73yO6+br5Pg==}
+    peerDependencies:
+      prettier: ^3.0.0
+      svelte: ^3.2.0 || ^4.0.0-next.0 || ^5.0.0-next.0
+
+  prettier@3.7.4:
+    resolution: {integrity: sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==}
+    engines: {node: '>=14'}
+    hasBin: true
 
   punycode@2.3.1:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
···
   rc9@2.1.2:
     resolution: {integrity: sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg==}
 
+  readdirp@4.1.2:
+    resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
+    engines: {node: '>= 14.18.0'}
+
   readdirp@5.0.0:
     resolution: {integrity: sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==}
     engines: {node: '>= 20.19.0'}
···
   rxjs@7.8.2:
     resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==}
 
+  sade@1.8.1:
+    resolution: {integrity: sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==}
+    engines: {node: '>=6'}
+
   safer-buffer@2.1.2:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
 
···
     engines: {node: '>=10'}
     hasBin: true
 
+  set-cookie-parser@2.7.2:
+    resolution: {integrity: sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==}
+
   shebang-command@2.0.0:
     resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
     engines: {node: '>=8'}
···
   siginfo@2.0.0:
     resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
 
+  sirv@3.0.2:
+    resolution: {integrity: sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==}
+    engines: {node: '>=18'}
+
   source-map-js@1.2.1:
     resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
     engines: {node: '>=0.10.0'}
···
     resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
     engines: {node: '>=8'}
 
+  svelte-check@4.3.5:
+    resolution: {integrity: sha512-e4VWZETyXaKGhpkxOXP+B/d0Fp/zKViZoJmneZWe/05Y2aqSKj3YN2nLfYPJBQ87WEiY4BQCQ9hWGu9mPT1a1Q==}
+    engines: {node: '>= 18.0.0'}
+    hasBin: true
+    peerDependencies:
+      svelte: ^4.0.0 || ^5.0.0-next.0
+      typescript: '>=5.0.0'
+
+  svelte-eslint-parser@1.4.1:
+    resolution: {integrity: sha512-1eqkfQ93goAhjAXxZiu1SaKI9+0/sxp4JIWQwUpsz7ybehRE5L8dNuz7Iry7K22R47p5/+s9EM+38nHV2OlgXA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0, pnpm: 10.24.0}
+    peerDependencies:
+      svelte: ^3.37.0 || ^4.0.0 || ^5.0.0
+    peerDependenciesMeta:
+      svelte:
+        optional: true
+
+  svelte@5.46.0:
+    resolution: {integrity: sha512-ZhLtvroYxUxr+HQJfMZEDRsGsmU46x12RvAv/zi9584f5KOX7bUrEbhPJ7cKFmUvZTJXi/CFZUYwDC6M1FigPw==}
+    engines: {node: '>=18'}
+
   symbol-tree@3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
···
   tldts@7.0.19:
     resolution: {integrity: sha512-8PWx8tvC4jDB39BQw1m4x8y5MH1BcQ5xHeL2n7UVFulMPH/3Q0uiamahFJ3lXA0zO2SUyRXuVVbWSDmstlt9YA==}
     hasBin: true
+
+  totalist@3.0.1:
+    resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
+    engines: {node: '>=6'}
 
   tough-cookie@6.0.0:
     resolution: {integrity: sha512-kXuRi1mtaKMrsLUxz3sQYvVl37B0Ns6MzfrtV5DvJceE9bPyspOqk9xxv7XbZWcfLWbFmm997vl83qUWVJA64w==}
···
   uri-js@4.4.1:
     resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
 
+  util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+
+  uuid@11.1.0:
+    resolution: {integrity: sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==}
+    hasBin: true
+
   uuid@13.0.0:
     resolution: {integrity: sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==}
     hasBin: true
+
+  vite-plugin-devtools-json@1.0.0:
+    resolution: {integrity: sha512-MobvwqX76Vqt/O4AbnNMNWoXWGrKUqZbphCUle/J2KXH82yKQiunOeKnz/nqEPosPsoWWPP9FtNuPBSYpiiwkw==}
+    peerDependencies:
+      vite: ^5.0.0 || ^6.0.0 || ^7.0.0
 
   vite@7.3.0:
     resolution: {integrity: sha512-dZwN5L1VlUBewiP6H9s2+B3e3Jg96D0vzN+Ry73sOefebhYr9f94wwkMNN/9ouoU8pV1BqA1d1zGk8928cx0rg==}
···
         optional: true
       yaml:
         optional: true
+
+  vitefu@1.1.1:
+    resolution: {integrity: sha512-B/Fegf3i8zh0yFbpzZ21amWzHmuNlLlmJT6n7bu5e+pCHUKQIfXSYokrqOBGEMMe9UG2sostKQF9mml/vYaWJQ==}
+    peerDependencies:
+      vite: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0
+    peerDependenciesMeta:
+      vite:
+        optional: true
+
+  vitest-browser-svelte@2.0.1:
+    resolution: {integrity: sha512-z7GFio7vxaOolY+xwPUMEKuwL4KcPzB8+bepA9F0Phqag/TJ4j7IAGSwm4Y/FBh7KznsP+7aEIllMay0qDpFXw==}
+    peerDependencies:
+      svelte: ^3 || ^4 || ^5 || ^5.0.0-next.0
+      vitest: ^4.0.0
 
   vitest@4.0.16:
     resolution: {integrity: sha512-E4t7DJ9pESL6E3I8nFjPa4xGUd3PmiWDLsDztS2qXSJWfHtbQnwAWylaBvSNY48I3vr8PTqIZlyK8TE3V3CA4Q==}
···
   xmlchars@2.2.0:
     resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
 
+  yaml@1.10.2:
+    resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==}
+    engines: {node: '>= 6'}
+
   yaml@2.8.2:
     resolution: {integrity: sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==}
     engines: {node: '>= 14.6'}
···
   yocto-queue@0.1.0:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
+
+  zimmerframe@1.1.4:
+    resolution: {integrity: sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==}
 
 snapshots:
 
···
     dependencies:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.28.5
+
+  '@bcoe/v8-coverage@1.0.2': {}
 
   '@csstools/color-helpers@5.1.0': {}
 
···
 
   '@eslint-community/regexpp@4.12.2': {}
 
+  '@eslint/compat@1.4.1(eslint@9.39.2(jiti@2.6.1))':
+    dependencies:
+      '@eslint/core': 0.17.0
+    optionalDependencies:
+      eslint: 9.39.2(jiti@2.6.1)
+
   '@eslint/config-array@0.21.1':
     dependencies:
       '@eslint/object-schema': 2.1.7
···
       '@jridgewell/sourcemap-codec': 1.5.5
       '@jridgewell/trace-mapping': 0.3.31
 
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+
   '@jridgewell/resolve-uri@3.1.2': {}
 
   '@jridgewell/sourcemap-codec@1.5.5': {}
···
     optional: true
 
   '@oxc-project/types@0.103.0': {}
+
+  '@polka/url@1.0.0-next.29': {}
 
   '@quansync/fs@1.0.0':
     dependencies:
···
 
   '@standard-schema/spec@1.1.0': {}
 
+  '@sveltejs/acorn-typescript@1.0.8(acorn@8.15.0)':
+    dependencies:
+      acorn: 8.15.0
+
+  '@sveltejs/adapter-static@3.0.10(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))':
+    dependencies:
+      '@sveltejs/kit': 2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+
+  '@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@sveltejs/acorn-typescript': 1.0.8(acorn@8.15.0)
+      '@sveltejs/vite-plugin-svelte': 6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      '@types/cookie': 0.6.0
+      acorn: 8.15.0
+      cookie: 0.6.0
+      devalue: 5.6.1
+      esm-env: 1.2.2
+      kleur: 4.1.5
+      magic-string: 0.30.21
+      mrmime: 2.0.1
+      sade: 1.8.1
+      set-cookie-parser: 2.7.2
+      sirv: 3.0.2
+      svelte: 5.46.0
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+
+  '@sveltejs/vite-plugin-svelte-inspector@5.0.1(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))':
+    dependencies:
+      '@sveltejs/vite-plugin-svelte': 6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      debug: 4.4.3
+      svelte: 5.46.0
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))':
+    dependencies:
+      '@sveltejs/vite-plugin-svelte-inspector': 5.0.1(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      debug: 4.4.3
+      deepmerge: 4.3.1
+      magic-string: 0.30.21
+      svelte: 5.46.0
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+      vitefu: 1.1.1(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+    transitivePeerDependencies:
+      - supports-color
+
   '@tybys/wasm-util@0.10.1':
     dependencies:
       tslib: 2.8.1
···
       '@types/deep-eql': 4.0.2
       assertion-error: 2.0.1
 
+  '@types/cookie@0.6.0': {}
+
   '@types/deep-eql@4.0.2': {}
 
   '@types/estree@1.0.8': {}
···
       parse5: 7.3.0
 
   '@types/json-schema@7.0.15': {}
+
+  '@types/node@24.10.4':
+    dependencies:
+      undici-types: 7.16.0
 
   '@types/node@25.0.3':
     dependencies:
···
       '@typescript-eslint/types': 8.50.0
       eslint-visitor-keys: 4.2.1
 
+  '@vitest/browser-playwright@4.0.16(playwright@1.57.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)':
+    dependencies:
+      '@vitest/browser': 4.0.16(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)
+      '@vitest/mocker': 4.0.16(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      playwright: 1.57.0
+      tinyrainbow: 3.0.3
+      vitest: 4.0.16(@types/node@24.10.4)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+    transitivePeerDependencies:
+      - bufferutil
+      - msw
+      - utf-8-validate
+      - vite
+
+  '@vitest/browser-playwright@4.0.16(playwright@1.57.0)(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)':
+    dependencies:
+      '@vitest/browser': 4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)
+      '@vitest/mocker': 4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))
+      playwright: 1.57.0
+      tinyrainbow: 3.0.3
+      vitest: 4.0.16(@types/node@25.0.3)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+    transitivePeerDependencies:
+      - bufferutil
+      - msw
+      - utf-8-validate
+      - vite
+    optional: true
+
+  '@vitest/browser@4.0.16(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)':
+    dependencies:
+      '@vitest/mocker': 4.0.16(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      '@vitest/utils': 4.0.16
+      magic-string: 0.30.21
+      pixelmatch: 7.1.0
+      pngjs: 7.0.0
+      sirv: 3.0.2
+      tinyrainbow: 3.0.3
+      vitest: 4.0.16(@types/node@24.10.4)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+      ws: 8.18.3
+    transitivePeerDependencies:
+      - bufferutil
+      - msw
+      - utf-8-validate
+      - vite
+
+  '@vitest/browser@4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)':
+    dependencies:
+      '@vitest/mocker': 4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))
+      '@vitest/utils': 4.0.16
+      magic-string: 0.30.21
+      pixelmatch: 7.1.0
+      pngjs: 7.0.0
+      sirv: 3.0.2
+      tinyrainbow: 3.0.3
+      vitest: 4.0.16(@types/node@25.0.3)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+      ws: 8.18.3
+    transitivePeerDependencies:
+      - bufferutil
+      - msw
+      - utf-8-validate
+      - vite
+    optional: true
+
+  '@vitest/coverage-v8@4.0.16(@vitest/browser@4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16))(vitest@4.0.16)':
+    dependencies:
+      '@bcoe/v8-coverage': 1.0.2
+      '@vitest/utils': 4.0.16
+      ast-v8-to-istanbul: 0.3.9
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-lib-source-maps: 5.0.6
+      istanbul-reports: 3.2.0
+      magicast: 0.5.1
+      obug: 2.1.1
+      std-env: 3.10.0
+      tinyrainbow: 3.0.3
+      vitest: 4.0.16(@types/node@25.0.3)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+    optionalDependencies:
+      '@vitest/browser': 4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)
+    transitivePeerDependencies:
+      - supports-color
+
   '@vitest/expect@4.0.16':
     dependencies:
       '@standard-schema/spec': 1.1.0
···
       chai: 6.2.1
       tinyrainbow: 3.0.3
 
+  '@vitest/mocker@4.0.16(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))':
+    dependencies:
+      '@vitest/spy': 4.0.16
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+
   '@vitest/mocker@4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))':
     dependencies:
       '@vitest/spy': 4.0.16
···
 
   args-tokenizer@0.3.0: {}
 
+  aria-query@5.3.2: {}
+
   assertion-error@2.0.1: {}
 
   ast-kit@2.2.0:
     dependencies:
       '@babel/parser': 7.28.5
       pathe: 2.0.3
+
+  ast-v8-to-istanbul@0.3.9:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      estree-walker: 3.0.3
+      js-tokens: 9.0.1
+
+  axobject-query@4.1.0: {}
 
   balanced-match@1.0.2: {}
 
···
 
   builtin-modules@5.0.0: {}
 
-  bumpp@10.3.2:
+  bumpp@10.3.2(magicast@0.5.1):
     dependencies:
       ansis: 4.2.0
       args-tokenizer: 0.3.0
-      c12: 3.3.3
+      c12: 3.3.3(magicast@0.5.1)
       cac: 6.7.14
       escalade: 3.2.0
       jsonc-parser: 3.3.1
···
     transitivePeerDependencies:
       - magicast
 
-  c12@3.3.3:
+  c12@3.3.3(magicast@0.5.1):
     dependencies:
       chokidar: 5.0.0
       confbox: 0.2.2
···
       perfect-debounce: 2.0.0
       pkg-types: 2.3.0
       rc9: 2.1.2
+    optionalDependencies:
+      magicast: 0.5.1
 
   cac@6.7.14: {}
 
···
 
   change-case@5.4.4: {}
 
+  chokidar@4.0.3:
+    dependencies:
+      readdirp: 4.1.2
+
   chokidar@5.0.0:
     dependencies:
       readdirp: 5.0.0
···
     dependencies:
       escape-string-regexp: 1.0.5
 
+  clsx@2.1.1: {}
+
   color-convert@2.0.1:
     dependencies:
       color-name: 1.1.4
···
   confbox@0.2.2: {}
 
   consola@3.4.2: {}
+
+  cookie@0.6.0: {}
 
   core-js-compat@3.47.0:
     dependencies:
···
       mdn-data: 2.12.2
       source-map-js: 1.2.1
 
+  cssesc@3.0.0: {}
+
   cssstyle@5.3.5:
     dependencies:
       '@asamuzakjp/css-color': 4.1.1
···
   decimal.js@10.6.0: {}
 
   deep-is@0.1.4: {}
+
+  deepmerge@4.3.1: {}
 
   defu@6.1.4: {}
 
   destr@2.0.5: {}
 
+  devalue@5.6.1: {}
+
   dotenv@17.2.3: {}
 
   dprint@0.50.2:
···
 
   escape-string-regexp@4.0.0: {}
 
+  eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@2.6.1)):
+    dependencies:
+      eslint: 9.39.2(jiti@2.6.1)
+
+  eslint-plugin-svelte@3.13.1(eslint@9.39.2(jiti@2.6.1))(svelte@5.46.0):
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.2(jiti@2.6.1))
+      '@jridgewell/sourcemap-codec': 1.5.5
+      eslint: 9.39.2(jiti@2.6.1)
+      esutils: 2.0.3
+      globals: 16.5.0
+      known-css-properties: 0.37.0
+      postcss: 8.5.6
+      postcss-load-config: 3.1.4(postcss@8.5.6)
+      postcss-safe-parser: 7.0.1(postcss@8.5.6)
+      semver: 7.7.3
+      svelte-eslint-parser: 1.4.1(svelte@5.46.0)
+    optionalDependencies:
+      svelte: 5.46.0
+    transitivePeerDependencies:
+      - ts-node
+
   eslint-plugin-unicorn@62.0.0(eslint@9.39.2(jiti@2.6.1)):
     dependencies:
       '@babel/helper-validator-identifier': 7.28.5
···
     transitivePeerDependencies:
       - supports-color
 
+  esm-env@1.2.2: {}
+
   espree@10.4.0:
     dependencies:
       acorn: 8.15.0
···
   esquery@1.6.0:
     dependencies:
       estraverse: 5.3.0
+
+  esrap@2.2.1:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
 
   esrecurse@4.3.0:
     dependencies:
···
       keyv: 4.5.4
 
   flatted@3.3.3: {}
+
+  fsevents@2.3.2:
+    optional: true
 
   fsevents@2.3.3:
     optional: true
···
     dependencies:
       whatwg-encoding: 3.1.1
 
+  html-escaper@2.0.2: {}
+
   http-proxy-agent@7.0.2:
     dependencies:
       agent-base: 7.1.4
···
 
   is-potential-custom-element-name@1.0.1: {}
 
+  is-reference@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+
   isexe@2.0.0: {}
 
+  istanbul-lib-coverage@3.2.2: {}
+
+  istanbul-lib-report@3.0.1:
+    dependencies:
+      istanbul-lib-coverage: 3.2.2
+      make-dir: 4.0.0
+      supports-color: 7.2.0
+
+  istanbul-lib-source-maps@5.0.6:
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      debug: 4.4.3
+      istanbul-lib-coverage: 3.2.2
+    transitivePeerDependencies:
+      - supports-color
+
+  istanbul-reports@3.2.0:
+    dependencies:
+      html-escaper: 2.0.2
+      istanbul-lib-report: 3.0.1
+
   jiti@2.6.1: {}
+
+  js-tokens@9.0.1: {}
 
   js-yaml@4.1.1:
     dependencies:
···
     dependencies:
       json-buffer: 3.0.1
 
+  kleur@4.1.5: {}
+
+  known-css-properties@0.37.0: {}
+
   levn@0.4.1:
     dependencies:
       prelude-ls: 1.2.1
       type-check: 0.4.0
 
+  lilconfig@2.1.0: {}
+
+  locate-character@3.0.0: {}
+
   locate-path@6.0.0:
     dependencies:
       p-locate: 5.0.0
···
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  magicast@0.5.1:
+    dependencies:
+      '@babel/parser': 7.28.5
+      '@babel/types': 7.28.5
+      source-map-js: 1.2.1
+
+  make-dir@4.0.0:
+    dependencies:
+      semver: 7.7.3
+
   mdn-data@2.12.2: {}
 
   minimatch@3.1.2:
···
   minimatch@9.0.5:
     dependencies:
       brace-expansion: 2.0.2
+
+  mri@1.2.0: {}
+
+  mrmime@2.0.1: {}
 
   ms@2.1.3: {}
 
···
 
   picomatch@4.0.3: {}
 
+  pixelmatch@7.1.0:
+    dependencies:
+      pngjs: 7.0.0
+
   pkg-types@2.3.0:
     dependencies:
       confbox: 0.2.2
       exsolve: 1.0.8
       pathe: 2.0.3
 
+  playwright-core@1.57.0: {}
+
+  playwright@1.57.0:
+    dependencies:
+      playwright-core: 1.57.0
+    optionalDependencies:
+      fsevents: 2.3.2
+
   pluralize@8.0.0: {}
 
+  pngjs@7.0.0: {}
+
+  postcss-load-config@3.1.4(postcss@8.5.6):
+    dependencies:
+      lilconfig: 2.1.0
+      yaml: 1.10.2
+    optionalDependencies:
+      postcss: 8.5.6
+
+  postcss-safe-parser@7.0.1(postcss@8.5.6):
+    dependencies:
+      postcss: 8.5.6
+
+  postcss-scss@4.0.9(postcss@8.5.6):
+    dependencies:
+      postcss: 8.5.6
+
+  postcss-selector-parser@7.1.1:
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+
   postcss@8.5.6:
     dependencies:
       nanoid: 3.3.11
···
 
   prelude-ls@1.2.1: {}
 
+  prettier-plugin-svelte@3.4.1(prettier@3.7.4)(svelte@5.46.0):
+    dependencies:
+      prettier: 3.7.4
+      svelte: 5.46.0
+
+  prettier@3.7.4: {}
+
   punycode@2.3.1: {}
 
   quansync@1.0.0: {}
···
     dependencies:
       defu: 6.1.4
       destr: 2.0.5
+
+  readdirp@4.1.2: {}
 
   readdirp@5.0.0: {}
 
···
     dependencies:
       tslib: 2.8.1
 
+  sade@1.8.1:
+    dependencies:
+      mri: 1.2.0
+
   safer-buffer@2.1.2: {}
 
   saxes@6.0.0:
···
 
   semver@7.7.3: {}
 
+  set-cookie-parser@2.7.2: {}
+
   shebang-command@2.0.0:
     dependencies:
       shebang-regex: 3.0.0
···
 
   siginfo@2.0.0: {}
 
+  sirv@3.0.2:
+    dependencies:
+      '@polka/url': 1.0.0-next.29
+      mrmime: 2.0.1
+      totalist: 3.0.1
+
   source-map-js@1.2.1: {}
 
   stackback@0.0.2: {}
···
     dependencies:
       has-flag: 4.0.0
 
+  svelte-check@4.3.5(picomatch@4.0.3)(svelte@5.46.0)(typescript@5.9.3):
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      chokidar: 4.0.3
+      fdir: 6.5.0(picomatch@4.0.3)
+      picocolors: 1.1.1
+      sade: 1.8.1
+      svelte: 5.46.0
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - picomatch
+
+  svelte-eslint-parser@1.4.1(svelte@5.46.0):
+    dependencies:
+      eslint-scope: 8.4.0
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      postcss: 8.5.6
+      postcss-scss: 4.0.9(postcss@8.5.6)
+      postcss-selector-parser: 7.1.1
+    optionalDependencies:
+      svelte: 5.46.0
+
+  svelte@5.46.0:
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@sveltejs/acorn-typescript': 1.0.8(acorn@8.15.0)
+      '@types/estree': 1.0.8
+      acorn: 8.15.0
+      aria-query: 5.3.2
+      axobject-query: 4.1.0
+      clsx: 2.1.1
+      devalue: 5.6.1
+      esm-env: 1.2.2
+      esrap: 2.2.1
+      is-reference: 3.0.3
+      locate-character: 3.0.0
+      magic-string: 0.30.21
+      zimmerframe: 1.1.4
+
   symbol-tree@3.2.4: {}
 
   tinybench@2.9.0: {}
···
     dependencies:
       tldts-core: 7.0.19
 
+  totalist@3.0.1: {}
+
   tough-cookie@6.0.0:
     dependencies:
       tldts: 7.0.19
···
     dependencies:
       punycode: 2.3.1
 
+  util-deprecate@1.0.2: {}
+
+  uuid@11.1.0: {}
+
   uuid@13.0.0: {}
 
+  vite-plugin-devtools-json@1.0.0(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)):
+    dependencies:
+      uuid: 11.1.0
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+
+  vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2):
+    dependencies:
+      esbuild: 0.27.2
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.54.0
+      tinyglobby: 0.2.15
+    optionalDependencies:
+      '@types/node': 24.10.4
+      fsevents: 2.3.3
+      jiti: 2.6.1
+      yaml: 2.8.2
+
   vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2):
     dependencies:
       esbuild: 0.27.2
···
       jiti: 2.6.1
       yaml: 2.8.2
 
-  vitest@4.0.16(@types/node@25.0.3)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2):
+  vitefu@1.1.1(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)):
+    optionalDependencies:
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+
+  vitest-browser-svelte@2.0.1(svelte@5.46.0)(vitest@4.0.16):
+    dependencies:
+      svelte: 5.46.0
+      vitest: 4.0.16(@types/node@24.10.4)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2)
+
+  vitest@4.0.16(@types/node@24.10.4)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2):
+    dependencies:
+      '@vitest/expect': 4.0.16
+      '@vitest/mocker': 4.0.16(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))
+      '@vitest/pretty-format': 4.0.16
+      '@vitest/runner': 4.0.16
+      '@vitest/snapshot': 4.0.16
+      '@vitest/spy': 4.0.16
+      '@vitest/utils': 4.0.16
+      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.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 24.10.4
+      '@vitest/browser-playwright': 4.0.16(playwright@1.57.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)
+      jsdom: 27.3.0
+    transitivePeerDependencies:
+      - jiti
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - terser
+      - tsx
+      - yaml
+
+  vitest@4.0.16(@types/node@25.0.3)(@vitest/browser-playwright@4.0.16)(jiti@2.6.1)(jsdom@27.3.0)(yaml@2.8.2):
     dependencies:
       '@vitest/expect': 4.0.16
       '@vitest/mocker': 4.0.16(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))
···
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 25.0.3
+      '@vitest/browser-playwright': 4.0.16(playwright@1.57.0)(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(yaml@2.8.2))(vitest@4.0.16)
       jsdom: 27.3.0
     transitivePeerDependencies:
       - jiti
···
 
   xmlchars@2.2.0: {}
 
+  yaml@1.10.2: {}
+
   yaml@2.8.2: {}
 
   yocto-queue@0.1.0: {}
+
+  zimmerframe@1.1.4: {}

pnpm-workspace.yaml

···
 packages:
   - packages/*
+  - apps/*
 
 onlyBuiltDependencies:
   - dprint