@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/utils/WorkerPool.js

@@ -1,272 +0,0 @@
-import { Worker } from 'node:worker_threads';
-import { WORKER_POOL_MIN_WORKERS, WORKER_POOL_MAX_WORKERS, WORKER_POOL_IDLE_TIMEOUT_MS, WORKER_POOL_JOB_TIMEOUT_MS, } from '../constants.js';
-const DEFAULT_MIN_WORKERS = WORKER_POOL_MIN_WORKERS;
-const DEFAULT_MAX_WORKERS = WORKER_POOL_MAX_WORKERS;
-const DEFAULT_IDLE_TIMEOUT_MS = WORKER_POOL_IDLE_TIMEOUT_MS;
-const DEFAULT_JOB_TIMEOUT_MS = WORKER_POOL_JOB_TIMEOUT_MS;
-export class WorkerPool {
-    name;
-    workerScript;
-    minWorkers;
-    maxWorkers;
-    idleTimeoutMs;
-    resourceLimits;
-    workers = new Map();
-    queuedJobs = [];
-    activeJobs = new Map();
-    nextWorkerId = 1;
-    nextJobId = 1;
-    closed = false;
-    constructor(options) {
-        this.name = options.name ?? 'worker-pool';
-        this.workerScript = options.workerScript;
-        this.minWorkers = options.minWorkers ?? DEFAULT_MIN_WORKERS;
-        this.maxWorkers = options.maxWorkers ?? DEFAULT_MAX_WORKERS;
-        this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-        this.resourceLimits = options.resourceLimits;
-        if (!this.workerScript || this.workerScript.trim().length === 0) {
-            throw this.toError('workerScript must be a non-empty string');
-        }
-        if (!Number.isInteger(this.minWorkers) || this.minWorkers < 0) {
-            throw this.toError('minWorkers must be an integer >= 0');
-        }
-        if (!Number.isInteger(this.maxWorkers) || this.maxWorkers < 1) {
-            throw this.toError('maxWorkers must be an integer >= 1');
-        }
-        if (this.minWorkers > this.maxWorkers) {
-            throw this.toError('minWorkers cannot be greater than maxWorkers');
-        }
-        this.ensureMinWorkers();
-    }
-    submit(payload, timeoutMs = DEFAULT_JOB_TIMEOUT_MS) {
-        if (this.closed) {
-            return Promise.reject(this.toError('pool is closed'));
-        }
-        return new Promise((resolve, reject) => {
-            const job = {
-                id: this.nextJobId++,
-                payload,
-                timeoutMs,
-                resolve,
-                reject,
-            };
-            this.queuedJobs.push(job);
-            this.pumpQueue();
-        });
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        const closeError = this.toError('pool is closed');
-        while (this.queuedJobs.length > 0) {
-            const job = this.queuedJobs.shift();
-            job?.reject(closeError);
-        }
-        for (const activeJob of this.activeJobs.values()) {
-            if (activeJob.timeoutHandle) {
-                clearTimeout(activeJob.timeoutHandle);
-            }
-            activeJob.reject(closeError);
-        }
-        this.activeJobs.clear();
-        const workerIds = Array.from(this.workers.keys());
-        await Promise.all(workerIds.map((workerId) => this.terminateWorker(workerId)));
-    }
-    ensureMinWorkers() {
-        if (this.closed)
-            return;
-        while (this.workers.size < this.minWorkers) {
-            this.spawnWorker();
-        }
-    }
-    pumpQueue() {
-        if (this.closed)
-            return;
-        while (this.queuedJobs.length > 0) {
-            let worker = this.findIdleWorker();
-            if (!worker) {
-                if (this.workers.size < this.maxWorkers) {
-                    worker = this.spawnWorker();
-                }
-                else {
-                    return;
-                }
-            }
-            const job = this.queuedJobs.shift();
-            if (!job)
-                return;
-            this.dispatchJob(worker, job);
-        }
-    }
-    findIdleWorker() {
-        for (const worker of this.workers.values()) {
-            if (!worker.busy)
-                return worker;
-        }
-        return undefined;
-    }
-    spawnWorker() {
-        const id = this.nextWorkerId++;
-        const worker = new Worker(this.workerScript, {
-            eval: true,
-            resourceLimits: this.resourceLimits,
-        });
-        const pooled = {
-            id,
-            worker,
-            busy: false,
-            activeJobId: null,
-            idleTimer: null,
-        };
-        worker.on('message', (message) => this.handleWorkerMessage(id, message));
-        worker.on('error', (error) => this.handleWorkerFailure(id, error));
-        worker.on('exit', (code) => this.handleWorkerExit(id, code));
-        this.workers.set(id, pooled);
-        return pooled;
-    }
-    dispatchJob(worker, job) {
-        worker.busy = true;
-        worker.activeJobId = job.id;
-        if (worker.idleTimer) {
-            clearTimeout(worker.idleTimer);
-            worker.idleTimer = null;
-        }
-        const timeoutHandle = setTimeout(() => {
-            this.handleJobTimeout(job.id, job.timeoutMs);
-        }, job.timeoutMs);
-        this.activeJobs.set(job.id, {
-            ...job,
-            workerId: worker.id,
-            timeoutHandle,
-        });
-        try {
-            worker.worker.postMessage({
-                jobId: job.id,
-                payload: job.payload,
-            });
-        }
-        catch (error) {
-            const activeJob = this.activeJobs.get(job.id);
-            if (activeJob?.timeoutHandle)
-                clearTimeout(activeJob.timeoutHandle);
-            this.activeJobs.delete(job.id);
-            worker.busy = false;
-            worker.activeJobId = null;
-            job.reject(this.toError(error instanceof Error ? error.message : String(error)));
-            void this.terminateWorker(worker.id).then(() => {
-                this.ensureMinWorkers();
-                this.pumpQueue();
-            });
-        }
-    }
-    handleWorkerMessage(workerId, message) {
-        const envelope = message;
-        if (!envelope || typeof envelope !== 'object' || typeof envelope.jobId !== 'number') {
-            return;
-        }
-        const activeJob = this.activeJobs.get(envelope.jobId);
-        if (!activeJob)
-            return;
-        if (activeJob.timeoutHandle)
-            clearTimeout(activeJob.timeoutHandle);
-        this.activeJobs.delete(envelope.jobId);
-        const worker = this.workers.get(workerId);
-        if (worker) {
-            worker.busy = false;
-            worker.activeJobId = null;
-            this.armIdleTimer(worker);
-        }
-        if (!envelope.ok) {
-            activeJob.reject(this.toError(envelope.error ?? 'worker task failed'));
-        }
-        else if (typeof envelope.result === 'undefined') {
-            activeJob.reject(this.toError('worker returned empty result'));
-        }
-        else {
-            activeJob.resolve(envelope.result);
-        }
-        this.pumpQueue();
-    }
-    handleWorkerFailure(workerId, error) {
-        const worker = this.workers.get(workerId);
-        if (!worker)
-            return;
-        const activeJobId = worker.activeJobId;
-        if (activeJobId !== null) {
-            const activeJob = this.activeJobs.get(activeJobId);
-            if (activeJob) {
-                if (activeJob.timeoutHandle)
-                    clearTimeout(activeJob.timeoutHandle);
-                this.activeJobs.delete(activeJobId);
-                activeJob.reject(this.toError(error.message));
-            }
-        }
-        void this.terminateWorker(workerId).then(() => {
-            this.ensureMinWorkers();
-            this.pumpQueue();
-        });
-    }
-    handleWorkerExit(workerId, code) {
-        const worker = this.workers.get(workerId);
-        if (!worker)
-            return;
-        const activeJobId = worker.activeJobId;
-        this.workers.delete(workerId);
-        if (worker.idleTimer)
-            clearTimeout(worker.idleTimer);
-        if (activeJobId !== null) {
-            const activeJob = this.activeJobs.get(activeJobId);
-            if (activeJob) {
-                if (activeJob.timeoutHandle)
-                    clearTimeout(activeJob.timeoutHandle);
-                this.activeJobs.delete(activeJobId);
-                activeJob.reject(this.toError(`worker exited unexpectedly with code ${code}`));
-            }
-        }
-        this.ensureMinWorkers();
-        this.pumpQueue();
-    }
-    handleJobTimeout(jobId, timeoutMs) {
-        const activeJob = this.activeJobs.get(jobId);
-        if (!activeJob)
-            return;
-        this.activeJobs.delete(jobId);
-        activeJob.reject(this.toError(`worker task timed out after ${timeoutMs}ms`));
-        void this.terminateWorker(activeJob.workerId).then(() => {
-            this.ensureMinWorkers();
-            this.pumpQueue();
-        });
-    }
-    armIdleTimer(worker) {
-        if (this.idleTimeoutMs <= 0 || this.workers.size <= this.minWorkers)
-            return;
-        if (worker.idleTimer)
-            clearTimeout(worker.idleTimer);
-        worker.idleTimer = setTimeout(() => {
-            const current = this.workers.get(worker.id);
-            if (!current || current.busy || this.workers.size <= this.minWorkers)
-                return;
-            void this.terminateWorker(worker.id);
-        }, this.idleTimeoutMs);
-    }
-    async terminateWorker(workerId) {
-        const worker = this.workers.get(workerId);
-        if (!worker)
-            return;
-        this.workers.delete(workerId);
-        if (worker.idleTimer)
-            clearTimeout(worker.idleTimer);
-        worker.worker.removeAllListeners('message');
-        worker.worker.removeAllListeners('error');
-        worker.worker.removeAllListeners('exit');
-        try {
-            await worker.worker.terminate();
-        }
-        catch {
-        }
-    }
-    toError(message) {
-        return new Error(`[${this.name}] ${message}`);
-    }
-}

package/dist/src/utils/artifactRetention.d.ts

@@ -1,30 +0,0 @@
-export interface ArtifactRetentionConfig {
-    enabled: boolean;
-    retentionDays: number;
-    maxTotalBytes: number;
-    cleanupOnStart: boolean;
-    cleanupIntervalMinutes: number;
-}
-export interface ArtifactCleanupResult {
-    success: boolean;
-    scannedFiles: number;
-    removedFiles: number;
-    removedBytes: number;
-    removedByAge: number;
-    removedBySize: number;
-    remainingFiles: number;
-    remainingBytes: number;
-    dryRun: boolean;
-    directories: string[];
-    removedSample: string[];
-    config: ArtifactRetentionConfig;
-}
-export declare function getArtifactRetentionConfig(env?: NodeJS.ProcessEnv): ArtifactRetentionConfig;
-export declare function cleanupArtifacts(options?: {
-    retentionDays?: number;
-    maxTotalBytes?: number;
-    dryRun?: boolean;
-    now?: number;
-    directories?: string[];
-}): Promise<ArtifactCleanupResult>;
-export declare function startArtifactRetentionScheduler(): (() => void) | null;

package/dist/src/utils/artifactRetention.js

@@ -1,206 +0,0 @@
-import { readdir, rm, stat } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { getArtifactDir, getArtifactsRoot } from './artifacts.js';
-import { getProjectRoot, resolveOutputDirectory } from './outputPaths.js';
-import { logger } from './logger.js';
-const DAY_MS = 24 * 60 * 60 * 1000;
-export function getArtifactRetentionConfig(env = process.env) {
-    const retentionDays = Math.max(0, parseInt(env.MCP_ARTIFACT_RETENTION_DAYS ?? '0', 10) || 0);
-    const maxTotalMb = Math.max(0, parseInt(env.MCP_ARTIFACT_MAX_TOTAL_MB ?? '0', 10) || 0);
-    const cleanupIntervalMinutes = Math.max(0, parseInt(env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES ?? '0', 10) || 0);
-    const cleanupOnStart = ['1', 'true'].includes((env.MCP_ARTIFACT_CLEANUP_ON_START ?? '').toLowerCase());
-    return {
-        enabled: retentionDays > 0 || maxTotalMb > 0,
-        retentionDays,
-        maxTotalBytes: maxTotalMb * 1024 * 1024,
-        cleanupOnStart,
-        cleanupIntervalMinutes,
-    };
-}
-export async function cleanupArtifacts(options) {
-    const envConfig = getArtifactRetentionConfig();
-    const config = {
-        ...envConfig,
-        retentionDays: options?.retentionDays ?? envConfig.retentionDays,
-        maxTotalBytes: options?.maxTotalBytes ?? envConfig.maxTotalBytes,
-    };
-    const now = options?.now ?? Date.now();
-    const dryRun = options?.dryRun ?? false;
-    const directories = options?.directories ?? getManagedArtifactDirectories();
-    const entries = await collectArtifactFiles(directories);
-    let remaining = [...entries];
-    const removedSample = [];
-    let removedFiles = 0;
-    let removedBytes = 0;
-    let removedByAge = 0;
-    let removedBySize = 0;
-    const cutoff = config.retentionDays > 0 ? now - config.retentionDays * DAY_MS : 0;
-    if (cutoff > 0) {
-        const agedOut = remaining
-            .filter((entry) => entry.mtimeMs < cutoff)
-            .toSorted((a, b) => a.mtimeMs - b.mtimeMs);
-        if (agedOut.length > 0) {
-            const agedOutPaths = new Set(agedOut.map((entry) => entry.path));
-            remaining = remaining.filter((entry) => !agedOutPaths.has(entry.path));
-            removedFiles += agedOut.length;
-            removedBytes += agedOut.reduce((sum, entry) => sum + entry.size, 0);
-            removedByAge += agedOut.reduce((sum, entry) => sum + entry.size, 0);
-            removedSample.push(...agedOut.slice(0, 20 - removedSample.length).map((entry) => entry.relativePath));
-            if (!dryRun) {
-                await Promise.all(agedOut.map((entry) => rm(entry.path, { force: true })));
-            }
-        }
-    }
-    if (config.maxTotalBytes > 0) {
-        let totalBytes = remaining.reduce((sum, entry) => sum + entry.size, 0);
-        if (totalBytes > config.maxTotalBytes) {
-            const sizeCandidates = [...remaining].toSorted((a, b) => a.mtimeMs - b.mtimeMs);
-            const removedPaths = new Set();
-            for (const entry of sizeCandidates) {
-                if (totalBytes <= config.maxTotalBytes)
-                    break;
-                totalBytes -= entry.size;
-                removedPaths.add(entry.path);
-                removedFiles += 1;
-                removedBytes += entry.size;
-                removedBySize += entry.size;
-                if (removedSample.length < 20)
-                    removedSample.push(entry.relativePath);
-                if (!dryRun) {
-                    await rm(entry.path, { force: true });
-                }
-            }
-            remaining = remaining.filter((entry) => !removedPaths.has(entry.path));
-        }
-    }
-    if (!dryRun) {
-        await Promise.all(directories.map((dir) => pruneEmptyDirectories(dir)));
-    }
-    return {
-        success: true,
-        scannedFiles: entries.length,
-        removedFiles,
-        removedBytes,
-        removedByAge,
-        removedBySize,
-        remainingFiles: remaining.length,
-        remainingBytes: remaining.reduce((sum, entry) => sum + entry.size, 0),
-        dryRun,
-        directories,
-        removedSample,
-        config,
-    };
-}
-export function startArtifactRetentionScheduler() {
-    const config = getArtifactRetentionConfig();
-    if (!config.enabled || config.cleanupIntervalMinutes <= 0) {
-        return null;
-    }
-    const handle = setInterval(() => {
-        void cleanupArtifacts()
-            .then((result) => {
-            if (result.removedFiles > 0) {
-                logger.info(`[artifacts] retention cleanup removed ${result.removedFiles} files (${result.removedBytes} bytes)`);
-            }
-        })
-            .catch((error) => {
-            logger.warn('[artifacts] retention cleanup failed', error);
-        });
-    }, config.cleanupIntervalMinutes * 60 * 1000);
-    handle.unref();
-    return () => clearInterval(handle);
-}
-function getManagedArtifactDirectories() {
-    const projectRoot = getProjectRoot();
-    const directories = new Set([
-        getArtifactsRoot(),
-        resolveOutputDirectory(process.env.MCP_SCREENSHOT_DIR, 'screenshots'),
-        resolve(projectRoot, 'debugger-sessions'),
-        resolve(process.cwd(), 'debugger-sessions'),
-    ]);
-    const categories = [
-        'wasm',
-        'traces',
-        'profiles',
-        'dumps',
-        'reports',
-        'har',
-        'sessions',
-        'tmp',
-    ];
-    for (const category of categories) {
-        directories.add(getArtifactDir(category));
-    }
-    return [...directories];
-}
-async function collectArtifactFiles(directories) {
-    const root = getProjectRoot();
-    const files = [];
-    for (const directory of directories) {
-        await walk(directory, async (path) => {
-            const info = await stat(path);
-            if (!info.isFile())
-                return;
-            files.push({
-                path,
-                relativePath: relativePathFromRoot(root, path),
-                size: info.size,
-                mtimeMs: info.mtimeMs,
-            });
-        });
-    }
-    return dedupeFiles(files);
-}
-async function walk(directory, onFile) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory()) {
-            await walk(path, onFile);
-        }
-        else if (entry.isFile()) {
-            await onFile(path);
-        }
-    }
-}
-async function pruneEmptyDirectories(directory) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    await Promise.all(entries
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => pruneEmptyDirectories(join(directory, entry.name))));
-    try {
-        const after = await readdir(directory);
-        if (after.length === 0) {
-            await rm(directory, { recursive: true, force: true });
-        }
-    }
-    catch {
-    }
-}
-function dedupeFiles(files) {
-    const byPath = new Map();
-    for (const file of files) {
-        byPath.set(file.path, file);
-    }
-    return [...byPath.values()];
-}
-function relativePathFromRoot(root, path) {
-    return path.startsWith(root)
-        ? path
-            .slice(root.length)
-            .replace(/^[\\/]/, '')
-            .replace(/\\/g, '/')
-        : path.replace(/\\/g, '/');
-}

package/dist/src/utils/artifacts.d.ts

@@ -1,13 +0,0 @@
-export type ArtifactCategory = 'wasm' | 'traces' | 'profiles' | 'dumps' | 'reports' | 'har' | 'sessions' | 'tmp';
-export declare function resolveArtifactPath(options: {
-    category: ArtifactCategory;
-    toolName: string;
-    target?: string;
-    ext: string;
-    customDir?: string;
-}): Promise<{
-    absolutePath: string;
-    displayPath: string;
-}>;
-export declare function getArtifactsRoot(): string;
-export declare function getArtifactDir(category: ArtifactCategory): string;

package/dist/src/utils/artifacts.js

@@ -1,37 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { resolve, relative, normalize, sep } from 'node:path';
-import { getProjectRoot } from './outputPaths.js';
-const ARTIFACT_BASE = 'artifacts';
-export async function resolveArtifactPath(options) {
-    const { category, toolName, target, ext, customDir } = options;
-    const root = getProjectRoot();
-    const dir = customDir ? resolve(root, customDir) : resolve(root, ARTIFACT_BASE, category);
-    const normalizedRoot = normalize(root);
-    const normalizedDir = normalize(dir);
-    if (normalizedDir !== normalizedRoot && !normalizedDir.startsWith(`${normalizedRoot}${sep}`)) {
-        throw new Error(`Path traversal blocked: artifact directory "${customDir}" escapes project root`);
-    }
-    await mkdir(dir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
-    const shortId = Math.random().toString(36).substring(2, 8);
-    const safeName = sanitizeFilename(toolName);
-    const safeTarget = target ? `-${sanitizeFilename(target)}` : '';
-    const safeExt = ext.replace(/^\./, '');
-    const filename = `${safeName}${safeTarget}-${ts}-${shortId}.${safeExt}`;
-    const absolutePath = resolve(dir, filename);
-    const displayPath = relative(root, absolutePath).replace(/\\/g, '/');
-    return { absolutePath, displayPath };
-}
-export function getArtifactsRoot() {
-    return resolve(getProjectRoot(), ARTIFACT_BASE);
-}
-export function getArtifactDir(category) {
-    return resolve(getProjectRoot(), ARTIFACT_BASE, category);
-}
-function sanitizeFilename(name) {
-    return name
-        .replace(/[^a-zA-Z0-9_-]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_|_$/g, '')
-        .substring(0, 60);
-}

package/dist/src/utils/betterSqlite3.d.ts

@@ -1,11 +0,0 @@
-export type BetterSqlite3Issue = 'missing' | 'abi-mismatch' | 'load-failed';
-export interface BetterSqlite3ProbeResult {
-    status: 'ok' | 'missing' | 'warn';
-    detail: string;
-    version: string | null;
-    issue?: BetterSqlite3Issue;
-}
-export declare function isBetterSqlite3RelatedError(error: unknown): boolean;
-export declare function classifyBetterSqlite3Issue(error: unknown): BetterSqlite3Issue;
-export declare function formatBetterSqlite3Error(error: unknown): string;
-export declare function probeBetterSqlite3(): BetterSqlite3ProbeResult;

package/dist/src/utils/betterSqlite3.js

@@ -1,88 +0,0 @@
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-const BETTER_SQLITE3_VERSION = '12.6.2';
-const INSTALL_HINT = `pnpm add -O better-sqlite3@${BETTER_SQLITE3_VERSION}`;
-const REBUILD_HINT = 'npm rebuild better-sqlite3 --foreground-scripts';
-function extractErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-}
-export function isBetterSqlite3RelatedError(error) {
-    return /better-sqlite3|better_sqlite3\.node|NODE_MODULE_VERSION|compiled against a different Node\.js version/i.test(extractErrorMessage(error));
-}
-export function classifyBetterSqlite3Issue(error) {
-    const message = extractErrorMessage(error);
-    if (/Cannot find module 'better-sqlite3'|Cannot find package 'better-sqlite3'|better-sqlite3 is not installed/i.test(message)) {
-        return 'missing';
-    }
-    if (/better_sqlite3\.node|NODE_MODULE_VERSION|compiled against a different Node\.js version|module was compiled against/i.test(message)) {
-        return 'abi-mismatch';
-    }
-    return 'load-failed';
-}
-export function formatBetterSqlite3Error(error) {
-    const issue = classifyBetterSqlite3Issue(error);
-    const message = extractErrorMessage(error);
-    if (issue === 'missing') {
-        return `better-sqlite3 is not installed. Install the optional trace backend with \`${INSTALL_HINT}\`.`;
-    }
-    if (issue === 'abi-mismatch') {
-        return `better-sqlite3 is installed but its native binary is incompatible with the current Node.js runtime (${process.version}, ABI ${process.versions.modules}). Rebuild it with \`${REBUILD_HINT}\` or reinstall dependencies under the active Node version. Original error: ${message}`;
-    }
-    return `better-sqlite3 failed to initialize. Try \`${REBUILD_HINT}\` or reinstall dependencies under the active Node version. Original error: ${message}`;
-}
-function readBetterSqlite3Version() {
-    try {
-        const packageJsonPath = require.resolve('better-sqlite3/package.json');
-        const packageJson = require(packageJsonPath);
-        return packageJson.version ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-export function probeBetterSqlite3() {
-    const version = readBetterSqlite3Version();
-    if (!version) {
-        return {
-            status: 'missing',
-            detail: `Optional SQLite backend for trace tools is not installed. Install it with: ${INSTALL_HINT}`,
-            version: null,
-            issue: 'missing',
-        };
-    }
-    try {
-        const Database = require('better-sqlite3');
-        const db = new Database(':memory:');
-        try {
-            db.prepare('SELECT 1 AS ok').get();
-        }
-        finally {
-            db.close();
-        }
-        return {
-            status: 'ok',
-            detail: `installed (${version}) — native trace backend healthy`,
-            version,
-        };
-    }
-    catch (error) {
-        const issue = classifyBetterSqlite3Issue(error);
-        if (issue === 'missing') {
-            return {
-                status: 'missing',
-                detail: `Optional SQLite backend for trace tools is not installed. Install it with: ${INSTALL_HINT}`,
-                version,
-                issue,
-            };
-        }
-        return {
-            status: 'warn',
-            detail: `installed (${version}) but ${formatBetterSqlite3Error(error)}`,
-            version,
-            issue,
-        };
-    }
-}

package/dist/src/utils/browserExecutable.d.ts

@@ -1,4 +0,0 @@
-export declare function findBrowserExecutable(): string | undefined;
-export declare function clearBrowserPathCache(): void;
-export declare function getCachedBrowserPath(): string | undefined;
-export declare const resolveBrowserExecutablePath: typeof findBrowserExecutable;