@d-zero/beholder 4.0.0 → 4.1.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [4.1.0](https://github.com/d-zero-dev/tools/compare/@d-zero/beholder@4.0.0...@d-zero/beholder@4.1.0) (2026-07-22)
+
+### Features
+
+- **beholder:** capture console messages and page errors ([f271bbb](https://github.com/d-zero-dev/tools/commit/f271bbb033f8cc6ccb21a3c2981d1c27b684e551))
+
 # [4.0.0](https://github.com/d-zero-dev/tools/compare/@d-zero/beholder@3.1.6...@d-zero/beholder@4.0.0) (2026-07-21)
 
 - feat(beholder)!: enrich PageData with mainContents metrics and scrollHeight ([8a0fc72](https://github.com/d-zero-dev/tools/commit/8a0fc72412295a92850b2c2fa2fa8cd8145eb5f6))

package/README.md

@@ -68,6 +68,16 @@ flowchart TD
 - `scrollHeight`: `{ desktop, mobile }`（各 `number | null`）。未計測時はフィールド全体が `null`
 - 配列要素のフィールド詳細は型（`MainContents*` / `ScrollHeightData`）を参照
 
+## console ログ・未捕捉例外の収集
+
+`ScrapeResult.consoleLogs`（`ConsoleLogEntry[]`）に、内部ページ（`isExternal: false`）が出力した `console` メッセージ（全type）と、未捕捉例外・未処理の Promise rejection（`page.on('pageerror')`、`type: 'pageerror'` として区別、スタックトレース付き）が格納される。`resources` と同様に `pageUrl` を持つ戻り値配列で、イベント経由では提供されない。`result.type` が `"success"` / `"skipped"` / `"error"` のいずれであっても常に配列として存在する（該当ログがなければ空配列）ため、エラー発生時のデバッグにもそのまま使える。
+
+```ts
+for (const entry of result.consoleLogs) {
+	console.log(entry.type, entry.text, entry.args);
+}
+```
+
 ## DOM 文字列からメタ抽出（Puppeteer なし）
 
 HTML 文字列を jsdom などでパースしてから `Meta` を取り出したい場合、`extractMetaFromDocument` を使う。`Scraper` が内部で呼ぶ `collectHead → detectTags → classify` パイプラインと同じ実装を再利用するため、戻り値の `Meta` 形状は `scrapeStart` と同一。DOM ライブラリ（jsdom 等）はユーザランドの責務。

package/dist/index.d.ts

@@ -18,6 +18,6 @@ export { detectCompress } from '@d-zero/shared/detect-compress';
 export type { CompressType } from '@d-zero/shared/detect-compress';
 export { detectCDN } from '@d-zero/shared/detect-cdn';
 export type { CDNType } from '@d-zero/shared/detect-cdn';
-export type { ScrapeResult, ResourceEntry, PageData } from './types.js';
+export type { ScrapeResult, ResourceEntry, ConsoleLogEntry, PageData } from './types.js';
 export type { ScraperOptions, ChangePhaseEvent, ScraperEventTypes } from './types.js';
 export type { Resource, AnchorData, Meta, ImageElement, SkippedPageData, NetworkLog, ScrollHeightData, MainContentsData, MainContentsMainTag, MainContentsHeading, MainContentsImage, MainContentsTable, MainContentsButton, MainContentsIframe, MainContentsVideo, MainContentsAudio, MainContentsCanvas, OpenGraphMeta, OgArticleMeta, OgBookMeta, OgProfileMeta, OgMusicMeta, OgVideoNsMeta, TwitterMeta, FbMeta, FediverseMeta, AppleMeta, MsApplicationMeta, VerificationMeta, GoogleMeta, GeoMeta, CitationMeta, RdfaMeta, MicrodataMeta, AmpMeta, LegacyMeta, MobileMeta, MicroformatsMeta, PinterestMeta, SlackMeta, LinkedInMeta, ExperimentalMeta, WikiMeta, LinkMeta, LinkEntry, JsonLdEntry, OthersBucket, ScriptEntry, IframeEntry, TagsMeta, TagDetail, TagEntry, TagSource, ViewportMeta, RobotsMeta, ReferrerMeta, FormatDetectionMeta, HttpEquivMeta, HttpEquivRefresh, RawHeadEntry, } from './types.js';

package/dist/scraper.d.ts

@@ -30,7 +30,10 @@ export default class Scraper extends EventEmitter<ScraperEventTypes> {
      * - `type: "error"` with `error` details when scraping fails
      *
      * Sub-resources are collected via the `resourceResponse` event and
-     * included in the returned `ScrapeResult.resources`.
+     * included in the returned `ScrapeResult.resources`. Console messages and
+     * uncaught page errors (internal pages only) are collected via
+     * Puppeteer's `console`/`pageerror` page events and included in
+     * `ScrapeResult.consoleLogs`.
      * @param page - The Puppeteer page instance to use for navigation and DOM evaluation.
      * @param url - The extended URL to scrape.
      * @param options - Optional scraper configuration overriding defaults.

package/dist/scraper.js

@@ -51,6 +51,8 @@ import { measureScrollHeight } from './measure-scroll-height.js';
 import { emptyMeta } from './meta/classify.js';
 import { findDisconnectionFailures } from './network-disconnection.js';
 import { parseUrl } from './parse-url.js';
+import { toConsoleLogEntry } from './to-console-log-entry.js';
+import { toPageErrorEntry } from './to-page-error-entry.js';
 const pid = `${process.pid}`;
 const log = scraperLog.extend(pid);
 const rLog = resourceLog.extend(pid);
@@ -121,17 +123,21 @@ let Scraper = (() => {
                         });
                     },
                 })];
-            __esDecorate(this, _private_fetchData_descriptor = { value: __setFunctionName(async function (page, url, isExternal, captureImages, imageLoadTimeout, resources, failedRequests, options) {
+            __esDecorate(this, _private_fetchData_descriptor = { value: __setFunctionName(async function (page, url, isExternal, captureImages, imageLoadTimeout, resources, consoleLogs, failedRequests, options) {
                     const parseOpts = options?.disableQueries == null
                         ? undefined
                         : { disableQueries: options.disableQueries };
                     const domEvaluationTimeout = options?.domEvaluationTimeout ?? DEFAULT_DOM_EVALUATION_TIMEOUT;
                     const networkLogs = {};
+                    // Tracks in-flight `toConsoleLogEntry()` resolutions (async `jsonValue()`
+                    // extraction) so callers can await them before reading `consoleLogs`.
+                    const pendingConsoleWork = [];
                     // Clear stale state from previous retries (@retryable may re-invoke this method
                     // with the same page and mutable arrays, so we must reset to avoid accumulation)
                     this.#cleanupPageListeners();
                     failedRequests.length = 0;
                     resources.length = 0;
+                    consoleLogs.length = 0;
                     // Define named listeners so they can be individually removed on retry/cleanup
                     const onDialog = async (dialog) => {
                         log(`Appear ${dialog.type()} dialog: ${dialog.message()}`);
@@ -147,6 +153,8 @@ let Scraper = (() => {
                     let onRequest = null;
                     let onResponse = null;
                     let onRequestFailed = null;
+                    let onConsole = null;
+                    let onPageError = null;
                     if (!isExternal) {
                         onRequest = (request) => {
                             const url = parseUrl(request.url(), parseOpts);
@@ -221,9 +229,23 @@ let Scraper = (() => {
                             rLog('Request failed: %s (%s)', request.url(), errorText);
                             failedRequests.push({ url: request.url(), errorText });
                         };
+                        onConsole = (msg) => {
+                            pendingConsoleWork.push(toConsoleLogEntry(msg, url.withoutHash).then((entry) => {
+                                consoleLogs.push(entry);
+                            }, (error) => {
+                                // A single malformed console message must not fail the whole
+                                // scrape (e.g. mid-navigation execution-context teardown).
+                                log('Error(CONSOLE_LOG): %s', error);
+                            }));
+                        };
+                        onPageError = (error) => {
+                            consoleLogs.push(toPageErrorEntry(error, url.withoutHash));
+                        };
                         page.on('request', onRequest);
                         page.on('response', onResponse);
                         page.on('requestfailed', onRequestFailed);
+                        page.on('console', onConsole);
+                        page.on('pageerror', onPageError);
                     }
                     // Store cleanup function for retry/post-fetch removal
                     this.#pageListenerCleanup = () => {
@@ -234,95 +256,184 @@ let Scraper = (() => {
                             page.off('response', onResponse);
                         if (onRequestFailed)
                             page.off('requestfailed', onRequestFailed);
+                        if (onConsole)
+                            page.off('console', onConsole);
+                        if (onPageError)
+                            page.off('pageerror', onPageError);
                     };
                     const navigationTimeout = options?.navigationTimeout ?? 60_000;
-                    void this.emit('changePhase', {
-                        pid: process.pid,
-                        name: 'openPage',
-                        url,
-                        isExternal,
-                        message: `%countdown(${navigationTimeout},openPage_${url.withoutHash},s)%s`,
-                    });
-                    if (url.username && url.password) {
-                        await page.setExtraHTTPHeaders({
-                            Authorization: `Basic ${Buffer.from(`${url.username}:${url.password}`).toString('base64')}`,
+                    // The whole navigation/extraction sequence below is wrapped in `finally`
+                    // so that `pendingConsoleWork` is always awaited exactly once — on every
+                    // return AND on every throw (e.g. `Page.goto returned null`, network
+                    // disconnection). A per-return-statement `await` would miss thrown exits
+                    // and let a still-resolving `toConsoleLogEntry()` push into `consoleLogs`
+                    // after a `@retryable` retry has already cleared it for a new attempt.
+                    try {
+                        void this.emit('changePhase', {
+                            pid: process.pid,
+                            name: 'openPage',
+                            url,
+                            isExternal,
+                            message: `%countdown(${navigationTimeout},openPage_${url.withoutHash},s)%s`,
                         });
-                    }
-                    const res = await page.goto(url.withoutHashAndAuth, { timeout: navigationTimeout });
-                    if (!res) {
-                        throw new Error('The method Page.goto returned null');
-                    }
-                    const destUrl = parseUrl(page.url(), parseOpts);
-                    const redirectPaths = new Set();
-                    if (url.withoutHash !== destUrl.withoutHash) {
-                        const redirectChain = res
-                            .request()
-                            .redirectChain()
-                            .map((req) => req.url());
-                        for (const redirectPath of redirectChain) {
-                            redirectPaths.add(redirectPath);
+                        if (url.username && url.password) {
+                            await page.setExtraHTTPHeaders({
+                                Authorization: `Basic ${Buffer.from(`${url.username}:${url.password}`).toString('base64')}`,
+                            });
                         }
-                        redirectPaths.add(destUrl.withoutHash);
-                    }
-                    if (destUrl.hostname !== url.hostname) {
-                        isExternal = true;
-                    }
-                    const status = res.status();
-                    const statusText = res.statusText();
-                    const responseHeaders = res.headers();
-                    const contentType = responseHeaders['content-type']?.split(';')[0] || null;
-                    const _contentLength = Number.parseInt(responseHeaders['content-length'] ?? '');
-                    const contentLength = Number.isFinite(_contentLength) ? _contentLength : null;
-                    if (!isHtmlContentType(contentType)) {
-                        return {
+                        const res = await page.goto(url.withoutHashAndAuth, { timeout: navigationTimeout });
+                        if (!res) {
+                            throw new Error('The method Page.goto returned null');
+                        }
+                        const destUrl = parseUrl(page.url(), parseOpts);
+                        const redirectPaths = new Set();
+                        if (url.withoutHash !== destUrl.withoutHash) {
+                            const redirectChain = res
+                                .request()
+                                .redirectChain()
+                                .map((req) => req.url());
+                            for (const redirectPath of redirectChain) {
+                                redirectPaths.add(redirectPath);
+                            }
+                            redirectPaths.add(destUrl.withoutHash);
+                        }
+                        if (destUrl.hostname !== url.hostname) {
+                            isExternal = true;
+                        }
+                        const status = res.status();
+                        const statusText = res.statusText();
+                        const responseHeaders = res.headers();
+                        const contentType = responseHeaders['content-type']?.split(';')[0] || null;
+                        const _contentLength = Number.parseInt(responseHeaders['content-length'] ?? '');
+                        const contentLength = Number.isFinite(_contentLength) ? _contentLength : null;
+                        if (!isHtmlContentType(contentType)) {
+                            return {
+                                url,
+                                isTarget: false,
+                                isExternal,
+                                redirectPaths: [...redirectPaths],
+                                status,
+                                statusText,
+                                contentType,
+                                contentLength,
+                                responseHeaders,
+                                meta: emptyMeta(),
+                                imageList: [],
+                                anchorList: [],
+                                html: '',
+                                mainContents: null,
+                                scrollHeight: null,
+                                isSkipped: false,
+                            };
+                        }
+                        void this.emit('changePhase', {
+                            pid: process.pid,
+                            name: 'loadDOMContent',
                             url,
-                            isTarget: false,
                             isExternal,
-                            redirectPaths: [...redirectPaths],
-                            status,
-                            statusText,
-                            contentType,
-                            contentLength,
-                            responseHeaders,
-                            meta: emptyMeta(),
-                            imageList: [],
-                            anchorList: [],
-                            html: '',
-                            mainContents: null,
-                            scrollHeight: null,
-                            isSkipped: false,
-                        };
-                    }
-                    void this.emit('changePhase', {
-                        pid: process.pid,
-                        name: 'loadDOMContent',
-                        url,
-                        isExternal,
-                        message: '',
-                    });
-                    await page
-                        .waitForNavigation({ waitUntil: 'domcontentloaded', timeout: 5000 })
-                        .catch(() => { });
-                    void this.emit('changePhase', {
-                        pid: process.pid,
-                        name: 'getHTML',
-                        url,
-                        isExternal,
-                        message: '',
-                    });
-                    const { title, html } = await page.evaluate(() => {
-                        /* global document */
-                        return {
-                            title: document.title,
-                            html: document.documentElement.outerHTML,
-                        };
-                    });
-                    if (isExternal) {
-                        const externalMeta = emptyMeta();
-                        externalMeta.title = title;
+                            message: '',
+                        });
+                        await page
+                            .waitForNavigation({ waitUntil: 'domcontentloaded', timeout: 5000 })
+                            .catch(() => { });
+                        void this.emit('changePhase', {
+                            pid: process.pid,
+                            name: 'getHTML',
+                            url,
+                            isExternal,
+                            message: '',
+                        });
+                        const { title, html } = await page.evaluate(() => {
+                            /* global document */
+                            return {
+                                title: document.title,
+                                html: document.documentElement.outerHTML,
+                            };
+                        });
+                        if (isExternal) {
+                            const externalMeta = emptyMeta();
+                            externalMeta.title = title;
+                            return {
+                                url,
+                                isTarget: false,
+                                isExternal,
+                                redirectPaths: [...redirectPaths],
+                                status,
+                                statusText,
+                                contentType,
+                                contentLength,
+                                responseHeaders,
+                                meta: externalMeta,
+                                imageList: [],
+                                anchorList: [],
+                                html,
+                                mainContents: null,
+                                scrollHeight: null,
+                                isSkipped: false,
+                            };
+                        }
+                        void this.emit('changePhase', {
+                            pid: process.pid,
+                            name: 'waitNetworkIdle',
+                            url,
+                            isExternal,
+                            message: '',
+                        });
+                        await page
+                            .waitForNavigation({ waitUntil: 'networkidle0', timeout: 5000 })
+                            .catch(() => { });
+                        // Check for network disconnection errors in failed requests
+                        const disconnectionFailures = findDisconnectionFailures(failedRequests);
+                        if (disconnectionFailures.length > 0) {
+                            const errorSummary = disconnectionFailures
+                                .map((r) => `${r.url} (${r.errorText})`)
+                                .join(', ');
+                            throw new Error(`Network disconnection detected during page load: ${errorSummary}`);
+                        }
+                        const mainContents = await getMainContents(page, {
+                            mainContentSelector: options?.mainContentSelector,
+                        });
+                        void this.emit('changePhase', {
+                            pid: process.pid,
+                            name: 'getAnchors',
+                            url,
+                            isExternal,
+                            message: `%countdown(${domEvaluationTimeout},getAnchors_${url.withoutHash},s)%s`,
+                        });
+                        const anchorList = await getAnchorList(page, parseOpts, domEvaluationTimeout);
+                        void this.emit('changePhase', {
+                            pid: process.pid,
+                            name: 'getMeta',
+                            url,
+                            isExternal,
+                            message: `%countdown(${domEvaluationTimeout},getMeta_${url.withoutHash},s)%s`,
+                        });
+                        const meta = await getMeta(page, {
+                            url: url.withoutHashAndAuth,
+                            html,
+                            statusCode: status,
+                            headers: responseHeaders ?? undefined,
+                        }, domEvaluationTimeout);
+                        let imageList = [];
+                        let scrollHeight = null;
+                        if (captureImages) {
+                            void this.emit('changePhase', {
+                                pid: process.pid,
+                                name: 'extractImages',
+                                url,
+                                isExternal,
+                                message: `%countdown(${domEvaluationTimeout},extractImages_${url.withoutHash},s)%s`,
+                            });
+                            const fetched = await this.#fetchImages(page, url.withoutHashAndAuth, isExternal, imageLoadTimeout, domEvaluationTimeout);
+                            imageList = fetched.imageList;
+                            scrollHeight = fetched.scrollHeight;
+                        }
+                        else {
+                            scrollHeight = await measureScrollHeight(page);
+                        }
                         return {
                             url,
-                            isTarget: false,
+                            isTarget: true,
                             isExternal,
                             redirectPaths: [...redirectPaths],
                             status,
@@ -330,92 +441,18 @@ let Scraper = (() => {
                             contentType,
                             contentLength,
                             responseHeaders,
-                            meta: externalMeta,
-                            imageList: [],
-                            anchorList: [],
+                            meta,
+                            anchorList,
+                            imageList,
                             html,
-                            mainContents: null,
-                            scrollHeight: null,
+                            mainContents,
+                            scrollHeight,
                             isSkipped: false,
                         };
                     }
-                    void this.emit('changePhase', {
-                        pid: process.pid,
-                        name: 'waitNetworkIdle',
-                        url,
-                        isExternal,
-                        message: '',
-                    });
-                    await page
-                        .waitForNavigation({ waitUntil: 'networkidle0', timeout: 5000 })
-                        .catch(() => { });
-                    // Check for network disconnection errors in failed requests
-                    const disconnectionFailures = findDisconnectionFailures(failedRequests);
-                    if (disconnectionFailures.length > 0) {
-                        const errorSummary = disconnectionFailures
-                            .map((r) => `${r.url} (${r.errorText})`)
-                            .join(', ');
-                        throw new Error(`Network disconnection detected during page load: ${errorSummary}`);
-                    }
-                    const mainContents = await getMainContents(page, {
-                        mainContentSelector: options?.mainContentSelector,
-                    });
-                    void this.emit('changePhase', {
-                        pid: process.pid,
-                        name: 'getAnchors',
-                        url,
-                        isExternal,
-                        message: `%countdown(${domEvaluationTimeout},getAnchors_${url.withoutHash},s)%s`,
-                    });
-                    const anchorList = await getAnchorList(page, parseOpts, domEvaluationTimeout);
-                    void this.emit('changePhase', {
-                        pid: process.pid,
-                        name: 'getMeta',
-                        url,
-                        isExternal,
-                        message: `%countdown(${domEvaluationTimeout},getMeta_${url.withoutHash},s)%s`,
-                    });
-                    const meta = await getMeta(page, {
-                        url: url.withoutHashAndAuth,
-                        html,
-                        statusCode: status,
-                        headers: responseHeaders ?? undefined,
-                    }, domEvaluationTimeout);
-                    let imageList = [];
-                    let scrollHeight = null;
-                    if (captureImages) {
-                        void this.emit('changePhase', {
-                            pid: process.pid,
-                            name: 'extractImages',
-                            url,
-                            isExternal,
-                            message: `%countdown(${domEvaluationTimeout},extractImages_${url.withoutHash},s)%s`,
-                        });
-                        const fetched = await this.#fetchImages(page, url.withoutHashAndAuth, isExternal, imageLoadTimeout, domEvaluationTimeout);
-                        imageList = fetched.imageList;
-                        scrollHeight = fetched.scrollHeight;
-                    }
-                    else {
-                        scrollHeight = await measureScrollHeight(page);
+                    finally {
+                        await Promise.all(pendingConsoleWork);
                     }
-                    return {
-                        url,
-                        isTarget: true,
-                        isExternal,
-                        redirectPaths: [...redirectPaths],
-                        status,
-                        statusText,
-                        contentType,
-                        contentLength,
-                        responseHeaders,
-                        meta,
-                        anchorList,
-                        imageList,
-                        html,
-                        mainContents,
-                        scrollHeight,
-                        isSkipped: false,
-                    };
                 }, "#fetchData") }, _private_fetchData_decorators, { kind: "method", name: "#fetchData", static: false, private: true, access: { has: obj => #fetchData in obj, get: obj => obj.#fetchData }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, _private_fetchImages_descriptor = { value: __setFunctionName(async function (page, url, isExternal, imageLoadTimeout, domEvaluationTimeout) {
                     const listener = this.#createPageScanListener(isExternal);
@@ -505,7 +542,10 @@ let Scraper = (() => {
          * - `type: "error"` with `error` details when scraping fails
          *
          * Sub-resources are collected via the `resourceResponse` event and
-         * included in the returned `ScrapeResult.resources`.
+         * included in the returned `ScrapeResult.resources`. Console messages and
+         * uncaught page errors (internal pages only) are collected via
+         * Puppeteer's `console`/`pageerror` page events and included in
+         * `ScrapeResult.consoleLogs`.
          * @param page - The Puppeteer page instance to use for navigation and DOM evaluation.
          * @param url - The extended URL to scrape.
          * @param options - Optional scraper configuration overriding defaults.
@@ -520,6 +560,7 @@ let Scraper = (() => {
             const metadataOnly = options?.metadataOnly ?? false;
             const imageLoadTimeout = options?.imageLoadTimeout ?? 5000;
             const resources = [];
+            const consoleLogs = [];
             const failedRequests = [];
             void this.emit('changePhase', {
                 pid: process.pid,
@@ -540,6 +581,7 @@ let Scraper = (() => {
                 return {
                     type: 'skipped',
                     resources,
+                    consoleLogs,
                     ignored: {
                         url,
                         matchedText: url.pathname || '',
@@ -574,7 +616,7 @@ let Scraper = (() => {
                     isExternal,
                     message: '',
                 });
-                return { type: 'success', pageData: result, resources };
+                return { type: 'success', pageData: result, resources, consoleLogs };
             }
             let headResult = options?.headCheckResult ?? null;
             if (headResult && metadataOnly) {
@@ -594,10 +636,11 @@ let Scraper = (() => {
                         scrollHeight: headResult.scrollHeight ?? null,
                     },
                     resources,
+                    consoleLogs,
                 };
             }
             if (headResult === null || isHtmlContentType(headResult.contentType)) {
-                const fetchResult = await this.#fetchData(page, url, isExternal, captureImages, imageLoadTimeout, resources, failedRequests, options).catch((error) => {
+                const fetchResult = await this.#fetchData(page, url, isExternal, captureImages, imageLoadTimeout, resources, consoleLogs, failedRequests, options).catch((error) => {
                     if (error instanceof Error) {
                         return error;
                     }
@@ -609,6 +652,7 @@ let Scraper = (() => {
                     return {
                         type: 'error',
                         resources,
+                        consoleLogs,
                         failedRequests: failedRequests.length > 0 ? failedRequests : undefined,
                         error: {
                             name: fetchResult.name,
@@ -639,6 +683,7 @@ let Scraper = (() => {
                         return {
                             type: 'skipped',
                             resources,
+                            consoleLogs,
                             ignored: {
                                 url,
                                 matchedText: url.pathname || '',
@@ -656,6 +701,7 @@ let Scraper = (() => {
                     return {
                         type: 'skipped',
                         resources,
+                        consoleLogs,
                         ignored: {
                             url,
                             matchedText: headResult.matched.text,
@@ -675,6 +721,7 @@ let Scraper = (() => {
                 type: 'success',
                 pageData: headResult,
                 resources,
+                consoleLogs,
                 failedRequests: failedRequests.length > 0 ? failedRequests : undefined,
             };
         }
@@ -730,7 +777,8 @@ let Scraper = (() => {
          * Frame" or "Session closed".
          *
          * Flow:
-         * 1. Register request/response/requestfailed listeners to capture sub-resources (internal pages only)
+         * 1. Register request/response/requestfailed/console/pageerror listeners to
+         *    capture sub-resources and console output (internal pages only)
          * 2. Navigate to URL via `page.goto()` and track redirect chain
          * 3. Wait for DOM content and network idle
          * 4. Check for network disconnection errors and throw to trigger retry
@@ -742,6 +790,7 @@ let Scraper = (() => {
          * @param captureImages - Whether to run the image extraction pipeline
          * @param imageLoadTimeout - Timeout (ms) for waiting lazy-loaded images to complete
          * @param resources - Mutable array to collect captured sub-resources into
+         * @param consoleLogs - Mutable array to collect captured console messages / page errors into
          * @param failedRequests - Mutable array to collect failed sub-resource requests into
          * @param options - Additional scraper options (e.g. `disableQueries`, `navigationTimeout`)
          * @returns Full page data or skipped page data if an exclusion rule matched

package/dist/to-console-log-entry.d.ts

@@ -0,0 +1,14 @@
+import type { ConsoleLogEntry } from './types.js';
+import type { ConsoleMessage } from 'puppeteer';
+/**
+ * Converts a Puppeteer `ConsoleMessage` into a `ConsoleLogEntry`.
+ *
+ * WHY per-argument try/catch: `JSHandle.jsonValue()` can reject when the
+ * page's execution context has been destroyed (e.g. mid-navigation) or when
+ * the value cannot be serialized (e.g. a circular reference). A single
+ * failing argument must not drop the rest of the message's arguments.
+ * @param msg - The console message captured via `page.on('console')`
+ * @param pageUrl - The URL (without hash) of the page that produced the message
+ * @returns The resolved console log entry
+ */
+export declare function toConsoleLogEntry(msg: ConsoleMessage, pageUrl: string): Promise<ConsoleLogEntry>;

package/dist/to-console-log-entry.js

@@ -0,0 +1,33 @@
+/**
+ * Converts a Puppeteer `ConsoleMessage` into a `ConsoleLogEntry`.
+ *
+ * WHY per-argument try/catch: `JSHandle.jsonValue()` can reject when the
+ * page's execution context has been destroyed (e.g. mid-navigation) or when
+ * the value cannot be serialized (e.g. a circular reference). A single
+ * failing argument must not drop the rest of the message's arguments.
+ * @param msg - The console message captured via `page.on('console')`
+ * @param pageUrl - The URL (without hash) of the page that produced the message
+ * @returns The resolved console log entry
+ */
+export async function toConsoleLogEntry(msg, pageUrl) {
+    const args = await Promise.all(msg.args().map(async (arg) => {
+        try {
+            return await arg.jsonValue();
+        }
+        catch {
+            return;
+        }
+        finally {
+            await arg.dispose().catch(() => { });
+        }
+    }));
+    const loc = msg.location();
+    return {
+        pageUrl,
+        type: msg.type(),
+        text: msg.text(),
+        args,
+        location: loc.url === undefined ? undefined : loc,
+        ts: Date.now(),
+    };
+}

package/dist/to-page-error-entry.d.ts

@@ -0,0 +1,10 @@
+import type { ConsoleLogEntry } from './types.js';
+/**
+ * Converts an uncaught exception / unhandled Promise rejection (captured via
+ * `page.on('pageerror')`) into a `ConsoleLogEntry`.
+ * @param error - The value emitted by `page.on('pageerror')`; typed as `unknown`
+ * because Puppeteer allows non-`Error` throw values (e.g. `throw 'oops'`)
+ * @param pageUrl - The URL (without hash) of the page that produced the error
+ * @returns The console log entry, with `type: 'pageerror'`
+ */
+export declare function toPageErrorEntry(error: unknown, pageUrl: string): ConsoleLogEntry;