autokap 1.0.6 → 1.0.8

package/dist/capture-transition-engine.js

@@ -0,0 +1,292 @@
+import { evaluateSurfaceContract } from "./capture-surface-contract.js";
+import { evaluateRequestedLanguageState, evaluateRequestedThemeState, } from "./session-profile.js";
+function normalizePath(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = new URL(value);
+        const pathname = parsed.pathname.replace(/\/+$/, "") || "/";
+        return `${parsed.origin}${pathname}`;
+    }
+    catch {
+        return value.trim().replace(/\/+$/, "") || null;
+    }
+}
+function sameOrigin(left, right) {
+    if (!left || !right)
+        return false;
+    try {
+        return new URL(left).origin === new URL(right).origin;
+    }
+    catch {
+        return false;
+    }
+}
+function urlMatchesPolicy(currentUrl, targetUrl, policy) {
+    if (policy === "ignore")
+        return true;
+    if (!currentUrl || !targetUrl)
+        return false;
+    try {
+        const current = new URL(currentUrl);
+        const target = new URL(targetUrl);
+        if (current.origin !== target.origin)
+            return false;
+        if (policy === "same_origin")
+            return true;
+        const normalizedTarget = target.pathname.replace(/\/+$/, "") || "/";
+        const normalizedCurrent = current.pathname.replace(/\/+$/, "") || "/";
+        if (normalizedCurrent === normalizedTarget)
+            return true;
+        return normalizedCurrent.startsWith(`${normalizedTarget}/`);
+    }
+    catch {
+        return normalizePath(currentUrl) === normalizePath(targetUrl);
+    }
+}
+function detectLikelyAuthMismatch(signals, profile) {
+    if (!signals || profile?.authState !== "authenticated")
+        return false;
+    const hasAuthenticatedHints = (signals.authHints?.logoutButtons.length ?? 0) > 0
+        || (signals.authHints?.accountMenuLabels.length ?? 0) > 0
+        || (signals.authHints?.accountLikeText.length ?? 0) > 0;
+    const hasAnonymousHints = signals.authHints?.hasAuthForm
+        || signals.authHints?.hasPasswordField
+        || ((signals.authHints?.loginButtons.length ?? 0) > 0 && !hasAuthenticatedHints);
+    return !!hasAnonymousHints && !hasAuthenticatedHints;
+}
+function detectLikelyVariantMismatch(params) {
+    const { signals, requestedLang, requestedTheme } = params;
+    if (!signals)
+        return false;
+    const languageState = requestedLang
+        ? evaluateRequestedLanguageState({
+            currentUrl: signals.url || signals.canonicalUrl || "",
+            requestedLang,
+            signals,
+        })
+        : null;
+    const themeState = requestedTheme
+        ? evaluateRequestedThemeState({
+            requestedTheme,
+            signals,
+        })
+        : null;
+    const langMismatch = !!languageState?.requested
+        && languageState.detected !== null
+        && languageState.active === false
+        && languageState.ambiguous === false
+        && languageState.confidence === "high";
+    const themeMismatch = !!themeState?.requested
+        && themeState.detected !== null
+        && themeState.active === false
+        && themeState.ambiguous === false
+        && themeState.confidence === "high";
+    return langMismatch || themeMismatch;
+}
+export function deriveCapturePageContract(params) {
+    const identity = params.pageIdentity ?? null;
+    switch (identity?.kind) {
+        case "modal_selection":
+            return {
+                expectedSurfaceKind: "dialog_selection",
+                dialogPolicy: "must_be_open",
+                routePolicy: "same_origin",
+                reusePolicy: "verified_only",
+                variantPolicy: "must_match",
+            };
+        case "modal_configuration":
+            return {
+                expectedSurfaceKind: "dialog_configuration",
+                dialogPolicy: "must_be_open",
+                routePolicy: "same_origin",
+                reusePolicy: "verified_only",
+                variantPolicy: "must_match",
+            };
+        case "editor_route":
+            return {
+                expectedSurfaceKind: "editor_route",
+                dialogPolicy: "must_be_closed",
+                routePolicy: "exact_or_descendant",
+                reusePolicy: "same_surface_only",
+                variantPolicy: "must_match",
+            };
+        case "detail_route":
+            return {
+                expectedSurfaceKind: "detail_route",
+                dialogPolicy: identity.dedicatedRoute ? "must_be_closed" : "allow_either",
+                routePolicy: identity.dedicatedRoute ? "exact_or_descendant" : "same_origin",
+                reusePolicy: "same_surface_only",
+                variantPolicy: "must_match",
+            };
+        case "gallery":
+            return {
+                expectedSurfaceKind: "gallery",
+                dialogPolicy: identity.dialogTarget ? "must_be_open" : "must_be_closed",
+                routePolicy: identity.dedicatedRoute ? "exact_or_descendant" : "same_origin",
+                reusePolicy: "same_surface_only",
+                variantPolicy: "must_match",
+            };
+        default:
+            return {
+                expectedSurfaceKind: "route",
+                dialogPolicy: identity?.dialogTarget ? "must_be_open" : "allow_either",
+                routePolicy: identity?.dedicatedRoute ? "exact_or_descendant" : "same_origin",
+                reusePolicy: "same_surface_only",
+                variantPolicy: "prefer_match",
+            };
+    }
+}
+export function buildCaptureCheckpointEvidence(params) {
+    const contract = deriveCapturePageContract({ pageIdentity: params.pageIdentity });
+    const reasons = [];
+    const urlMatched = urlMatchesPolicy(params.currentUrl ?? params.observation.url, params.targetUrl, contract.routePolicy);
+    if (!urlMatched) {
+        reasons.push("current route does not match the target route policy");
+    }
+    const dialogMatched = contract.dialogPolicy === "allow_either"
+        ? true
+        : contract.dialogPolicy === "must_be_open"
+            ? params.observation.dialogCount > 0
+            : params.observation.dialogCount === 0;
+    if (!dialogMatched) {
+        reasons.push(contract.dialogPolicy === "must_be_open"
+            ? "expected dialog/configuration surface is not open"
+            : "unexpected dialog/overlay is still open");
+    }
+    const authMatched = !detectLikelyAuthMismatch(params.pageSignals ?? null, params.profile);
+    if (!authMatched) {
+        reasons.push("authenticated session looks degraded on the current page");
+    }
+    const variantMatched = !detectLikelyVariantMismatch({
+        signals: params.pageSignals ?? null,
+        requestedLang: params.requestedLang,
+        requestedTheme: params.requestedTheme,
+    });
+    if (!variantMatched && contract.variantPolicy === "must_match") {
+        reasons.push("current page hints do not match the requested language/theme variant");
+    }
+    const strongSurfaceObserved = !!params.observation.strongSurfaceSignature
+        && (!!params.observation.primarySurface
+            || !!params.observation.overlaySurface
+            || !!params.observation.configurationSurface);
+    if (!strongSurfaceObserved) {
+        reasons.push("current page surface is too weakly identified for a strong checkpoint");
+    }
+    const surfaceContract = evaluateSurfaceContract({
+        contract,
+        currentUrl: params.currentUrl,
+        observation: params.observation,
+        pageSignals: params.pageSignals ?? null,
+        pageIdentity: params.pageIdentity ?? null,
+    });
+    if (!surfaceContract.matched) {
+        reasons.push(surfaceContract.reason ?? "current page surface does not match the expected capture contract");
+    }
+    const evidence = {
+        urlMatched,
+        dialogMatched,
+        authMatched,
+        variantMatched: contract.variantPolicy === "ignore" ? true : variantMatched,
+        strongSurfaceObserved,
+        surfaceMatched: surfaceContract.matched,
+        strongSurfaceSignature: params.observation.strongSurfaceSignature ?? params.observation.surfaceSignature ?? null,
+        primarySurface: params.observation.primarySurface ?? null,
+        overlaySurface: params.observation.overlaySurface ?? null,
+        navigationSurface: params.observation.navigationSurface ?? null,
+        configurationSurface: params.observation.configurationSurface ?? null,
+        reasons: [...reasons],
+    };
+    const mode = evidence.urlMatched
+        && evidence.dialogMatched
+        && evidence.authMatched
+        && evidence.variantMatched
+        && (evidence.surfaceMatched ?? true)
+        && evidence.strongSurfaceObserved
+        ? "verified"
+        : !evidence.authMatched
+            ? "dirty"
+            : "degraded";
+    return {
+        mode,
+        contract,
+        evidence,
+        reasons,
+    };
+}
+export function decideCaptureTransition(params) {
+    const contract = deriveCapturePageContract({ pageIdentity: params.pageIdentity });
+    if (!params.observation) {
+        return {
+            mode: "degraded",
+            contract,
+            evidence: {
+                urlMatched: false,
+                dialogMatched: contract.dialogPolicy === "allow_either",
+                authMatched: true,
+                variantMatched: true,
+                strongSurfaceObserved: false,
+                surfaceMatched: false,
+                strongSurfaceSignature: null,
+                primarySurface: null,
+                overlaySurface: null,
+                navigationSurface: null,
+                configurationSurface: null,
+                reasons: ["baseline observation unavailable"],
+            },
+            reasons: ["baseline observation unavailable"],
+            shouldNavigateToCanonical: true,
+            shouldRecreateContext: false,
+            allowFastPath: false,
+        };
+    }
+    const checkpointDecision = buildCaptureCheckpointEvidence({
+        currentUrl: params.currentUrl ?? params.observation.url,
+        targetUrl: params.resumeUrl ?? params.targetUrl,
+        pageIdentity: params.pageIdentity,
+        observation: params.observation,
+        pageSignals: params.pageSignals ?? null,
+        profile: params.profile,
+        requestedLang: params.requestedLang,
+        requestedTheme: params.requestedTheme,
+    });
+    const reasons = [...checkpointDecision.reasons];
+    const handoffTrust = params.handoffContext?.trust ?? "degraded";
+    const sameSessionOrigin = sameOrigin(params.currentUrl ?? params.observation.url, params.targetUrl)
+        || sameOrigin(params.currentUrl ?? params.observation.url, params.resumeUrl ?? null);
+    const derivedFromRepair = params.handoffContext?.derivedFromRepair === true;
+    let mode = checkpointDecision.mode;
+    if (params.pageIndex === 0) {
+        mode = checkpointDecision.mode === "dirty" ? "dirty" : "degraded";
+        reasons.push("first page in variant must rebase canonically before capture");
+    }
+    else if (derivedFromRepair) {
+        mode = checkpointDecision.mode === "dirty" ? "dirty" : "degraded";
+        reasons.push("previous page state came from repair/recovery and cannot be reused as trusted handoff");
+    }
+    else if (handoffTrust !== "verified") {
+        mode = checkpointDecision.mode === "dirty" ? "dirty" : "degraded";
+        reasons.push("handoff context is not strongly trusted");
+    }
+    else if (!sameSessionOrigin) {
+        mode = "dirty";
+        reasons.push("current live state belongs to a different origin");
+    }
+    else if (checkpointDecision.mode !== "verified") {
+        mode = checkpointDecision.mode;
+    }
+    else if (contract.reusePolicy === "never") {
+        mode = "degraded";
+        reasons.push("current page contract forbids opportunistic live-state reuse");
+    }
+    return {
+        mode,
+        contract,
+        evidence: checkpointDecision.evidence,
+        reasons,
+        shouldNavigateToCanonical: mode === "degraded",
+        shouldRecreateContext: mode === "dirty",
+        allowFastPath: mode === "verified",
+    };
+}
+//# sourceMappingURL=capture-transition-engine.js.map

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

@@ -0,0 +1,56 @@
+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>;
+    pagePromptFingerprints: Record<string, string>;
+    validatedCaptures: VariantValidatedCapture[];
+    captureStatuses: Record<string, VariantCaptureStatus>;
+    lastCheckpointId: string | null;
+    blockedReasons: Record<string, string | null>;
+    recoveryAttempts: Record<string, number>;
+    repairHistory: VariantCaptureRepairRecord[];
+}
+export declare function buildPageRunPromptFingerprint(pageRun: Pick<ScreenshotPageRunInput, "prompt" | "url">, pageIdentity?: CapturePageIdentity | null): string;
+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;

package/dist/capture-variant-state.js

@@ -0,0 +1,182 @@
+import { createHash } from "crypto";
+import { inferCapturePageIdentity } from "./capture-page-identity.js";
+function normalizePageId(pageId) {
+    return pageId ?? "main";
+}
+export function buildPageRunPromptFingerprint(pageRun, pageIdentity) {
+    return createHash("sha1")
+        .update(pageRun.prompt ?? "")
+        .update("\n")
+        .update(pageRun.url ?? "")
+        .update("\n")
+        .update(pageIdentity?.summary ?? "")
+        .digest("hex");
+}
+export function createVariantCaptureState(pageRuns, precomputedIdentities) {
+    const pageIdentities = precomputedIdentities ?? Object.fromEntries(pageRuns.map((pageRun) => [
+        normalizePageId(pageRun.pageId),
+        inferCapturePageIdentity(pageRun),
+    ]));
+    const pagePromptFingerprints = Object.fromEntries(pageRuns.map((pageRun) => {
+        const pageId = normalizePageId(pageRun.pageId);
+        return [
+            pageId,
+            buildPageRunPromptFingerprint(pageRun, pageIdentities[pageId] ?? null),
+        ];
+    }));
+    return {
+        expectedPageIds: pageRuns.map((pageRun) => normalizePageId(pageRun.pageId)),
+        pageIdentities,
+        pagePromptFingerprints,
+        validatedCaptures: [],
+        captureStatuses: Object.fromEntries(pageRuns.map((pageRun) => [normalizePageId(pageRun.pageId), "pending"])),
+        lastCheckpointId: null,
+        blockedReasons: {},
+        recoveryAttempts: {},
+        repairHistory: [],
+    };
+}
+export function buildVariantManifestContext(params) {
+    const currentPageId = normalizePageId(params.currentPageRun.pageId);
+    const completedPages = params.state.validatedCaptures.map((capture) => capture.pageId);
+    return {
+        expectedPageIds: [...params.state.expectedPageIds],
+        currentPageId,
+        currentPageIdentity: params.state.pageIdentities[currentPageId] ?? null,
+        promptFingerprint: params.state.pagePromptFingerprints[currentPageId] ?? null,
+        pagePromptFingerprints: { ...params.state.pagePromptFingerprints },
+        completedPages,
+        remainingPages: params.state.expectedPageIds.filter((pageId) => !completedPages.includes(pageId)),
+        previousValidatedCaptures: [...params.state.validatedCaptures],
+        captureStatuses: { ...params.state.captureStatuses },
+        lastCheckpointId: params.state.lastCheckpointId,
+        blockedReason: params.state.blockedReasons[currentPageId] ?? null,
+        recoveryAttempts: { ...params.state.recoveryAttempts },
+        repairHistory: [...params.state.repairHistory],
+    };
+}
+export function recordValidatedVariantCapture(params) {
+    const pageId = normalizePageId(params.capture.pageId);
+    const duplicateOfPageId = params.capture.fingerprint
+        ? params.state.validatedCaptures.find((existing) => existing.pageId !== pageId
+            && existing.fingerprint
+            && existing.fingerprint === params.capture.fingerprint)?.pageId ?? null
+        : null;
+    const nextValidated = [
+        ...params.state.validatedCaptures.filter((existing) => existing.pageId !== pageId),
+        {
+            ...params.capture,
+            pageId,
+        },
+    ];
+    return {
+        state: {
+            expectedPageIds: [...params.state.expectedPageIds],
+            pageIdentities: { ...params.state.pageIdentities },
+            pagePromptFingerprints: { ...params.state.pagePromptFingerprints },
+            validatedCaptures: nextValidated,
+            captureStatuses: {
+                ...params.state.captureStatuses,
+                [pageId]: "completed",
+            },
+            lastCheckpointId: params.checkpointId ?? params.state.lastCheckpointId,
+            blockedReasons: {
+                ...params.state.blockedReasons,
+                [pageId]: null,
+            },
+            recoveryAttempts: { ...params.state.recoveryAttempts },
+            repairHistory: [...params.state.repairHistory],
+        },
+        duplicateOfPageId,
+    };
+}
+export function validateVariantCaptureState(state) {
+    const missingPages = state.expectedPageIds.filter((pageId) => !state.validatedCaptures.some((capture) => capture.pageId === pageId)
+        && state.captureStatuses[pageId] !== "blocked");
+    const blockedPages = state.expectedPageIds
+        .filter((pageId) => state.captureStatuses[pageId] === "blocked")
+        .map((pageId) => ({ pageId, reason: state.blockedReasons[pageId] ?? null }));
+    const duplicatePageIds = [];
+    const seenFingerprints = new Map();
+    for (const capture of state.validatedCaptures) {
+        if (!capture.fingerprint)
+            continue;
+        const existingPageId = seenFingerprints.get(capture.fingerprint);
+        if (existingPageId && existingPageId !== capture.pageId) {
+            duplicatePageIds.push({ pageId: capture.pageId, duplicateOfPageId: existingPageId });
+            continue;
+        }
+        seenFingerprints.set(capture.fingerprint, capture.pageId);
+    }
+    return {
+        ok: missingPages.length === 0 && blockedPages.length === 0 && duplicatePageIds.length === 0,
+        missingPages,
+        blockedPages,
+        duplicatePageIds,
+    };
+}
+export function hasValidatedVariantPage(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return state.validatedCaptures.some((capture) => capture.pageId === normalized);
+}
+export function getVariantCaptureStatus(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return state.captureStatuses[normalized] ?? "pending";
+}
+export function markVariantCaptureInProgress(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return {
+        ...state,
+        pagePromptFingerprints: { ...state.pagePromptFingerprints },
+        captureStatuses: {
+            ...state.captureStatuses,
+            [normalized]: "in_progress",
+        },
+        blockedReasons: {
+            ...state.blockedReasons,
+            [normalized]: null,
+        },
+    };
+}
+export function markVariantCaptureBlocked(params) {
+    const normalized = normalizePageId(params.pageId);
+    return {
+        ...params.state,
+        pagePromptFingerprints: { ...params.state.pagePromptFingerprints },
+        captureStatuses: {
+            ...params.state.captureStatuses,
+            [normalized]: "blocked",
+        },
+        blockedReasons: {
+            ...params.state.blockedReasons,
+            [normalized]: params.reason,
+        },
+    };
+}
+export function recordVariantRecoveryAttempt(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return {
+        ...state,
+        pagePromptFingerprints: { ...state.pagePromptFingerprints },
+        recoveryAttempts: {
+            ...state.recoveryAttempts,
+            [normalized]: (state.recoveryAttempts[normalized] ?? 0) + 1,
+        },
+    };
+}
+export function recordVariantRepair(params) {
+    const nextHistory = [...params.state.repairHistory, params.repair];
+    return {
+        ...params.state,
+        pagePromptFingerprints: { ...params.state.pagePromptFingerprints },
+        repairHistory: nextHistory.slice(-12),
+    };
+}
+export function recordVariantCheckpoint(params) {
+    return {
+        ...params.state,
+        pagePromptFingerprints: { ...params.state.pagePromptFingerprints },
+        lastCheckpointId: params.checkpoint.id,
+    };
+}
+//# sourceMappingURL=capture-variant-state.js.map

package/dist/capture-verification.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Capture Agent — Capture Verification
+ *
+ * Post-capture quality check via LLM vision.
+ * Detects: blank pages, error pages, loading spinners, skeletons,
+ * obstructing overlays, and other visual issues.
+ *
+ * This is the ONLY place where AutoKap uses AI at runtime.
+ * Cost: ~0.002 EUR per check (1 image + short prompt).
+ */
+import { type LLMProviderConfig, type LLMCallResult } from './llm-provider.js';
+export interface VerificationResult {
+    /** Whether the screenshot is acceptable for delivery */
+    passed: boolean;
+    /** Issue detected (if failed) */
+    issue?: 'blank_page' | 'error_page' | 'loading' | 'overlay_blocking' | 'wrong_content' | 'other';
+    /** Human-readable explanation */
+    reason: string;
+    /** LLM call metadata */
+    llmResult?: LLMCallResult;
+}
+export interface VerificationContext {
+    /** What was this screenshot supposed to show? */
+    expectedDescription: string;
+    /** Target URL */
+    url: string;
+    /** Locale of this variant */
+    locale?: string;
+    /** Theme of this variant */
+    theme?: string;
+}
+/**
+ * Verifies a captured screenshot is clean and ready for delivery.
+ */
+export declare function verifyCaptureQuality(screenshot: Buffer, context: VerificationContext, llmConfig: LLMProviderConfig): Promise<VerificationResult>;

package/dist/capture-verification.js

@@ -0,0 +1,95 @@
+/**
+ * Capture Agent — Capture Verification
+ *
+ * Post-capture quality check via LLM vision.
+ * Detects: blank pages, error pages, loading spinners, skeletons,
+ * obstructing overlays, and other visual issues.
+ *
+ * This is the ONLY place where AutoKap uses AI at runtime.
+ * Cost: ~0.002 EUR per check (1 image + short prompt).
+ */
+import { callLLM } from './llm-provider.js';
+const SYSTEM_PROMPT = `You are a screenshot quality checker for a web capture tool. You receive a screenshot of a web page and must verify it is clean and ready for delivery.
+
+Check for these issues:
+1. BLANK - The page is completely white/blank or has no meaningful content
+2. ERROR - The page shows an error message (404, 500, "something went wrong", crash screen)
+3. LOADING - The page has visible loading indicators (spinners, skeletons, progress bars, "Loading..." text)
+4. OVERLAY - A modal, popup, cookie banner, or other overlay is blocking the main content
+5. WRONG - The content doesn't match what was expected
+
+Respond with EXACTLY one line in this format:
+PASS: Screenshot looks clean and ready.
+or
+FAIL:<issue>: <explanation>
+
+Where <issue> is one of: blank_page, error_page, loading, overlay_blocking, wrong_content, other
+
+Examples:
+PASS: Screenshot looks clean and ready.
+FAIL:loading: A skeleton loader is visible in the main content area.
+FAIL:overlay_blocking: A cookie consent banner covers the bottom of the page.
+FAIL:error_page: The page shows a 404 Not Found error.`;
+/**
+ * Verifies a captured screenshot is clean and ready for delivery.
+ */
+export async function verifyCaptureQuality(screenshot, context, llmConfig) {
+    const userPrompt = buildUserPrompt(context);
+    try {
+        const result = await callLLM(llmConfig, SYSTEM_PROMPT, userPrompt, screenshot);
+        return parseVerificationResponse(result.text, result);
+    }
+    catch (err) {
+        // If LLM fails, pass the screenshot — don't block delivery because of LLM issues
+        return {
+            passed: true,
+            reason: `verification skipped (LLM error: ${err instanceof Error ? err.message : String(err)})`,
+        };
+    }
+}
+function buildUserPrompt(context) {
+    const parts = [
+        `Expected content: ${context.expectedDescription}`,
+        `URL: ${context.url}`,
+    ];
+    if (context.locale)
+        parts.push(`Locale: ${context.locale}`);
+    if (context.theme)
+        parts.push(`Theme: ${context.theme}`);
+    parts.push('\nIs this screenshot clean and ready for delivery?');
+    return parts.join('\n');
+}
+function parseVerificationResponse(text, llmResult) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith('PASS')) {
+        return {
+            passed: true,
+            reason: trimmed.replace(/^PASS:?\s*/, ''),
+            llmResult,
+        };
+    }
+    if (trimmed.startsWith('FAIL')) {
+        const match = trimmed.match(/^FAIL:(\w+):\s*(.+)/);
+        if (match) {
+            return {
+                passed: false,
+                issue: match[1],
+                reason: match[2],
+                llmResult,
+            };
+        }
+        return {
+            passed: false,
+            issue: 'other',
+            reason: trimmed.replace(/^FAIL:?\s*/, ''),
+            llmResult,
+        };
+    }
+    // Ambiguous response — assume pass
+    return {
+        passed: true,
+        reason: `ambiguous LLM response: "${trimmed.slice(0, 100)}"`,
+        llmResult,
+    };
+}
+//# sourceMappingURL=capture-verification.js.map