@hanivanrizky/nestjs-browser-action 0.20.1 → 0.22.0

package/dist/services/browser-action.service.js

@@ -15,59 +15,63 @@ var BrowserActionService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BrowserActionService = void 0;
 const common_1 = require("@nestjs/common");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const class_validator_1 = require("class-validator");
+const core_1 = require("@nestjs/core");
 const path_util_1 = require("../utils/path.util");
 const workflow_validator_1 = require("../validators/workflow.validator");
 const page_service_1 = require("./page.service");
 const cookie_service_1 = require("./cookie.service");
 const cleansing_service_1 = require("./cleansing.service");
 const pipe_engine_1 = require("../pipes/pipe-engine");
+const operators_1 = require("../operators");
 const user_agent_util_1 = require("../utils/user-agent.util");
 const logger_util_1 = require("../utils/logger.util");
-const delay_util_1 = require("../utils/delay.util");
 const dom_util_1 = require("../utils/dom.util");
 const truncate_log_util_1 = require("../utils/truncate-log.util");
 const browser_action_constants_1 = require("../constants/browser-action.constants");
-const isTargetClosed = (err) => err instanceof Error &&
-    (err.message.includes('Target closed') ||
-        err.message.includes('No target with given id') ||
-        err.message.includes('detached Frame') ||
-        err.message.includes('Attempted to use detached') ||
-        err.message.includes('Execution context was destroyed') ||
-        err.message.includes('context was destroyed') ||
-        err.message.includes('Session closed') ||
-        err.message.includes('Navigating frame was detached'));
 let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
     pageService;
     cookieService;
     cleansingService;
+    moduleRef;
     moduleOptions;
     logger;
     pipeEngine = new pipe_engine_1.PipeEngine();
     activeDebugLogMaxLength;
-    constructor(pageService, cookieService, cleansingService, moduleOptions) {
+    extraction;
+    capture;
+    container;
+    workflow;
+    pagination;
+    constructor(pageService, cookieService, cleansingService, moduleRef, moduleOptions) {
         this.pageService = pageService;
         this.cookieService = cookieService;
         this.cleansingService = cleansingService;
+        this.moduleRef = moduleRef;
         this.moduleOptions = moduleOptions;
         this.logger = new logger_util_1.LoggerWithLevel(BrowserActionService_1.name, this.pageService.getLogLevel());
         this.activeDebugLogMaxLength =
             moduleOptions?.debugLogMaxLength ?? browser_action_constants_1.DEFAULT_DEBUG_LOG_MAX_LENGTH;
+        this.extraction = new operators_1.ExtractionOperator(this.pipeEngine, this.logger);
+        this.capture = new operators_1.CaptureOperator(this.logger);
+        this.container = new operators_1.ContainerOperator(this.extraction, this.pipeEngine, this.logger);
+        this.workflow = new operators_1.WorkflowOperator(this.extraction, this.container, this.pipeEngine, this.cleansingService, this.logger, () => this.cookieService);
+        this.pagination = new operators_1.PaginationOperator(this.logger);
+    }
+    async newPage() {
+        return this.moduleRef.resolve(page_service_1.PageService, undefined, { strict: false });
     }
     async takeScreenshot(url, path, options, scraperOptions) {
         this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Taking screenshot of ${url}`));
         const cloak = scraperOptions?.useRandomUserAgent
             ? { ...scraperOptions?.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : scraperOptions?.cloak;
-        const page = await this.pageService.navigateTo(url, this.buildNavOptions(scraperOptions), cloak, scraperOptions?.interceptResource);
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url, this.buildNavOptions(scraperOptions), cloak, scraperOptions?.interceptResource);
         try {
-            const result = await page.screenshot({ path, ...options });
-            return result;
+            return await this.capture.screenshot(page, path, options);
         }
         finally {
-            await this.pageService.closePage();
+            await pageService.closePage();
         }
     }
     async generatePDF(url, path, options, scraperOptions) {
@@ -75,99 +79,39 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
         const cloak = scraperOptions?.useRandomUserAgent
             ? { ...scraperOptions?.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : scraperOptions?.cloak;
-        const page = await this.pageService.navigateTo(url, this.buildNavOptions(scraperOptions), cloak, scraperOptions?.interceptResource);
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url, this.buildNavOptions(scraperOptions), cloak, scraperOptions?.interceptResource);
         try {
-            const pdf = await page.pdf({ path, ...options });
-            return Buffer.from(pdf);
+            return await this.capture.pdf(page, path, options);
         }
         finally {
-            await this.pageService.closePage();
+            await pageService.closePage();
         }
     }
     async captureTlsFingerprint(path, url = browser_action_constants_1.TLS_CAPTURE_URL) {
         this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Capturing TLS fingerprint from ${url}`));
-        const page = await this.pageService.navigateTo(url);
-        let rawJson;
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url);
         try {
-            rawJson = await page.evaluate(() => document.body.innerText);
+            return await this.capture.tlsFingerprint(page, path);
         }
         finally {
-            await this.pageService.closePage();
+            await pageService.closePage();
         }
-        const data = JSON.parse(rawJson);
-        const fingerprint = this.buildTlsFingerprint(data);
-        await fs_1.promises.mkdir((0, path_1.dirname)(path), { recursive: true });
-        await fs_1.promises.writeFile(path, JSON.stringify(fingerprint, null, 2), 'utf-8');
-        this.logger.log(`Saved TLS fingerprint to ${path}`);
-        return fingerprint;
-    }
-    buildTlsFingerprint(data) {
-        const tls = (data.tls ?? {});
-        const http2 = (data.http2 ?? {});
-        const extensions = Array.isArray(tls.extensions)
-            ? tls.extensions
-            : [];
-        const sentFrames = Array.isArray(http2.sent_frames)
-            ? http2.sent_frames
-            : [];
-        const headersFrame = sentFrames.find((frame) => frame.frame_type === 'HEADERS');
-        return {
-            capturedAt: new Date().toISOString(),
-            ip: data.ip ?? '',
-            httpVersion: data.http_version ?? '',
-            method: data.method ?? '',
-            userAgent: data.user_agent ?? '',
-            ja3: tls.ja3 ?? '',
-            ja3Hash: tls.ja3_hash ?? '',
-            ja4: tls.ja4 ?? '',
-            ja4_r: tls.ja4_r,
-            peetprint: tls.peetprint ?? '',
-            peetprintHash: tls.peetprint_hash ?? '',
-            ciphers: Array.isArray(tls.ciphers) ? tls.ciphers : [],
-            tlsExtensions: extensions.map((ext) => String(ext.name)),
-            akamaiFingerprint: http2.akamai_fingerprint ?? '',
-            akamaiFingerprintHash: http2.akamai_fingerprint_hash ?? '',
-            headers: Array.isArray(headersFrame?.headers)
-                ? headersFrame.headers
-                : [],
-            raw: data,
-        };
     }
     async scrape(url, selectors, options) {
         this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Scraping ${url}`));
         const cloak = options?.useRandomUserAgent
             ? { ...options?.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : options?.cloak;
-        const page = await this.pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
-        const result = {};
-        const evalOne = page['$eval'].bind(page);
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
         try {
-            await Promise.all(Object.entries(selectors).map(async ([key, rawSelector]) => {
-                const { selector, attribute } = this.parseSelector(rawSelector);
-                try {
-                    const value = attribute
-                        ? await evalOne(selector, (el, attr) => el.getAttribute(attr), attribute)
-                        : await evalOne(selector, (el) => el.textContent);
-                    result[key] = options?.pipes?.[key]
-                        ? this.pipeEngine.apply(typeof value === 'string' ? value : String(value ?? ''), options.pipes[key], url)
-                        : value;
-                }
-                catch (err) {
-                    this.logger.warn(`Failed to scrape '${key}' (${rawSelector}): ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }));
+            return await this.extraction.extractSingle(page, url, selectors, options?.pipes);
         }
         finally {
-            await this.pageService.closePage();
-        }
-        return result;
-    }
-    parseSelector(raw) {
-        const match = raw.match(/^(.*)@([A-Za-z_][\w-]*)$/);
-        if (match && match[1].trim() !== '') {
-            return { selector: match[1], attribute: match[2] };
+            await pageService.closePage();
         }
-        return { selector: raw };
     }
     buildNavOptions(options) {
         if (!options?.waitUntil && !options?.timeout)
@@ -182,12 +126,13 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
         const cloak = options?.useRandomUserAgent
             ? { ...options?.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : options?.cloak;
-        const page = await this.pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
         const result = {};
         const evalAll = page['$$eval'].bind(page);
-        Object.entries(selectors).forEach(([key, selector]) => this.validateSelector(key, selector));
+        Object.entries(selectors).forEach(([key, selector]) => this.extraction.validateSelector(key, selector));
         await Promise.all(Object.entries(selectors).map(async ([key, rawSelector]) => {
-            const { selector, attribute } = this.parseSelector(rawSelector);
+            const { selector, attribute } = this.extraction.parseSelector(rawSelector);
             try {
                 const isXPath = (0, dom_util_1.isXPathSelector)(selector);
                 let values;
@@ -232,7 +177,7 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
                 this.logger.warn(`Failed to scrape '${key}' (${rawSelector}): ${err instanceof Error ? err.message : String(err)}`);
             }
         }));
-        await this.pageService.closePage();
+        await pageService.closePage();
         return result;
     }
     async scrapeContainerFields(url, descriptor, options) {
@@ -240,12 +185,13 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
         const cloak = options?.useRandomUserAgent
             ? { ...options?.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : options?.cloak;
+        const pageService = await this.newPage();
         let page;
         try {
-            page = await this.pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
+            page = await pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
         }
         catch (err) {
-            await this.pageService.closePage();
+            await pageService.closePage();
             throw err;
         }
         try {
@@ -273,7 +219,7 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
             return { items, pagination: raw.pagination };
         }
         finally {
-            await this.pageService.closePage();
+            await pageService.closePage();
         }
     }
     async evaluateWebsite(options) {
@@ -325,7 +271,7 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
             const template = pagination.urlTemplate ?? url;
             const startPage = pagination.startPage ?? 2;
             const { items: page1Items } = await this.scrapeContainerFields(url, descriptor, scraperOpts);
-            const { items: restItems, pages: restPages } = await this.paginateUrlIncrement(template, async (pageUrl) => {
+            const { items: restItems, pages: restPages } = await this.pagination.paginateUrlIncrement(template, async (pageUrl) => {
                 const { items } = await this.scrapeContainerFields(pageUrl, descriptor, scraperOpts);
                 return items;
             }, pagination, startPage);
@@ -337,12 +283,13 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
         const cloak = scraperOpts.useRandomUserAgent
             ? { ...scraperOpts.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : scraperOpts.cloak;
+        const pageService = await this.newPage();
         let page;
         try {
-            page = await this.pageService.navigateTo(url, this.buildNavOptions(scraperOpts), cloak, scraperOpts.interceptResource);
+            page = await pageService.navigateTo(url, this.buildNavOptions(scraperOpts), cloak, scraperOpts.interceptResource);
         }
         catch (err) {
-            await this.pageService.closePage();
+            await pageService.closePage();
             throw err;
         }
         try {
@@ -370,271 +317,29 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
                 });
             };
             if (pagination.type === 'click-next') {
-                const { items, pages } = await this.paginateClickNext(page, containerFn, pagination);
+                const { items, pages } = await this.pagination.paginateClickNext(page, containerFn, pagination);
                 return { results: items, totalPages: pages };
             }
             else if (pagination.type === 'load-more') {
-                const { items, pages } = await this.paginateLoadMore(page, containerFn, pagination);
+                const { items, pages } = await this.pagination.paginateLoadMore(page, containerFn, pagination);
                 return { results: items, totalPages: pages };
             }
             else {
-                const { items, pages } = await this.paginateInfiniteScroll(page, containerFn, pagination);
+                const { items, pages } = await this.pagination.paginateInfiniteScroll(page, containerFn, pagination);
                 return { results: items, totalPages: pages };
             }
         }
         finally {
-            await this.pageService.closePage();
-        }
-    }
-    async findPaginationElement(page, selector) {
-        if (!(0, dom_util_1.isXPathSelector)(selector)) {
-            return page.$(selector);
-        }
-        const pageWithX = page;
-        if (typeof pageWithX.$x === 'function') {
-            const results = await pageWithX.$x(selector);
-            return results[0] ?? null;
-        }
-        const handle = await page
-            .evaluateHandle((sel) => {
-            const res = document.evaluate(sel, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-            return res.singleNodeValue;
-        }, selector)
-            .then((h) => h.asElement());
-        return handle;
-    }
-    async paginateClickNext(page, containerFn, opts) {
-        const max = opts.maxPages ?? 10;
-        const wait = opts.waitAfter ?? 800;
-        const all = [];
-        let pages = 0;
-        for (let i = 0; i < max; i++) {
-            try {
-                const items = await containerFn(page);
-                all.push(...items);
-                pages++;
-                if (!opts.selector)
-                    break;
-                const btn = await this.findPaginationElement(page, opts.selector);
-                if (!btn)
-                    break;
-                await Promise.all([
-                    page.waitForNavigation({ waitUntil: 'domcontentloaded' }),
-                    btn.click(),
-                ]);
-                await (0, delay_util_1.delay)(wait);
-            }
-            catch (err) {
-                if (isTargetClosed(err))
-                    break;
-                if (err instanceof Error && err.message.includes('TimeoutError'))
-                    break;
-                throw err;
-            }
-        }
-        return { items: all, pages };
-    }
-    async paginateLoadMore(page, containerFn, opts) {
-        const max = opts.maxPages ?? 10;
-        const wait = opts.waitAfter ?? 800;
-        let previousCount = 0;
-        let clicks = 0;
-        let lastItems = [];
-        for (let i = 0; i < max; i++) {
-            try {
-                const items = await containerFn(page);
-                if (items.length === previousCount) {
-                    return { items, pages: clicks + 1 };
-                }
-                lastItems = items;
-                previousCount = items.length;
-                if (!opts.selector)
-                    break;
-                const btn = await this.findPaginationElement(page, opts.selector);
-                if (!btn)
-                    break;
-                await btn.click();
-                clicks++;
-                await (0, delay_util_1.delay)(wait);
-            }
-            catch (err) {
-                if (isTargetClosed(err))
-                    break;
-                throw err;
-            }
-        }
-        try {
-            const finalItems = await containerFn(page);
-            return { items: finalItems, pages: clicks + 1 };
-        }
-        catch (err) {
-            if (isTargetClosed(err))
-                return { items: lastItems, pages: clicks + 1 };
-            throw err;
-        }
-    }
-    async paginateInfiniteScroll(page, containerFn, opts) {
-        const max = opts.maxPages ?? 10;
-        const wait = opts.waitAfter ?? 800;
-        let previousCount = 0;
-        let scrolls = 0;
-        let lastItems = [];
-        for (let i = 0; i < max; i++) {
-            try {
-                const items = await containerFn(page);
-                if (opts.endSelector) {
-                    const endEl = await this.findPaginationElement(page, opts.endSelector);
-                    if (endEl)
-                        return { items, pages: scrolls + 1 };
-                }
-                if (items.length === previousCount)
-                    return { items, pages: scrolls + 1 };
-                lastItems = items;
-                previousCount = items.length;
-                if (opts.selector) {
-                    const sentinel = await this.findPaginationElement(page, opts.selector);
-                    if (sentinel) {
-                        await page.evaluate((el) => el.scrollIntoView(), sentinel);
-                    }
-                    else {
-                        await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
-                    }
-                }
-                else {
-                    await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
-                }
-                scrolls++;
-                await (0, delay_util_1.delay)(wait);
-            }
-            catch (err) {
-                if (isTargetClosed(err))
-                    break;
-                throw err;
-            }
-        }
-        try {
-            const finalItems = await containerFn(page);
-            return { items: finalItems, pages: scrolls + 1 };
-        }
-        catch (err) {
-            if (isTargetClosed(err))
-                return { items: lastItems, pages: scrolls + 1 };
-            throw err;
-        }
-    }
-    async paginateUrlIncrement(urlTemplate, containerFn, opts, startPage) {
-        const max = opts.maxPages ?? 10;
-        const wait = opts.waitAfter ?? 800;
-        const all = [];
-        let pagesScraped = 0;
-        for (let p = startPage; p < startPage + max; p++) {
-            try {
-                const url = urlTemplate.replace('{page}', String(p));
-                const items = await containerFn(url);
-                if (items.length === 0)
-                    break;
-                all.push(...items);
-                pagesScraped++;
-                if (p < startPage + max - 1)
-                    await (0, delay_util_1.delay)(wait);
-            }
-            catch (err) {
-                if (isTargetClosed(err))
-                    break;
-                throw err;
-            }
+            await pageService.closePage();
         }
-        return { items: all, pages: pagesScraped };
-    }
-    async extractAllData(page, target, as = 'text', attribute) {
-        if (target.shadowHost && !target.value) {
-            const hosts = await page.$$(target.shadowHost);
-            const results = await Promise.all(hosts.map((host) => host.evaluate((el, extractAs, attr) => {
-                const sr = el.shadowRoot;
-                if (!sr)
-                    return '';
-                if (extractAs === 'html' || extractAs === 'outerHtml')
-                    return sr.innerHTML;
-                if (extractAs === 'attribute')
-                    return el.getAttribute(attr || '') || '';
-                return sr.textContent?.trim() || '';
-            }, as, attribute)));
-            return results;
-        }
-        if (target.shadowHost) {
-            return await this.extractAllFromShadowRoot(page, target, as, attribute);
-        }
-        if (target.type === 'css') {
-            return await page.$$eval(target.value, (elements, extractAs, attr) => elements.map((el) => {
-                if (extractAs === 'html')
-                    return el.innerHTML;
-                if (extractAs === 'outerHtml')
-                    return el.outerHTML;
-                if (extractAs === 'attribute')
-                    return el.getAttribute(attr || '') || '';
-                return el.textContent?.trim() || '';
-            }), as, attribute);
-        }
-        return await page.evaluate((selector, extractAs, attr) => {
-            const results = document.evaluate(selector, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-            const values = [];
-            for (let i = 0; i < results.snapshotLength; i++) {
-                const node = results.snapshotItem(i);
-                if (!(node instanceof Element)) {
-                    values.push(node?.textContent?.trim() || '');
-                    continue;
-                }
-                if (extractAs === 'html')
-                    values.push(node.innerHTML);
-                else if (extractAs === 'outerHtml')
-                    values.push(node.outerHTML);
-                else if (extractAs === 'attribute')
-                    values.push(node.getAttribute(attr || '') || '');
-                else
-                    values.push(node.textContent?.trim() || '');
-            }
-            return values;
-        }, target.value, as, attribute);
-    }
-    async extractAllFromShadowRoot(page, target, as = 'text', attribute) {
-        const hosts = await page.$$(target.shadowHost);
-        const allResults = await Promise.all(hosts.map(async (host) => {
-            return await host.evaluate((el, selector, targetType, extractAs, attr) => {
-                const shadowRoot = el.shadowRoot;
-                if (!shadowRoot)
-                    return [];
-                const getVal = (e) => {
-                    if (extractAs === 'html')
-                        return e.innerHTML;
-                    if (extractAs === 'outerHtml')
-                        return e.outerHTML;
-                    if (extractAs === 'attribute')
-                        return e.getAttribute(attr || '') || '';
-                    return e.textContent?.trim() || '';
-                };
-                if (targetType === 'css') {
-                    const elements = shadowRoot.querySelectorAll(selector);
-                    return Array.from(elements).map(getVal);
-                }
-                const results = document.evaluate(selector, shadowRoot, null, XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null);
-                const values = [];
-                let node;
-                while ((node = results.iterateNext())) {
-                    values.push(node instanceof Element
-                        ? getVal(node)
-                        : node?.textContent?.trim() || '');
-                }
-                return values;
-            }, target.value, target.type, as, attribute);
-        }));
-        return allResults.flat();
     }
     async waitForSelector(url, selector, timeout, scraperOptions) {
         this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Waiting for ${selector} on ${url}`));
         const cloak = scraperOptions?.useRandomUserAgent
             ? { ...scraperOptions?.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : scraperOptions?.cloak;
-        const page = await this.pageService.navigateTo(url, this.buildNavOptions(scraperOptions), cloak, scraperOptions?.interceptResource);
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url, this.buildNavOptions(scraperOptions), cloak, scraperOptions?.interceptResource);
         await page.waitForSelector(selector, { timeout });
         return page;
     }
@@ -643,11 +348,12 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
         const cloak = options?.useRandomUserAgent
             ? { ...options?.cloak, userAgent: (0, user_agent_util_1.getRandomUserAgent)() }
             : options?.cloak;
-        const page = await this.pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url, this.buildNavOptions(options), cloak, options?.interceptResource);
         const result = typeof script === 'function'
             ? await page.evaluate(script)
             : await page.evaluate(script);
-        await this.pageService.closePage();
+        await pageService.closePage();
         return result;
     }
     async scrapeWithWorkflow(url, workflow, variables) {
@@ -657,7 +363,8 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
                 this.moduleOptions?.debugLogMaxLength ??
                 browser_action_constants_1.DEFAULT_DEBUG_LOG_MAX_LENGTH;
         this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Starting workflow execution for ${url}`));
-        const page = await this.pageService.navigateTo(url, undefined, workflow.cloak, workflow.interceptResource);
+        const pageService = await this.newPage();
+        const page = await pageService.navigateTo(url, undefined, workflow.cloak, workflow.interceptResource);
         const result = {
             success: false,
             data: {},
@@ -669,7 +376,7 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
             const errorConfig = workflow.onError || {};
             for (const action of workflow.actions) {
                 try {
-                    await this.executeAction(page, action, context);
+                    await this.workflow.executeAction(page, action, context, this.activeDebugLogMaxLength);
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -685,7 +392,7 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
                     }
                     if (!errorConfig.continue) {
                         result.errors.push(errorMessage);
-                        await this.pageService.closePage();
+                        await pageService.closePage();
                         return result;
                     }
                 }
@@ -699,666 +406,36 @@ let BrowserActionService = BrowserActionService_1 = class BrowserActionService {
             this.logger.error(`Workflow execution failed: ${errorMessage}`);
         }
         finally {
-            await this.pageService.closePage();
+            await pageService.closePage();
         }
         return result;
     }
     async scrapeAllWithWorkflow(url, workflow, variables) {
         return await this.scrapeWithWorkflow(url, workflow, variables);
     }
+    async executeContainerExtraction(page, descriptor, currentPage = 1) {
+        return this.container.executeContainerExtraction(page, descriptor, currentPage);
+    }
     async executeAction(page, action, context) {
         if (action.condition) {
             const shouldExecute = await this.evaluateCondition(page, action.condition);
-            if (!shouldExecute) {
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Skipping action due to condition: ${action.action}`));
+            if (!shouldExecute)
                 return;
-            }
-        }
-        const value = this.interpolateValue(String(action.value || ''), context);
-        const actionLabel = action.id
-            ? `[${action.action}] id="${action.id}"`
-            : `[${action.action}]`;
-        this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Executing action: ${actionLabel}`));
-        const maxRetries = Math.min(action.options?.retry ?? 0, 100);
-        const retryDelay = Math.min(action.options?.retryDelay ?? 0, 300_000);
-        for (let attempt = 0;; attempt++) {
-            try {
-                await this.dispatchAction(page, action, value, context);
-                return;
-            }
-            catch (err) {
-                if (attempt >= maxRetries)
-                    throw err;
-                this.logger.warn((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Action ${actionLabel} failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying: ${err instanceof Error ? err.message : String(err)}`));
-                if (retryDelay > 0)
-                    await (0, delay_util_1.delay)(retryDelay);
-            }
-        }
-    }
-    async dispatchAction(page, action, value, context) {
-        switch (action.action) {
-            case 'navigate': {
-                const navOptions = {};
-                if (action.options?.waitUntil)
-                    navOptions.waitUntil = action.options.waitUntil;
-                if (action.options?.timeout)
-                    navOptions.timeout = action.options.timeout;
-                if (!(0, class_validator_1.isURL)(value, {
-                    require_protocol: true,
-                    protocols: ['http', 'https'],
-                })) {
-                    throw new Error(`Invalid or disallowed URL: ${value}`);
-                }
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  navigate → ${value}`));
-                await page.goto(value, Object.keys(navOptions).length ? navOptions : undefined);
-                break;
-            }
-            case 'wait':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  wait ${Number(action.value) || 0}ms`));
-                await (0, delay_util_1.delay)(Math.min(Number(action.value) || 0, 300_000));
-                break;
-            case 'waitFor':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  waitFor target: ${this.describeTarget(action.target)}`));
-                await this.waitForTarget(page, action.target, action.options);
-                break;
-            case 'click':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  click target: ${this.describeTarget(action.target)}`));
-                await this.clickElement(page, action.target, action.options);
-                break;
-            case 'type':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  type target: ${this.describeTarget(action.target)} value: "${value}"`));
-                await this.typeText(page, action.target, value, action.options);
-                break;
-            case 'select':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  select target: ${this.describeTarget(action.target)} value: "${value}"`));
-                await this.selectOption(page, action.target, value, action.options);
-                break;
-            case 'scroll':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  scroll target: ${this.describeTarget(action.target)}`));
-                await this.scrollToElement(page, action.target);
-                break;
-            case 'extract': {
-                const extractOptions = action.options || {};
-                const extractAs = extractOptions.as ?? 'text';
-                const extractAttr = extractOptions.attribute;
-                if (!action.target) {
-                    this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  extract full page HTML`));
-                    if (action.id)
-                        context[action.id] = await page.content();
-                    break;
-                }
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  extract target: ${this.describeTarget(action.target)} as="${extractAs}"${extractAttr ? ` attr="${extractAttr}"` : ''}${extractOptions.multiple ? ' multiple=true' : ''}`));
-                if (extractOptions.multiple) {
-                    const allValues = await this.extractAllData(page, action.target, extractAs, extractAttr);
-                    if (action.id) {
-                        context[action.id] = allValues;
-                        this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  extracted ${Array.isArray(allValues) ? allValues.length : 1} item(s) → id="${action.id}"`));
-                    }
-                }
-                else {
-                    const extractedValue = await this.extractData(page, action.target, extractAs, extractAttr);
-                    if (action.id) {
-                        context[action.id] = extractedValue;
-                        this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  extracted → id="${action.id}": ${JSON.stringify(extractedValue)}`));
-                    }
-                }
-                break;
-            }
-            case 'screenshot': {
-                const screenshotPath = String(action.value || `${browser_action_constants_1.DEFAULT_SCREENSHOT_FILENAME}-${Date.now()}.png`);
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  screenshot → ${screenshotPath}`));
-                await page.screenshot({ path: screenshotPath });
-                break;
-            }
-            case 'evaluate': {
-                let evalCode;
-                if (value.includes('=>')) {
-                    evalCode = `(${value})()`;
-                }
-                else {
-                    evalCode = value;
-                }
-                if (evalCode.length > 50_000) {
-                    throw new Error('evaluate script exceeds maximum length of 50000 characters');
-                }
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Evaluating: ${evalCode}`));
-                const evalResult = await page.evaluate(evalCode);
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Result: ${JSON.stringify(evalResult)}`));
-                if (action.id) {
-                    context[action.id] = evalResult;
-                }
-                break;
-            }
-            case 'cleanse': {
-                const pipes = action.options?.pipes;
-                if (!pipes) {
-                    throw new Error('cleanse action requires pipes');
-                }
-                const valueKey = String(action.value || '');
-                const rawValue = this.resolveRawValue(valueKey, context);
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  cleanse raw: ${JSON.stringify(rawValue)}`));
-                const cleanedValue = Array.isArray(rawValue)
-                    ? rawValue.map((item) => this.pipeEngine.apply(String(item), pipes))
-                    : this.pipeEngine.apply(String(rawValue), pipes);
-                if (action.id) {
-                    context[action.id] = cleanedValue;
-                    this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `Cleansed value for '${action.id}': ${JSON.stringify(cleanedValue)}`));
-                }
-                break;
-            }
-            case 'saveCookies': {
-                const sessionName = String(value);
-                const overwrite = action.options?.overwrite ?? false;
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  saveCookies session="${sessionName}" overwrite=${overwrite}`));
-                const metadata = {};
-                if (action.options?.metadata) {
-                    Object.assign(metadata, action.options.metadata);
-                }
-                await this.cookieService.saveCookies(page, sessionName, {
-                    overwrite,
-                    metadata,
-                });
-                break;
-            }
-            case 'loadCookies': {
-                const sessionName = String(value);
-                const throwIfNotExists = action.onError !== 'skip' && action.onError !== 'continue';
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  loadCookies session="${sessionName}"`));
-                await this.cookieService.loadCookies(page, sessionName, {
-                    throwIfNotExists,
-                });
-                break;
-            }
-            case 'clearCookies': {
-                const sessionName = String(value);
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  clearCookies session="${sessionName}"`));
-                await this.cookieService.deleteCookies(sessionName);
-                break;
-            }
-            case 'listCookies': {
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  listCookies`));
-                const sessions = await this.cookieService.listCookies();
-                if (action.id) {
-                    context[action.id] = sessions;
-                }
-                break;
-            }
-            case 'hover':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  hover target: ${this.describeTarget(action.target)}`));
-                await this.hoverElement(page, action.target, action.options);
-                break;
-            case 'keyPress':
-                if (!value) {
-                    throw new Error('keyPress action requires a key value');
-                }
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  keyPress key="${value}"`));
-                await page.keyboard.press(value);
-                break;
-            case 'clear':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  clear target: ${this.describeTarget(action.target)}`));
-                await this.clearElement(page, action.target);
-                break;
-            case 'waitForNetwork':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  waitForNetwork timeout=${action.options?.timeout ?? browser_action_constants_1.DEFAULT_ACTION_TIMEOUT}ms`));
-                await page.waitForNetworkIdle({
-                    timeout: action.options?.timeout ?? browser_action_constants_1.DEFAULT_ACTION_TIMEOUT,
-                });
-                break;
-            case 'reload':
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  reload waitUntil="${action.options?.waitUntil ?? 'load'}"`));
-                await page.reload({
-                    waitUntil: action.options?.waitUntil ?? 'load',
-                    timeout: action.options?.timeout ?? browser_action_constants_1.DEFAULT_NAVIGATION_TIMEOUT,
-                });
-                break;
-            case 'scrapeContainer': {
-                const o = action.options;
-                if (!o?.container || !o?.fields) {
-                    throw new Error('scrapeContainer requires options.container and options.fields');
-                }
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  scrapeContainer container="${o.container}"`));
-                const containerResult = await this.executeContainerExtraction(page, {
-                    container: o.container,
-                    fields: o.fields,
-                    pagination: o.pagination,
-                }, o.currentPage ?? 1);
-                if (action.id) {
-                    context[action.id] = containerResult.items;
-                    if (containerResult.pagination) {
-                        context[`${action.id}_pagination`] = containerResult.pagination;
-                    }
-                    this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  scrapeContainer → id="${action.id}": ${containerResult.items.length} items`));
-                }
-                break;
-            }
-            case 'extractPagination': {
-                const o = action.options;
-                if (!o?.container || !o?.linkSelector || !o?.labelSelector) {
-                    throw new Error('extractPagination requires options.container, linkSelector, and labelSelector');
-                }
-                this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  extractPagination container="${o.container}"`));
-                const paginationResult = await this.resolvePagination(page, {
-                    container: o.container,
-                    linkSelector: o.linkSelector,
-                    labelSelector: o.labelSelector,
-                }, o.currentPage ?? 1);
-                if (action.id) {
-                    context[action.id] = paginationResult;
-                    this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  extractPagination → id="${action.id}": nextUrl=${paginationResult.nextUrl}`));
-                }
-                break;
-            }
-            default: {
-                const exhaustiveCheck = action.action;
-                throw new Error(`Unknown action type: ${String(exhaustiveCheck)}`);
-            }
         }
+        await this.workflow.executeAction(page, { ...action, condition: undefined }, context, this.activeDebugLogMaxLength);
     }
     async evaluateCondition(page, condition) {
-        if (!condition)
-            return true;
-        if (condition.ifExists) {
-            const element = await this.findElement(page, condition.ifExists);
-            return element !== null;
-        }
-        if (condition.unlessExists) {
-            const element = await this.findElement(page, condition.unlessExists);
-            return element === null;
-        }
-        return true;
-    }
-    describeTarget(target) {
-        const base = target.value
-            ? `${target.type}="${target.value}"`
-            : `(no selector)`;
-        return target.shadowHost
-            ? `shadowHost="${target.shadowHost}" > ${base}`
-            : base;
-    }
-    async findElement(page, target) {
-        this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  findElement: ${this.describeTarget(target)}`));
-        if (target.shadowHost) {
-            const el = await this.findElementInShadowRoot(page, target);
-            this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  findElement result: ${el ? 'found' : 'NOT FOUND'}`));
-            return el;
-        }
-        if (target.type === 'css') {
-            const el = await page.$(target.value);
-            this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  findElement result: ${el ? 'found' : 'NOT FOUND'}`));
-            return el;
-        }
-        const el = await page
-            .evaluateHandle((selector) => {
-            const result = document.evaluate(selector, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-            return result.singleNodeValue;
-        }, target.value)
-            .then((handle) => handle.asElement());
-        this.logger.debug((0, truncate_log_util_1.truncateLog)(this.activeDebugLogMaxLength, `  findElement result: ${el ? 'found' : 'NOT FOUND'}`));
-        return el;
-    }
-    async findElementInShadowRoot(page, target) {
-        const host = await page.$(target.shadowHost);
-        if (!host)
-            return null;
-        return host
-            .evaluateHandle((el, selector, targetType) => {
-            const shadowRoot = el.shadowRoot;
-            if (!shadowRoot)
-                return null;
-            if (targetType === 'css') {
-                return shadowRoot.querySelector(selector);
-            }
-            const result = document.evaluate(selector, shadowRoot, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-            return result.singleNodeValue;
-        }, target.value, target.type)
-            .then((handle) => handle.asElement());
-    }
-    async waitForTarget(page, target, options) {
-        const timeout = options?.timeout || browser_action_constants_1.DEFAULT_ACTION_TIMEOUT;
-        if (target.type === 'css') {
-            await page.waitForSelector(target.value, { timeout });
-        }
-        else {
-            await page.waitForFunction((selector) => {
-                const result = document.evaluate(selector, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-                return result.singleNodeValue !== null;
-            }, { timeout }, target.value);
-        }
-    }
-    async clickElement(page, target, options) {
-        const element = await this.findElement(page, target);
-        if (!element) {
-            throw new Error(`Element not found: ${target.value}`);
-        }
-        await this.maybeScrollToElement(element, options?.scrollTo);
-        const elem = element;
-        await elem.click();
-        if (options?.waitForNavigation) {
-            await page.waitForNavigation({
-                timeout: options.navigationTimeout || browser_action_constants_1.DEFAULT_NAVIGATION_TIMEOUT,
-            });
-        }
-    }
-    async typeText(page, target, value, options) {
-        const element = await this.findElement(page, target);
-        if (!element) {
-            throw new Error(`Element not found: ${target.value}`);
-        }
-        await this.maybeScrollToElement(element, options?.scrollTo);
-        const elem = element;
-        await elem.click();
-        const delay = options?.delay || 0;
-        await elem.type(value, { delay });
-        await elem.evaluate((el) => {
-            el.dispatchEvent(new Event('change', { bubbles: true }));
-            el.dispatchEvent(new Event('blur', { bubbles: true }));
-        });
-    }
-    async selectOption(page, target, value, options) {
-        const element = await this.findElement(page, target);
-        if (!element) {
-            throw new Error(`Element not found: ${target.value}`);
-        }
-        await this.maybeScrollToElement(element, options?.scrollTo);
-        const elem = element;
-        await elem.select(value);
-    }
-    async scrollToElement(page, target) {
-        const element = await this.findElement(page, target);
-        if (!element) {
-            throw new Error(`Element not found: ${target.value}`);
-        }
-        await this.scrollElementIntoView(element);
-    }
-    async maybeScrollToElement(element, shouldScroll) {
-        if (shouldScroll) {
-            await this.scrollElementIntoView(element);
-        }
-    }
-    async scrollElementIntoView(element) {
-        await element.evaluate((el) => el.scrollIntoView({ behavior: 'smooth', block: 'center' }), {});
-        await (0, delay_util_1.delay)(browser_action_constants_1.DEFAULT_SCROLL_DELAY_MS);
-    }
-    async executeContainerExtraction(page, descriptor, currentPage = 1) {
-        const rawItems = await page.evaluate((containerSel, fieldDefs) => {
-            const isXPath = (s) => s.trim().startsWith('//') ||
-                s.trim().startsWith('(') ||
-                s.trim().startsWith('./');
-            const getContainerNodes = (sel) => {
-                if (isXPath(sel)) {
-                    const res = document.evaluate(sel, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-                    const nodes = [];
-                    for (let i = 0; i < res.snapshotLength; i++)
-                        nodes.push(res.snapshotItem(i));
-                    return nodes;
-                }
-                return Array.from(document.querySelectorAll(sel));
-            };
-            const extractOne = (sel, root, attr, returnType) => {
-                let node = null;
-                if (isXPath(sel)) {
-                    const res = document.evaluate(sel, root, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-                    node = res.singleNodeValue;
-                }
-                else {
-                    node = root.querySelector(sel);
-                }
-                if (!node)
-                    return '';
-                if (attr)
-                    return node.getAttribute?.(attr) ?? '';
-                if (returnType === 'html')
-                    return node.innerHTML ?? '';
-                return node.textContent?.trim() ?? '';
-            };
-            const extractMany = (sel, root, attr, returnType) => {
-                let nodes = [];
-                if (isXPath(sel)) {
-                    const res = document.evaluate(sel, root, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-                    for (let i = 0; i < res.snapshotLength; i++)
-                        nodes.push(res.snapshotItem(i));
-                }
-                else {
-                    nodes = Array.from(root.querySelectorAll(sel));
-                }
-                return nodes.map((n) => {
-                    if (attr)
-                        return n.getAttribute?.(attr) ?? '';
-                    if (returnType === 'html')
-                        return n.innerHTML ?? '';
-                    return n.textContent?.trim() ?? '';
-                });
-            };
-            const extractField = (root, fd) => {
-                const selectors = [fd.selector, ...(fd.fallback ?? [])];
-                for (const sel of selectors) {
-                    const val = fd.multiple
-                        ? extractMany(sel, root, fd.attribute, fd.returnType)
-                        : extractOne(sel, root, fd.attribute, fd.returnType);
-                    if (Array.isArray(val) ? val.length > 0 : val !== '')
-                        return val;
-                }
-                return fd.multiple ? [] : '';
-            };
-            return getContainerNodes(containerSel).map((node) => {
-                const item = {};
-                for (const [key, fd] of Object.entries(fieldDefs))
-                    item[key] = extractField(node, fd);
-                return item;
-            });
-        }, descriptor.container, descriptor.fields);
-        const items = rawItems;
-        let pagination;
-        if (descriptor.pagination) {
-            pagination = await this.resolvePagination(page, descriptor.pagination, currentPage);
-        }
-        return { items, pagination };
-    }
-    async resolvePagination(page, descriptor, currentPage = 1) {
-        currentPage = Math.max(1, currentPage);
-        const rawPages = await page.evaluate((containerSel, linkSel, labelSel) => {
-            const getNode = (sel, root) => {
-                if (sel.trim().startsWith('//') ||
-                    sel.trim().startsWith('(') ||
-                    sel.trim().startsWith('./')) {
-                    const res = document.evaluate(sel, root, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-                    return res.singleNodeValue;
-                }
-                return root.querySelector(sel);
-            };
-            const getNodes = (sel, root) => {
-                if (sel.trim().startsWith('//') ||
-                    sel.trim().startsWith('(') ||
-                    sel.trim().startsWith('./')) {
-                    const res = document.evaluate(sel, root, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-                    const nodes = [];
-                    for (let i = 0; i < res.snapshotLength; i++)
-                        nodes.push(res.snapshotItem(i));
-                    return nodes;
-                }
-                return Array.from(root.querySelectorAll(sel));
-            };
-            const container = getNode(containerSel, document);
-            if (!container)
-                return [];
-            return getNodes(linkSel, container).map((el) => {
-                const isXPath = (s) => s.trim().startsWith('//') ||
-                    s.trim().startsWith('(') ||
-                    s.trim().startsWith('./');
-                const labelNodes = isXPath(labelSel)
-                    ? (() => {
-                        const r = document.evaluate(labelSel, el, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-                        const ns = [];
-                        for (let i = 0; i < r.snapshotLength; i++)
-                            ns.push(r.snapshotItem(i));
-                        return ns;
-                    })()
-                    : Array.from(el.querySelectorAll(labelSel));
-                const label = labelNodes.length > 0
-                    ? (labelNodes[0].textContent?.trim() ?? '')
-                    : (el.textContent?.trim() ?? '');
-                return {
-                    label,
-                    url: el.getAttribute('href') ?? '',
-                };
-            });
-        }, descriptor.container, descriptor.linkSelector, descriptor.labelSelector);
-        const pages = rawPages.filter((p) => p.url);
-        const numericNext = pages
-            .filter((p) => !Number.isNaN(parseInt(p.label, 10)) &&
-            parseInt(p.label, 10) > currentPage)
-            .sort((a, b) => parseInt(a.label, 10) - parseInt(b.label, 10))[0];
-        const nextUrl = numericNext?.url ??
-            pages.find((p) => ['next', '>'].includes(p.label.toLowerCase()))?.url ??
-            null;
-        return { pages, nextUrl };
-    }
-    validateSelector(key, selector) {
-        if (!selector || selector.trim() === '') {
-            throw new Error(`Selector for '${key}' cannot be empty`);
-        }
-    }
-    async extractData(page, target, as = 'text', attribute) {
-        if (target.shadowHost && !target.value) {
-            const host = await page.$(target.shadowHost);
-            if (!host)
-                throw new Error(`Shadow host not found: ${target.shadowHost}`);
-            return host.evaluate((el, extractAs, attr) => {
-                const sr = el.shadowRoot;
-                if (!sr)
-                    return '';
-                if (extractAs === 'html' || extractAs === 'outerHtml')
-                    return sr.innerHTML;
-                if (extractAs === 'attribute')
-                    return el.getAttribute(attr || '') || '';
-                return sr.textContent?.trim() || '';
-            }, as, attribute);
-        }
-        const element = await this.findElement(page, target);
-        if (!element) {
-            throw new Error(`Element not found: ${target.value}`);
-        }
-        return element.evaluate((el, extractAs, attr) => {
-            if (extractAs === 'html')
-                return el.innerHTML;
-            if (extractAs === 'outerHtml')
-                return el.outerHTML;
-            if (extractAs === 'attribute')
-                return el.getAttribute(attr || '') || '';
-            return el.textContent?.trim() || '';
-        }, as, attribute);
-    }
-    async hoverElement(page, target, options) {
-        const element = await this.findElement(page, target);
-        if (!element) {
-            throw new Error(`Element not found: ${target.value}`);
-        }
-        await this.maybeScrollToElement(element, options?.scrollTo);
-        const elem = element;
-        await elem.hover();
-    }
-    async clearElement(page, target) {
-        const element = await this.findElement(page, target);
-        if (!element) {
-            throw new Error(`Element not found: ${target.value}`);
-        }
-        await element.evaluate((el) => {
-            if ('value' in el) {
-                el.value = '';
-                el.dispatchEvent(new Event('input', { bubbles: true }));
-                el.dispatchEvent(new Event('change', { bubbles: true }));
-            }
-        });
-    }
-    resolveRawValue(value, context) {
-        if (value.startsWith('${') && value.endsWith('}')) {
-            const path = value.slice(2, -1);
-            if (!path.includes('${') && !path.includes('.') && !path.includes('[')) {
-                return context[path] ?? value;
-            }
-        }
-        return this.resolveValue(value, context);
-    }
-    resolveValue(value, context) {
-        if (value.startsWith('${') && value.endsWith('}')) {
-            const path = value.slice(2, -1);
-            if (!path.includes('${')) {
-                const keys = path.split('.');
-                let result = context;
-                for (const key of keys) {
-                    const arrayMatch = key.match(/^(\w+)\[(\d+)\]$/);
-                    if (arrayMatch) {
-                        const [, arrayKey, indexStr] = arrayMatch;
-                        if (!result || typeof result !== 'object') {
-                            return value;
-                        }
-                        const arrayValue = result[arrayKey];
-                        const index = parseInt(indexStr, 10);
-                        result = Array.isArray(arrayValue) ? arrayValue[index] : undefined;
-                    }
-                    else {
-                        if (!result || typeof result !== 'object') {
-                            return value;
-                        }
-                        result = result[key];
-                    }
-                    if (result === undefined) {
-                        return value;
-                    }
-                }
-                if (result === null || typeof result === 'object') {
-                    return value;
-                }
-                return result;
-            }
-            return this.interpolateValue(path, context);
-        }
-        return value;
-    }
-    interpolateValue(value, context) {
-        return value.replace(/\$\{([^}]+)\}/g, (_match, path) => {
-            const keys = path.split('.');
-            let result = context;
-            for (const key of keys) {
-                if (key === '__proto__' ||
-                    key === 'constructor' ||
-                    key === 'prototype') {
-                    return '';
-                }
-                const arrayMatch = key.match(/^(\w+)\[(\d+)\]$/);
-                if (arrayMatch) {
-                    const [, arrayKey, indexStr] = arrayMatch;
-                    if (!result || typeof result !== 'object') {
-                        return '';
-                    }
-                    const arrayValue = result[arrayKey];
-                    const index = parseInt(indexStr, 10);
-                    result = Array.isArray(arrayValue) ? arrayValue[index] : undefined;
-                }
-                else {
-                    if (!result || typeof result !== 'object') {
-                        return '';
-                    }
-                    result = result[key];
-                }
-                if (result === undefined) {
-                    return '';
-                }
-            }
-            if (result === null || typeof result === 'object') {
-                return '';
-            }
-            return result;
-        });
+        return this.workflow.evaluateCondition(page, condition, this.activeDebugLogMaxLength);
     }
 };
 exports.BrowserActionService = BrowserActionService;
 exports.BrowserActionService = BrowserActionService = BrowserActionService_1 = __decorate([
-    (0, common_1.Injectable)({ scope: common_1.Scope.TRANSIENT }),
-    __param(3, (0, common_1.Optional)()),
-    __param(3, (0, common_1.Inject)(browser_action_constants_1.BROWSER_ACTION_OPTIONS)),
+    (0, common_1.Injectable)(),
+    __param(4, (0, common_1.Optional)()),
+    __param(4, (0, common_1.Inject)(browser_action_constants_1.BROWSER_ACTION_OPTIONS)),
     __metadata("design:paramtypes", [page_service_1.PageService,
         cookie_service_1.CookieService,
-        cleansing_service_1.CleansingService, Object])
+        cleansing_service_1.CleansingService,
+        core_1.ModuleRef, Object])
 ], BrowserActionService);
 //# sourceMappingURL=browser-action.service.js.map