autokap 1.0.7 → 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

@@ -3,6 +3,7 @@ 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;
@@ -10,6 +11,7 @@ export interface VariantCaptureState {
     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;

package/dist/capture-variant-state.js

@@ -1,15 +1,33 @@
+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,
@@ -25,6 +43,8 @@ export function buildVariantManifestContext(params) {
         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],
@@ -53,6 +73,7 @@ export function recordValidatedVariantCapture(params) {
         state: {
             expectedPageIds: [...params.state.expectedPageIds],
             pageIdentities: { ...params.state.pageIdentities },
+            pagePromptFingerprints: { ...params.state.pagePromptFingerprints },
             validatedCaptures: nextValidated,
             captureStatuses: {
                 ...params.state.captureStatuses,
@@ -106,6 +127,7 @@ export function markVariantCaptureInProgress(state, pageId) {
     const normalized = normalizePageId(pageId);
     return {
         ...state,
+        pagePromptFingerprints: { ...state.pagePromptFingerprints },
         captureStatuses: {
             ...state.captureStatuses,
             [normalized]: "in_progress",
@@ -120,6 +142,7 @@ export function markVariantCaptureBlocked(params) {
     const normalized = normalizePageId(params.pageId);
     return {
         ...params.state,
+        pagePromptFingerprints: { ...params.state.pagePromptFingerprints },
         captureStatuses: {
             ...params.state.captureStatuses,
             [normalized]: "blocked",
@@ -134,6 +157,7 @@ export function recordVariantRecoveryAttempt(state, pageId) {
     const normalized = normalizePageId(pageId);
     return {
         ...state,
+        pagePromptFingerprints: { ...state.pagePromptFingerprints },
         recoveryAttempts: {
             ...state.recoveryAttempts,
             [normalized]: (state.recoveryAttempts[normalized] ?? 0) + 1,
@@ -144,12 +168,14 @@ 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,
     };
 }

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

package/dist/capture-viewport-lock.d.ts

@@ -0,0 +1,48 @@
+export interface CaptureViewport {
+    width: number;
+    height: number;
+}
+export interface ViewportLockBrowser {
+    resizeViewport(width: number, height: number): Promise<void>;
+    wait(ms: number): Promise<void>;
+    takeScreenshot(): Promise<Buffer>;
+    currentPage: {
+        viewportSize(): {
+            width: number;
+            height: number;
+        } | null;
+    };
+}
+export interface LockedViewportScreenshot {
+    buffer: Buffer;
+    actualViewport: {
+        width: number;
+        height: number;
+    } | null;
+    screenshotSize: {
+        width: number;
+        height: number;
+    };
+    expectedScreenshotSize: {
+        width: number;
+        height: number;
+    };
+    repaired: boolean;
+}
+interface ViewportLockOptions {
+    settleMs?: number;
+    maxAttempts?: number;
+}
+interface TakeViewportLockedScreenshotOptions extends ViewportLockOptions {
+    deviceScaleFactor: number;
+    maxScreenshotAttempts?: number;
+}
+export declare function lockCaptureViewport(browser: ViewportLockBrowser, viewport: CaptureViewport, options?: ViewportLockOptions): Promise<{
+    actualViewport: {
+        width: number;
+        height: number;
+    } | null;
+    repaired: boolean;
+}>;
+export declare function takeViewportLockedScreenshot(browser: ViewportLockBrowser, viewport: CaptureViewport, options: TakeViewportLockedScreenshotOptions): Promise<LockedViewportScreenshot>;
+export {};

package/dist/capture-viewport-lock.js

@@ -0,0 +1,74 @@
+import sharp from 'sharp';
+const DEFAULT_SETTLE_MS = 300;
+const DEFAULT_MAX_VIEWPORT_ATTEMPTS = 2;
+const DEFAULT_MAX_SCREENSHOT_ATTEMPTS = 2;
+function matchesDimension(actual, expected) {
+    return Math.abs(actual - expected) <= 1;
+}
+function matchesViewport(actual, expected) {
+    return !!actual
+        && matchesDimension(actual.width, expected.width)
+        && matchesDimension(actual.height, expected.height);
+}
+function formatViewport(value) {
+    if (!value)
+        return 'unknown';
+    return `${value.width}x${value.height}`;
+}
+export async function lockCaptureViewport(browser, viewport, options = {}) {
+    const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
+    const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_VIEWPORT_ATTEMPTS;
+    let repaired = false;
+    let actualViewport = browser.currentPage.viewportSize();
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        await browser.resizeViewport(viewport.width, viewport.height);
+        if (settleMs > 0) {
+            await browser.wait(settleMs);
+        }
+        actualViewport = browser.currentPage.viewportSize();
+        if (matchesViewport(actualViewport, viewport)) {
+            return {
+                actualViewport,
+                repaired,
+            };
+        }
+        repaired = true;
+    }
+    throw new Error(`Viewport lock failed: expected ${viewport.width}x${viewport.height}, got ${formatViewport(actualViewport)}.`);
+}
+export async function takeViewportLockedScreenshot(browser, viewport, options) {
+    const deviceScaleFactor = Math.max(0.5, Number(options.deviceScaleFactor) || 1);
+    const maxScreenshotAttempts = options.maxScreenshotAttempts ?? DEFAULT_MAX_SCREENSHOT_ATTEMPTS;
+    const expectedScreenshotSize = {
+        width: Math.round(viewport.width * deviceScaleFactor),
+        height: Math.round(viewport.height * deviceScaleFactor),
+    };
+    let repaired = false;
+    let lastViewport = null;
+    let lastScreenshotSize = null;
+    for (let attempt = 1; attempt <= maxScreenshotAttempts; attempt += 1) {
+        const viewportLock = await lockCaptureViewport(browser, viewport, options);
+        repaired ||= viewportLock.repaired;
+        lastViewport = viewportLock.actualViewport;
+        const buffer = await browser.takeScreenshot();
+        const metadata = await sharp(buffer).metadata();
+        const screenshotSize = {
+            width: metadata.width ?? 0,
+            height: metadata.height ?? 0,
+        };
+        lastScreenshotSize = screenshotSize;
+        if (matchesDimension(screenshotSize.width, expectedScreenshotSize.width)
+            && matchesDimension(screenshotSize.height, expectedScreenshotSize.height)) {
+            return {
+                buffer,
+                actualViewport: lastViewport,
+                screenshotSize,
+                expectedScreenshotSize,
+                repaired: repaired || attempt > 1,
+            };
+        }
+        repaired = true;
+    }
+    throw new Error(`Screenshot viewport mismatch: expected ${expectedScreenshotSize.width}x${expectedScreenshotSize.height}, got ${formatViewport(lastScreenshotSize)} (viewport ${formatViewport(lastViewport)}).`);
+}
+//# sourceMappingURL=capture-viewport-lock.js.map