@parhelia/core 0.1.12479 → 0.1.12496

package/dist/editor/ai/dialogs/browserBoundCapture.js

@@ -0,0 +1,117 @@
+export const CAPTURE_ERROR_CODES = {
+    BROWSER_CLAIM_MISMATCH: "browser_claim_mismatch",
+    BROWSER_CONTEXT_MISSING: "browser_context_missing",
+    PAGE_VIEWER_NOT_OPEN: "page_viewer_not_open",
+};
+function normalize(value) {
+    return value?.trim().toLowerCase() || "";
+}
+export function getBrowserCaptureClaim(metadata) {
+    const raw = metadata?.additionalData?.browserCaptureClaim ||
+        metadata
+            ?.browserCaptureClaim;
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    return raw;
+}
+export function setBrowserCaptureClaim(metadata, claim) {
+    const nextAdditionalData = { ...(metadata?.additionalData || {}) };
+    const nextMetadata = {
+        ...(metadata || {}),
+        additionalData: nextAdditionalData,
+    };
+    if (claim) {
+        nextAdditionalData.browserCaptureClaim = claim;
+        nextMetadata.browserCaptureClaim = claim;
+    }
+    else {
+        delete nextAdditionalData.browserCaptureClaim;
+        delete nextMetadata.browserCaptureClaim;
+    }
+    return nextMetadata;
+}
+export function buildOpenCaptureContext(editContext) {
+    const currentItem = editContext?.currentItemDescriptor;
+    if (!currentItem && !editContext?.workspaceId) {
+        return undefined;
+    }
+    return {
+        itemId: currentItem?.id,
+        itemName: editContext?.item?.name,
+        itemPath: currentItem?.path,
+        language: currentItem?.language,
+        version: currentItem?.version,
+        activeWorkspace: editContext?.workspaceId,
+    };
+}
+export function validateBrowserBoundCaptureRequest(params) {
+    const { request, editContext, scope } = params;
+    const requiredContext = request.parameters?.targetContext ||
+        undefined;
+    const currentContext = buildOpenCaptureContext(editContext);
+    if (request.targetSessionId &&
+        editContext?.sessionId &&
+        normalize(request.targetSessionId) !== normalize(editContext.sessionId)) {
+        return buildCaptureFailure({
+            scope,
+            errorCode: CAPTURE_ERROR_CODES.BROWSER_CLAIM_MISMATCH,
+            error: "This browser is not the claimed browser for the capture request.",
+            currentContext,
+            requiredContext,
+            recommendedAction: "Attach this agent to the current browser or switch back to the claimed browser, then retry capture.",
+        });
+    }
+    if (scope === "editor-ui") {
+        return null;
+    }
+    if (!requiredContext?.itemId) {
+        return buildCaptureFailure({
+            scope,
+            errorCode: CAPTURE_ERROR_CODES.BROWSER_CONTEXT_MISSING,
+            error: "The capture request is missing a concrete page target, so it cannot safely run against the currently open page.",
+            currentContext,
+            requiredContext,
+            recommendedAction: "Refresh the agent context or load the intended item first, then retry capture.",
+        });
+    }
+    return null;
+}
+export function buildPageViewerNotOpenFailure(params) {
+    const requiredContext = params.request.parameters?.targetContext || undefined;
+    return buildCaptureFailure({
+        scope: params.scope,
+        errorCode: CAPTURE_ERROR_CODES.PAGE_VIEWER_NOT_OPEN,
+        error: "No page viewer or editor surface is open in the claimed browser, so capture cannot run.",
+        currentContext: buildOpenCaptureContext(params.editContext),
+        requiredContext,
+        recommendedAction: buildLoadItemAction(requiredContext),
+    });
+}
+function buildLoadItemAction(targetContext) {
+    if (!targetContext?.itemId) {
+        return "Open the intended page in the page editor or viewer, then retry capture.";
+    }
+    const parts = [`Call load-item with itemId "${targetContext.itemId}"`];
+    if (targetContext.language) {
+        parts.push(`language "${targetContext.language}"`);
+    }
+    if (targetContext.version != null) {
+        parts.push(`version ${targetContext.version}`);
+    }
+    return `${parts.join(", ")}, then retry capture.`;
+}
+function buildCaptureFailure(params) {
+    return {
+        success: false,
+        scope: params.scope,
+        errorCode: params.errorCode,
+        error: params.recommendedAction
+            ? `${params.error} ${params.recommendedAction}`
+            : params.error,
+        requiredContext: params.requiredContext,
+        currentContext: params.currentContext,
+        recommendedAction: params.recommendedAction,
+    };
+}
+//# sourceMappingURL=browserBoundCapture.js.map

package/dist/editor/ai/dialogs/browserBoundCapture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserBoundCapture.js","sourceRoot":"","sources":["../../../../src/editor/ai/dialogs/browserBoundCapture.ts"],"names":[],"mappings":"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"}

package/dist/editor/ai/dialogs/capturePageDom.d.ts

@@ -0,0 +1,3 @@
+import type { EditContextType } from "../../client/editContext";
+import type { AgentDialogRequest, CapturePageDomParameters, CapturePageDomResult } from "./agentDialogTypes";
+export declare function capturePageDom(request: AgentDialogRequest, _params: CapturePageDomParameters, editContext: EditContextType | undefined): Promise<CapturePageDomResult>;

package/dist/editor/ai/dialogs/capturePageDom.js

@@ -0,0 +1,64 @@
+import { buildPageViewerNotOpenFailure, validateBrowserBoundCaptureRequest, } from "./browserBoundCapture";
+function getActiveEditorIframe(editContext) {
+    return editContext.getActiveSlotContext?.()?.primaryPageViewContext.editorIframe;
+}
+export async function capturePageDom(request, _params, editContext) {
+    if (!editContext) {
+        return buildPageViewerNotOpenFailure({
+            request,
+            editContext,
+            scope: "page",
+        });
+    }
+    const iframe = getActiveEditorIframe(editContext);
+    if (!iframe) {
+        return buildPageViewerNotOpenFailure({
+            request,
+            editContext,
+            scope: "page",
+        });
+    }
+    const validationFailure = validateBrowserBoundCaptureRequest({
+        request,
+        editContext,
+        scope: "page",
+    });
+    if (validationFailure) {
+        return validationFailure;
+    }
+    let iframeDocument = null;
+    let html = "";
+    try {
+        iframeDocument = iframe.contentDocument;
+        html = iframeDocument?.documentElement?.outerHTML ?? "";
+    }
+    catch {
+        return {
+            success: false,
+            scope: "page",
+            error: "The current page iframe is not accessible from the editor, so DOM capture is unavailable.",
+        };
+    }
+    if (!iframeDocument?.documentElement) {
+        return {
+            success: false,
+            scope: "page",
+            error: "The current page has not finished loading inside the editor iframe.",
+        };
+    }
+    if (!html.trim()) {
+        return {
+            success: false,
+            scope: "page",
+            error: "The current page DOM is empty.",
+        };
+    }
+    return {
+        success: true,
+        scope: "page",
+        html,
+        length: html.length,
+        documentTitle: iframeDocument.title || undefined,
+    };
+}
+//# sourceMappingURL=capturePageDom.js.map

package/dist/editor/ai/dialogs/capturePageDom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capturePageDom.js","sourceRoot":"","sources":["../../../../src/editor/ai/dialogs/capturePageDom.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,6BAA6B,EAC7B,kCAAkC,GACnC,MAAM,uBAAuB,CAAC;AAE/B,SAAS,qBAAqB,CAAC,WAA4B;IACzD,OAAO,WAAW,CAAC,oBAAoB,EAAE,EAAE,EAAE,sBAAsB,CAAC,YAAY,CAAC;AACnF,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,OAA2B,EAC3B,OAAiC,EACjC,WAAwC;IAExC,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,6BAA6B,CAAC;YACnC,OAAO;YACP,WAAW;YACX,KAAK,EAAE,MAAM;SACd,CAAyB,CAAC;IAC7B,CAAC;IAED,MAAM,MAAM,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAAC;IAClD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,6BAA6B,CAAC;YACnC,OAAO;YACP,WAAW;YACX,KAAK,EAAE,MAAM;SACd,CAAyB,CAAC;IAC7B,CAAC;IAED,MAAM,iBAAiB,GAAG,kCAAkC,CAAC;QAC3D,OAAO;QACP,WAAW;QACX,KAAK,EAAE,MAAM;KACd,CAAC,CAAC;IACH,IAAI,iBAAiB,EAAE,CAAC;QACtB,OAAO,iBAAyC,CAAC;IACnD,CAAC;IAED,IAAI,cAAc,GAAoB,IAAI,CAAC;IAC3C,IAAI,IAAI,GAAG,EAAE,CAAC;IAEd,IAAI,CAAC;QACH,cAAc,GAAG,MAAM,CAAC,eAAe,CAAC;QACxC,IAAI,GAAG,cAAc,EAAE,eAAe,EAAE,SAAS,IAAI,EAAE,CAAC;IAC1D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,MAAM;YACb,KAAK,EACH,2FAA2F;SAC9F,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,cAAc,EAAE,eAAe,EAAE,CAAC;QACrC,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,MAAM;YACb,KAAK,EAAE,qEAAqE;SAC7E,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QACjB,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,MAAM;YACb,KAAK,EAAE,gCAAgC;SACxC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,OAAO,EAAE,IAAI;QACb,KAAK,EAAE,MAAM;QACb,IAAI;QACJ,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,aAAa,EAAE,cAAc,CAAC,KAAK,IAAI,SAAS;KACjD,CAAC;AACJ,CAAC"}

package/dist/editor/ai/dialogs/capturePageScreenshot.d.ts

@@ -0,0 +1,3 @@
+import type { EditContextType } from "../../client/editContext";
+import type { AgentDialogRequest, CapturePageScreenshotParameters, CapturePageScreenshotResult } from "./agentDialogTypes";
+export declare function capturePageScreenshot(request: AgentDialogRequest, params: CapturePageScreenshotParameters, editContext: EditContextType | undefined): Promise<CapturePageScreenshotResult>;

package/dist/editor/ai/dialogs/capturePageScreenshot.js

@@ -0,0 +1,446 @@
+import html2canvas from "html2canvas-pro";
+import { getComponentById } from "../../componentTreeHelper";
+import { findComponentRect, getAbsolutePosition } from "../../utils";
+import { buildPageViewerNotOpenFailure, validateBrowserBoundCaptureRequest, } from "./browserBoundCapture";
+const MAX_TOOL_RESULT_IMAGE_DIMENSION = 1280;
+const PNG_SIZE_FALLBACK_THRESHOLD = 2_500_000;
+const JPEG_QUALITY = 0.9;
+function normalizeScope(scope) {
+    switch (scope) {
+        case "editor-ui":
+        case "selection":
+        case "component":
+        case "component-range":
+        case "page":
+            return scope;
+        case "viewport":
+        default:
+            return "viewport";
+    }
+}
+function getPageDimensions(doc) {
+    const body = doc.body;
+    const root = doc.documentElement;
+    return {
+        width: Math.max(root?.scrollWidth ?? 0, root?.clientWidth ?? 0, body?.scrollWidth ?? 0, body?.clientWidth ?? 0),
+        height: Math.max(root?.scrollHeight ?? 0, root?.clientHeight ?? 0, body?.scrollHeight ?? 0, body?.clientHeight ?? 0),
+    };
+}
+function getWindowViewportBounds(targetWindow, zoom = 1, viewportWidth = targetWindow.innerWidth, viewportHeight = targetWindow.innerHeight) {
+    const safeZoom = zoom > 0 ? zoom : 1;
+    return {
+        x: Math.floor(targetWindow.scrollX ?? 0),
+        y: Math.floor(targetWindow.scrollY ?? 0),
+        width: Math.max(1, Math.ceil(viewportWidth / safeZoom)),
+        height: Math.max(1, Math.ceil(viewportHeight / safeZoom)),
+    };
+}
+function clampBounds(bounds, pageSize, padding = 0) {
+    const x = Math.max(0, Math.floor(bounds.x - padding));
+    const y = Math.max(0, Math.floor(bounds.y - padding));
+    const right = Math.min(pageSize.width, Math.ceil(bounds.x + bounds.width + padding));
+    const bottom = Math.min(pageSize.height, Math.ceil(bounds.y + bounds.height + padding));
+    return {
+        x,
+        y,
+        width: Math.max(1, right - x),
+        height: Math.max(1, bottom - y),
+    };
+}
+function unionBounds(boundsList) {
+    const minX = Math.min(...boundsList.map((bounds) => bounds.x));
+    const minY = Math.min(...boundsList.map((bounds) => bounds.y));
+    const maxRight = Math.max(...boundsList.map((bounds) => bounds.x + bounds.width));
+    const maxBottom = Math.max(...boundsList.map((bounds) => bounds.y + bounds.height));
+    return {
+        x: minX,
+        y: minY,
+        width: maxRight - minX,
+        height: maxBottom - minY,
+    };
+}
+function normalizeComponentIdentifier(value) {
+    return value?.trim().replace(/[{}]/g, "").toLowerCase() ?? "";
+}
+function matchesComponentIdentifier(candidate, target) {
+    const normalizedCandidate = normalizeComponentIdentifier(candidate);
+    const normalizedTarget = normalizeComponentIdentifier(target);
+    return !!normalizedCandidate && normalizedCandidate === normalizedTarget;
+}
+function findExactComponentById(page, componentId) {
+    const targetId = normalizeComponentIdentifier(componentId);
+    if (!targetId) {
+        return null;
+    }
+    const queue = [...(page.rootComponent.placeholders ?? [])];
+    while (queue.length > 0) {
+        const placeholder = queue.shift();
+        if (!placeholder) {
+            continue;
+        }
+        for (const component of placeholder.components) {
+            if (matchesComponentIdentifier(component.id, targetId)) {
+                return component;
+            }
+            if (component.placeholders?.length) {
+                queue.push(...component.placeholders);
+            }
+        }
+    }
+    return null;
+}
+function getElementBounds(iframe, element) {
+    const rect = getAbsolutePosition(element, iframe);
+    if (rect.width <= 0 || rect.height <= 0) {
+        return null;
+    }
+    return {
+        x: Math.floor(rect.x),
+        y: Math.floor(rect.y),
+        width: Math.ceil(rect.width),
+        height: Math.ceil(rect.height),
+    };
+}
+function getComponentBoundsFromLiveDom(iframe, componentId) {
+    const doc = iframe.contentDocument;
+    if (!doc?.body) {
+        return null;
+    }
+    const matchingElements = Array.from(doc.querySelectorAll("[data-component-id]")).filter((element) => {
+        return (element instanceof HTMLElement &&
+            matchesComponentIdentifier(element.getAttribute("data-component-id"), componentId));
+    });
+    const bounds = matchingElements
+        .map((element) => getElementBounds(iframe, element))
+        .filter((item) => !!item && item.width > 0 && item.height > 0);
+    if (bounds.length === 0) {
+        return null;
+    }
+    return unionBounds(bounds);
+}
+function getComponentBounds(iframe, page, componentId) {
+    const exactComponent = findExactComponentById(page, componentId);
+    const component = exactComponent ?? getComponentById(componentId, page);
+    const candidateIds = [
+        componentId,
+        component?.id,
+        component?.datasourceItem?.id,
+    ].filter((value, index, values) => {
+        return (!!value &&
+            values.findIndex((other) => matchesComponentIdentifier(other, value)) ===
+                index);
+    });
+    if (component) {
+        const componentRect = findComponentRect(iframe, component, true)?.rect;
+        if (componentRect) {
+            return {
+                x: Math.floor(componentRect.x),
+                y: Math.floor(componentRect.y),
+                width: Math.ceil(componentRect.width),
+                height: Math.ceil(componentRect.height),
+            };
+        }
+    }
+    for (const candidateId of candidateIds) {
+        const liveDomBounds = getComponentBoundsFromLiveDom(iframe, candidateId);
+        if (liveDomBounds) {
+            return liveDomBounds;
+        }
+    }
+    return null;
+}
+function getViewportBounds(iframe, zoom) {
+    const iframeWindow = iframe.contentWindow;
+    return getWindowViewportBounds(iframeWindow ?? window, zoom, iframe.clientWidth, iframe.clientHeight);
+}
+function resolveCaptureArea(iframe, page, selection, zoom, params, pageSize) {
+    const scope = normalizeScope(params.scope);
+    const padding = Math.max(0, params.padding ?? 0);
+    if (scope === "page") {
+        return {
+            scope,
+            bounds: clampBounds({
+                x: 0,
+                y: 0,
+                width: pageSize.width,
+                height: pageSize.height,
+            }, pageSize, padding),
+        };
+    }
+    if (!page) {
+        if (scope === "viewport") {
+            return {
+                scope,
+                bounds: clampBounds(getViewportBounds(iframe, zoom), pageSize, padding),
+            };
+        }
+        throw new Error("No page model is loaded, so component-based capture is unavailable.");
+    }
+    const fromComponentId = params.fromComponentId?.trim();
+    const toComponentId = params.toComponentId?.trim();
+    if (scope === "selection") {
+        const bounds = selection
+            .map((componentId) => getComponentBounds(iframe, page, componentId))
+            .filter((item) => !!item && item.width > 0 && item.height > 0);
+        if (!bounds.length) {
+            throw new Error("There are no selected components to capture.");
+        }
+        return {
+            scope,
+            bounds: clampBounds(unionBounds(bounds), pageSize, padding),
+        };
+    }
+    if (fromComponentId && toComponentId) {
+        const bounds = [fromComponentId, toComponentId]
+            .map((componentId) => getComponentBounds(iframe, page, componentId))
+            .filter((item) => !!item && item.width > 0 && item.height > 0);
+        if (bounds.length !== 2) {
+            throw new Error("Could not resolve both component boundaries for the requested capture range.");
+        }
+        return {
+            scope: "component-range",
+            bounds: clampBounds(unionBounds(bounds), pageSize, padding),
+        };
+    }
+    if (fromComponentId) {
+        const bounds = getComponentBounds(iframe, page, fromComponentId);
+        if (!bounds) {
+            throw new Error(`Could not resolve a visible component for '${fromComponentId}'.`);
+        }
+        return {
+            scope: "component",
+            bounds: clampBounds(bounds, pageSize, padding),
+        };
+    }
+    if (scope === "component" || scope === "component-range") {
+        return {
+            scope: "viewport",
+            bounds: clampBounds(getViewportBounds(iframe, zoom), pageSize, padding),
+        };
+    }
+    return {
+        scope: "viewport",
+        bounds: clampBounds(getViewportBounds(iframe, zoom), pageSize, padding),
+    };
+}
+async function canvasToBlob(canvas, contentType, quality) {
+    const blob = await new Promise((resolve, reject) => {
+        canvas.toBlob((value) => {
+            if (value) {
+                resolve(value);
+            }
+            else {
+                reject(new Error("Failed to convert screenshot canvas into an image."));
+            }
+        }, contentType, quality);
+    });
+    return blob;
+}
+async function blobToDataUrl(blob) {
+    return await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const value = reader.result;
+            if (typeof value === "string" && value.length > 0) {
+                resolve(value);
+                return;
+            }
+            reject(new Error("Failed to encode screenshot image data."));
+        };
+        reader.onerror = () => {
+            reject(reader.error ?? new Error("Failed to encode screenshot image data."));
+        };
+        reader.readAsDataURL(blob);
+    });
+}
+function buildFileName(scope, extension = "png") {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return `page-screenshot-${scope}-${timestamp}.${extension}`;
+}
+function scaleCanvasForToolResult(canvas) {
+    const maxDimension = Math.max(canvas.width, canvas.height);
+    if (maxDimension <= MAX_TOOL_RESULT_IMAGE_DIMENSION) {
+        return canvas;
+    }
+    const scale = MAX_TOOL_RESULT_IMAGE_DIMENSION / maxDimension;
+    const scaledCanvas = document.createElement("canvas");
+    scaledCanvas.width = Math.max(1, Math.round(canvas.width * scale));
+    scaledCanvas.height = Math.max(1, Math.round(canvas.height * scale));
+    const context = scaledCanvas.getContext("2d");
+    if (!context) {
+        throw new Error("Failed to prepare the screenshot for the tool result.");
+    }
+    context.drawImage(canvas, 0, 0, scaledCanvas.width, scaledCanvas.height);
+    return scaledCanvas;
+}
+function replaceFileExtension(fileName, extension) {
+    return fileName.replace(/\.[^.]+$/, "") + `.${extension}`;
+}
+async function canvasToResultImage(canvas, scope) {
+    const processedCanvas = scaleCanvasForToolResult(canvas);
+    let contentType = "image/png";
+    let fileName = buildFileName(scope, "png");
+    let blob = await canvasToBlob(processedCanvas, contentType);
+    if (blob.size > PNG_SIZE_FALLBACK_THRESHOLD) {
+        contentType = "image/jpeg";
+        fileName = replaceFileExtension(fileName, "jpg");
+        blob = await canvasToBlob(processedCanvas, contentType, JPEG_QUALITY);
+    }
+    return {
+        image: {
+            dataUrl: await blobToDataUrl(blob),
+            fileName,
+            fileSize: blob.size,
+            contentType,
+        },
+        width: processedCanvas.width,
+        height: processedCanvas.height,
+    };
+}
+function getActiveEditorIframe(editContext) {
+    return editContext.getActiveSlotContext?.()?.primaryPageViewContext.editorIframe;
+}
+export async function capturePageScreenshot(request, params, editContext) {
+    const normalizedScope = normalizeScope(params.scope);
+    const captureEditorUi = normalizedScope === "editor-ui";
+    if (!editContext) {
+        return buildPageViewerNotOpenFailure({
+            request,
+            editContext,
+            scope: normalizedScope,
+        });
+    }
+    const validationFailure = validateBrowserBoundCaptureRequest({
+        request,
+        editContext,
+        scope: normalizedScope,
+    });
+    if (validationFailure) {
+        return validationFailure;
+    }
+    let targetElement;
+    let pageSize;
+    let captureArea;
+    const activeSlotContext = editContext.getActiveSlotContext?.();
+    if (captureEditorUi) {
+        if (!document.documentElement || !document.body) {
+            return {
+                success: false,
+                scope: normalizedScope,
+                error: "The Parhelia UI has not finished loading yet.",
+            };
+        }
+        targetElement = document.documentElement;
+        pageSize = getPageDimensions(document);
+        const padding = Math.max(0, params.padding ?? 0);
+        captureArea = {
+            scope: "editor-ui",
+            bounds: clampBounds(getWindowViewportBounds(window), pageSize, padding),
+        };
+    }
+    else {
+        const iframe = getActiveEditorIframe(editContext);
+        if (!iframe) {
+            return buildPageViewerNotOpenFailure({
+                request,
+                editContext,
+                scope: normalizedScope,
+            });
+        }
+        let iframeDocument = null;
+        let iframeWindow = null;
+        try {
+            iframeWindow = iframe.contentWindow;
+            iframeDocument = iframe.contentDocument;
+            void iframeWindow?.document?.body;
+        }
+        catch {
+            return {
+                success: false,
+                scope: normalizedScope,
+                error: "The current page iframe is not accessible from the editor, so screenshot capture is unavailable.",
+            };
+        }
+        if (!iframeDocument?.documentElement || !iframeDocument.body || !iframeWindow) {
+            return {
+                success: false,
+                scope: normalizedScope,
+                error: "The current page has not finished loading inside the editor iframe.",
+            };
+        }
+        targetElement = iframeDocument.documentElement;
+        pageSize = getPageDimensions(iframeDocument);
+        const zoom = activeSlotContext?.primaryPageViewContext.zoom ?? 1;
+        try {
+            captureArea = resolveCaptureArea(iframe, editContext?.page, editContext?.selection ?? [], zoom, params, pageSize);
+        }
+        catch (error) {
+            return {
+                success: false,
+                scope: normalizedScope,
+                error: error instanceof Error ? error.message : "Failed to resolve capture bounds.",
+            };
+        }
+    }
+    const rootStyle = targetElement.style;
+    const previousTransform = rootStyle.transform;
+    const previousTransformOrigin = rootStyle.transformOrigin;
+    const previousOverflow = rootStyle.overflow;
+    let canvas;
+    try {
+        rootStyle.transform = "none";
+        rootStyle.transformOrigin = "";
+        rootStyle.overflow = previousOverflow || "auto";
+        await new Promise((resolve) => requestAnimationFrame(() => resolve(undefined)));
+        canvas = await html2canvas(targetElement, {
+            backgroundColor: "#ffffff",
+            logging: false,
+            removeContainer: true,
+            scale: Math.min(globalThis.devicePixelRatio || 1, 2),
+            useCORS: true,
+            windowWidth: pageSize.width,
+            windowHeight: pageSize.height,
+            scrollX: 0,
+            scrollY: 0,
+            x: captureArea.bounds.x,
+            y: captureArea.bounds.y,
+            width: captureArea.bounds.width,
+            height: captureArea.bounds.height,
+        });
+    }
+    catch (error) {
+        return {
+            success: false,
+            scope: captureArea.scope,
+            error: error instanceof Error
+                ? error.message
+                : "Failed to render the requested screenshot.",
+        };
+    }
+    finally {
+        rootStyle.transform = previousTransform;
+        rootStyle.transformOrigin = previousTransformOrigin;
+        rootStyle.overflow = previousOverflow;
+    }
+    try {
+        const resultImage = await canvasToResultImage(canvas, captureArea.scope);
+        return {
+            success: true,
+            scope: captureArea.scope,
+            image: resultImage.image,
+            bounds: captureArea.bounds,
+            imageWidth: resultImage.width,
+            imageHeight: resultImage.height,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            scope: captureArea.scope,
+            error: error instanceof Error
+                ? error.message
+                : "Failed to encode the screenshot for the tool result.",
+        };
+    }
+}
+//# sourceMappingURL=capturePageScreenshot.js.map