@michaelmagan/dnumb 0.1.0

package/dist/snapshot/capture.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capture = capture;
+/**
+ * Capture a page as an `ElementRecord[]`, by whichever path this browser
+ * supports.
+ *
+ * The CDP path is tried first and is allowed to fail silently — it is an
+ * experimental domain on a single browser engine, and a capture that works
+ * everywhere matters more than one that is 6x faster on Chromium. The portable
+ * walk is the floor, not the fallback of last resort.
+ */
+const page_js_1 = require("../page.cjs");
+const cdp_js_1 = require("./cdp.cjs");
+const clip_js_1 = require("./clip.cjs");
+const collect_js_1 = require("./collect.cjs");
+/** A compact description of a value for an error message — not a full dump. */
+function describeValue(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return `an array of length ${value.length}`;
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        return keys.length > 0 ? `an object with keys: ${keys.join(', ')}` : 'an empty object';
+    }
+    return `${typeof value} ${JSON.stringify(value)}`;
+}
+/**
+ * `PageLike` is deliberately minimal — anything with an `evaluate` that
+ * actually runs the function it is given and returns the result qualifies,
+ * Playwright or not. A double that does not hold up that contract (returns
+ * `undefined`, a canned mock, the wrong shape) used to reach `attachClipFacts`
+ * and die on `elements.map` inside a function the caller has never heard of.
+ * This checks the contract at the one point it can be checked without
+ * assuming anything about *which* driver is behind `page` — real Playwright,
+ * Puppeteer, or a hand-rolled test double all satisfy it identically when
+ * `evaluate` behaves.
+ */
+function assertSnapshot(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        !Array.isArray(value.elements)) {
+        throw new Error('dnumb: page.evaluate(collectSnapshot) did not return a Snapshot ' +
+            '({ elements: ElementRecord[], truncated: boolean, viewport: { width, height } }); ' +
+            `got ${describeValue(value)}. This page satisfies the minimal PageLike shape ` +
+            '({ evaluate }), but its evaluate() did not actually run the function it was given ' +
+            'and hand back the result — check whatever is behind it: a mock, a test double, or a ' +
+            "driver whose evaluate() doesn't behave like Playwright's or Puppeteer's.");
+    }
+}
+async function capture(page, options = {}) {
+    const strategy = options.strategy ?? 'auto';
+    let cdpFellBack = false;
+    if (strategy !== 'walk' && (0, page_js_1.isCDPCapable)(page)) {
+        const viaCDP = await (0, cdp_js_1.captureViaCDP)(page);
+        if (viaCDP) {
+            (0, clip_js_1.attachClipFacts)(viaCDP.elements);
+            return { ...viaCDP, strategy: 'cdp' };
+        }
+        if (strategy === 'cdp') {
+            throw new Error('dnumb: the CDP capture path failed. It requires Chromium and the experimental ' +
+                'DOMSnapshot domain. Use strategy "auto" to fall back to the portable walk.');
+        }
+        // This page could open a CDP session -- it is Chromium -- but the
+        // DOMSnapshot call itself failed, so the walk below is an unplanned
+        // downgrade, not a deliberate portable capture.
+        cdpFellBack = true;
+    }
+    else if (strategy === 'cdp') {
+        throw new Error('dnumb: this page cannot open a CDP session. CDP capture is Chromium-only. ' +
+            'Use strategy "auto" or "walk".');
+    }
+    const walked = await page.evaluate(collect_js_1.collectSnapshot);
+    assertSnapshot(walked);
+    (0, clip_js_1.attachClipFacts)(walked.elements);
+    return { ...walked, strategy: 'walk', ...(cdpFellBack ? { cdpFellBack: true } : {}) };
+}

package/dist/snapshot/capture.d.cts

@@ -0,0 +1,34 @@
+/**
+ * Capture a page as an `ElementRecord[]`, by whichever path this browser
+ * supports.
+ *
+ * The CDP path is tried first and is allowed to fail silently — it is an
+ * experimental domain on a single browser engine, and a capture that works
+ * everywhere matters more than one that is 6x faster on Chromium. The portable
+ * walk is the floor, not the fallback of last resort.
+ */
+import { type PageLike } from "../page.cjs";
+import type { Snapshot } from "./types.cjs";
+export interface CaptureOptions {
+    /**
+     * Force a path instead of preferring CDP. `'walk'` is the portable in-page
+     * collector; `'cdp'` returns an error rather than silently degrading, which
+     * is what a test asserting the two paths agree needs.
+     */
+    strategy?: 'auto' | 'walk' | 'cdp';
+}
+export interface CaptureResult extends Snapshot {
+    /** Which path produced these records. Recorded in the bundle, not inferred. */
+    strategy: 'cdp' | 'walk';
+    /**
+     * `true` only for a `'walk'` result that got there because the CDP fast
+     * path was tried on a CDP-capable (Chromium) page and its own protocol call
+     * failed — never for a `'walk'` result on a browser that was never
+     * CDP-capable to begin with. `strategy` alone cannot tell the two apart,
+     * and only the first is a downgrade worth flagging: it means this page's
+     * shadow DOM content, which CDP would have captured in full, went uncounted
+     * for a reason that had nothing to do with which browser this is.
+     */
+    cdpFellBack?: boolean;
+}
+export declare function capture(page: PageLike, options?: CaptureOptions): Promise<CaptureResult>;

package/dist/snapshot/capture.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Capture a page as an `ElementRecord[]`, by whichever path this browser
+ * supports.
+ *
+ * The CDP path is tried first and is allowed to fail silently — it is an
+ * experimental domain on a single browser engine, and a capture that works
+ * everywhere matters more than one that is 6x faster on Chromium. The portable
+ * walk is the floor, not the fallback of last resort.
+ */
+import { type PageLike } from "../page.js";
+import type { Snapshot } from "./types.js";
+export interface CaptureOptions {
+    /**
+     * Force a path instead of preferring CDP. `'walk'` is the portable in-page
+     * collector; `'cdp'` returns an error rather than silently degrading, which
+     * is what a test asserting the two paths agree needs.
+     */
+    strategy?: 'auto' | 'walk' | 'cdp';
+}
+export interface CaptureResult extends Snapshot {
+    /** Which path produced these records. Recorded in the bundle, not inferred. */
+    strategy: 'cdp' | 'walk';
+    /**
+     * `true` only for a `'walk'` result that got there because the CDP fast
+     * path was tried on a CDP-capable (Chromium) page and its own protocol call
+     * failed — never for a `'walk'` result on a browser that was never
+     * CDP-capable to begin with. `strategy` alone cannot tell the two apart,
+     * and only the first is a downgrade worth flagging: it means this page's
+     * shadow DOM content, which CDP would have captured in full, went uncounted
+     * for a reason that had nothing to do with which browser this is.
+     */
+    cdpFellBack?: boolean;
+}
+export declare function capture(page: PageLike, options?: CaptureOptions): Promise<CaptureResult>;

package/dist/snapshot/capture.js

@@ -0,0 +1,77 @@
+/**
+ * Capture a page as an `ElementRecord[]`, by whichever path this browser
+ * supports.
+ *
+ * The CDP path is tried first and is allowed to fail silently — it is an
+ * experimental domain on a single browser engine, and a capture that works
+ * everywhere matters more than one that is 6x faster on Chromium. The portable
+ * walk is the floor, not the fallback of last resort.
+ */
+import { isCDPCapable } from "../page.js";
+import { captureViaCDP } from "./cdp.js";
+import { attachClipFacts } from "./clip.js";
+import { collectSnapshot } from "./collect.js";
+/** A compact description of a value for an error message — not a full dump. */
+function describeValue(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return `an array of length ${value.length}`;
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        return keys.length > 0 ? `an object with keys: ${keys.join(', ')}` : 'an empty object';
+    }
+    return `${typeof value} ${JSON.stringify(value)}`;
+}
+/**
+ * `PageLike` is deliberately minimal — anything with an `evaluate` that
+ * actually runs the function it is given and returns the result qualifies,
+ * Playwright or not. A double that does not hold up that contract (returns
+ * `undefined`, a canned mock, the wrong shape) used to reach `attachClipFacts`
+ * and die on `elements.map` inside a function the caller has never heard of.
+ * This checks the contract at the one point it can be checked without
+ * assuming anything about *which* driver is behind `page` — real Playwright,
+ * Puppeteer, or a hand-rolled test double all satisfy it identically when
+ * `evaluate` behaves.
+ */
+function assertSnapshot(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        !Array.isArray(value.elements)) {
+        throw new Error('dnumb: page.evaluate(collectSnapshot) did not return a Snapshot ' +
+            '({ elements: ElementRecord[], truncated: boolean, viewport: { width, height } }); ' +
+            `got ${describeValue(value)}. This page satisfies the minimal PageLike shape ` +
+            '({ evaluate }), but its evaluate() did not actually run the function it was given ' +
+            'and hand back the result — check whatever is behind it: a mock, a test double, or a ' +
+            "driver whose evaluate() doesn't behave like Playwright's or Puppeteer's.");
+    }
+}
+export async function capture(page, options = {}) {
+    const strategy = options.strategy ?? 'auto';
+    let cdpFellBack = false;
+    if (strategy !== 'walk' && isCDPCapable(page)) {
+        const viaCDP = await captureViaCDP(page);
+        if (viaCDP) {
+            attachClipFacts(viaCDP.elements);
+            return { ...viaCDP, strategy: 'cdp' };
+        }
+        if (strategy === 'cdp') {
+            throw new Error('dnumb: the CDP capture path failed. It requires Chromium and the experimental ' +
+                'DOMSnapshot domain. Use strategy "auto" to fall back to the portable walk.');
+        }
+        // This page could open a CDP session -- it is Chromium -- but the
+        // DOMSnapshot call itself failed, so the walk below is an unplanned
+        // downgrade, not a deliberate portable capture.
+        cdpFellBack = true;
+    }
+    else if (strategy === 'cdp') {
+        throw new Error('dnumb: this page cannot open a CDP session. CDP capture is Chromium-only. ' +
+            'Use strategy "auto" or "walk".');
+    }
+    const walked = await page.evaluate(collectSnapshot);
+    assertSnapshot(walked);
+    attachClipFacts(walked.elements);
+    return { ...walked, strategy: 'walk', ...(cdpFellBack ? { cdpFellBack: true } : {}) };
+}

package/dist/snapshot/cdp.cjs

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureViaCDP = captureViaCDP;
+const limits_js_1 = require("./limits.cjs");
+/**
+ * Requested in this exact order; `layout.styles[i]` comes back in it. Every
+ * name is kebab-case because Blink rejects camelCase and takes the whole call
+ * down with it (`whiteSpace` -> "Protocol error: invalid CSS property").
+ */
+// biome-ignore format: the order of this list is the wire format -- one name per
+// line would hide the grouping that makes a mismatch with `S` visible.
+const STYLES = [
+    'color', 'background-color', 'font-size', 'font-weight', 'text-align',
+    'overflow-x', 'overflow-y', 'position', 'display', 'visibility', 'opacity',
+    'flex-direction', 'grid-template-columns', 'row-gap', 'column-gap',
+    'margin-top', 'margin-right', 'margin-bottom', 'margin-left',
+    'padding-top', 'padding-right', 'padding-bottom', 'padding-left',
+    'border-top-width', 'border-right-width', 'border-bottom-width', 'border-left-width',
+    'text-overflow', 'white-space', 'overflow-wrap',
+    'background-image', 'text-shadow', '-webkit-text-stroke-width', '-webkit-text-stroke-color',
+    // Requested so `build()` can read `<html>`'s own values off this same
+    // per-node styles array -- see `DocumentBackground` (A2). Not per-element
+    // data; every other record's slot for this name is simply unused.
+    'color-scheme',
+];
+const S = Object.fromEntries(STYLES.map((name, i) => [name, i]));
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+/** Roles too generic to be worth carrying; matches the identity ladder's set. */
+const WEAK_AX_ROLES = new Set(['generic', 'none', 'presentation', 'InlineTextBox']);
+function rect(r, dx = 0, dy = 0) {
+    return {
+        x: (r?.[0] ?? 0) - dx,
+        y: (r?.[1] ?? 0) - dy,
+        width: r?.[2] ?? 0,
+        height: r?.[3] ?? 0,
+    };
+}
+function sides(values, strings, keys) {
+    const num = (i) => Number.parseFloat(strings[values?.[i] ?? -1] ?? '') || 0;
+    return { top: num(keys[0]), right: num(keys[1]), bottom: num(keys[2]), left: num(keys[3]) };
+}
+function trimName(value) {
+    const text = (value ?? '').replace(/\s+/g, ' ').trim();
+    return text ? text.slice(0, limits_js_1.NAME_LENGTH) : null;
+}
+/**
+ * Same-origin vs cross-origin for an `<iframe>` found in `documents[0]`, using
+ * only that document's own data: resolve `src` against the document's own
+ * `baseURL`, exactly as the browser resolves it when it assigns `iframe.src`.
+ * This never reads `documents[1..]` -- the slots `captureViaCDP` does not use,
+ * per the file header -- classifying an iframe's origin is not the same as
+ * reading what is inside it.
+ */
+function iframeOrigin(attrs, baseURL) {
+    // `srcdoc` and no `src` both resolve to a document that inherits the
+    // parent's origin (`about:srcdoc` / `about:blank`), not the frame's own.
+    if (attrs.has('srcdoc'))
+        return 'same';
+    const src = (attrs.get('src') ?? '').trim();
+    if (src === '' || src.toLowerCase() === 'about:blank')
+        return 'same';
+    try {
+        return new URL(src, baseURL).origin === new URL(baseURL).origin ? 'same' : 'cross';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Real open/closed shadow root counts from `nodes.shadowRootType`, or the
+ * honest "cannot know" shape when the payload has no such field at all.
+ *
+ * Every node flattened out of a shadow root is tagged `'open'` or `'closed'`
+ * (see `NodeArrays.shadowRootType`'s doc comment), not just the root itself,
+ * so counting tagged *nodes* would count a shadow root once per descendant it
+ * flattened in. Instead, for each tagged node this walks `parentIndex` up
+ * through other tagged nodes until it reaches the first untagged ancestor --
+ * that ancestor is the shadow host -- and counts each distinct host once,
+ * keyed by the type its tagged descendants carried. A shadow root with no
+ * flattened content at all (empty) has no tagged node to find and is not
+ * counted; a shadow root nested inside another shadow root is counted once
+ * under the outer host rather than twice, because the walk does not stop at
+ * the inner boundary -- an known, narrow gap on real pages, which is why this
+ * function is a best-effort count, not a claim of perfect precision.
+ */
+function countShadowRoots(nodes, strings) {
+    const srt = nodes.shadowRootType;
+    // The field is absent, not merely empty, on a payload this build has never
+    // seen shaped this way -- report the same "cannot know" shape the walk
+    // path uses rather than assuming zero.
+    if (!srt)
+        return { open: 0, closed: 'unknown' };
+    const typeByNode = new Map();
+    for (let i = 0; i < srt.index.length; i++) {
+        const nodeIdx = srt.index[i];
+        const valueIdx = srt.value[i];
+        if (nodeIdx === undefined || valueIdx === undefined)
+            continue;
+        const value = strings[valueIdx];
+        // `'user-agent'` (a browser-internal shadow root, e.g. inside `<video>`)
+        // is a real `ShadowRootType` this field can carry but which this package
+        // has no author-facing fact to report -- excluded from both counts rather
+        // than folded into either.
+        typeByNode.set(nodeIdx, value === 'open' ? 'open' : value === 'closed' ? 'closed' : null);
+    }
+    const hostType = new Map();
+    for (const [nodeIdx, type] of typeByNode) {
+        if (!type)
+            continue;
+        let cursor = nodes.parentIndex[nodeIdx];
+        while (cursor !== undefined && cursor >= 0 && typeByNode.has(cursor)) {
+            cursor = nodes.parentIndex[cursor];
+        }
+        if (cursor === undefined || cursor < 0)
+            continue;
+        hostType.set(cursor, type);
+    }
+    let open = 0;
+    let closed = 0;
+    for (const type of hostType.values()) {
+        if (type === 'open')
+            open++;
+        else
+            closed++;
+    }
+    return { open, closed };
+}
+/**
+ * Computed role and accessible name, which `captureSnapshot` does not return —
+ * it carries only the literal `role=` attribute, so a `<button>` comes back
+ * with no role at all. This is a second experimental call joined on
+ * `backendDOMNodeId`.
+ *
+ * Failure is non-fatal: without it the records simply carry the attribute role,
+ * which is the state the prototype shipped in.
+ */
+async function axIndex(cdp) {
+    const out = new Map();
+    let tree;
+    try {
+        tree = (await cdp.send('Accessibility.getFullAXTree'));
+    }
+    catch {
+        return out;
+    }
+    for (const node of tree.nodes ?? []) {
+        if (node.backendDOMNodeId === undefined || node.ignored)
+            continue;
+        const role = typeof node.role?.value === 'string' ? node.role.value : null;
+        const name = typeof node.name?.value === 'string' ? node.name.value : null;
+        out.set(node.backendDOMNodeId, {
+            role: role && !WEAK_AX_ROLES.has(role) ? role : null,
+            name: trimName(name),
+        });
+    }
+    return out;
+}
+/**
+ * Capture via CDP, or `null` if this page or this Chromium cannot.
+ *
+ * Returning null rather than throwing is deliberate: the caller's job is to
+ * fall back to the portable walk, and an experimental domain failing is an
+ * expected outcome, not an error.
+ */
+async function captureViaCDP(page) {
+    let cdp;
+    try {
+        cdp = await page.context().newCDPSession(page);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const snapshot = (await cdp.send('DOMSnapshot.captureSnapshot', {
+            computedStyles: [...STYLES],
+            includeDOMRects: true,
+            includePaintOrder: true,
+        }));
+        const viewport = await page.evaluate(() => ({
+            width: window.innerWidth,
+            height: window.innerHeight,
+        }));
+        const ax = await axIndex(cdp);
+        const doc = snapshot.documents[0];
+        if (!doc)
+            return null;
+        return { ...build(doc, snapshot.strings, ax), viewport };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await cdp.detach().catch(() => { });
+    }
+}
+function build(doc, strings, ax) {
+    const { nodes, layout } = doc;
+    const str = (i) => i === undefined || i < 0 ? '' : (strings[i] ?? '');
+    // layout rows are sparse: only nodes that generated a box have one.
+    const layoutOf = new Map();
+    for (let layoutIdx = 0; layoutIdx < layout.nodeIndex.length; layoutIdx++) {
+        const nodeIdx = layout.nodeIndex[layoutIdx];
+        if (nodeIdx !== undefined)
+            layoutOf.set(nodeIdx, layoutIdx);
+    }
+    const attrsOf = (nodeIdx) => {
+        const flat = nodes.attributes[nodeIdx] ?? [];
+        const map = new Map();
+        for (let i = 0; i + 1 < flat.length; i += 2) {
+            map.set(str(flat[i]), str(flat[i + 1]));
+        }
+        return map;
+    };
+    // Own text: direct text-node children only, matching the walk's `ownText`.
+    const ownText = new Map();
+    nodes.nodeType.forEach((type, nodeIdx) => {
+        if (type !== TEXT_NODE)
+            return;
+        const parent = nodes.parentIndex[nodeIdx];
+        if (parent === undefined || parent < 0)
+            return;
+        ownText.set(parent, (ownText.get(parent) ?? '') + str(nodes.nodeValue[nodeIdx]));
+    });
+    // `<html>`'s own `background-color` / `color-scheme` -- the real terminal
+    // layer a compositing walk that runs off the top of `<body>`'s ancestor
+    // chain reaches (A2). Read the same way any element's own styles are, off
+    // this same per-node `layout.styles` array -- `<html>` itself is never one
+    // of `elements` below, this walk stays inside the <body> subtree exactly
+    // like the portable walk does, so without this it would be unreachable.
+    //
+    // The `nodeType === ELEMENT_NODE` guard is required, not defensive
+    // decoration: `<!doctype html>` is its own node in this same
+    // `nodes.nodeName` array (a `DocumentType` node, name `"html"`), and it
+    // sorts *before* the real `<html>` element -- an unguarded search finds
+    // the doctype first, which has no layout row at all, and every style
+    // this function reads off it comes back the empty string. *Verified*:
+    // this is exactly what happened on the first pass of this fix, caught by
+    // `test/browser/color-canvas.test.ts`'s `cdp`-path case.
+    const htmlIndex = nodes.nodeName.findIndex((name, i) => nodes.nodeType[i] === ELEMENT_NODE && str(name).toUpperCase() === 'HTML');
+    const htmlLayoutIdx = htmlIndex < 0 ? undefined : layoutOf.get(htmlIndex);
+    const htmlStyles = htmlLayoutIdx === undefined ? undefined : layout.styles[htmlLayoutIdx];
+    const htmlStyle = (name) => str(htmlStyles?.[S[name]]);
+    const documentBackground = {
+        backgroundColor: htmlStyle('background-color'),
+        colorScheme: htmlStyle('color-scheme'),
+    };
+    // Only the <body> subtree, matching the walk's entry point.
+    const bodyIndex = nodes.nodeName.findIndex((name) => str(name).toUpperCase() === 'BODY');
+    if (bodyIndex < 0) {
+        return {
+            elements: [],
+            truncated: false,
+            notMeasured: {
+                shadowRoots: countShadowRoots(nodes, strings),
+                iframes: { sameOrigin: 0, crossOrigin: 0, unknownOrigin: 0 },
+            },
+            documentBackground,
+        };
+    }
+    const SKIPPED = new Set(limits_js_1.SKIPPED_TAGS);
+    const idOf = new Map();
+    const elements = [];
+    let truncated = false;
+    const baseURL = str(doc.baseURL);
+    let iframesSameOrigin = 0;
+    let iframesCrossOrigin = 0;
+    let iframesUnknownOrigin = 0;
+    const inBody = (nodeIdx) => {
+        let cursor = nodeIdx;
+        while (cursor !== undefined && cursor >= 0) {
+            if (cursor === bodyIndex)
+                return true;
+            cursor = nodes.parentIndex[cursor];
+        }
+        return false;
+    };
+    // Document order is array order, so one forward pass keys parents before
+    // children — the same invariant the recursive walk gets for free.
+    for (let nodeIdx = 0; nodeIdx < nodes.nodeType.length; nodeIdx++) {
+        // Same ceiling as the walk, so `truncated` means one thing across paths.
+        if (elements.length >= limits_js_1.MAX_ELEMENTS) {
+            truncated = true;
+            break;
+        }
+        if (nodes.nodeType[nodeIdx] !== ELEMENT_NODE)
+            continue;
+        if (!inBody(nodeIdx))
+            continue;
+        const tagName = str(nodes.nodeName[nodeIdx]).toUpperCase();
+        if (SKIPPED.has(tagName))
+            continue;
+        // `documents[0]` is the only slot this path reads (see the file header),
+        // so an iframe's own content document is never entered -- counted here
+        // regardless of whether the iframe itself survives the ancestor check
+        // below, because it was encountered either way.
+        if (tagName === 'IFRAME') {
+            switch (iframeOrigin(attrsOf(nodeIdx), baseURL)) {
+                case 'same':
+                    iframesSameOrigin++;
+                    break;
+                case 'cross':
+                    iframesCrossOrigin++;
+                    break;
+                case 'unknown':
+                    iframesUnknownOrigin++;
+                    break;
+            }
+        }
+        // An ancestor that was skipped takes its subtree with it.
+        let parentIdx = nodes.parentIndex[nodeIdx];
+        while (parentIdx !== undefined && parentIdx >= 0 && !idOf.has(parentIdx)) {
+            if (parentIdx === bodyIndex)
+                break;
+            parentIdx = nodes.parentIndex[parentIdx];
+        }
+        const parentId = parentIdx !== undefined && parentIdx >= 0 ? (idOf.get(parentIdx) ?? null) : null;
+        if (nodeIdx !== bodyIndex && parentId === null)
+            continue;
+        const id = `e${elements.length}`;
+        idOf.set(nodeIdx, id);
+        const attrs = attrsOf(nodeIdx);
+        const layoutIdx = layoutOf.get(nodeIdx);
+        const styles = layoutIdx === undefined ? undefined : layout.styles[layoutIdx];
+        const box = rect(layoutIdx === undefined ? undefined : layout.bounds[layoutIdx], doc.scrollOffsetX, doc.scrollOffsetY);
+        const scrollRect = layoutIdx === undefined ? undefined : layout.scrollRects?.[layoutIdx];
+        const clientRect = layoutIdx === undefined ? undefined : layout.clientRects?.[layoutIdx];
+        const style = (name) => str(styles?.[S[name]]);
+        // A node with no layout row generated no box: that absence is the signal.
+        const display = layoutIdx === undefined ? 'none' : style('display') || 'block';
+        const visibility = style('visibility') || 'visible';
+        const opacity = Number.parseFloat(style('opacity'));
+        let testId = null;
+        for (const attr of limits_js_1.TESTID_ATTRS) {
+            const value = attrs.get(attr);
+            if (value) {
+                testId = value;
+                break;
+            }
+        }
+        const backendId = nodes.backendNodeId[nodeIdx];
+        const computed = backendId === undefined ? undefined : ax.get(backendId);
+        const attrRole = (attrs.get('role') ?? '').trim().split(/\s+/)[0] || null;
+        const ariaLevel = Number(attrs.get('aria-level'));
+        const headingMatch = /^H([1-6])$/.exec(tagName);
+        elements.push({
+            id,
+            tag: tagName.toLowerCase(),
+            testId,
+            domId: attrs.get('id') ?? null,
+            role: computed?.role ?? attrRole,
+            name: computed?.name ?? null,
+            className: attrs.get('class') ?? '',
+            headingLevel: Number.isFinite(ariaLevel) && attrs.has('aria-level')
+                ? ariaLevel
+                : headingMatch?.[1]
+                    ? Number(headingMatch[1])
+                    : null,
+            rect: box,
+            scrollWidth: scrollRect?.[2] ?? box.width,
+            scrollHeight: scrollRect?.[3] ?? box.height,
+            clientWidth: clientRect?.[2] ?? box.width,
+            clientHeight: clientRect?.[3] ?? box.height,
+            overflowX: style('overflow-x') || 'visible',
+            overflowY: style('overflow-y') || 'visible',
+            position: style('position') || 'static',
+            display,
+            visibility,
+            opacity: Number.isFinite(opacity) ? opacity : 1,
+            margin: sides(styles, strings, [
+                S['margin-top'],
+                S['margin-right'],
+                S['margin-bottom'],
+                S['margin-left'],
+            ]),
+            padding: sides(styles, strings, [
+                S['padding-top'],
+                S['padding-right'],
+                S['padding-bottom'],
+                S['padding-left'],
+            ]),
+            gap: {
+                row: Number.parseFloat(style('row-gap')) || 0,
+                column: Number.parseFloat(style('column-gap')) || 0,
+            },
+            border: sides(styles, strings, [
+                S['border-top-width'],
+                S['border-right-width'],
+                S['border-bottom-width'],
+                S['border-left-width'],
+            ]),
+            color: style('color'),
+            backgroundColor: style('background-color'),
+            backgroundImage: (0, limits_js_1.capBackgroundImage)(style('background-image')),
+            textShadow: style('text-shadow').slice(0, limits_js_1.COLOR_TOKEN_CAP),
+            textStrokeWidth: style('-webkit-text-stroke-width') || '0px',
+            textStrokeColor: style('-webkit-text-stroke-color'),
+            fontSize: style('font-size'),
+            fontWeight: Number.parseFloat(style('font-weight')) || 400,
+            textAlign: style('text-align'),
+            flexDirection: style('flex-direction'),
+            gridTemplateColumns: style('grid-template-columns'),
+            textOverflow: style('text-overflow') || 'clip',
+            whiteSpace: style('white-space') || 'normal',
+            overflowWrap: style('overflow-wrap') || 'normal',
+            text: (ownText.get(nodeIdx) ?? '').replace(/\s+/g, ' ').trim().slice(0, limits_js_1.TEXT_PREVIEW_LENGTH),
+            parentId,
+            childIds: [],
+            visible: display !== 'none' &&
+                visibility !== 'hidden' &&
+                !(Number.isFinite(opacity) && opacity === 0) &&
+                box.width > 0 &&
+                box.height > 0,
+            ariaExpanded: attrs.get('aria-expanded') ?? null,
+            // `cdp` never calls `elementsFromPoint` -- it has `paintOrder` plus
+            // rects instead, which is the whole-rect answer to the same question
+            // `hitStackIds` answers on the `walk` path. See both fields' doc
+            // comments on `ElementRecord`.
+            hitStackIds: null,
+            paintOrder: layoutIdx === undefined ? null : (layout.paintOrders?.[layoutIdx] ?? null),
+        });
+    }
+    const byId = new Map(elements.map((el) => [el.id, el]));
+    for (const el of elements) {
+        if (el.parentId)
+            byId.get(el.parentId)?.childIds.push(el.id);
+    }
+    return {
+        elements,
+        truncated,
+        notMeasured: {
+            // Counted from `nodes.shadowRootType`, not assumed: `DOMSnapshot`
+            // flattens an author shadow root's content directly under its host
+            // (both open and closed -- verified in `test/browser/not-measured.test.ts`)
+            // and tags every flattened node, so `countShadowRoots` recovers the real
+            // per-host counts from those tags instead of asserting a permanent zero.
+            // A page whose shadow content this specific capture failed to flatten
+            // for any reason now reports that failure as a nonzero count rather
+            // than silence -- see `countShadowRoots`'s doc comment for the one
+            // known narrow gap (nested shadow roots) and the absent-field fallback.
+            shadowRoots: countShadowRoots(nodes, strings),
+            iframes: {
+                sameOrigin: iframesSameOrigin,
+                crossOrigin: iframesCrossOrigin,
+                unknownOrigin: iframesUnknownOrigin,
+            },
+        },
+        documentBackground,
+    };
+}