autokap 1.0.6 → 1.0.7

package/dist/capture-selector-memory.d.ts

@@ -0,0 +1,26 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+export interface ScreenshotSelectorMemoryUpdate {
+    stepSignature: string;
+    selector: string;
+    source: 'agent' | 'deterministic' | 'manual';
+    success: boolean;
+}
+export declare function loadScreenshotSelectorMemory(supabase: SupabaseClient, params: {
+    projectId: string | null;
+    presetId?: string | null;
+    domain: string;
+    lang: string;
+    theme: 'light' | 'dark';
+}): Promise<Record<string, string[]>>;
+export declare function persistScreenshotSelectorMemoryUpdates(supabase: SupabaseClient, params: {
+    projectId: string | null;
+    presetId?: string | null;
+    domain: string;
+    lang: string;
+    theme: 'light' | 'dark';
+}, updates: ScreenshotSelectorMemoryUpdate[]): Promise<void>;
+export declare function extractSelectorUpdates(actions: Array<{
+    action: string;
+    params: Record<string, unknown>;
+    success: boolean;
+}>): ScreenshotSelectorMemoryUpdate[];

package/dist/capture-selector-memory.js

@@ -0,0 +1,327 @@
+const GENERIC_NAV_TOKENS = new Set([
+    'page',
+    'pages',
+    'open',
+    'view',
+    'link',
+    'button',
+    'click',
+    'menu',
+    'nav',
+    'navigation',
+    'section',
+    'screen',
+    'capture',
+    'prepare',
+    'show',
+    'the',
+    'and',
+    'for',
+    'with',
+]);
+const INTERNAL_AUTOMATION_SELECTOR_RE = /\[data-ak-[^\]]+\]|data-ak-interactive-index/i;
+function containsInternalAutomationSelector(selector) {
+    return !!selector && INTERNAL_AUTOMATION_SELECTOR_RE.test(selector);
+}
+function uniqueInOrder(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+function normalizeNavigationTokens(values) {
+    const tokens = [];
+    for (const value of values) {
+        if (!value)
+            continue;
+        const parts = value
+            .toLowerCase()
+            .split(/[^a-z0-9]+/i)
+            .map((part) => part.trim())
+            .filter((part) => part.length >= 3 && part.length <= 32 && !GENERIC_NAV_TOKENS.has(part));
+        tokens.push(...parts);
+    }
+    return uniqueInOrder(tokens).slice(0, 8);
+}
+function extractPathTokens(rawUrl) {
+    if (!rawUrl)
+        return [];
+    try {
+        const url = new URL(rawUrl);
+        return normalizeNavigationTokens(url.pathname.split('/'));
+    }
+    catch {
+        return normalizeNavigationTokens(rawUrl.split('/'));
+    }
+}
+export async function loadScreenshotSelectorMemory(supabase, params) {
+    const selectFields = 'step_signature, selector, confidence, last_success_at';
+    const grouped = {};
+    const appendRows = (rows) => {
+        for (const row of rows) {
+            const signature = String(row.step_signature ?? '').trim();
+            const selector = String(row.selector ?? '').trim();
+            if (!signature || !selector)
+                continue;
+            if (!grouped[signature])
+                grouped[signature] = [];
+            if (!grouped[signature].includes(selector)) {
+                grouped[signature].push(selector);
+            }
+        }
+    };
+    if (params.presetId) {
+        let query = supabase
+            .from('screenshot_step_memory')
+            .select(selectFields)
+            .eq('domain', params.domain)
+            .eq('preset_id', params.presetId)
+            .eq('lang', params.lang)
+            .eq('theme', params.theme)
+            .order('confidence', { ascending: false })
+            .order('last_success_at', { ascending: false })
+            .limit(200);
+        if (params.projectId) {
+            query = query.eq('project_id', params.projectId);
+        }
+        const { data } = await query;
+        if (data && data.length > 0) {
+            appendRows(data);
+            return grouped;
+        }
+    }
+    let fallbackQuery = supabase
+        .from('screenshot_step_memory')
+        .select(selectFields)
+        .eq('domain', params.domain)
+        .order('confidence', { ascending: false })
+        .order('last_success_at', { ascending: false })
+        .limit(200);
+    if (params.projectId) {
+        fallbackQuery = fallbackQuery.eq('project_id', params.projectId);
+    }
+    const { data: fallbackData } = await fallbackQuery;
+    if (fallbackData) {
+        appendRows(fallbackData);
+    }
+    return grouped;
+}
+export async function persistScreenshotSelectorMemoryUpdates(supabase, params, updates) {
+    const nowIso = new Date().toISOString();
+    const uniqueUpdates = new Map();
+    for (const update of updates) {
+        if (!update.stepSignature || !update.selector)
+            continue;
+        const key = `${update.stepSignature}|${update.selector}|${update.source}`;
+        uniqueUpdates.set(key, update);
+    }
+    for (const update of uniqueUpdates.values()) {
+        const baseQuery = supabase
+            .from('screenshot_step_memory')
+            .select('id, success_count, fail_count, confidence')
+            .eq('domain', params.domain)
+            .eq('step_signature', update.stepSignature)
+            .eq('selector', update.selector)
+            .eq('lang', params.lang)
+            .eq('theme', params.theme)
+            .limit(1);
+        const scopedQuery = params.presetId
+            ? baseQuery.eq('preset_id', params.presetId)
+            : baseQuery.is('preset_id', null);
+        const projectScopedQuery = params.projectId
+            ? scopedQuery.eq('project_id', params.projectId)
+            : scopedQuery.is('project_id', null);
+        const { data: existingRows } = await projectScopedQuery;
+        const existing = existingRows?.[0];
+        if (!existing) {
+            await supabase.from('screenshot_step_memory').insert({
+                project_id: params.projectId,
+                preset_id: params.presetId ?? null,
+                domain: params.domain,
+                lang: params.lang,
+                theme: params.theme,
+                step_signature: update.stepSignature,
+                selector: update.selector,
+                source: update.source,
+                success_count: update.success ? 1 : 0,
+                fail_count: update.success ? 0 : 1,
+                confidence: update.success ? 0.65 : 0.35,
+                last_success_at: update.success ? nowIso : null,
+                last_failure_at: update.success ? null : nowIso,
+            });
+            continue;
+        }
+        const successCount = (existing.success_count ?? 0) + (update.success ? 1 : 0);
+        const failCount = (existing.fail_count ?? 0) + (update.success ? 0 : 1);
+        const currentConfidence = existing.confidence ?? 0.5;
+        const confidence = update.success
+            ? Math.min(0.98, currentConfidence + 0.08)
+            : Math.max(0.05, currentConfidence - 0.12);
+        await supabase
+            .from('screenshot_step_memory')
+            .update({
+            success_count: successCount,
+            fail_count: failCount,
+            confidence,
+            last_success_at: update.success ? nowIso : undefined,
+            last_failure_at: update.success ? undefined : nowIso,
+        })
+            .eq('id', existing.id);
+    }
+}
+export function extractSelectorUpdates(actions) {
+    const updates = [];
+    const languageAliases = {
+        en: ['en', 'english'],
+        fr: ['fr', 'french', 'francais', 'français'],
+        de: ['de', 'german', 'deutsch'],
+        es: ['es', 'spanish', 'espanol', 'español'],
+        it: ['it', 'italian', 'italiano'],
+        pt: ['pt', 'portuguese', 'portugues', 'português'],
+    };
+    for (const action of actions) {
+        if (action.action !== 'click'
+            && action.action !== 'type_text'
+            && action.action !== 'safe_expand'
+            && action.action !== 'select_option') {
+            continue;
+        }
+        const selector = action.params.selector
+            ?? action.params.resolvedSelector
+            ?? (action.params.index !== undefined ? `[index:${action.params.index}]` : null);
+        if (!selector || selector.startsWith('[index:') || containsInternalAutomationSelector(selector)) {
+            continue;
+        }
+        const text = String(action.params.text ?? '').toLowerCase();
+        const label = String(action.params.elementLabel ?? '').toLowerCase();
+        const optionLabel = String(action.params.optionLabel ?? '').toLowerCase();
+        const optionValue = String(action.params.optionValue ?? '').toLowerCase();
+        const href = String(action.params.href ?? '').toLowerCase();
+        const selectorLower = selector.toLowerCase();
+        const combined = `${selectorLower} ${text} ${label} ${optionLabel} ${optionValue} ${href}`;
+        if (combined.includes('login')
+            || combined.includes('sign in')
+            || combined.includes('signin')
+            || combined.includes('password')
+            || combined.includes('email')
+            || combined.includes('auth')) {
+            updates.push({
+                stepSignature: action.action === 'type_text'
+                    ? combined.includes('password')
+                        ? 'login:password_field'
+                        : 'login:email_field'
+                    : 'login:submit',
+                selector,
+                source: 'agent',
+                success: action.success,
+            });
+        }
+        if (action.action === 'type_text'
+            && (combined.includes('search') || combined.includes('query'))) {
+            updates.push({
+                stepSignature: 'search:field',
+                selector,
+                source: 'agent',
+                success: action.success,
+            });
+        }
+        if ((action.action === 'click' || action.action === 'safe_expand')
+            && (combined.includes('menu') || combined.includes('navigation') || combined.includes('hamburger') || combined.includes('drawer'))) {
+            updates.push({
+                stepSignature: 'menu:primary',
+                selector,
+                source: 'agent',
+                success: action.success,
+            });
+        }
+        if ((action.action === 'click' || action.action === 'safe_expand')
+            && (combined.includes('account') || combined.includes('profile') || combined.includes('avatar') || combined.includes('user'))) {
+            updates.push({
+                stepSignature: 'account:menu',
+                selector,
+                source: 'agent',
+                success: action.success,
+            });
+        }
+        const languageLike = combined.includes('lang')
+            || combined.includes('locale')
+            || combined.includes('language')
+            || Object.values(languageAliases).some((aliases) => aliases.some((alias) => combined.includes(alias)));
+        if (languageLike) {
+            updates.push({
+                stepSignature: 'lang:switcher',
+                selector,
+                source: 'agent',
+                success: action.success,
+            });
+            for (const [langCode, aliases] of Object.entries(languageAliases)) {
+                if (aliases.some((alias) => combined.includes(alias))) {
+                    updates.push({
+                        stepSignature: `lang:option:${langCode}`,
+                        selector,
+                        source: 'agent',
+                        success: action.success,
+                    });
+                    break;
+                }
+            }
+        }
+        if (action.action === 'click' || action.action === 'safe_expand' || action.action === 'select_option') {
+            for (const token of extractPathTokens(String(action.params.href ?? '')).slice(0, 4)) {
+                updates.push({
+                    stepSignature: `nav:path:${token}`,
+                    selector,
+                    source: 'agent',
+                    success: action.success,
+                });
+            }
+            for (const token of normalizeNavigationTokens([
+                action.params.elementLabel,
+                action.params.optionLabel,
+            ]).slice(0, 4)) {
+                updates.push({
+                    stepSignature: `nav:label:${token}`,
+                    selector,
+                    source: 'agent',
+                    success: action.success,
+                });
+            }
+        }
+        const themeLike = combined.includes('theme')
+            || combined.includes('appearance')
+            || combined.includes('dark')
+            || combined.includes('light')
+            || combined.includes('mode');
+        if (themeLike) {
+            updates.push({
+                stepSignature: 'theme:toggle',
+                selector,
+                source: 'agent',
+                success: action.success,
+            });
+            if (combined.includes('dark')) {
+                updates.push({
+                    stepSignature: 'theme:option:dark',
+                    selector,
+                    source: 'agent',
+                    success: action.success,
+                });
+            }
+            if (combined.includes('light')) {
+                updates.push({
+                    stepSignature: 'theme:option:light',
+                    selector,
+                    source: 'agent',
+                    success: action.success,
+                });
+            }
+        }
+    }
+    return updates;
+}
+//# sourceMappingURL=capture-selector-memory.js.map

package/dist/capture-session-profile-encryption.d.ts

@@ -0,0 +1,2 @@
+export declare function encryptSessionField(value: unknown): unknown;
+export declare function decryptSessionField<T>(value: unknown): T | undefined;

package/dist/capture-session-profile-encryption.js

@@ -0,0 +1,22 @@
+import { decrypt, encrypt, isEncryptedEnvelope } from './capture-encryption.js';
+function getSecret() {
+    const secret = process.env.SESSION_PROFILE_ENCRYPTION_SECRET;
+    if (!secret) {
+        throw new Error('Missing SESSION_PROFILE_ENCRYPTION_SECRET for session profile encryption');
+    }
+    return secret;
+}
+export function encryptSessionField(value) {
+    if (!value)
+        return value;
+    return encrypt(JSON.stringify(value), getSecret());
+}
+export function decryptSessionField(value) {
+    if (!value)
+        return undefined;
+    if (isEncryptedEnvelope(value)) {
+        return JSON.parse(decrypt(value, getSecret()));
+    }
+    return value;
+}
+//# sourceMappingURL=capture-session-profile-encryption.js.map

package/dist/capture-step-timeout.d.ts

@@ -0,0 +1,10 @@
+export declare class CaptureStepTimeoutError extends Error {
+    readonly timeoutMs: number;
+    readonly stepLabel: string;
+    constructor(stepLabel: string, timeoutMs: number);
+}
+export declare function isCaptureStepTimeoutError(error: unknown): error is CaptureStepTimeoutError;
+export declare function withCaptureStepTimeout<T>(work: () => Promise<T>, params: {
+    stepLabel: string;
+    timeoutMs: number;
+}): Promise<T>;

package/dist/capture-step-timeout.js

@@ -0,0 +1,30 @@
+export class CaptureStepTimeoutError extends Error {
+    timeoutMs;
+    stepLabel;
+    constructor(stepLabel, timeoutMs) {
+        super(`Timed out after ${timeoutMs}ms while ${stepLabel}.`);
+        this.name = "CaptureStepTimeoutError";
+        this.stepLabel = stepLabel;
+        this.timeoutMs = timeoutMs;
+    }
+}
+export function isCaptureStepTimeoutError(error) {
+    return error instanceof CaptureStepTimeoutError;
+}
+export async function withCaptureStepTimeout(work, params) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new CaptureStepTimeoutError(params.stepLabel, params.timeoutMs));
+        }, params.timeoutMs);
+        void work()
+            .then((result) => {
+            clearTimeout(timer);
+            resolve(result);
+        })
+            .catch((error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+//# sourceMappingURL=capture-step-timeout.js.map

package/dist/capture-studio-sync.d.ts

@@ -0,0 +1,22 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+type StudioBrowserBarConfig = {
+    url?: string;
+    pageTitle?: string;
+    tabIconUrl?: string;
+} | null | undefined;
+export declare function syncStudioVariantAfterCapture(params: {
+    supabase: SupabaseClient;
+    projectId: string;
+    presetId: string;
+    targetId?: string | null;
+    lang: string;
+    theme: string;
+    elementName: string | null;
+    captureId: string;
+    screenshotUrl: string | null;
+    rawScreenshotUrl?: string | null;
+    deviceFrame?: string | null;
+    browserBar?: StudioBrowserBarConfig;
+    matchTargetId?: boolean;
+}): Promise<void>;
+export {};

package/dist/capture-studio-sync.js

@@ -0,0 +1,166 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getNullableString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+function mergeStudioMockupConfig(existingConfig, deviceFrame, browserBar, rawScreenshotUrl) {
+    const normalizedBrowserBar = browserBar && Object.keys(browserBar).length > 0
+        ? {
+            ...(browserBar.url ? { url: browserBar.url } : {}),
+            ...(browserBar.pageTitle ? { pageTitle: browserBar.pageTitle } : {}),
+            ...(browserBar.tabIconUrl ? { tabIconUrl: browserBar.tabIconUrl } : {}),
+        }
+        : null;
+    const normalizedFrame = deviceFrame ?? null;
+    const normalizedRawUrl = rawScreenshotUrl ?? null;
+    const base = isRecord(existingConfig) ? { ...existingConfig } : {};
+    if (normalizedFrame) {
+        base.deviceFrame = normalizedFrame;
+    }
+    else {
+        delete base.deviceFrame;
+    }
+    if (normalizedRawUrl) {
+        base.rawScreenshotUrl = normalizedRawUrl;
+    }
+    else {
+        delete base.rawScreenshotUrl;
+    }
+    if (normalizedBrowserBar) {
+        base.browserBar = normalizedBrowserBar;
+    }
+    else {
+        delete base.browserBar;
+    }
+    return Object.keys(base).length > 0 ? base : null;
+}
+export async function syncStudioVariantAfterCapture(params) {
+    const { supabase, projectId, presetId, targetId = null, lang, theme, elementName, captureId, screenshotUrl, rawScreenshotUrl = null, deviceFrame = null, browserBar, matchTargetId = true, } = params;
+    if (!projectId || !presetId || !screenshotUrl) {
+        return;
+    }
+    let linkSelect = supabase
+        .from('screenshot_links')
+        .select('id, latest_capture:captures!latest_capture_id(screenshot_url, raw_screenshot_url)')
+        .eq('preset_id', presetId)
+        .eq('lang', lang)
+        .eq('theme', theme);
+    if (matchTargetId && targetId) {
+        linkSelect = linkSelect.eq('target_id', targetId);
+    }
+    if (elementName !== null) {
+        linkSelect = linkSelect.eq('element_name', elementName);
+    }
+    else {
+        linkSelect = linkSelect.is('element_name', null);
+    }
+    const { data: existingLinks, error: linkSelectError } = await linkSelect;
+    if (linkSelectError) {
+        console.error('[capture] failed to load screenshot links for studio sync:', linkSelectError.message);
+        return;
+    }
+    let linkUpdate = supabase
+        .from('screenshot_links')
+        .update({ latest_capture_id: captureId })
+        .eq('preset_id', presetId)
+        .eq('lang', lang)
+        .eq('theme', theme);
+    if (matchTargetId && targetId) {
+        linkUpdate = linkUpdate.eq('target_id', targetId);
+    }
+    if (elementName !== null) {
+        linkUpdate = linkUpdate.eq('element_name', elementName);
+    }
+    else {
+        linkUpdate = linkUpdate.is('element_name', null);
+    }
+    const { error: linkUpdateError } = await linkUpdate;
+    if (linkUpdateError) {
+        console.error('[capture] failed to update screenshot links:', linkUpdateError.message);
+        return;
+    }
+    const previousUrls = new Set();
+    for (const link of existingLinks ?? []) {
+        const latestCapture = isRecord(link.latest_capture) ? link.latest_capture : null;
+        const previousScreenshotUrl = getNullableString(latestCapture?.screenshot_url);
+        const previousRawScreenshotUrl = getNullableString(latestCapture?.raw_screenshot_url);
+        if (previousScreenshotUrl)
+            previousUrls.add(previousScreenshotUrl);
+        if (previousRawScreenshotUrl)
+            previousUrls.add(previousRawScreenshotUrl);
+    }
+    const { data: compositions, error: compositionsError } = await supabase
+        .from('compositions')
+        .select('id, pages')
+        .eq('project_id', projectId);
+    if (compositionsError) {
+        console.error('[capture] failed to load compositions for studio sync:', compositionsError.message);
+        return;
+    }
+    for (const composition of compositions ?? []) {
+        const pages = Array.isArray(composition.pages) ? composition.pages : [];
+        let changed = false;
+        const nextPages = pages.map((page) => {
+            if (!isRecord(page) || !isRecord(page.screenshot)) {
+                return page;
+            }
+            const screenshot = page.screenshot;
+            if (getNullableString(screenshot.presetId) !== presetId) {
+                return page;
+            }
+            const currentTargetId = getNullableString(screenshot.targetId);
+            const currentLang = getNullableString(screenshot.lang);
+            const currentTheme = getNullableString(screenshot.theme);
+            const currentElementName = getNullableString(screenshot.elementName);
+            const currentScreenshotUrl = getNullableString(screenshot.screenshotUrl);
+            const currentRawScreenshotUrl = getNullableString(screenshot.rawScreenshotUrl);
+            const targetMatches = !matchTargetId || !targetId || currentTargetId === targetId;
+            const exactMatch = targetMatches
+                && currentLang === lang
+                && currentTheme === theme
+                && currentElementName === elementName;
+            const legacyMatch = (!currentTargetId || !currentLang || !currentTheme)
+                && (currentElementName === null || currentElementName === elementName)
+                && ((currentScreenshotUrl !== null && previousUrls.has(currentScreenshotUrl))
+                    || (currentRawScreenshotUrl !== null && previousUrls.has(currentRawScreenshotUrl)));
+            if (!exactMatch && !legacyMatch) {
+                return page;
+            }
+            const nextMockupConfig = mergeStudioMockupConfig(screenshot.mockupConfig, deviceFrame, browserBar, rawScreenshotUrl);
+            const nextScreenshot = {
+                ...screenshot,
+                presetId,
+                captureId,
+                targetId: targetId ?? currentTargetId,
+                lang,
+                theme,
+                elementName,
+                screenshotUrl,
+                rawScreenshotUrl,
+            };
+            if (nextMockupConfig) {
+                nextScreenshot.mockupConfig = nextMockupConfig;
+            }
+            if (JSON.stringify(nextScreenshot) === JSON.stringify(screenshot)) {
+                return page;
+            }
+            changed = true;
+            return {
+                ...page,
+                screenshot: nextScreenshot,
+            };
+        });
+        if (!changed) {
+            continue;
+        }
+        const { error: compositionUpdateError } = await supabase
+            .from('compositions')
+            .update({ pages: nextPages })
+            .eq('id', composition.id);
+        if (compositionUpdateError) {
+            console.error(`[capture] failed to sync composition ${composition.id} with latest capture:`, compositionUpdateError.message);
+        }
+    }
+}
+//# sourceMappingURL=capture-studio-sync.js.map

package/dist/capture-variant-state.d.ts

@@ -0,0 +1,54 @@
+import type { CaptureCheckpoint, CapturePageIdentity, VariantCaptureRepairRecord, VariantCaptureManifest, VariantCaptureStatus, VariantValidatedCapture } from "./types.js";
+import type { ScreenshotPageRunInput } from "./capture-run-optimizer.js";
+export interface VariantCaptureState {
+    expectedPageIds: string[];
+    pageIdentities: Record<string, CapturePageIdentity>;
+    validatedCaptures: VariantValidatedCapture[];
+    captureStatuses: Record<string, VariantCaptureStatus>;
+    lastCheckpointId: string | null;
+    blockedReasons: Record<string, string | null>;
+    recoveryAttempts: Record<string, number>;
+    repairHistory: VariantCaptureRepairRecord[];
+}
+export declare function createVariantCaptureState(pageRuns: ScreenshotPageRunInput[], precomputedIdentities?: Record<string, CapturePageIdentity>): VariantCaptureState;
+export declare function buildVariantManifestContext(params: {
+    state: VariantCaptureState;
+    currentPageRun: ScreenshotPageRunInput;
+}): VariantCaptureManifest;
+export declare function recordValidatedVariantCapture(params: {
+    state: VariantCaptureState;
+    capture: VariantValidatedCapture;
+    checkpointId?: string | null;
+}): {
+    state: VariantCaptureState;
+    duplicateOfPageId: string | null;
+};
+export declare function validateVariantCaptureState(state: VariantCaptureState): {
+    ok: boolean;
+    missingPages: string[];
+    blockedPages: Array<{
+        pageId: string;
+        reason: string | null;
+    }>;
+    duplicatePageIds: Array<{
+        pageId: string;
+        duplicateOfPageId: string;
+    }>;
+};
+export declare function hasValidatedVariantPage(state: VariantCaptureState, pageId: string | null | undefined): boolean;
+export declare function getVariantCaptureStatus(state: VariantCaptureState, pageId: string | null | undefined): VariantCaptureStatus;
+export declare function markVariantCaptureInProgress(state: VariantCaptureState, pageId: string | null | undefined): VariantCaptureState;
+export declare function markVariantCaptureBlocked(params: {
+    state: VariantCaptureState;
+    pageId: string | null | undefined;
+    reason: string;
+}): VariantCaptureState;
+export declare function recordVariantRecoveryAttempt(state: VariantCaptureState, pageId: string | null | undefined): VariantCaptureState;
+export declare function recordVariantRepair(params: {
+    state: VariantCaptureState;
+    repair: VariantCaptureRepairRecord;
+}): VariantCaptureState;
+export declare function recordVariantCheckpoint(params: {
+    state: VariantCaptureState;
+    checkpoint: CaptureCheckpoint;
+}): VariantCaptureState;