spiracha 2.0.0 → 2.2.0

package/src/lib/ui-cache.ts

@@ -1,27 +1,152 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readdir, rename, rm, stat } from 'node:fs/promises';
+import { chmod, lstat, mkdir, readdir, rename, rm, stat, utimes } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
 const CACHE_DIR = path.join(os.tmpdir(), 'spiracha-ui-cache');
 const CACHE_ENVELOPE_VERSION = 1;
+const DEFAULT_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_CACHE_MAX_BYTES = 256 * 1024 * 1024;
+const CACHE_PURGE_INTERVAL_MS = 60 * 1000;
+const CACHE_KEY_PREFIX_MAX_LENGTH = 80;
 
 type CacheEnvelope<T> = {
     value: T;
     version: number;
 };
 
-const ensureCacheDir = async () => {
-    await mkdir(CACHE_DIR, { recursive: true });
+type CacheReadResult<T> = { hit: true; value: T } | { hit: false };
+
+const inFlightCacheLoads = new Map<string, Promise<unknown>>();
+const activeCachePathCounts = new Map<string, number>();
+const pendingCachePathRemovals = new Set<string>();
+let cacheDirectoryInitialized = false;
+let cacheInvalidationGeneration = 0;
+let lastCachePurgeAtMs = 0;
+
+const removeInactiveCachePath = async (filePath: string): Promise<void> => {
+    if (activeCachePathCounts.has(filePath)) {
+        pendingCachePathRemovals.add(filePath);
+        return;
+    }
+    await rm(filePath, { force: true });
 };
 
-const toCachePath = (key: string) => {
-    const safeKey = key.replace(/[^a-zA-Z0-9._-]/gu, '_');
-    return path.join(CACHE_DIR, `${safeKey}-${hashCacheKeyParts(key)}.json`);
+const beginActiveCachePath = (filePath: string): void => {
+    activeCachePathCounts.set(filePath, (activeCachePathCounts.get(filePath) ?? 0) + 1);
+};
+
+const finishActiveCachePath = async (filePath: string): Promise<void> => {
+    const remainingCount = (activeCachePathCounts.get(filePath) ?? 1) - 1;
+    if (remainingCount > 0) {
+        activeCachePathCounts.set(filePath, remainingCount);
+        return;
+    }
+    activeCachePathCounts.delete(filePath);
+    if (pendingCachePathRemovals.delete(filePath)) {
+        await rm(filePath, { force: true });
+    }
+};
+
+export const pruneUiCacheEntries = async (
+    cacheDir: string = CACHE_DIR,
+    maxAgeMs: number = DEFAULT_CACHE_MAX_AGE_MS,
+    maxBytes: number = DEFAULT_CACHE_MAX_BYTES,
+) => {
+    const cutoff = Date.now() - maxAgeMs;
+    const entries = await readdir(cacheDir, { withFileTypes: true }).catch((error: unknown) => {
+        if ((error as { code?: unknown }).code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    });
+    const cacheFiles = (
+        await Promise.all(
+            entries
+                .filter((entry) => entry.isFile())
+                .map(async (entry) => {
+                    const filePath = path.join(cacheDir, entry.name);
+                    try {
+                        const metadata = await stat(filePath);
+                        return { filePath, mtimeMs: metadata.mtimeMs, name: entry.name, size: metadata.size };
+                    } catch (error) {
+                        if ((error as { code?: unknown }).code === 'ENOENT') {
+                            return null;
+                        }
+                        throw error;
+                    }
+                }),
+        )
+    ).filter((entry): entry is NonNullable<typeof entry> => entry !== null);
+    const staleFiles = cacheFiles.filter((entry) => entry.name.endsWith('.json') && entry.mtimeMs < cutoff);
+    await Promise.all(staleFiles.map((entry) => removeInactiveCachePath(entry.filePath)));
+
+    const retainedCacheFiles = cacheFiles.filter((entry) => entry.mtimeMs >= cutoff && entry.name.endsWith('.json'));
+    let retainedBytes = retainedCacheFiles.reduce((total, entry) => total + entry.size, 0);
+    if (retainedBytes <= maxBytes) {
+        return;
+    }
+
+    const retainedOldestFirst = retainedCacheFiles.sort(
+        (left, right) => left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name),
+    );
+    const oversizedFiles = [];
+    for (const entry of retainedOldestFirst) {
+        if (retainedBytes <= maxBytes) {
+            break;
+        }
+        oversizedFiles.push(entry.filePath);
+        retainedBytes -= entry.size;
+    }
+    await Promise.all(oversizedFiles.map(removeInactiveCachePath));
+};
+
+const assertSafeCacheDirectory = async () => {
+    const metadata = await lstat(CACHE_DIR);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        throw new Error(`Unsafe Spiracha cache directory: ${CACHE_DIR}`);
+    }
+    return metadata;
+};
+
+const refreshCacheDirectoryState = async () => {
+    try {
+        await assertSafeCacheDirectory();
+    } catch (error) {
+        if ((error as { code?: unknown }).code !== 'ENOENT') {
+            throw error;
+        }
+        cacheDirectoryInitialized = false;
+    }
 };
 
-export const hashCacheKeyParts = (...parts: string[]) => {
-    return createHash('sha1').update(parts.join('|')).digest('hex');
+const ensureCacheDir = async () => {
+    if (cacheDirectoryInitialized) {
+        await refreshCacheDirectoryState();
+    }
+
+    if (!cacheDirectoryInitialized) {
+        await mkdir(CACHE_DIR, { mode: 0o700, recursive: true });
+        const metadata = await assertSafeCacheDirectory();
+        if ((metadata.mode & 0o777) !== 0o700) {
+            await chmod(CACHE_DIR, 0o700);
+        }
+        cacheDirectoryInitialized = true;
+    }
+    const now = Date.now();
+    if (now - lastCachePurgeAtMs >= CACHE_PURGE_INTERVAL_MS) {
+        lastCachePurgeAtMs = now;
+        void pruneUiCacheEntries(CACHE_DIR).catch((error) => {
+            console.warn('[spiracha:ui-cache] cache pruning failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
+};
+
+const toCachePath = (key: string) => {
+    const safeKey = key.replace(/[^a-zA-Z0-9._-]/gu, '_').slice(0, CACHE_KEY_PREFIX_MAX_LENGTH);
+    return path.join(CACHE_DIR, `${safeKey}-${hashCacheKeyPartsIterable([key])}.json`);
 };
 
 export const hashCacheKeyPartsIterable = (parts: Iterable<string>) => {
@@ -41,20 +166,23 @@ export const getFileFingerprint = async (filePath: string) => {
     return `${filePath}:${metadata.size}:${metadata.mtimeMs}`;
 };
 
-export const getCachedJson = async <T>(key: string): Promise<T | null> => {
+const readCachedJson = async <T>(key: string): Promise<CacheReadResult<T>> => {
     await ensureCacheDir();
     const filePath = toCachePath(key);
     const file = Bun.file(filePath);
     if (!(await file.exists())) {
-        return null;
+        return { hit: false };
     }
 
     let parsed: CacheEnvelope<T> | T;
+    beginActiveCachePath(filePath);
     try {
         parsed = (await file.json()) as CacheEnvelope<T> | T;
     } catch {
         await rm(filePath, { force: true });
-        return null;
+        return { hit: false };
+    } finally {
+        await finishActiveCachePath(filePath);
     }
 
     if (
@@ -64,11 +192,18 @@ export const getCachedJson = async <T>(key: string): Promise<T | null> => {
         (parsed as CacheEnvelope<T>).version === CACHE_ENVELOPE_VERSION &&
         'value' in parsed
     ) {
-        return (parsed as CacheEnvelope<T>).value;
+        const now = new Date();
+        await utimes(filePath, now, now).catch(() => undefined);
+        return { hit: true, value: (parsed as CacheEnvelope<T>).value };
     }
 
     await rm(filePath, { force: true });
-    return null;
+    return { hit: false };
+};
+
+export const getCachedJson = async <T>(key: string): Promise<T | null> => {
+    const cached = await readCachedJson<T>(key);
+    return cached.hit ? cached.value : null;
 };
 
 export const setCachedJson = async <T>(key: string, value: T) => {
@@ -80,30 +215,56 @@ export const setCachedJson = async <T>(key: string, value: T) => {
         version: CACHE_ENVELOPE_VERSION,
     };
 
-    await Bun.write(tempPath, JSON.stringify(envelope));
-    await rename(tempPath, filePath);
+    beginActiveCachePath(filePath);
+    beginActiveCachePath(tempPath);
+    try {
+        await Bun.write(tempPath, JSON.stringify(envelope));
+        await rename(tempPath, filePath);
+    } finally {
+        await rm(tempPath, { force: true });
+        await finishActiveCachePath(tempPath);
+        await finishActiveCachePath(filePath);
+    }
 };
 
 export const withCachedJson = async <T>(key: string, loader: () => Promise<T>): Promise<T> => {
-    const filePath = toCachePath(key);
-    const existedBeforeRead = await Bun.file(filePath).exists();
-    const cached = await getCachedJson<T>(key);
-    if (cached !== null || (existedBeforeRead && (await Bun.file(filePath).exists()))) {
-        return cached as T;
+    const inFlight = inFlightCacheLoads.get(key);
+    if (inFlight) {
+        return (await inFlight) as T;
     }
 
-    const value = await loader();
-    await setCachedJson(key, value);
-    return value;
+    const load = (async () => {
+        const generation = cacheInvalidationGeneration;
+        const cached = await readCachedJson<T>(key);
+        if (cached.hit) {
+            return cached.value;
+        }
+
+        const value = await loader();
+        if (generation === cacheInvalidationGeneration) {
+            await setCachedJson(key, value);
+        }
+        return value;
+    })();
+    inFlightCacheLoads.set(key, load);
+
+    try {
+        return await load;
+    } finally {
+        if (inFlightCacheLoads.get(key) === load) {
+            inFlightCacheLoads.delete(key);
+        }
+    }
 };
 
 export const invalidateCacheByPrefix = async (...prefixes: string[]) => {
+    cacheInvalidationGeneration += 1;
     await ensureCacheDir();
     const entries = await readdir(CACHE_DIR);
 
     await Promise.all(
         entries
             .filter((entry) => prefixes.some((prefix) => entry.startsWith(prefix)))
-            .map((entry) => rm(path.join(CACHE_DIR, entry), { force: true })),
+            .map((entry) => removeInactiveCachePath(path.join(CACHE_DIR, entry))),
     );
 };

package/src/lib/ui-export-archive.ts

@@ -1,5 +1,15 @@
+import { getPortablePathBasename } from './portable-path';
 import type { ExportFormat } from './shared';
 
+type BatchExportNameEntry = {
+    cwd: string | null;
+    updatedAtMs: number | null;
+};
+
+type ConversationExportNameEntry = BatchExportNameEntry & {
+    id: string;
+};
+
 export const sanitizeExportFileName = (value: string) => {
     return value
         .replace(/[<>:"/\\|?*\u0000-\u001f]/gu, ' ')
@@ -13,49 +23,58 @@ export const getExportMimeType = (outputFormat: ExportFormat) => {
 };
 
 export const resolveUniqueExportFileBaseName = (baseName: string, usedCounts: Map<string, number>) => {
-    const count = (usedCounts.get(baseName) ?? 0) + 1;
-    usedCounts.set(baseName, count);
-    return count === 1 ? baseName : `${baseName}-${count}`;
-};
-
-const readPipeText = async (pipe: ReadableStream<Uint8Array> | number | undefined) => {
-    return pipe && typeof pipe !== 'number' ? new Response(pipe).text() : '';
-};
-
-const runZip = async (args: string[], options: { cwd?: string } = {}) => {
-    let proc: ReturnType<typeof Bun.spawn>;
-    try {
-        proc = Bun.spawn(['zip', '-9', ...args], {
-            cwd: options.cwd,
-            stderr: 'pipe',
-            stdout: 'pipe',
-        });
-    } catch (error) {
-        throw new Error(
-            `zip command failed to start. Install the "zip" executable or choose a non-zip export. ${error instanceof Error ? error.message : String(error)}`,
-        );
-    }
+    const normalizeKey = (value: string) => value.normalize('NFC').toLowerCase();
+    const baseKey = normalizeKey(baseName);
+    let count = (usedCounts.get(baseKey) ?? 0) + 1;
+    let candidate = count === 1 ? baseName : `${baseName}-${count}`;
 
-    const [stdoutText, stderrText, exitCode] = await Promise.all([
-        readPipeText(proc.stdout),
-        readPipeText(proc.stderr),
-        proc.exited,
-    ]);
-
-    if (exitCode !== 0) {
-        const output = (stderrText || stdoutText).trim();
-        throw new Error(
-            output
-                ? `zip command failed (${exitCode}): ${output}`
-                : `zip command failed (${exitCode}). Install the "zip" executable or choose a non-zip export.`,
-        );
+    while (usedCounts.has(normalizeKey(candidate))) {
+        count += 1;
+        candidate = `${baseName}-${count}`;
     }
+
+    usedCounts.set(baseKey, count);
+    usedCounts.set(normalizeKey(candidate), Math.max(usedCounts.get(normalizeKey(candidate)) ?? 0, 1));
+    return candidate;
 };
 
-export const zipExportFile = async (sourcePath: string, zipPath: string) => {
-    await runZip(['-j', zipPath, sourcePath]);
+const formatBatchExportDate = (value: number) => {
+    const date = new Date(value);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    return `${year}-${month}-${day}-${hours}${minutes}`;
 };
 
-export const zipExportDirectory = async (sourceDirectory: string, zipPath: string) => {
-    await runZip(['-r', zipPath, '.'], { cwd: sourceDirectory });
+const resolveExportProjectName = (cwd: string | null, fallbackProjectName: string) => {
+    return sanitizeExportFileName(getPortablePathBasename(cwd ?? '') || fallbackProjectName) || 'threads';
+};
+
+export const buildConversationExportBaseName = (
+    { cwd, id, updatedAtMs }: ConversationExportNameEntry,
+    fallbackProjectName: string,
+) => {
+    const projectName = resolveExportProjectName(cwd, fallbackProjectName);
+    const shortId = sanitizeExportFileName(id).slice(0, 8) || 'conversation';
+    return Number.isFinite(updatedAtMs) && (updatedAtMs ?? 0) > 0
+        ? `${projectName}-${formatBatchExportDate(updatedAtMs!)}-${shortId}`
+        : `${projectName}-${shortId}`;
+};
+
+export const buildBatchExportBaseName = (entries: BatchExportNameEntry[], fallbackProjectName: string) => {
+    if (entries.length === 0) {
+        throw new Error('No conversations selected for export');
+    }
+
+    const firstCwd = entries.find((entry) => entry.cwd?.trim())?.cwd ?? null;
+    const projectName = resolveExportProjectName(firstCwd, fallbackProjectName);
+    const latestUpdatedAtMs = Math.max(
+        ...entries.map((entry) => (Number.isFinite(entry.updatedAtMs) ? (entry.updatedAtMs ?? 0) : 0)),
+    );
+
+    return latestUpdatedAtMs > 0
+        ? `${projectName}-${formatBatchExportDate(latestUpdatedAtMs)}-threads-${entries.length}`
+        : `${projectName}-threads-${entries.length}`;
 };

package/src/lib/ui-export-files.ts

@@ -1,4 +1,4 @@
-import { mkdir, readdir, rm, stat } from 'node:fs/promises';
+import { chmod, mkdir, readdir, rm, stat } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -7,6 +7,8 @@ export const UI_EXPORT_URL_PREFIX = '/__exports/';
 
 const DEFAULT_UI_EXPORT_DIR = path.join(os.tmpdir(), 'spiracha-ui-exports');
 const DEFAULT_EXPORT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_EXPORT_MAX_BYTES = 1024 * 1024 * 1024;
+const MAX_EXPORT_FILE_NAME_BYTES = 200;
 
 const decodeExportFileName = (value: string) => {
     try {
@@ -17,7 +19,15 @@ const decodeExportFileName = (value: string) => {
 };
 
 const isSafeExportFileName = (value: string) => {
-    return value.length > 0 && value === path.basename(value) && !/[\\/]/u.test(value) && !value.includes('\0');
+    return (
+        value.length > 0 &&
+        Buffer.byteLength(value) <= MAX_EXPORT_FILE_NAME_BYTES &&
+        value !== '.' &&
+        value !== '..' &&
+        value === path.basename(value) &&
+        !/[\\/]/u.test(value) &&
+        !value.includes('\0')
+    );
 };
 
 export const getUiExportDir = () => {
@@ -26,7 +36,8 @@ export const getUiExportDir = () => {
 
 export const ensureUiExportDir = async () => {
     const exportDir = getUiExportDir();
-    await mkdir(exportDir, { recursive: true });
+    await mkdir(exportDir, { mode: 0o700, recursive: true });
+    await chmod(exportDir, 0o700);
     await purgeStaleUiExports(exportDir);
     return exportDir;
 };
@@ -40,26 +51,61 @@ export const buildUiExportContentDisposition = (filePath: string) => {
     return `attachment; filename*=UTF-8''${encodeURIComponent(fileName)}`;
 };
 
+export const purgeStaleUiExportFile = async (filePath: string, cutoff: number) => {
+    let metadata: Awaited<ReturnType<typeof stat>>;
+    try {
+        metadata = await stat(filePath);
+    } catch (error) {
+        if ((error as { code?: unknown }).code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+    if (metadata.mtimeMs < cutoff) {
+        await rm(filePath, { force: true });
+    }
+};
+
 export const purgeStaleUiExports = async (
     exportDir: string = getUiExportDir(),
     maxAgeMs: number = DEFAULT_EXPORT_MAX_AGE_MS,
+    maxBytes: number = DEFAULT_EXPORT_MAX_BYTES,
 ) => {
     const entries = await readdir(exportDir, { withFileTypes: true });
     const cutoff = Date.now() - maxAgeMs;
+    const files = (
+        await Promise.all(
+            entries
+                .filter((entry) => entry.isFile())
+                .map(async (entry) => {
+                    const filePath = path.join(exportDir, entry.name);
+                    try {
+                        const metadata = await stat(filePath);
+                        return { filePath, mtimeMs: metadata.mtimeMs, name: entry.name, size: metadata.size };
+                    } catch (error) {
+                        if ((error as { code?: unknown }).code === 'ENOENT') {
+                            return null;
+                        }
+                        throw error;
+                    }
+                }),
+        )
+    ).filter((file): file is NonNullable<typeof file> => file !== null);
+    const staleFiles = files.filter((file) => file.mtimeMs < cutoff);
+    await Promise.all(staleFiles.map((file) => rm(file.filePath, { force: true })));
 
-    await Promise.all(
-        entries
-            .filter((entry) => entry.isFile())
-            .map(async (entry) => {
-                const filePath = path.join(exportDir, entry.name);
-                const metadata = await stat(filePath);
-                if (metadata.mtimeMs >= cutoff) {
-                    return;
-                }
-
-                await rm(filePath, { force: true });
-            }),
+    const retainedFiles = files.filter((file) => file.mtimeMs >= cutoff);
+    let retainedBytes = retainedFiles.reduce((total, file) => total + file.size, 0);
+    const oldestFirst = retainedFiles.sort(
+        (left, right) => left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name),
     );
+    for (const file of oldestFirst) {
+        if (retainedBytes <= maxBytes) {
+            break;
+        }
+        await rm(file.filePath, { force: true });
+        retainedBytes -= file.size;
+    }
 };
 
 export const resolveUiExportFilePathFromRequestPath = (pathname: string) => {
@@ -75,3 +121,17 @@ export const resolveUiExportFilePathFromRequestPath = (pathname: string) => {
 
     return path.join(getUiExportDir(), fileName);
 };
+
+export const resolveReadableUiExportFileFromRequestPath = async (pathname: string) => {
+    const filePath = resolveUiExportFilePathFromRequestPath(pathname);
+    if (!filePath) {
+        return null;
+    }
+
+    try {
+        const metadata = await stat(filePath);
+        return metadata.isFile() ? filePath : null;
+    } catch {
+        return null;
+    }
+};

package/src/lib/ui-export-zip.ts

@@ -0,0 +1,40 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { type Zippable, zipSync } from 'fflate';
+
+const readZipFile = async (filePath: string) => {
+    return new Uint8Array(await Bun.file(filePath).arrayBuffer());
+};
+
+const createZip = async (files: Zippable) => zipSync(files, { level: 3 });
+
+const readZipDirectory = async (
+    rootDirectory: string,
+    currentDirectory = rootDirectory,
+    files: Zippable = {},
+): Promise<Zippable> => {
+    const entries = await readdir(currentDirectory, { withFileTypes: true });
+    await Promise.all(
+        entries.map(async (entry) => {
+            const entryPath = path.join(currentDirectory, entry.name);
+            if (entry.isDirectory()) {
+                await readZipDirectory(rootDirectory, entryPath, files);
+                return;
+            }
+
+            if (entry.isFile()) {
+                const archivePath = path.relative(rootDirectory, entryPath).split(path.sep).join('/');
+                files[archivePath] = await readZipFile(entryPath);
+            }
+        }),
+    );
+    return files;
+};
+
+export const zipExportFile = async (sourcePath: string, zipPath: string) => {
+    await Bun.write(zipPath, await createZip({ [path.basename(sourcePath)]: await readZipFile(sourcePath) }));
+};
+
+export const zipExportDirectory = async (sourceDirectory: string, zipPath: string) => {
+    await Bun.write(zipPath, await createZip(await readZipDirectory(sourceDirectory)));
+};

package/apps/ui/package.json

@@ -1,65 +0,0 @@
-{
-    "dependencies": {
-        "@tailwindcss/vite": "4.3.1",
-        "@tanstack/match-sorter-utils": "8.19.4",
-        "@tanstack/react-devtools": "0.10.5",
-        "@tanstack/react-query": "5.101.0",
-        "@tanstack/react-query-devtools": "5.101.0",
-        "@tanstack/react-router": "1.170.15",
-        "@tanstack/react-router-devtools": "1.167.0",
-        "@tanstack/react-router-ssr-query": "1.167.1",
-        "@tanstack/react-start": "1.168.25",
-        "@tanstack/react-table": "8.21.3",
-        "@tanstack/react-virtual": "3.14.2",
-        "@tanstack/router-plugin": "1.168.18",
-        "class-variance-authority": "0.7.1",
-        "clsx": "2.1.1",
-        "lucide-react": "1.18.0",
-        "radix-ui": "1.5.0",
-        "react": "19.2.7",
-        "react-dom": "19.2.7",
-        "tailwind-merge": "3.6.0",
-        "tailwindcss": "4.3.1",
-        "tw-animate-css": "1.4.0",
-        "zod": "4.4.3"
-    },
-    "devDependencies": {
-        "@biomejs/biome": "2.5.0",
-        "@tailwindcss/typography": "0.5.20",
-        "@tanstack/devtools-vite": "0.7.0",
-        "@testing-library/dom": "10.4.1",
-        "@testing-library/react": "16.3.2",
-        "@types/node": "25.9.3",
-        "@types/react": "19.2.17",
-        "@types/react-dom": "19.2.3",
-        "@vitejs/plugin-react": "6.0.2",
-        "@vitest/coverage-v8": "4.1.8",
-        "jsdom": "29.1.1",
-        "typescript": "6.0.3",
-        "vite": "8.0.16",
-        "vitest": "4.1.8"
-    },
-    "imports": {
-        "#/*": "./src/*"
-    },
-    "name": "ui",
-    "pnpm": {
-        "onlyBuiltDependencies": [
-            "esbuild",
-            "lightningcss"
-        ]
-    },
-    "private": true,
-    "scripts": {
-        "build": "bun --bun vite build",
-        "check": "biome check",
-        "coverage": "vitest run --coverage",
-        "dev": "bun --bun vite dev --host 127.0.0.1 --port 3000",
-        "format": "biome format",
-        "lint": "biome lint",
-        "preview": "bun --bun vite preview",
-        "test": "vitest run",
-        "typecheck": "tsc --noEmit"
-    },
-    "type": "module"
-}