autokap 1.0.7 → 1.0.10

package/dist/cost-logging.js

@@ -1,49 +1,88 @@
+function isFiniteInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value);
+}
+function normalizeUsageForCostLog(step, index) {
+    const normalizedStepNumber = isFiniteInteger(step.stepNumber) && step.stepNumber >= 0
+        ? step.stepNumber
+        : index + 1;
+    const normalizedStepType = typeof step.stepType === 'string' && step.stepType.trim().length > 0
+        ? step.stepType
+        : 'agent_iteration';
+    const normalizedModelRequested = typeof step.modelRequested === 'string' && step.modelRequested.trim().length > 0
+        ? step.modelRequested
+        : step.modelUsed ?? 'unknown';
+    const normalizedImagesInPrompt = typeof step.imagesInPrompt === 'number' && Number.isFinite(step.imagesInPrompt)
+        ? step.imagesInPrompt
+        : 0;
+    if (normalizedStepNumber !== step.stepNumber
+        || normalizedStepType !== step.stepType
+        || normalizedModelRequested !== step.modelRequested
+        || normalizedImagesInPrompt !== step.imagesInPrompt) {
+        console.warn('Normalizing invalid cost log usage entry:', JSON.stringify({
+            stepNumber: step.stepNumber ?? null,
+            stepType: step.stepType ?? null,
+            modelRequested: step.modelRequested ?? null,
+            modelUsed: step.modelUsed ?? null,
+            fallbackStepNumber: normalizedStepNumber,
+        }));
+    }
+    return {
+        ...step,
+        stepNumber: normalizedStepNumber,
+        stepType: normalizedStepType,
+        modelRequested: normalizedModelRequested,
+        imagesInPrompt: normalizedImagesInPrompt,
+    };
+}
 export async function insertCostLogs(supabase, ctx, steps) {
     if (steps.length === 0)
         return [];
-    const rows = steps.map((step) => ({
-        id: crypto.randomUUID(),
-        run_id: ctx.runId,
-        user_id: ctx.userId,
-        project_id: ctx.projectId ?? null,
-        preset_id: ctx.presetId ?? null,
-        capture_id: ctx.captureId ?? null,
-        step_number: step.stepNumber,
-        step_type: step.stepType,
-        model_requested: step.modelRequested,
-        model_used: step.modelUsed,
-        generation_id: step.generationId,
-        prompt_tokens: step.promptTokens,
-        completion_tokens: step.completionTokens,
-        total_tokens: step.totalTokens,
-        cost_resolved: false,
-        images_in_prompt: step.imagesInPrompt,
-        lang: ctx.lang ?? null,
-        theme: ctx.theme ?? null,
-        capture_type: ctx.captureType ?? null,
-        element_name: ctx.elementName ?? null,
-        target_id: ctx.targetId ?? null,
-        viewport_width: ctx.viewportWidth ?? null,
-        viewport_height: ctx.viewportHeight ?? null,
-        system_prompt_chars: step.systemPromptChars ?? null,
-        tool_schema_chars: step.toolSchemaChars ?? null,
-        user_payload_chars: step.userPayloadChars ?? null,
-        accessibility_chars: step.accessibilityChars ?? null,
-        interactive_element_count: step.interactiveElementCount ?? null,
-        action_history_count: step.actionHistoryCount ?? null,
-        elements_chars: step.elementsChars ?? null,
-        session_summary_chars: step.sessionSummaryChars ?? null,
-        selector_memory_chars: step.selectorMemoryChars ?? null,
-        agent_context_chars: step.agentContextChars ?? null,
-        profile_validation_status: step.profileValidationStatus ?? null,
-        session_profile_source: step.sessionProfileSource ?? null,
-        repair_path_used: step.repairPathUsed ?? null,
-        evaluator_used: step.evaluatorUsed ?? false,
-        cache_read_tokens: step.cacheReadTokens ?? null,
-        cache_write_tokens: step.cacheWriteTokens ?? null,
-        session_profile_reused: step.sessionProfileReused ?? false,
-        action_replay_used: step.actionReplayUsed ?? false,
-    }));
+    const rows = steps.map((rawStep, index) => {
+        const step = normalizeUsageForCostLog(rawStep, index);
+        return {
+            id: crypto.randomUUID(),
+            run_id: ctx.runId,
+            user_id: ctx.userId,
+            project_id: ctx.projectId ?? null,
+            preset_id: ctx.presetId ?? null,
+            capture_id: ctx.captureId ?? null,
+            step_number: step.stepNumber,
+            step_type: step.stepType,
+            model_requested: step.modelRequested,
+            model_used: step.modelUsed,
+            generation_id: step.generationId,
+            prompt_tokens: step.promptTokens,
+            completion_tokens: step.completionTokens,
+            total_tokens: step.totalTokens,
+            cost_resolved: false,
+            images_in_prompt: step.imagesInPrompt,
+            lang: ctx.lang ?? null,
+            theme: ctx.theme ?? null,
+            capture_type: ctx.captureType ?? null,
+            element_name: ctx.elementName ?? null,
+            target_id: ctx.targetId ?? null,
+            viewport_width: ctx.viewportWidth ?? null,
+            viewport_height: ctx.viewportHeight ?? null,
+            system_prompt_chars: step.systemPromptChars ?? null,
+            tool_schema_chars: step.toolSchemaChars ?? null,
+            user_payload_chars: step.userPayloadChars ?? null,
+            accessibility_chars: step.accessibilityChars ?? null,
+            interactive_element_count: step.interactiveElementCount ?? null,
+            action_history_count: step.actionHistoryCount ?? null,
+            elements_chars: step.elementsChars ?? null,
+            session_summary_chars: step.sessionSummaryChars ?? null,
+            selector_memory_chars: step.selectorMemoryChars ?? null,
+            agent_context_chars: step.agentContextChars ?? null,
+            profile_validation_status: step.profileValidationStatus ?? null,
+            session_profile_source: step.sessionProfileSource ?? null,
+            repair_path_used: step.repairPathUsed ?? null,
+            evaluator_used: step.evaluatorUsed ?? false,
+            cache_read_tokens: step.cacheReadTokens ?? null,
+            cache_write_tokens: step.cacheWriteTokens ?? null,
+            session_profile_reused: step.sessionProfileReused ?? false,
+            action_replay_used: step.actionReplayUsed ?? false,
+        };
+    });
     try {
         const { error } = await supabase.from('cost_logs').insert(rows);
         if (error) {
@@ -79,9 +118,21 @@ export async function updateCostLogCaptureContext(supabase, costLogIds, params)
     }
 }
 async function resolveCost(updateClient, generationId, costLogId, apiKey) {
-    const delays = [10_000, 20_000, 40_000];
+    const delays = [10_000, 20_000, 40_000, 80_000, 160_000];
     for (let attempt = 0; attempt < delays.length; attempt += 1) {
         await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+        // Track resolution attempt (best-effort)
+        try {
+            await updateClient
+                .from('cost_logs')
+                .update({
+                resolution_attempts: attempt + 1,
+                last_resolution_attempt_at: new Date().toISOString(),
+                cost_resolution_status: 'pending',
+            })
+                .eq('id', costLogId);
+        }
+        catch { /* best-effort tracking */ }
         try {
             const response = await fetch(`https://openrouter.ai/api/v1/generation?id=${generationId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
             if (response.status === 404 && attempt < delays.length - 1) {
@@ -89,13 +140,19 @@ async function resolveCost(updateClient, generationId, costLogId, apiKey) {
             }
             if (!response.ok) {
                 console.error(`OpenRouter generation lookup failed (${generationId}): HTTP ${response.status}`);
-                return;
+                if (attempt === delays.length - 1) {
+                    await markCostResolutionFailed(updateClient, costLogId, `HTTP ${response.status}`);
+                }
+                continue;
             }
             const generation = await response.json();
             const totalCost = generation.data?.total_cost ?? null;
             if (totalCost == null) {
                 console.warn(`OpenRouter returned no total_cost for generation ${generationId}`);
-                return;
+                if (attempt === delays.length - 1) {
+                    await markCostResolutionFailed(updateClient, costLogId, 'no total_cost in response');
+                }
+                continue;
             }
             const { error } = await updateClient
                 .from('cost_logs')
@@ -103,6 +160,7 @@ async function resolveCost(updateClient, generationId, costLogId, apiKey) {
                 cost_usd: totalCost,
                 cost_resolved: true,
                 resolved_at: new Date().toISOString(),
+                cost_resolution_status: 'resolved',
             })
                 .eq('id', costLogId);
             if (error) {
@@ -113,10 +171,66 @@ async function resolveCost(updateClient, generationId, costLogId, apiKey) {
         catch (error) {
             if (attempt === delays.length - 1) {
                 console.error(`Cost resolution failed for ${generationId}:`, error.message);
+                await markCostResolutionFailed(updateClient, costLogId, error.message);
             }
         }
     }
 }
+async function markCostResolutionFailed(updateClient, costLogId, reason) {
+    try {
+        await updateClient
+            .from('cost_logs')
+            .update({ cost_resolution_status: 'failed' })
+            .eq('id', costLogId);
+        console.error(`Cost resolution marked as failed for ${costLogId}: ${reason}`);
+    }
+    catch {
+        // best-effort — don't fail the caller
+    }
+}
+/**
+ * Retry resolution for previously failed cost logs.
+ * Designed to be called by a reconciliation cron job.
+ */
+export async function reconcileUnresolvedCosts(supabase, apiKey) {
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const { data: failedLogs, error } = await supabase
+        .from('cost_logs')
+        .select('id, generation_id')
+        .eq('cost_resolution_status', 'failed')
+        .gt('created_at', sevenDaysAgo)
+        .not('generation_id', 'is', null)
+        .limit(100);
+    if (error || !failedLogs?.length) {
+        return { retried: 0, resolved: 0 };
+    }
+    let resolved = 0;
+    for (const log of failedLogs) {
+        try {
+            const response = await fetch(`https://openrouter.ai/api/v1/generation?id=${log.generation_id}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+            if (!response.ok)
+                continue;
+            const generation = await response.json();
+            const totalCost = generation.data?.total_cost ?? null;
+            if (totalCost == null)
+                continue;
+            await supabase
+                .from('cost_logs')
+                .update({
+                cost_usd: totalCost,
+                cost_resolved: true,
+                resolved_at: new Date().toISOString(),
+                cost_resolution_status: 'resolved',
+            })
+                .eq('id', log.id);
+            resolved += 1;
+        }
+        catch {
+            // skip this entry, will be retried next run
+        }
+    }
+    return { retried: failedLogs.length, resolved };
+}
 export function resolveAllCosts(supabase, entries, apiKey, serviceClient) {
     const toResolve = entries.filter((entry) => entry.generationId != null);
     if (toResolve.length === 0) {

package/dist/cost-resolution-monitor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cost resolution monitoring — exposes metrics for alerting
+ * when the failure rate of OpenRouter cost lookups exceeds thresholds.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+export interface CostResolutionStats {
+    /** Number of cost logs with status 'failed' in the last hour. */
+    failedLastHour: number;
+    /** Total cost logs created in the last hour. */
+    totalLastHour: number;
+    /** Failure rate as a percentage (0-100). */
+    failureRate: number;
+    /** Number of cost logs still pending (older than 5 minutes). */
+    stalePending: number;
+}
+export declare function getCostResolutionStats(supabase: SupabaseClient): Promise<CostResolutionStats>;

package/dist/cost-resolution-monitor.js

@@ -0,0 +1,34 @@
+/**
+ * Cost resolution monitoring — exposes metrics for alerting
+ * when the failure rate of OpenRouter cost lookups exceeds thresholds.
+ */
+export async function getCostResolutionStats(supabase) {
+    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
+    const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+    const [failedResult, totalResult, staleResult] = await Promise.all([
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .eq('cost_resolution_status', 'failed')
+            .gt('created_at', oneHourAgo),
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .gt('created_at', oneHourAgo)
+            .not('generation_id', 'is', null),
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .eq('cost_resolution_status', 'pending')
+            .lt('created_at', fiveMinutesAgo)
+            .not('generation_id', 'is', null),
+    ]);
+    const failedLastHour = failedResult.count ?? 0;
+    const totalLastHour = totalResult.count ?? 0;
+    const stalePending = staleResult.count ?? 0;
+    const failureRate = totalLastHour > 0
+        ? Math.round((failedLastHour / totalLastHour) * 10000) / 100
+        : 0;
+    return { failedLastHour, totalLastHour, failureRate, stalePending };
+}
+//# sourceMappingURL=cost-resolution-monitor.js.map

package/dist/credential-templates.js

@@ -47,9 +47,9 @@ export function resolveActionCredentialArgs(action, args, credentials) {
     if (!credentials)
         return args;
     const resolved = { ...args };
-    if (action === "type_text" && typeof resolved.text === "string") {
+    if ((action === "type_text" || action === "type") && typeof resolved.text === "string") {
         resolved.text = resolveCredentialTemplates(resolved.text, credentials);
-        ensureNoCredentialTemplate("type_text.text", resolved.text);
+        ensureNoCredentialTemplate(`${action}.text`, resolved.text);
     }
     if (action === "navigate_to" && typeof resolved.url === "string") {
         resolved.url = resolveCredentialTemplates(resolved.url, credentials);

package/dist/cursor-overlay-script.d.ts

@@ -0,0 +1,6 @@
+import type { VideoCursorTheme } from './types.js';
+/**
+ * JavaScript injected via `context.addInitScript()` to show a visible animated
+ * cursor in Playwright video recordings (the native OS cursor is invisible).
+ */
+export declare function buildCursorOverlayScript(theme?: VideoCursorTheme): string;

package/dist/cursor-overlay-script.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+// SVG files are the single source of truth — edit web/public/cursors/*.svg directly.
+function loadCursorSvg(name) {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidatePaths = [
+        // From dist/ → ../web/public/cursors/
+        path.resolve(currentDir, '../web/public/cursors', `${name}.svg`),
+        // From package/dist/ → ../../web/public/cursors/
+        path.resolve(currentDir, '../../web/public/cursors', `${name}.svg`),
+        // Bundled alongside dist in package/assets/cursors/
+        path.resolve(currentDir, '../assets/cursors', `${name}.svg`),
+        // Fallback: same directory
+        path.resolve(currentDir, './web/public/cursors', `${name}.svg`),
+    ];
+    for (const candidatePath of candidatePaths) {
+        if (fs.existsSync(candidatePath)) {
+            return fs.readFileSync(candidatePath, 'utf-8').trim();
+        }
+    }
+    throw new Error(`Cursor asset "${name}.svg" not found. Looked in: ${candidatePaths.join(', ')}`);
+}
+const CURSOR_THEME_SVGS = {};
+function getCursorThemeSvg(theme) {
+    if (!CURSOR_THEME_SVGS[theme]) {
+        CURSOR_THEME_SVGS[theme] = loadCursorSvg(theme);
+    }
+    return CURSOR_THEME_SVGS[theme];
+}
+/**
+ * JavaScript injected via `context.addInitScript()` to show a visible animated
+ * cursor in Playwright video recordings (the native OS cursor is invisible).
+ */
+export function buildCursorOverlayScript(theme = 'minimal') {
+    const cursorSvg = theme === 'minimal' ? null : getCursorThemeSvg(theme);
+    return `
+(function() {
+  function injectCursor() {
+    if (document.getElementById('__ak_cursor__')) return;
+    const cursorTheme = ${JSON.stringify(theme)};
+    const cursorSvg = ${JSON.stringify(cursorSvg)};
+
+    const style = document.createElement('style');
+    style.textContent = [
+      '*, *::before, *::after { cursor: none !important; }',
+      '#__ak_cursor__ { mix-blend-mode: normal; }',
+      '#__ak_cursor__ svg { width: 100%; height: 100%; display: block; overflow: visible; }',
+      '#__ak_cursor__[data-theme="macos"], #__ak_cursor__[data-theme="windows"] { width: 28px !important; height: 28px !important; background: transparent !important; border: 0 !important; border-radius: 0 !important; box-shadow: none !important; }',
+      '#__ak_cursor__.__ak_pressed { transform: translate(-50%, -50%) scale(0.72) !important; box-shadow: 0 0 0 8px rgba(37, 99, 235, 0.18), 0 4px 18px rgba(0,0,0,0.28) !important; background: rgba(255,255,255,0.98) !important; border-color: rgba(30,41,59,0.92) !important; }',
+      '#__ak_cursor__[data-theme="macos"].__ak_pressed, #__ak_cursor__[data-theme="windows"].__ak_pressed { background: transparent !important; border-color: transparent !important; box-shadow: none !important; filter: drop-shadow(0 0 0 rgba(37, 99, 235, 0)) drop-shadow(0 0 0 rgba(37, 99, 235, 0)) !important; }',
+      '#__ak_cursor__[data-theme="macos"].__ak_pressed svg, #__ak_cursor__[data-theme="windows"].__ak_pressed svg { filter: drop-shadow(0 0 0.5px rgba(255,255,255,0.9)) drop-shadow(0 0 10px rgba(37, 99, 235, 0.45)); }',
+      '#__ak_cursor_click_pulse__ { position: fixed; width: 20px; height: 20px; border-radius: 9999px; pointer-events: none; z-index: 2147483646; border: 3px solid rgba(37, 99, 235, 0.75); box-shadow: 0 0 0 1px rgba(255,255,255,0.45) inset; transform: translate(-50%, -50%) scale(0.55); opacity: 0; }',
+      '#__ak_cursor_click_pulse__.__ak_active { animation: __ak_cursor_pulse__ 340ms cubic-bezier(0.16, 1, 0.3, 1) forwards; }',
+      '@keyframes __ak_cursor_pulse__ { 0% { opacity: 0.95; transform: translate(-50%, -50%) scale(0.55); } 100% { opacity: 0; transform: translate(-50%, -50%) scale(2.6); } }',
+    ].join('\\n');
+    document.head.appendChild(style);
+
+    const cursor = document.createElement('div');
+    cursor.id = '__ak_cursor__';
+    cursor.dataset.theme = cursorTheme;
+    cursor.style.cssText = [
+      'position: fixed',
+      'top: -100px',
+      'left: -100px',
+      'width: 20px',
+      'height: 20px',
+      'background: rgba(255, 255, 255, 0.95)',
+      'border: 2.5px solid rgba(0, 0, 0, 0.8)',
+      'border-radius: 50%',
+      'pointer-events: none',
+      'z-index: 2147483647',
+      'transform: translate(-50%, -50%)',
+      'box-shadow: 0 2px 8px rgba(0,0,0,0.4)',
+      'transition: transform 0.09s ease, box-shadow 0.12s ease, background 0.12s ease, border-color 0.12s ease',
+      'will-change: left, top',
+    ].join(';');
+    if (cursorSvg) cursor.innerHTML = cursorSvg;
+
+    const pulse = document.createElement('div');
+    pulse.id = '__ak_cursor_click_pulse__';
+
+    document.body.appendChild(cursor);
+    document.body.appendChild(pulse);
+
+    let pulseResetTimer = null;
+
+    function setCursorPosition(x, y) {
+      cursor.style.left = x + 'px';
+      cursor.style.top = y + 'px';
+      pulse.style.left = x + 'px';
+      pulse.style.top = y + 'px';
+    }
+
+    function triggerPulse() {
+      pulse.classList.remove('__ak_active');
+      void pulse.offsetWidth;
+      pulse.classList.add('__ak_active');
+      if (pulseResetTimer) clearTimeout(pulseResetTimer);
+      pulseResetTimer = setTimeout(function() {
+        pulse.classList.remove('__ak_active');
+      }, 380);
+    }
+
+    // CDP mouse events (page.mouse.move) don't fire DOM mousemove events in
+    // Playwright video recording. Expose global helpers so the runner can
+    // position the cursor directly via page.evaluate().
+    window.__akMoveCursor = function(x, y) { setCursorPosition(x, y); };
+    window.__akPressCursor = function() { cursor.classList.add('__ak_pressed'); };
+    window.__akReleaseCursor = function() { cursor.classList.remove('__ak_pressed'); };
+    window.__akClickPulse = function(x, y) {
+      setCursorPosition(x, y);
+      triggerPulse();
+    };
+
+    // Keep DOM event listeners as fallback for real mouse events (headed mode)
+    document.addEventListener('mousemove', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+    }, { passive: true });
+
+    window.addEventListener('mousedown', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+      cursor.classList.add('__ak_pressed');
+      triggerPulse();
+    }, true);
+    window.addEventListener('mouseup', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+      cursor.classList.remove('__ak_pressed');
+    }, true);
+    window.addEventListener('click', function(e) {
+      setCursorPosition(e.clientX, e.clientY);
+      triggerPulse();
+    }, true);
+  }
+
+  // Inject immediately and re-inject if a framework (React, Next.js, etc.)
+  // replaces the body during hydration and removes our cursor element.
+  function ensureCursor() {
+    if (!document.getElementById('__ak_cursor__')) {
+      if (document.body) injectCursor();
+    }
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', ensureCursor);
+  } else {
+    ensureCursor();
+  }
+
+  // Re-inject when frameworks replace body content during hydration.
+  var observer = new MutationObserver(function() {
+    if (document.body && !document.getElementById('__ak_cursor__')) {
+      injectCursor();
+    }
+  });
+  function startObserving() {
+    if (document.body) {
+      observer.observe(document.body, { childList: true });
+    } else {
+      document.addEventListener('DOMContentLoaded', function() {
+        observer.observe(document.body, { childList: true });
+      });
+    }
+  }
+  startObserving();
+})();
+`;
+}
+//# sourceMappingURL=cursor-overlay-script.js.map

package/dist/dom-css-purger.d.ts

@@ -0,0 +1,65 @@
+/**
+ * DOM CSS Purger — AUT-121 Interactive Demos, Phase 3
+ *
+ * Walks captured HTML, collects every tag/class/id present in the DOM, then
+ * walks each inline `<style>` block and drops CSS rules whose selectors
+ * never match any element. Designed to shrink captured DOMs by 60-80% per
+ * the Linear estimate.
+ *
+ * Conservative on purpose — better to keep a few unused bytes than break a
+ * captured layout. Specifically, the purger PRESERVES:
+ *   - All at-rules: @media, @supports, @keyframes, @font-face, @import,
+ *     @charset, @namespace, @page (passed through unchanged for the rules
+ *     inside @media/@supports, recursively pruned)
+ *   - Selectors that only contain pseudo-classes (`:hover`, `:focus`, etc.)
+ *     since they may match elements only in interactive states
+ *   - Universal selector `*`
+ *   - Attribute selectors (parsed but not validated against the DOM —
+ *     `[data-state]` would require a DOM walk to verify, kept for safety)
+ *
+ * For Phase 3 minimum viable, only inline `<style>` blocks are purged.
+ * External `<link rel="stylesheet">` files would require server-side
+ * fetching of the asset bytes — that's left to a follow-up.
+ *
+ * No regex CSS parser is perfect, but the trade-off is:
+ *  - dependency-free (we already pay for parse5 in dom-serializer)
+ *  - small footprint (~150 LOC)
+ *  - good enough for the 95% of CSS that captures produce
+ *
+ * Worst case: a malformed CSS block is left untouched.
+ */
+export interface PurgeStats {
+    /** Number of `<style>` blocks processed */
+    blocks: number;
+    /** Bytes of CSS before purging */
+    preBytes: number;
+    /** Bytes of CSS after purging */
+    postBytes: number;
+    /** Number of rules removed */
+    rulesRemoved: number;
+}
+export interface PurgeResult {
+    html: string;
+    stats: PurgeStats;
+}
+/**
+ * Walk an HTML document, find every `<style>` block, and purge each one
+ * against the set of tags/classes/ids actually present in the document.
+ */
+export declare function purgeInlineStyleBlocks(html: string): PurgeResult;
+interface DomPresence {
+    tags: Set<string>;
+    classes: Set<string>;
+    ids: Set<string>;
+}
+interface PurgedCss {
+    css: string;
+    removed: number;
+}
+/**
+ * Tokenize CSS into a flat sequence of `at-rule` / `rule` blocks and walk
+ * each rule to decide whether to keep it. At-rules are preserved verbatim
+ * — `@media`/`@supports` bodies are recursively purged.
+ */
+export declare function purgeCss(input: string, presence: DomPresence): PurgedCss;
+export {};