@tracelog/lib 0.0.8 → 0.2.0

package/dist/esm/utils/logging/debug-logger.utils.js

@@ -1,136 +1,45 @@
 import { StateManager } from '../../managers/state.manager';
-/**
- * Debug logger class that extends StateManager for clean access to global state
- */
 class DebugLogger extends StateManager {
-    /**
-     * Client-facing error - Configuration/usage errors by the client
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    clientError(namespace, message, data) {
-        this.logMessage('CLIENT_ERROR', namespace, message, data);
-    }
-    /**
-     * Client-facing warning - Configuration/usage warnings by the client
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    clientWarn(namespace, message, data) {
-        this.logMessage('CLIENT_WARN', namespace, message, data);
-    }
-    /**
-     * General operational information
-     * Console: qa and debug modes | Events: NODE_ENV=dev
-     */
-    info(namespace, message, data) {
-        this.logMessage('INFO', namespace, message, data);
-    }
-    /**
-     * Internal library errors
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    error(namespace, message, data) {
-        this.logMessage('ERROR', namespace, message, data);
-    }
-    /**
-     * Internal library warnings
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    warn(namespace, message, data) {
-        this.logMessage('WARN', namespace, message, data);
-    }
-    /**
-     * Strategic debug information
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    debug(namespace, message, data) {
-        this.logMessage('DEBUG', namespace, message, data);
-    }
-    /**
-     * Detailed trace information
-     * Console: debug mode only | Events: NODE_ENV=dev
-     */
-    verbose(namespace, message, data) {
-        this.logMessage('VERBOSE', namespace, message, data);
-    }
-    getCurrentMode() {
-        try {
-            return this.get('config')?.mode;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    shouldShowLog(level) {
-        const mode = this.getCurrentMode();
-        switch (mode) {
-            case 'qa':
-                return ['INFO', 'CLIENT_ERROR', 'CLIENT_WARN'].includes(level);
-            case 'debug':
-                return true;
-            default:
-                return false;
-        }
-    }
-    formatMessage(namespace, message) {
-        return `[TraceLog:${namespace}] ${message}`;
-    }
-    getConsoleMethod(level) {
-        switch (level) {
-            case 'CLIENT_ERROR':
-            case 'ERROR':
-                return 'error';
-            case 'CLIENT_WARN':
-            case 'WARN':
-                return 'warn';
-            case 'INFO':
-            case 'DEBUG':
-            case 'VERBOSE':
-            default:
-                return 'log';
-        }
-    }
-    logMessage(level, namespace, message, data) {
-        if (!this.shouldShowLog(level)) {
+    constructor() {
+        super(...arguments);
+        this.clientError = (ns, msg, data) => this.log('CLIENT_ERROR', ns, msg, data);
+        this.clientWarn = (ns, msg, data) => this.log('CLIENT_WARN', ns, msg, data);
+        this.info = (ns, msg, data) => this.log('INFO', ns, msg, data);
+        this.error = (ns, msg, data) => this.log('ERROR', ns, msg, data);
+        this.warn = (ns, msg, data) => this.log('WARN', ns, msg, data);
+        this.debug = (ns, msg, data) => this.log('DEBUG', ns, msg, data);
+        this.verbose = (ns, msg, data) => this.log('VERBOSE', ns, msg, data);
+    }
+    log(level, ns, msg, data) {
+        const mode = this.get('config')?.mode;
+        if (!this.shouldShow(level, mode))
             return;
-        }
-        const formattedMessage = this.formatMessage(namespace, message);
-        const consoleMethod = this.getConsoleMethod(level);
+        const formattedMsg = `[TraceLog:${ns}] ${msg}`;
+        const method = this.getMethod(level);
         if (data !== undefined) {
-            console[consoleMethod](formattedMessage, data);
+            console[method](formattedMsg, data);
         }
         else {
-            console[consoleMethod](formattedMessage);
-        }
-        if (process.env.NODE_ENV === 'dev') {
-            this.dispatchEvent(level, namespace, message, data);
-        }
-    }
-    /**
-     * Dispatches tracelog:log events for E2E testing and development debugging
-     */
-    dispatchEvent(level, namespace, message, data) {
-        if (typeof window === 'undefined' || typeof CustomEvent === 'undefined') {
-            return;
-        }
-        try {
-            const event = new CustomEvent('tracelog:log', {
-                detail: {
-                    timestamp: new Date().toISOString(),
-                    level,
-                    namespace,
-                    message,
-                    data,
-                },
-            });
-            window.dispatchEvent(event);
-        }
-        catch {
-            console.log(`[TraceLog:${namespace}] ${message}`, data);
-        }
+            console[method](formattedMsg);
+        }
+    }
+    shouldShow(level, mode) {
+        if (['CLIENT_ERROR', 'ERROR'].includes(level))
+            return true;
+        if (!mode)
+            return level === 'CLIENT_WARN';
+        if (mode === 'qa')
+            return ['INFO', 'CLIENT_ERROR', 'CLIENT_WARN'].includes(level);
+        if (mode === 'debug')
+            return true; // Debug mode shows all logs
+        return false;
+    }
+    getMethod(level) {
+        if (['CLIENT_ERROR', 'ERROR'].includes(level))
+            return 'error';
+        if (['CLIENT_WARN', 'WARN'].includes(level))
+            return 'warn';
+        return 'log';
     }
 }
-/**
- * Singleton debug logger instance
- * Provides the same API as before: debugLog.clientError(), debugLog.info(), etc.
- */
 export const debugLog = new DebugLogger();

package/dist/esm/utils/network/fetch-with-timeout.utils.d.ts

@@ -0,0 +1,4 @@
+export interface FetchWithTimeoutOptions extends RequestInit {
+    timeout?: number;
+}
+export declare function fetchWithTimeout(url: string, options?: FetchWithTimeoutOptions): Promise<Response>;

package/dist/esm/utils/network/fetch-with-timeout.utils.js

@@ -0,0 +1,22 @@
+export async function fetchWithTimeout(url, options = {}) {
+    const { timeout = 10000, ...fetchOptions } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort();
+    }, timeout);
+    try {
+        const response = await fetch(url, {
+            ...fetchOptions,
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        return response;
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Request timeout after ${timeout}ms`);
+        }
+        throw error;
+    }
+}

package/dist/esm/utils/network/index.d.ts

@@ -1 +1,2 @@
 export * from './url.utils';
+export * from './fetch-with-timeout.utils';

package/dist/esm/utils/network/index.js

@@ -1 +1,2 @@
 export * from './url.utils';
+export * from './fetch-with-timeout.utils';

package/dist/esm/utils/network/url.utils.js

@@ -6,7 +6,6 @@ import { debugLog } from '../logging';
  * @returns The generated API URL
  */
 export const getApiUrl = (id, allowHttp = false) => {
-    debugLog.debug('URLUtils', 'Generating API URL', { projectId: id, allowHttp });
     const url = new URL(window.location.href);
     const host = url.hostname;
     const parts = host.split('.');
@@ -17,14 +16,6 @@ export const getApiUrl = (id, allowHttp = false) => {
     const cleanDomain = parts.slice(-2).join('.');
     const protocol = allowHttp && url.protocol === 'http:' ? 'http' : 'https';
     const apiUrl = `${protocol}://${id}.${cleanDomain}`;
-    debugLog.debug('URLUtils', 'Generated API URL', {
-        originalUrl: window.location.href,
-        hostname: host,
-        domainParts: parts.length,
-        cleanDomain,
-        protocol,
-        generatedUrl: apiUrl,
-    });
     const isValid = isValidUrl(apiUrl, allowHttp);
     if (!isValid) {
         debugLog.clientError('URLUtils', 'Generated API URL failed validation', {
@@ -33,7 +24,6 @@ export const getApiUrl = (id, allowHttp = false) => {
         });
         throw new Error('Invalid URL');
     }
-    debugLog.debug('URLUtils', 'API URL generation completed successfully', { apiUrl });
     return apiUrl;
 };
 /**
@@ -43,10 +33,6 @@ export const getApiUrl = (id, allowHttp = false) => {
  * @returns The normalized URL
  */
 export const normalizeUrl = (url, sensitiveQueryParams = []) => {
-    debugLog.debug('URLUtils', 'Normalizing URL', {
-        urlLength: url.length,
-        sensitiveParamsCount: sensitiveQueryParams.length,
-    });
     try {
         const urlObject = new URL(url);
         const searchParams = urlObject.searchParams;
@@ -68,16 +54,10 @@ export const normalizeUrl = (url, sensitiveQueryParams = []) => {
             });
         }
         if (!hasChanged && url.includes('?')) {
-            debugLog.debug('URLUtils', 'URL normalization - no changes needed');
             return url;
         }
         urlObject.search = searchParams.toString();
         const result = urlObject.toString();
-        debugLog.debug('URLUtils', 'URL normalization completed', {
-            hasChanged,
-            originalLength: url.length,
-            normalizedLength: result.length,
-        });
         return result;
     }
     catch (error) {
@@ -95,18 +75,13 @@ export const normalizeUrl = (url, sensitiveQueryParams = []) => {
  * @returns True if the URL should be excluded
  */
 export const isUrlPathExcluded = (url, excludedPaths = []) => {
-    debugLog.debug('URLUtils', 'Checking if URL path is excluded', {
-        urlLength: url.length,
-        excludedPathsCount: excludedPaths.length,
-    });
     if (excludedPaths.length === 0) {
-        debugLog.debug('URLUtils', 'No excluded paths configured');
         return false;
     }
     let path;
     try {
-        path = new URL(url, window.location.origin).pathname;
-        debugLog.debug('URLUtils', 'Extracted path from URL', { path });
+        const parsedUrl = new URL(url, window.location.origin);
+        path = parsedUrl.pathname + (parsedUrl.hash ?? '');
     }
     catch (error) {
         debugLog.warn('URLUtils', 'Failed to parse URL for path exclusion check', {
@@ -127,23 +102,14 @@ export const isUrlPathExcluded = (url, excludedPaths = []) => {
         try {
             if (isRegularExpression(pattern)) {
                 const matches = pattern.test(path);
-                if (matches) {
-                    debugLog.debug('URLUtils', 'Path matched regex pattern', { path, pattern: pattern.toString() });
-                }
                 return matches;
             }
             if (pattern.includes('*')) {
                 const regex = wildcardToRegex(pattern);
                 const matches = regex.test(path);
-                if (matches) {
-                    debugLog.debug('URLUtils', 'Path matched wildcard pattern', { path, pattern, regex: regex.toString() });
-                }
                 return matches;
             }
             const matches = pattern === path;
-            if (matches) {
-                debugLog.debug('URLUtils', 'Path matched exact pattern', { path, pattern });
-            }
             return matches;
         }
         catch (error) {
@@ -156,11 +122,5 @@ export const isUrlPathExcluded = (url, excludedPaths = []) => {
         }
     });
     const isExcluded = !!matchedPattern;
-    debugLog.debug('URLUtils', 'URL path exclusion check completed', {
-        path,
-        isExcluded,
-        matchedPattern: matchedPattern ?? null,
-        totalPatternsChecked: excludedPaths.length,
-    });
     return isExcluded;
 };

package/dist/esm/utils/security/sanitize.utils.d.ts

@@ -1,5 +1,4 @@
-import { MetadataType } from '../../types/common.types';
-import { ApiConfig } from '../../types/config.types';
+import { MetadataType, ApiConfig } from '../../types';
 /**
  * Sanitizes a string value to prevent XSS attacks
  * @param value - The string to sanitize
@@ -24,9 +23,3 @@ export declare const sanitizeApiConfig: (data: unknown) => ApiConfig;
  * @returns The sanitized metadata
  */
 export declare const sanitizeMetadata: (metadata: unknown) => Record<string, MetadataType>;
-/**
- * Sanitizes URL strings for tracking
- * @param url - The URL to sanitize
- * @returns The sanitized URL
- */
-export declare const sanitizeUrl: (url: string) => string;

package/dist/esm/utils/security/sanitize.utils.js

@@ -206,6 +206,12 @@ export const sanitizeApiConfig = (data) => {
                         debugLog.warn('Sanitize', 'Tags value is not an array', { value, type: typeof value });
                     }
                 }
+                else if (key === 'samplingRate') {
+                    const sanitizedValue = sanitizeValue(value);
+                    if (typeof sanitizedValue === 'number') {
+                        safeData.samplingRate = sanitizedValue;
+                    }
+                }
                 else {
                     const sanitizedValue = sanitizeValue(value);
                     if (sanitizedValue !== null) {
@@ -270,42 +276,3 @@ export const sanitizeMetadata = (metadata) => {
         throw new Error(`Metadata sanitization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 };
-/**
- * Sanitizes URL strings for tracking
- * @param url - The URL to sanitize
- * @returns The sanitized URL
- */
-export const sanitizeUrl = (url) => {
-    debugLog.debug('Sanitize', 'Starting URL sanitization', { urlLength: typeof url === 'string' ? url.length : 0 });
-    if (typeof url !== 'string') {
-        debugLog.warn('Sanitize', 'URL is not a string', { url, type: typeof url });
-        return '';
-    }
-    try {
-        // Basic URL validation
-        const urlObject = new URL(url);
-        // Only allow http/https protocols
-        if (!['http:', 'https:'].includes(urlObject.protocol)) {
-            debugLog.warn('Sanitize', 'URL protocol not allowed', {
-                protocol: urlObject.protocol,
-                allowedProtocols: ['http:', 'https:'],
-            });
-            return '';
-        }
-        // Sanitize the URL string
-        const result = sanitizeString(urlObject.href);
-        debugLog.debug('Sanitize', 'URL sanitization completed via URL object', {
-            originalLength: url.length,
-            sanitizedLength: result.length,
-            protocol: urlObject.protocol,
-        });
-        return result;
-    }
-    catch {
-        // If URL parsing fails, sanitize as string
-        debugLog.warn('Sanitize', 'URL parsing failed, falling back to string sanitization', {
-            urlPreview: url.slice(0, 100),
-        });
-        return sanitizeString(url);
-    }
-};

package/dist/esm/utils/validations/config-validations.utils.d.ts

@@ -24,6 +24,12 @@ export declare const validateAndNormalizeConfig: (config: AppConfig) => AppConfi
 export declare const validateConfig: (config: Config) => {
     errors: string[];
     warnings: string[];
+    samplingRate: number;
+};
+export declare const normalizeConfig: (config: Config) => {
+    config: Config;
+    errors: string[];
+    warnings: string[];
 };
 /**
  * Validates the final configuration
@@ -33,6 +39,7 @@ export declare const validateConfig: (config: Config) => {
 export declare const validateFinalConfig: (config: Config) => {
     errors: string[];
     warnings: string[];
+    samplingRate: number;
 };
 /**
  * Type guard to check if a JSON response is a valid API config

package/dist/esm/utils/validations/config-validations.utils.js

@@ -1,4 +1,4 @@
-import { MAX_SESSION_TIMEOUT_MS, MIN_SESSION_TIMEOUT_MS, VALIDATION_MESSAGES } from '../../constants';
+import { DEFAULT_SAMPLING_RATE, MAX_SESSION_TIMEOUT_MS, MIN_SESSION_TIMEOUT_MS, VALIDATION_MESSAGES, } from '../../constants';
 import { Mode } from '../../types';
 import { ProjectIdValidationError, AppConfigValidationError, SessionTimeoutValidationError, SamplingRateValidationError, IntegrationValidationError, } from '../../types/validation-error.types';
 import { debugLog } from '../logging';
@@ -83,6 +83,47 @@ export const validateAppConfig = (config) => {
         }
     }
 };
+/**
+ * Validates CSS selector syntax without executing querySelector (XSS prevention)
+ * @param selector - CSS selector to validate
+ * @returns True if the selector syntax is valid
+ */
+const isValidCssSelectorSyntax = (selector) => {
+    // Prevent dangerous characters that could indicate XSS attempts
+    if (selector.includes('<') || selector.includes('>') || /on\w+\s*=/i.test(selector)) {
+        return false;
+    }
+    // Safe CSS selector pattern - allows common selector syntax
+    const safePattern = /^[a-zA-Z0-9\-_#.[\]="':, >+~*()]+$/;
+    if (!safePattern.test(selector)) {
+        return false;
+    }
+    // Check for balanced parentheses
+    let parenthesesCount = 0;
+    for (const char of selector) {
+        if (char === '(')
+            parenthesesCount++;
+        if (char === ')')
+            parenthesesCount--;
+        if (parenthesesCount < 0)
+            return false;
+    }
+    if (parenthesesCount !== 0)
+        return false;
+    // Check for balanced square brackets
+    let bracketsCount = 0;
+    for (const char of selector) {
+        if (char === '[')
+            bracketsCount++;
+        if (char === ']')
+            bracketsCount--;
+        if (bracketsCount < 0)
+            return false;
+    }
+    if (bracketsCount !== 0)
+        return false;
+    return true;
+};
 /**
  * Validates scroll container selectors
  * @param selectors - CSS selectors to validate
@@ -98,16 +139,14 @@ const validateScrollContainerSelectors = (selectors) => {
             });
             throw new AppConfigValidationError(VALIDATION_MESSAGES.INVALID_SCROLL_CONTAINER_SELECTORS, 'config');
         }
-        // Validate CSS selector syntax but handle invalid selectors gracefully
-        if (typeof document !== 'undefined') {
-            try {
-                document.querySelector(selector);
-            }
-            catch {
-                // Invalid CSS selectors are handled gracefully
-                // they will be ignored by the ScrollHandler and it will fall back to window scrolling
-                debugLog.clientWarn('ConfigValidation', `Invalid CSS selector will be ignored: "${selector}"`);
-            }
+        // Validate CSS selector syntax using regex-based validation (XSS prevention)
+        // This validates syntax WITHOUT executing document.querySelector()
+        if (!isValidCssSelectorSyntax(selector)) {
+            debugLog.clientError('ConfigValidation', 'Invalid or potentially unsafe CSS selector', {
+                selector,
+                reason: 'Failed security validation',
+            });
+            throw new AppConfigValidationError('Invalid or potentially unsafe CSS selector', 'config');
         }
     }
 };
@@ -171,14 +210,18 @@ export const validateAndNormalizeConfig = (config) => {
  * @param errors - Array to push errors to
  */
 const validateSamplingRate = (samplingRate, errors) => {
-    if (samplingRate !== undefined) {
-        if (typeof samplingRate !== 'number') {
-            errors.push('samplingRate must be a number');
-        }
-        else if (samplingRate < 0 || samplingRate > 1) {
-            errors.push('samplingRate must be between 0 and 1');
-        }
+    if (samplingRate === undefined) {
+        return undefined;
+    }
+    if (typeof samplingRate !== 'number') {
+        errors.push('samplingRate must be a number');
+        return DEFAULT_SAMPLING_RATE;
+    }
+    if (Number.isNaN(samplingRate) || samplingRate <= 0 || samplingRate > 1) {
+        errors.push(VALIDATION_MESSAGES.INVALID_SAMPLING_RATE);
+        return DEFAULT_SAMPLING_RATE;
     }
+    return samplingRate;
 };
 /**
  * Validates excluded URL paths
@@ -242,12 +285,23 @@ export const validateConfig = (config) => {
         }
     }
     // No custom API endpoints supported
-    validateSamplingRate(config.samplingRate, errors);
+    const validatedSamplingRate = validateSamplingRate(config.samplingRate, errors) ?? DEFAULT_SAMPLING_RATE;
     if (config.tags !== undefined && !Array.isArray(config.tags)) {
         errors.push('tags must be an array');
     }
     validateExcludedUrlPaths(config.excludedUrlPaths, errors);
-    return { errors, warnings };
+    return { errors, warnings, samplingRate: validatedSamplingRate };
+};
+export const normalizeConfig = (config) => {
+    const { errors, warnings, samplingRate } = validateConfig(config);
+    return {
+        config: {
+            ...config,
+            samplingRate,
+        },
+        errors,
+        warnings,
+    };
 };
 /**
  * Validates the final configuration
@@ -257,10 +311,10 @@ export const validateConfig = (config) => {
 export const validateFinalConfig = (config) => {
     const errors = [];
     const warnings = [];
-    validateSamplingRate(config.samplingRate, errors);
+    const validatedSamplingRate = validateSamplingRate(config.samplingRate, errors) ?? DEFAULT_SAMPLING_RATE;
     validateExcludedUrlPaths(config.excludedUrlPaths, errors);
     // No custom API endpoints supported
-    return { errors, warnings };
+    return { errors, warnings, samplingRate: validatedSamplingRate };
 };
 /**
  * Type guard to check if a JSON response is a valid API config

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tracelog/lib",
   "description": "JavaScript library for web analytics and real-time event tracking",
   "license": "MIT",
-  "version": "0.0.8",
+  "version": "0.2.0",
   "main": "./dist/cjs/public-api.js",
   "module": "./dist/esm/public-api.js",
   "types": "./dist/esm/public-api.d.ts",
@@ -20,13 +20,13 @@
   },
   "scripts": {
     "build": "npx tsc",
+    "type-check": "npx tsc --noEmit",
+    "type-check:watch": "npx tsc --noEmit --watch",
     "build:esm": "tsc -p tsconfig.esm.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:browser": "NODE_ENV=production vite build",
-    "build:browser:production": "NODE_ENV=production vite build",
-    "build:browser:testing": "NODE_ENV=dev vite build",
-    "build:browser:playground": "NODE_ENV=dev vite build",
-    "build:all": "npm run build:esm && npm run build:cjs && npm run build:browser:production",
+    "build:browser:dev": "NODE_ENV=dev vite build",
+    "build:all": "npm run build:esm && npm run build:cjs && npm run build:browser",
     "build-ugly": "npm run build:all && find dist -name '*.js' -exec npx uglify-js {} -o {} --compress --mangle --toplevel \\;",
     "build-ugly:win": "npm run build:all && Get-ChildItem -Path dist -Recurse -Filter *.js | ForEach-Object { npx uglify-js $_.FullName -o $_.FullName --compress --mangle --toplevel }",
     "lint": "npx eslint \"src/**/*.ts\" \"tests/**/*.ts\"",
@@ -35,16 +35,16 @@
     "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*{.ts,.js,.html,.css,.json,.md}\" \"scripts/**/*.js\"",
     "check": "npm run lint && npm run format:check",
     "fix": "npm run lint:fix && npm run format",
-    "serve:test": "http-server tests/fixtures -p 3000 --cors",
-    "serve:playground": "http-server playground -p 3001 --cors",
-    "playground:setup": "npm run build:browser:playground && cp dist/browser/tracelog.js playground/tracelog.js",
-    "playground:dev": "npm run playground:setup && npm run serve:playground",
-    "test:e2e": "npm run build:browser:testing && cp dist/browser/tracelog.js tests/fixtures/tracelog.js && NODE_ENV=dev playwright test",
-    "test:anomaly-report": "node scripts/test-anomaly-report.js",
-    "ci:health-check": "node scripts/ci-health-check.js",
-    "ci:health-strict": "TRACELOG_STRICT_MODE=true node scripts/ci-health-check.js",
-    "ci:pre-deploy": "npm run build:all && npm run ci:health-check",
-    "ci:pre-release": "npm run build:all && npm run ci:health-strict",
+    "test:unit": "vitest run",
+    "test:unit:ci": "NODE_OPTIONS=\"--max-old-space-size=4096 --no-experimental-fetch\" vitest run --pool=forks --poolOptions.forks.singleFork=true --poolOptions.forks.isolate=false",
+    "test:unit:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:integration": "vitest run --config vitest.integration.config.mjs",
+    "serve": "http-server playground -p 3000 --cors",
+    "playground:setup": "npm run build:browser:dev && cp dist/browser/tracelog.js playground/tracelog.js",
+    "playground:dev": "npm run playground:setup && npm run serve",
+    "test:e2e": "npm run build:browser:dev && cp dist/browser/tracelog.js playground/tracelog.js && NODE_ENV=dev playwright test",
+    "ci:build": "npm run build:all",
     "prepare": "husky",
     "release": "node scripts/release.js",
     "release:patch": "node scripts/release.js --force-version $(node -p \"const v=require('./package.json').version.split('.').map(Number); v[2]++; v.join('.')\")",
@@ -61,20 +61,27 @@
     "@commitlint/config-conventional": "^19.8.1",
     "@eslint/js": "^9.30.1",
     "@playwright/test": "^1.54.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.5.2",
     "@typescript-eslint/eslint-plugin": "^8.36.0",
     "@typescript-eslint/parser": "^8.36.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "commitlint": "^19.8.1",
+    "cross-env": "^10.0.0",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-prettier": "^5.5.1",
     "globals": "^16.3.0",
     "http-server": "^14.1.1",
     "husky": "^9.1.6",
+    "jsdom": "^27.0.0",
     "lint-staged": "^15.2.10",
     "prettier": "^3.4.2",
+    "terser": "^5.44.0",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.36.0",
     "uglify-js": "^3.19.3",
-    "vite": "^7.0.4"
+    "vite": "^7.0.4",
+    "vitest": "^3.2.4"
   }
 }