@mkterswingman/5mghost-wonder 0.0.14 → 0.0.16

package/dist/commands/browser.js

@@ -2,19 +2,27 @@
 // Experimental browser runtime commands.
 import { resolveWonderPaths } from "../platform/paths.js";
 import { parseWecomUrl } from "../wecom/url.js";
-import { runBrowserNoExportProbe } from "../wecom/browser-probe.js";
+import { runBrowserNoExportProbe, runBrowserNoExportRead, } from "../wecom/browser-probe.js";
 export async function runBrowserCommand(argv, context) {
     const [sub, ...rest] = argv;
     switch (sub) {
         case "probe":
             return runBrowserProbe(rest, context);
+        case "read":
+            return runBrowserRead(rest, context);
         default:
             context.io.stderr(`Unknown subcommand: browser ${sub ?? "(none)"}\n` +
-                "Usage: wonder browser probe <url> [--headed] [--timeout-ms <ms>] [--save <dir>]");
+                "Usage: wonder browser probe|read <url> [--headed] [--timeout-ms <ms>] [--save <dir>]");
             return { exitCode: 1 };
     }
 }
+async function runBrowserRead(args, context) {
+    return runBrowserAction(args, context, "read");
+}
 async function runBrowserProbe(args, context) {
+    return runBrowserAction(args, context, "probe");
+}
+async function runBrowserAction(args, context, action) {
     let url;
     let saveDir;
     let timeoutMs;
@@ -37,7 +45,7 @@ async function runBrowserProbe(args, context) {
     if (!url) {
         context.io.stderr(JSON.stringify({
             error: "missing_url",
-            message: "用法：wonder browser probe <url> [--headed] [--timeout-ms <ms>] [--save <dir>]",
+            message: `用法：wonder browser ${action} <url> [--headed] [--timeout-ms <ms>] [--save <dir>]`,
         }));
         return { exitCode: 1, telemetry: { outcome: "failure", errorKind: "missing_url" } };
     }
@@ -57,14 +65,17 @@ async function runBrowserProbe(args, context) {
         return { exitCode: 1, telemetry: { outcome: "failure", errorKind: "invalid_timeout" } };
     }
     const paths = resolveWonderPaths({ homeDir: context.homeDir });
-    const result = await runBrowserNoExportProbe({
+    const options = {
         url,
         chromeProfilePath: paths.chromeProfilePath,
         saveDir,
         headed,
         timeoutMs,
         io: context.io,
-    });
+    };
+    const result = action === "read"
+        ? await runBrowserNoExportRead(options)
+        : await runBrowserNoExportProbe(options);
     context.io.stdout(JSON.stringify(result));
     return {
         exitCode: result.status === "fail" ? 1 : 0,

package/dist/commands/help.js

@@ -34,6 +34,7 @@ export function renderHelpText() {
         "Experimental browser runtime:",
         "  browser probe <url>           Open in Wonder browser profile and capture",
         "                                no-export evidence summaries",
+        "  browser read <url>            Experimental no-export text read",
         "  browser probe <url> --headed  Show the browser while probing",
     ].join("\n");
 }

package/dist/wecom/browser-probe.js

@@ -10,6 +10,8 @@ const CDP_CALL_TIMEOUT_MS = 5000;
 const BROWSER_START_TIMEOUT_MS = 20_000;
 const DEFAULT_CAPTURE_MS = 8_000;
 const MAX_NETWORK_CANDIDATES = 40;
+const MAX_IMAGE_DOWNLOADS = 20;
+const MAX_IMAGE_BYTES = 25 * 1024 * 1024;
 let cdpNextId = 1;
 export async function runBrowserNoExportProbe(options) {
     const timeoutMs = options.timeoutMs ?? DEFAULT_CAPTURE_MS;
@@ -52,7 +54,8 @@ export async function runBrowserNoExportProbe(options) {
             await sendCdpCommand(socket, "Page.navigate", { url: options.url });
             await delay(timeoutMs);
             const pageInfo = await evaluatePageInfo(socket);
-            const networkCandidates = await collectNetworkCandidates(socket, responses);
+            const networkArtifacts = await collectNetworkArtifacts(socket, responses);
+            const networkCandidates = summarizeNetworkArtifacts(networkArtifacts);
             const evidence = ["browser-page"];
             if (pageInfo.visibleTextSample)
                 evidence.push("visible-text");
@@ -107,6 +110,115 @@ export async function runBrowserNoExportProbe(options) {
         await terminateBrowserProcess(child);
     }
 }
+export async function runBrowserNoExportRead(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_CAPTURE_MS;
+    const browser = findInstalledBrowser(options.executablePath);
+    const port = await getFreePort();
+    const endpoint = `http://127.0.0.1:${port}`;
+    const child = spawnBrowser({
+        browser,
+        port,
+        profilePath: options.chromeProfilePath,
+        url: options.url,
+        headed: options.headed ?? false,
+    });
+    try {
+        await waitForDebugger(endpoint, BROWSER_START_TIMEOUT_MS);
+        const pageWsUrl = await waitForPageWebSocket(endpoint, options.url, BROWSER_START_TIMEOUT_MS);
+        const socket = await openDevToolsSocket(pageWsUrl);
+        const responses = [];
+        try {
+            socket.addEventListener("message", (event) => {
+                const payload = safeJsonParse(String(event.data));
+                if (payload?.method !== "Network.responseReceived")
+                    return;
+                const response = payload.params?.response;
+                const requestId = payload.params?.requestId;
+                if (!response?.url || !requestId)
+                    return;
+                if (!isInterestingNetworkUrl(response.url, response.mimeType ?? ""))
+                    return;
+                responses.push({
+                    requestId,
+                    url: response.url,
+                    status: response.status ?? 0,
+                    mimeType: response.mimeType ?? "",
+                });
+            });
+            await sendCdpCommand(socket, "Network.enable");
+            await sendCdpCommand(socket, "Page.enable");
+            await sendCdpCommand(socket, "Runtime.enable");
+            await sendCdpCommand(socket, "Page.navigate", { url: options.url });
+            await delay(timeoutMs);
+            const pageInfo = await evaluatePageInfo(socket);
+            const networkArtifacts = await collectNetworkArtifacts(socket, responses);
+            const opendoc = networkArtifacts.find((artifact) => artifact.rawUrl.includes("/dop-api/opendoc") && artifact.body);
+            const extracted = opendoc?.body ? extractTextFromOpendoc(opendoc.body) : null;
+            const evidence = ["browser-page", "network-response-summary"];
+            if (opendoc)
+                evidence.push("opendoc-response");
+            if (extracted?.text)
+                evidence.push("initial-attributed-text");
+            const images = options.saveDir && extracted?.imageUrls
+                ? await downloadImageResources(extracted.imageUrls, options.saveDir)
+                : (extracted?.imageUrls ?? []).map((url) => ({
+                    url,
+                    ...parseImageDimensionsFromUrl(url),
+                    status: "skipped",
+                    error: "pass --save <dir> to download image resources",
+                }));
+            if (images.some((image) => image.status === "downloaded"))
+                evidence.push("image-resource-download");
+            const result = {
+                mode: "browser-no-export-read",
+                status: extracted?.text ? "partial" : "fail",
+                url: redactUrl(options.url),
+                finalUrl: pageInfo.finalUrl ? redactUrl(pageInfo.finalUrl) : undefined,
+                title: extracted?.title ?? pageInfo.title,
+                padType: extracted?.padType,
+                text: extracted?.text,
+                textLength: extracted?.text.length,
+                imageUrls: extracted?.imageUrls,
+                images,
+                extraction: extracted?.text ? "opendoc-initial-attributed-text" : "none",
+                evidence,
+                warnings: extracted?.warnings ?? [
+                    "No readable opendoc initialAttributedText was captured.",
+                ],
+                missing: [
+                    "table merge ranges",
+                    ...(images.some((image) => image.status === "downloaded") ? [] : ["image original resources"]),
+                    "image anchors",
+                    "floating vs fixed image classification",
+                ],
+            };
+            if (options.saveDir) {
+                mkdirSync(options.saveDir, { recursive: true });
+                const savedPath = resolve(options.saveDir, `wonder-browser-read-${Date.now()}.json`);
+                writeFileSync(savedPath, JSON.stringify(result, null, 2), { mode: 0o600 });
+                result.savedPath = savedPath;
+            }
+            return result;
+        }
+        finally {
+            socket.close();
+        }
+    }
+    catch (err) {
+        return {
+            mode: "browser-no-export-read",
+            status: "fail",
+            url: redactUrl(options.url),
+            extraction: "none",
+            evidence: [],
+            warnings: [],
+            missing: [err instanceof Error ? err.message : String(err)],
+        };
+    }
+    finally {
+        await terminateBrowserProcess(child);
+    }
+}
 async function evaluatePageInfo(socket) {
     const expression = `(() => {
     const text = (document.body && document.body.innerText || "").replace(/\\s+/g, " ").trim();
@@ -136,14 +248,14 @@ async function evaluatePageInfo(socket) {
         runtimeGlobals: value?.runtimeGlobals ?? [],
     };
 }
-async function collectNetworkCandidates(socket, responses) {
+async function collectNetworkArtifacts(socket, responses) {
     const unique = new Map();
     for (const response of responses) {
         if (unique.size >= MAX_NETWORK_CANDIDATES)
             break;
         unique.set(response.requestId, response);
     }
-    const candidates = [];
+    const artifacts = [];
     for (const response of unique.values()) {
         let body = "";
         let base64Encoded = false;
@@ -156,16 +268,283 @@ async function collectNetworkCandidates(socket, responses) {
             // Some responses are streamed, cached, too large, or not retained.
         }
         const signals = detectBodySignals(body, response.mimeType);
-        candidates.push({
+        artifacts.push({
+            requestId: response.requestId,
+            rawUrl: response.url,
             url: redactUrl(response.url),
             status: response.status,
             mimeType: response.mimeType,
             bodyLength: body ? body.length : undefined,
             base64Encoded: body ? base64Encoded : undefined,
             signals,
+            body,
         });
     }
-    return candidates;
+    return artifacts;
+}
+function summarizeNetworkArtifacts(artifacts) {
+    return artifacts.map((artifact) => ({
+        url: artifact.url,
+        status: artifact.status,
+        mimeType: artifact.mimeType,
+        bodyLength: artifact.bodyLength,
+        base64Encoded: artifact.base64Encoded,
+        signals: artifact.signals,
+    }));
+}
+export function extractTextFromOpendoc(body) {
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    const initialText = payload.clientVars?.collab_client_vars?.initialAttributedText?.text;
+    const chunks = Array.isArray(initialText) ? initialText : [];
+    const decodedChunks = chunks
+        .filter((chunk) => typeof chunk === "string")
+        .flatMap((chunk) => extractInitialAttributedTextCandidates(chunk));
+    const textCandidate = chooseTextCandidate(decodedChunks);
+    const text = normalizeExtractedText(textCandidate ?? decodedChunks.join("\n"));
+    if (!text)
+        return null;
+    const imageUrls = extractImageUrls(decodedChunks.join("\n"));
+    return {
+        title: payload.clientVars?.title ?? payload.clientVars?.initialTitle,
+        padType: payload.clientVars?.padType ?? payload.padType,
+        text,
+        imageUrls,
+        warnings: [
+            "No-export text is decoded from opendoc initialAttributedText; rich styles are not reconstructed yet.",
+            ...(imageUrls.length > 0
+                ? ["Image resource URLs were detected, but image anchors and fixed/floating placement are not reconstructed yet."]
+                : []),
+        ],
+    };
+}
+function extractInitialAttributedTextCandidates(chunk) {
+    let decoded;
+    try {
+        decoded = Buffer.from(chunk, "base64");
+    }
+    catch {
+        decoded = Buffer.from(chunk, "utf8");
+    }
+    const candidates = collectProtobufStringCandidates(decoded);
+    if (candidates.length > 0)
+        return candidates.map((candidate) => candidate.text);
+    return [decoded.toString("utf8")];
+}
+function chooseTextCandidate(candidates) {
+    const scored = candidates
+        .map((text) => ({
+        text,
+        score: text.length +
+            (/\[[^\]]+\]/.test(text) ? 200 : 0) +
+            (/[\u4e00-\u9fff]/.test(text) ? 200 : 0) -
+            ((text.match(/https?:\/\//g)?.length ?? 0) * 100),
+    }))
+        .filter((candidate) => candidate.text.length > 0)
+        .sort((a, b) => b.score - a.score);
+    return scored[0]?.text ?? null;
+}
+function collectProtobufStringCandidates(buffer) {
+    const candidates = [];
+    walkProtobuf(buffer, 0, buffer.length, 0, candidates);
+    return candidates
+        .filter((candidate) => candidate.byteLength >= 2 &&
+        candidate.printableRatio >= 0.8 &&
+        /[\p{L}\p{N}\[]/u.test(candidate.text))
+        .sort((a, b) => b.byteLength - a.byteLength);
+}
+function walkProtobuf(buffer, start, end, depth, candidates) {
+    if (depth > 6)
+        return;
+    let offset = start;
+    let fieldsSeen = 0;
+    while (offset < end && fieldsSeen < 10_000) {
+        fieldsSeen++;
+        const key = readVarint(buffer, offset, end);
+        if (!key)
+            return;
+        offset = key.nextOffset;
+        const wireType = key.value & 7;
+        if (wireType === 0) {
+            const value = readVarint(buffer, offset, end);
+            if (!value)
+                return;
+            offset = value.nextOffset;
+        }
+        else if (wireType === 1) {
+            offset += 8;
+        }
+        else if (wireType === 5) {
+            offset += 4;
+        }
+        else if (wireType === 2) {
+            const length = readVarint(buffer, offset, end);
+            if (!length)
+                return;
+            offset = length.nextOffset;
+            const fieldEnd = offset + length.value;
+            if (fieldEnd > end)
+                return;
+            const raw = buffer.subarray(offset, fieldEnd);
+            const text = raw.toString("utf8");
+            candidates.push({
+                text,
+                byteLength: length.value,
+                printableRatio: printableRatio(text),
+            });
+            if (length.value > 2) {
+                walkProtobuf(buffer, offset, fieldEnd, depth + 1, candidates);
+            }
+            offset = fieldEnd;
+        }
+        else {
+            return;
+        }
+    }
+}
+function readVarint(buffer, offset, end) {
+    let value = 0n;
+    let shift = 0n;
+    let current = offset;
+    while (current < end) {
+        const byte = buffer[current++];
+        value |= BigInt(byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            return { value: Number(value), nextOffset: current };
+        }
+        shift += 7n;
+        if (shift > 63n)
+            return null;
+    }
+    return null;
+}
+function printableRatio(text) {
+    if (!text)
+        return 0;
+    let printable = 0;
+    for (const char of text) {
+        if (/[\p{L}\p{N}\p{P}\p{Zs}\r\n\t]/u.test(char))
+            printable++;
+    }
+    return printable / text.length;
+}
+function extractImageUrls(text) {
+    const urls = text.match(/https?:\/\/[^\s"'<>\\\u0000-\u001f]+/g) ?? [];
+    return Array.from(new Set(urls
+        .map((url) => url.replace(/[)*,.;:]+$/g, ""))
+        .filter((url) => /qpic\.cn|weixin\.qq\.com|doc\.weixin\.qq\.com/i.test(url))));
+}
+async function downloadImageResources(imageUrls, saveDir) {
+    const imageDir = resolve(saveDir, "images");
+    mkdirSync(imageDir, { recursive: true });
+    const results = [];
+    for (const [index, url] of imageUrls.slice(0, MAX_IMAGE_DOWNLOADS).entries()) {
+        const dimensions = parseImageDimensionsFromUrl(url);
+        try {
+            const res = await fetch(url);
+            if (!res.ok) {
+                results.push({
+                    url,
+                    ...dimensions,
+                    status: "failed",
+                    error: `HTTP ${res.status}`,
+                });
+                continue;
+            }
+            const contentType = res.headers.get("content-type") ?? undefined;
+            const bytes = Buffer.from(await res.arrayBuffer());
+            if (bytes.length > MAX_IMAGE_BYTES) {
+                results.push({
+                    url,
+                    ...dimensions,
+                    contentType,
+                    sizeBytes: bytes.length,
+                    status: "failed",
+                    error: `image exceeds ${MAX_IMAGE_BYTES} bytes`,
+                });
+                continue;
+            }
+            const filePath = resolve(imageDir, `image-${String(index + 1).padStart(3, "0")}${extensionForContentType(contentType)}`);
+            writeFileSync(filePath, bytes, { mode: 0o600 });
+            results.push({
+                url,
+                path: filePath,
+                contentType,
+                sizeBytes: bytes.length,
+                ...dimensions,
+                status: "downloaded",
+            });
+        }
+        catch (err) {
+            results.push({
+                url,
+                ...dimensions,
+                status: "failed",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    if (imageUrls.length > MAX_IMAGE_DOWNLOADS) {
+        for (const url of imageUrls.slice(MAX_IMAGE_DOWNLOADS)) {
+            results.push({
+                url,
+                ...parseImageDimensionsFromUrl(url),
+                status: "skipped",
+                error: `only first ${MAX_IMAGE_DOWNLOADS} images are downloaded`,
+            });
+        }
+    }
+    return results;
+}
+export function parseImageDimensionsFromUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const width = Number(parsed.searchParams.get("w"));
+        const height = Number(parsed.searchParams.get("h"));
+        return {
+            width: Number.isFinite(width) && width > 0 ? width : undefined,
+            height: Number.isFinite(height) && height > 0 ? height : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function extensionForContentType(contentType) {
+    if (!contentType)
+        return ".bin";
+    if (contentType.includes("png"))
+        return ".png";
+    if (contentType.includes("jpeg") || contentType.includes("jpg"))
+        return ".jpg";
+    if (contentType.includes("gif"))
+        return ".gif";
+    if (contentType.includes("webp"))
+        return ".webp";
+    if (contentType.includes("svg"))
+        return ".svg";
+    return ".bin";
+}
+function normalizeExtractedText(text) {
+    return text
+        .replace(/p\.\d{8,}/g, "")
+        .replace(/\b\d{12,}@eJ\b/g, "")
+        .replace(/[^\S\r\n]+/g, " ")
+        .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]+/g, "\n")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => line.length > 1 || /[\u4e00-\u9fff]/.test(line))
+        .filter((line) => !line.includes("\uFFFD"))
+        .filter((line) => /[\p{L}\p{N}\]\)]/u.test(line))
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
 }
 function detectBodySignals(body, mimeType) {
     const haystack = `${mimeType}\n${body.slice(0, 200_000)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mkterswingman/5mghost-wonder",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "企微文档读取 CLI — WeCom document reader",
   "type": "module",
   "engines": {
@@ -26,7 +26,7 @@
     "build": "rm -rf dist && tsc && chmod +x dist/cli.js",
     "typecheck": "tsc --noEmit",
     "check:skills": "node scripts/check-skills.mjs",
-    "test": "npm run check:skills && node dist/wecom/url.test.js && node --test tests/sheet-parity.test.mjs && node --test tests/export-sanitize.test.mjs && node --test tests/format.test.mjs && node --test tests/cookies-validation.test.mjs",
+    "test": "npm run check:skills && node dist/wecom/url.test.js && node --test tests/sheet-parity.test.mjs && node --test tests/export-sanitize.test.mjs && node --test tests/format.test.mjs && node --test tests/cookies-validation.test.mjs && node --test tests/browser-read.test.mjs",
     "smoke": "npm run build && node dist/cli.js help > /dev/null",
     "postinstall": "node scripts/postinstall.mjs"
   },

package/skills/setup-5mghost-wonder/SKILL.md

@@ -7,9 +7,9 @@ description: Use this skill when the user wants to install or set up wonder, say
 
 ## Skill version
 
-This skill matches **wonder 0.0.14**.
+This skill matches **wonder 0.0.16**.
 
-Once the CLI is installed in Step 1, run `wonder --version`. If the output does not equal `0.0.14`, the CLI on disk has drifted from the skill text loaded in this session. Ask the user to run `/update-5mghost-wonder`, then **start a fresh AI session** (`/exit` and re-enter, or open a new chat) — skill text already loaded into a running session does not refresh after `wonder update`, even though the file on disk has been replaced.
+Once the CLI is installed in Step 1, run `wonder --version`. If the output does not equal `0.0.16`, the CLI on disk has drifted from the skill text loaded in this session. Ask the user to run `/update-5mghost-wonder`, then **start a fresh AI session** (`/exit` and re-enter, or open a new chat) — skill text already loaded into a running session does not refresh after `wonder update`, even though the file on disk has been replaced.
 
 After a successful first install, also remind the user to start a fresh AI session before invoking `/use-5mghost-wonder` for the first time. The skill files were just written to disk; the current session never loaded them.
 

package/skills/update-5mghost-wonder/SKILL.md

@@ -7,7 +7,7 @@ description: Use this skill when the user wants to update or upgrade wonder, say
 
 ## Skill version
 
-This skill matches **wonder 0.0.14**.
+This skill matches **wonder 0.0.16**.
 
 ---
 

package/skills/use-5mghost-wonder/SKILL.md

@@ -10,10 +10,10 @@ the referenced workflow files needed for the current task.
 
 ## Version Gate
 
-This skill matches **wonder 0.0.14**.
+This skill matches **wonder 0.0.16**.
 
 On first use in a session, follow `references/session-init.md`. If the installed
-CLI version differs from `0.0.14`, stop and ask the user to run
+CLI version differs from `0.0.16`, stop and ask the user to run
 `/update-5mghost-wonder`, then start a fresh AI session.
 
 ## Hard Rules

package/skills/use-5mghost-wonder/references/cli-reference.md

@@ -7,6 +7,7 @@ wonder read <url> --save <dir>     # Output directory
 wonder read <url> --no-cache       # Force fresh export
 
 wonder browser probe <url>         # Experimental no-export browser evidence probe
+wonder browser read <url>          # Experimental no-export text read
 wonder browser probe <url> --headed
 wonder browser probe <url> --save <dir>
 
@@ -22,5 +23,5 @@ wonder auth login                  # Browser OAuth login
 wonder version                     # Print version
 ```
 
-Browser editor runtime remains experimental. No-export read now has an
-experimental evidence probe command, but it is not a lossless reader yet.
+Browser editor runtime remains experimental. No-export read has experimental
+browser commands, but it is not a lossless reader yet.

package/skills/use-5mghost-wonder/references/read-no-export-browser.md

@@ -30,7 +30,17 @@ Do not describe screenshot/OCR output as lossless.
 ## Procedure
 
 1. Confirm cookies are valid. If not, follow `cookie-recovery.md`.
-2. Start with the built-in evidence probe:
+2. Start with the built-in browser read:
+
+```bash
+wonder browser read <url> --save /tmp/wonder-browser-read
+```
+
+This currently attempts text extraction from the browser `opendoc`
+`initialAttributedText`. Treat it as `partial` unless it also proves image and
+table structure.
+
+3. If the read is insufficient, run the evidence probe:
 
 ```bash
 wonder browser probe <url> --save /tmp/wonder-browser-probe
@@ -38,9 +48,9 @@ wonder browser probe <url> --save /tmp/wonder-browser-probe
 
 Use `--headed` only when login/debug visibility is needed.
 
-3. If the probe is insufficient, continue with the available browser automation
+4. If the probe is insufficient, continue with the available browser automation
    runtime.
-4. Capture non-destructive evidence:
+5. Capture non-destructive evidence:
    - page URL and document type
    - visible title
    - loaded script/runtime globals that look like document stores
@@ -48,16 +58,16 @@ Use `--headed` only when login/debug visibility is needed.
      media URLs
    - WebSocket messages if they expose structured document operations
    - screenshots only as a fallback or visual cross-check
-5. For tables, specifically look for:
+6. For tables, specifically look for:
    - cell coordinates
    - displayed text
    - merge ranges
    - row/column sizes if available
    - fixed cell images
    - floating images with position, size, and anchor
-6. For image-heavy docs, verify whether each image can be fetched as an original
+7. For image-heavy docs, verify whether each image can be fetched as an original
    resource or only appears in a raster screenshot.
-7. Report `pass`, `partial`, or `fail` with the missing fields.
+8. Report `pass`, `partial`, or `fail` with the missing fields.
 
 ## Output Contract