@levo-so/insights 0.1.64 → 0.1.71

package/dist/legacy/index.d.ts

@@ -0,0 +1,71 @@
+import { ILevoClient } from '@levo-so/core';
+import { AnalyticsInstance } from 'analytics';
+import { AnalyticsEventType, ILevoAudience } from '../types/analytics';
+import { IInsightOptions } from '../types/options';
+/**
+ * Creates the Levo Audience analytics module.
+ *
+ * This factory function creates a new audience module instance tied to
+ * a specific Levo control instance and HTTP client. The module manages
+ * all analytics tracking for the page.
+ *
+ * @param core - The Levo control instance containing workspace config
+ * @param httpClient - HTTP client for making API requests
+ * @returns The audience module with tracking methods
+ *
+ * @example
+ * ```typescript
+ * const audience = createLevoAudienceModule(levoControl, httpClient);
+ *
+ * // Initialize on page load
+ * await audience.initiate({ id: 'page-123' });
+ *
+ * // Track custom events
+ * audience.track('button.click', { buttonId: 'cta-signup' });
+ *
+ * // Cleanup on unmount (optional, for SPAs)
+ * audience.destroy();
+ * ```
+ */
+export declare const createLevoInsights: (client: ILevoClient, options: IInsightOptions) => {
+    /** Get the underlying analytics instance (read-only) */
+    readonly instance: AnalyticsInstance | null;
+    /** Check if session has been established (read-only) */
+    readonly is_identified: boolean;
+    /** Storage keys used by the module */
+    storage_keys: {
+        readonly identify: "lock:lv_aud_identify";
+        readonly open_tabs: "lv_insights_ot";
+        readonly current_tab: "lv_insights_ct";
+        readonly all_tabs: "lv_insights_at";
+        readonly device_token: "lv_aud_device";
+        readonly session_token: "lv_aud_session";
+        readonly mode: "lv_aud_mode";
+        readonly session: "lv_insights_session";
+    };
+    /** Initialize the module for a page */
+    initiate: (properties: ILevoAudience.Properties) => Promise<any>;
+    /** Identify/establish session */
+    identify: (options?: {
+        withLock?: boolean;
+    }) => Promise<void>;
+    /** Track a custom event */
+    track: <T extends ILevoAudience.Properties>(event: AnalyticsEventType, properties: T & ILevoAudience.Properties) => Promise<any>;
+    /** Track a bounce event */
+    bounce: (properties: ILevoAudience.Properties) => Promise<void>;
+    /** Cleanup the module */
+    destroy: () => void;
+};
+/**
+ * Type representing the audience module instance.
+ * Use this when you need to type a variable holding the module.
+ *
+ * @example
+ * ```typescript
+ * let audience: ILevoAudienceModule;
+ * audience = createLevoAudienceModule(core, httpClient);
+ * ```
+ */
+export type ILevoInsights = ReturnType<typeof createLevoInsights>;
+export * from '../types/analytics';
+export * from '../types/options';

package/dist/lib/analytics.d.ts

@@ -0,0 +1,10 @@
+import { ILevoClient } from '@levo-so/core';
+import { TrackFn } from '../types/analytics';
+/**
+ * Creates the analytics instance with our custom plugin.
+ *
+ * @param client - The Levo client instance
+ * @param sendEvent - Function to handle event tracking
+ * @param isValid - Function to check if the current instance is still valid/active
+ */
+export declare const createAnalytics: (client: ILevoClient, sendEvent: TrackFn, isValid: () => boolean) => import('analytics').AnalyticsInstance | null;

package/dist/lib/insights.d.ts

@@ -0,0 +1,24 @@
+import { ILevoClient } from '@levo-so/core';
+import { TrackFn } from '../types/analytics';
+import { IInsightOptions } from '../types/options';
+/**
+ * Creates the Levo Audience analytics module.
+ *
+ * This factory function creates a new audience module instance tied to
+ * a specific Levo control instance and HTTP client. The module manages
+ * all analytics tracking for the page.
+ *
+ * @param client - The Levo control instance containing workspace config
+ * @param options - Configuration options for the insights module
+ * @returns The audience module with tracking methods
+ */
+declare const createLevoInsights: (client: ILevoClient, options: IInsightOptions) => {
+    init: (initOptions?: {
+        pageId?: string | null;
+    }) => void;
+    destroy: () => void;
+    track: TrackFn;
+    readonly instance: import('analytics').AnalyticsInstance | null;
+};
+type ILevoInsights = ReturnType<typeof createLevoInsights>;
+export { createLevoInsights, type ILevoInsights };

package/dist/stores/config.d.ts

@@ -0,0 +1,11 @@
+interface IInsightsConfig {
+    workspace: string | null;
+    page_id: string | null;
+    site_id: string | null;
+    debug: boolean;
+}
+declare const $config: import('nanostores').PreinitializedMapStore<IInsightsConfig> & object;
+declare const getConfig: () => IInsightsConfig;
+declare const setConfig: (v: Partial<IInsightsConfig>) => void;
+declare const updateConfigKey: <T extends keyof IInsightsConfig>(key: T, value: IInsightsConfig[T]) => void;
+export { $config, getConfig, setConfig, updateConfigKey, type IInsightsConfig };

package/dist/stores/events.d.ts

@@ -0,0 +1,45 @@
+import { ILevoAudience } from '../types/analytics';
+type IQueuedEvent = Partial<ILevoAudience.CollectInput> & {
+    event: string;
+    created_at: string;
+};
+declare const $eventQueue: import('nanostores').PreinitializedWritableAtom<IQueuedEvent[]> & object;
+declare const $lifetimePageCount: import('nanostores').PreinitializedWritableAtom<number> & object;
+declare const $totalEventCount: import('nanostores').ReadableAtom<number>;
+/**
+ * Initialize a listener that flushes the event queue immediately
+ * when the session becomes identified.
+ *
+ * @returns Unsubscribe function
+ */
+declare const initSessionFlushListener: () => () => void;
+declare const getEventQueue: () => IQueuedEvent[];
+/**
+ * Flush all queued events to the server.
+ *
+ * This function:
+ * 1. Takes all events from the queue
+ * 2. Merges context from stores (workspace, session, tab info)
+ * 3. Sends to /v1/insights/event/bulk via sendBeacon (preferred) or fetch
+ *
+ * sendBeacon is preferred because:
+ * - It survives page unload (critical for page exit events)
+ * - It doesn't block the main thread
+ * - Browser queues it and sends when convenient
+ *
+ * fetch with keepalive is the fallback for when sendBeacon fails or
+ * isn't available.
+ */
+declare const flushEventQueue: (_eventQueue: IQueuedEvent[]) => void;
+/**
+ * Add an event to the queue for batched sending.
+ * Only stores in-time data (event, properties, page context).
+ * Context from stores is merged at flush time.
+ */
+declare const queueEvent: (event: IQueuedEvent) => void;
+declare const resetRateLimit: () => void;
+/**
+ * Clear all pending events and reset state.
+ */
+export declare const clearEventQueue: () => void;
+export { $eventQueue, $lifetimePageCount, $totalEventCount, queueEvent, resetRateLimit, initSessionFlushListener, getEventQueue, flushEventQueue, type IQueuedEvent, };

package/dist/stores/session.d.ts

@@ -0,0 +1,21 @@
+import { IIdentity } from '../types/identity';
+interface ISession {
+    isIdentified: boolean;
+    isIdentifying: boolean;
+    sessionId: string | null;
+    deviceId: string | null;
+    deviceToken: string | null;
+    sessionToken: string | null;
+    allTabs: string[];
+    mode: "proxy" | "direct";
+    insightsBaseUrl: string | null;
+    identity: IIdentity | null;
+}
+declare const $session: import('nanostores').PreinitializedWritableAtom<ISession> & object;
+declare const onSessionReady: (cb: () => void) => void;
+declare const isSessionReady: () => boolean;
+declare const getSession: () => ISession;
+declare const updateSession: (v: Partial<ISession>) => void;
+export { $session, getSession, updateSession, onSessionReady, isSessionReady, type ISession };
+declare const $isContextReady: import('nanostores').ReadableAtom<boolean>;
+export { $isContextReady };

package/dist/stores.d.ts

@@ -0,0 +1,8 @@
+export { $config } from './stores/config';
+export { $eventQueue, $lifetimePageCount, $totalEventCount } from './stores/events';
+export { $isContextReady, $session } from './stores/session';
+export { $activity } from './tracking/activity';
+export { $pageLifecycle } from './tracking/bounce';
+export { $currentTab } from './tracking/currentTab';
+export { $scrollBehavior } from './tracking/scrollBehavior';
+export { $selectedText } from './tracking/textSelection';

package/dist/stores.js

@@ -0,0 +1,14 @@
+import { f as s, $ as t, h as $, a as i, d as o, b as c, g as n, i as l, j as r, e as f, c as u } from "./S_TwsxGkG8z9.js";
+export {
+  s as $activity,
+  t as $config,
+  $ as $currentTab,
+  i as $eventQueue,
+  o as $isContextReady,
+  c as $lifetimePageCount,
+  n as $pageLifecycle,
+  l as $scrollBehavior,
+  r as $selectedText,
+  f as $session,
+  u as $totalEventCount
+};

package/dist/tracking/activity.d.ts

@@ -0,0 +1,21 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Activity state interface.
+ */
+interface IActivityState {
+    status: "active" | "idle";
+    seconds: number;
+}
+/**
+ * Reactive store for user activity.
+ */
+declare const $activity: import('nanostores').PreinitializedMapStore<IActivityState> & object;
+/**
+ * Initialize activity tracking.
+ *
+ * @param instance - Analytics instance
+ * @returns Cleanup function
+ */
+declare const initActivityTracker: (instance: AnalyticsInstance) => () => void;
+declare const getActivityStatus: () => IActivityState;
+export { $activity, initActivityTracker, getActivityStatus };

package/dist/tracking/bounce.d.ts

@@ -0,0 +1,24 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Page lifecycle states.
+ */
+declare enum LifecycleState {
+    ACTIVE = "active",
+    PASSIVE = "passive",
+    HIDDEN = "hidden",
+    FROZEN = "frozen",
+    TERMINATED = "terminated"
+}
+/**
+ * Reactive store for the current page lifecycle state.
+ */
+declare const $pageLifecycle: import('nanostores').PreinitializedWritableAtom<LifecycleState> & object;
+/**
+ * Initialize bounce tracking.
+ *
+ * @param instance - Analytics instance
+ * @param options - Configuration options (e.g., page ID)
+ * @returns Cleanup function
+ */
+declare const initBounceTracker: (instance: AnalyticsInstance) => () => void;
+export { $pageLifecycle, initBounceTracker, LifecycleState };

package/dist/tracking/clicks.d.ts

@@ -0,0 +1,9 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Create a clicks tracker instance.
+ *
+ * @param instance - Analytics instance for tracking events
+ * @returns Cleanup function
+ */
+declare const initClicksTracker: (instance: AnalyticsInstance) => () => void;
+export { initClicksTracker };

package/dist/tracking/clipboard.d.ts

@@ -0,0 +1,8 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Initialize clipboard tracking.
+ *
+ * @param instance - Analytics instance
+ * @returns Cleanup function
+ */
+export declare const initClipboardTracker: (instance: AnalyticsInstance) => () => void;

package/dist/tracking/currentTab.d.ts

@@ -0,0 +1,16 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Reactive store for the local unique tab ID.
+ * This ID is NOT shared across tabs (unlike the session store).
+ */
+declare const $currentTab: import('nanostores').PreinitializedWritableAtom<string | null> & object;
+/**
+ * Initialize current tab tracking.
+ * Assumes the session store is already synchronized (isReady).
+ *
+ * @param _instance - Analytics instance
+ * @returns Cleanup function
+ */
+declare const initCurrentTabTracker: (_instance: AnalyticsInstance) => () => void;
+declare const getCurrentTab: () => string | null;
+export { $currentTab, initCurrentTabTracker, getCurrentTab };

package/dist/tracking/forms.d.ts

@@ -0,0 +1,8 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Initialize form tracking.
+ *
+ * @param instance - Analytics instance
+ * @returns Cleanup function
+ */
+export declare const initFormsTracker: (instance: AnalyticsInstance) => () => void;

package/dist/tracking/page.d.ts

@@ -0,0 +1,8 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Initialize page tracking.
+ *
+ * @param instance - Analytics instance
+ * @returns Cleanup function
+ */
+export declare const initPageTracker: (instance: AnalyticsInstance) => () => void;

package/dist/tracking/scrollBehavior.d.ts

@@ -0,0 +1,21 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Scroll state interface.
+ */
+interface IScrollState {
+    depth: number;
+    speedCategory: "read" | "scan";
+    direction: "down" | "up";
+}
+/**
+ * Reactive store for scroll behavior.
+ */
+declare const $scrollBehavior: import('nanostores').PreinitializedMapStore<IScrollState> & object;
+/**
+ * Initialize scroll behavior tracking.
+ *
+ * @param instance - Analytics instance
+ * @returns Cleanup function
+ */
+declare const initScrollBehaviorTracker: (instance: AnalyticsInstance) => () => void;
+export { $scrollBehavior, initScrollBehaviorTracker };

package/dist/tracking/textSelection.d.ts

@@ -0,0 +1,13 @@
+import { AnalyticsInstance } from 'analytics';
+/**
+ * Reactive store for the currently selected text.
+ */
+declare const $selectedText: import('nanostores').PreinitializedWritableAtom<string | null> & object;
+/**
+ * Initialize text selection tracking.
+ *
+ * @param instance - Analytics instance
+ * @returns Cleanup function
+ */
+declare const initTextSelectionTracker: (instance: AnalyticsInstance) => () => void;
+export { $selectedText, initTextSelectionTracker };

package/dist/types/analytics.d.ts

@@ -0,0 +1,4 @@
+import { ILevoAudience } from '@levo-so/core';
+export type { AnalyticsEventType, ILevoAudience } from '@levo-so/core';
+export { AnalyticsEvents } from '@levo-so/core';
+export type TrackFn = <T extends ILevoAudience.Properties>(event: ILevoAudience.Properties["event"] & string, properties: T & ILevoAudience.Properties) => Promise<void>;

package/dist/types/identity.d.ts

@@ -0,0 +1,12 @@
+import { ILevoAudience } from '@levo-so/core';
+export type IIdentityReferrer = ILevoAudience.Traits["referrer"] & {
+    raw: string;
+};
+export interface IIdentity {
+    locale: ILevoAudience.Traits["locale"] | null;
+    timezone: ILevoAudience.Traits["timezone"] | null;
+    darkMode: ILevoAudience.Traits["dark_mode"] | null;
+    privateMode: ILevoAudience.Traits["private_mode"] | null;
+    referrer: IIdentityReferrer | null;
+    properties: ILevoAudience.Traits["properties"] | null;
+}

package/dist/types/options.d.ts

@@ -0,0 +1,14 @@
+export interface IInsightOptions {
+    insightsUrl: string;
+    /** Site ID for analytics tracking */
+    site?: string | null;
+    /** Page ID for analytics tracking */
+    pageId?: string | null;
+    /** Direct insights API URL for third-party mode (when reverse proxy unavailable) */
+    directInsightsUrl?: string;
+    /** Insights mode: 'auto' (default) detects via ping, 'proxy' forces reverse proxy, 'direct' forces direct API */
+    mode?: "auto" | "proxy" | "direct";
+    /** Timeout for proxy ping detection in ms (default: 3000) */
+    pingTimeout?: number;
+    debug?: boolean;
+}

package/dist/utils/autocapture.d.ts

@@ -0,0 +1,22 @@
+export declare const isTextNode: (el: Element | undefined | null) => el is HTMLElement;
+export declare const makeSafeText: (s: string | null | undefined, length?: number) => string;
+export declare const getSafeText: (el: Element) => string;
+export declare const getEventTarget: (e: Event) => Element | null;
+export declare const shouldCaptureDomEvent: (el: Element, event: Event) => boolean;
+export declare const shouldCaptureValue: (value: string, anchorRegexes?: boolean) => boolean;
+export declare const isAngularStyleAttr: (attributeName: string) => boolean;
+export declare const getDirectAndNestedSpanText: (target: Element) => string;
+export type Property = any;
+export type Properties = Record<string, Property>;
+/** Text source indicates where the text was found */
+export type TextSource = "text" | "aria-label" | "title" | "data-track-label" | "alt" | "placeholder" | "innerText" | "none";
+/**
+ * Get element text with comprehensive fallback chain.
+ * Priority: direct text → aria-label → title → data-track-label → alt (for images) → placeholder → innerText
+ */
+export declare const getElementTextWithFallback: (el: Element) => {
+    text: string;
+    source: TextSource;
+};
+export declare const getAttributes: (element: Element) => Properties;
+export declare const getPropertiesFromEvent: (e: Event, eventName: string) => Properties | null;

package/dist/utils/checkLocalStorage.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if localStorage is available (SSR-safe).
+ */
+export declare const checkLocalStorageAvailable: () => boolean;

package/dist/utils/createPlugin.d.ts

@@ -0,0 +1,66 @@
+import { STORAGE_KEYS } from '../constants/storageKeys';
+import { AnalyticsEventType, ILevoAudience } from '../types/analytics';
+export interface PluginContext {
+    workspace: string;
+    insightsUrl: string;
+    site?: string | null;
+    session: {
+        get: () => string;
+        set: (v: string) => void;
+    };
+    device: {
+        get: () => string;
+        set: (v: string) => void;
+    };
+    isIdentified: {
+        get: () => boolean;
+        set: (v: boolean) => void;
+    };
+    pendingIdentify: {
+        get: () => boolean;
+        set: (v: boolean) => void;
+    };
+    insightsMode: {
+        get: () => "proxy" | "direct";
+    };
+    getCurrentTabId: () => string;
+    getTabCount: () => number;
+    queueEvent: (event: ILevoAudience.CollectInput) => void;
+    broadcastSession: () => void;
+    request: <R, T>(url: string, data: T) => Promise<R | null>;
+    setInStorage: (key: string, value: string) => void;
+    resetEventCount: () => void;
+    storage_keys: typeof STORAGE_KEYS;
+    properties: ILevoAudience.Properties;
+    track: (event: AnalyticsEventType, props: any) => void;
+    debugEvents?: {
+        input: Partial<ILevoAudience.CollectInput>;
+        payload: ILevoAudience.CollectInput;
+        queued: boolean;
+    }[];
+}
+/**
+ * Factory function to create the analytics plugin.
+ * Extracted from initiate() to improve maintainability.
+ */
+export declare const createPlugin: (context: PluginContext) => {
+    name: string;
+    /**
+     * Handle track events (custom events like clicks, scrolls, etc.)
+     */
+    track: ({ payload }: {
+        payload: ILevoAudience.Properties;
+    }) => void;
+    /**
+     * Handle page view events.
+     */
+    page: ({ payload }: {
+        payload: ILevoAudience.EventProperties;
+    }) => void;
+    /**
+     * Handle identify events (session establishment).
+     */
+    identify: ({ payload }: {
+        payload: ILevoAudience.EventProperties;
+    }) => void;
+};

package/dist/utils/detectMode.d.ts

@@ -0,0 +1,10 @@
+import { IInsightOptions } from '../types/options';
+type DetectionResult = {
+    mode: "proxy" | "direct";
+    url: string | null;
+};
+/**
+ * Detect the insights mode (proxy vs direct).
+ */
+export declare const detectMode: (options: IInsightOptions) => Promise<DetectionResult>;
+export {};

package/dist/utils/getAuthHeaders.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get authentication headers for direct mode.
+ * Returns empty object in proxy mode (cookies handle auth).
+ */
+export declare const getAuthHeaders: ({ deviceToken, sessionToken, mode, }: {
+    deviceToken?: string | null;
+    sessionToken?: string | null;
+    mode?: string | null;
+}) => Record<string, string>;

package/dist/utils/getReferrer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Extract referrer information for the current page.
+ *
+ * Uses @analytics/visitor-source to parse:
+ * - Referrer type (direct, organic, paid, social, etc.)
+ * - UTM parameters (source, medium, campaign, content, term)
+ * - Raw referrer URL
+ *
+ * Handles array-to-string conversion for UTM params that may come
+ * as arrays from the parser.
+ *
+ * @returns Referrer information object
+ */
+export declare const getReferrer: () => {
+    type?: undefined;
+    referrer?: undefined;
+    data?: undefined;
+    raw?: undefined;
+} | {
+    type: string;
+    referrer: Record<string, string>;
+    data: Record<string, string>;
+    raw: string;
+};

package/dist/utils/getUserProperties.d.ts

@@ -0,0 +1,7 @@
+export declare const getUserProperties: () => Promise<{
+    locale: string;
+    timezone: string;
+    dark_mode: boolean;
+    private_mode: boolean;
+    properties: Record<string, any>;
+}>;

package/dist/utils/isIncognito.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @link {https://www.npmjs.com/package/detectincognitojs}
+ */
+declare const isIncognito: () => Promise<{
+    isPrivate: boolean;
+    browserName: string;
+}>;
+export default isIncognito;

package/dist/utils/lock.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @example
+ *
+ * const lock = new LocalStorageLock("myResource");
+ * if (lock.acquireLock()) {
+ *   console.log("Lock acquired");
+ *   // Do some work...
+ *   lock.releaseLock();
+ * } else {
+ *   console.log("Lock is already held by another instance");
+ * }
+ *
+ */
+export declare class LocalStorageLock {
+    private key;
+    constructor(lockKey: string);
+    acquireLock(expiryMs?: number): boolean;
+    releaseLock(): void;
+    isLocked(expiryMs?: number): boolean;
+}

package/dist/utils/pingEndpoint.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Ping an endpoint to check if it's reachable.
+ */
+export declare const pingEndpoint: (url: string, timeout: number) => Promise<boolean>;

package/dist/utils/rageclick.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rage click detection: If mouse has not moved further than RAGE_CLICK_THRESHOLD_PX
+ * over RAGE_CLICK_CLICK_COUNT+ clicks with max RAGE_CLICK_TIMEOUT_MS between clicks,
+ * it's counted as a rage click.
+ */
+/**
+ * Check if the current click is part of a rage click sequence.
+ * Returns true for 3+ consecutive clicks within threshold.
+ *
+ * @param x - Click X coordinate
+ * @param y - Click Y coordinate
+ * @param timestamp - Click timestamp
+ * @returns True if this click completes a rage click sequence
+ */
+declare const isRageClick: (x: number, y: number, timestamp: number) => boolean;
+/**
+ * Reset the click sequence (useful for testing)
+ */
+declare const reset: () => void;
+export { isRageClick, reset };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levo-so/insights",
-  "version": "0.1.64",
+  "version": "0.1.71",
   "author": "Levo Engineering <devs@theinternetfolks.com>",
   "description": "Levo analytics",
   "type": "module",
@@ -17,15 +17,18 @@
     "@analytics/visitor-source": "0.0.7",
     "analytics": "0.8.14",
     "get-user-locale": "2.3.2",
-    "lodash-es": "4.17.21"
+    "lodash-es": "4.17.21",
+    "nanostores": "0.11.4"
   },
   "peerDependencies": {
-    "@levo-so/core": "0.1.64"
+    "@levo-so/core": "0.1.71"
   },
   "devDependencies": {
+    "@playwright/test": "1.58.2",
     "@types/lodash-es": "4.17.12",
-    "tsup": "8.2.4",
     "typescript": "5.9.3",
+    "vite": "7.2.4",
+    "vite-plugin-dts": "4.1.0",
     "@levo/ts-config": "0.0.0"
   },
   "main": "./dist/index.js",
@@ -35,14 +38,17 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./stores": {
+      "types": "./dist/stores.d.ts",
+      "default": "./dist/stores.js"
     }
   },
   "scripts": {
     "clean": "rimraf dist node_modules .turbo",
     "check-types": "tsc --noEmit",
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "demo:serve": "python3 -m http.server 8080",
-    "demo": "pnpm build && pnpm demo:serve"
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test:e2e": "playwright test"
   }
 }