explorbot 0.4.0 → 0.4.2

package/dist/boat/doc-collector/src/docbot.js

@@ -9,8 +9,9 @@ import { DocbotConfigParser } from "./config.js";
 import { renderPageDocumentation, renderSpecIndex } from "./docs-renderer.js";
 import { getDocPageKey, shouldCrawlDocPath } from "./path-filter.js";
 import { extractResearchNavigationTargets } from "./research-navigation.js";
-import { captureBeforeInteraction, captureDocumentationScreenshots, captureInteractionScreenshot } from "./screenshots.js";
+import { captureBeforeInteraction, captureDocumentationScreenshots, captureEvidenceScreenshots, captureInteractionScreenshot } from "./screenshots.js";
 import { renderMermaidBody } from "./state-diagram.js";
+import { buildTemplateRecord, findTemplateMatch } from "./template-dedup.js";
 class DocBot {
     explorBot;
     configParser;
@@ -20,7 +21,7 @@ class DocBot {
     scopeRoot = '/';
     constructor(options = {}) {
         this.options = options;
-        const baseUrl = this.extractAbsoluteBaseUrl(options.startUrl || '/');
+        const baseUrl = this.extractAbsoluteBaseUrl(options.startUrl || '/') || options.baseUrl;
         this.explorBot = new ExplorBot({
             baseUrl,
             verbose: options.verbose,
@@ -53,6 +54,7 @@ class DocBot {
         const queue = [];
         const queued = new Set();
         const documented = new Set();
+        const templates = [];
         const pages = [];
         const skipped = [];
         const baseUrl = this.explorBot.getConfig().playwright.url;
@@ -73,14 +75,6 @@ class DocBot {
             try {
                 tag('info').log(`Collecting docs for ${this.toDisplayUrl(target, baseUrl)}`);
                 await this.explorBot.visit(target);
-                if (stateManager.isInDeadLoop()) {
-                    tag('warning').log('Dead loop detected during docs crawl, stopping collection');
-                    skipped.push({
-                        url: target,
-                        reason: 'dead loop detected during crawl',
-                    });
-                    break;
-                }
                 const state = this.explorBot.getCurrentState();
                 if (!state) {
                     skipped.push({
@@ -93,6 +87,22 @@ class DocBot {
                 if (documented.has(pageKey)) {
                     continue;
                 }
+                if (this.shouldCollapseTemplates(opts.collapseTemplatePages)) {
+                    const templateUrl = findTemplateMatch(state.ariaSnapshot ?? null, templates, this.getTemplateSimilarity(opts.templateSimilarity));
+                    if (templateUrl) {
+                        skipped.push({
+                            url: state.url,
+                            reason: `same layout as ${templateUrl} (only content differs)`,
+                        });
+                        documented.add(pageKey);
+                        for (const nextPath of this.extractNextPaths(state, baseUrl, '')) {
+                            if (documented.has(this.getPageKey(nextPath)) || stateManager.hasVisitedState(nextPath))
+                                continue;
+                            this.enqueuePath(nextPath, queue, queued);
+                        }
+                        continue;
+                    }
+                }
                 const research = await this.explorBot.agentResearcher().research(state, {
                     screenshot: this.shouldUseScreenshots(),
                     force: true,
@@ -134,6 +144,9 @@ class DocBot {
                     filePath,
                 });
                 documented.add(pageKey);
+                const templateRecord = buildTemplateRecord(state.url, state.ariaSnapshot ?? null);
+                if (templateRecord)
+                    templates.push(templateRecord);
                 const nextPaths = this.extractNextPaths(state, baseUrl, research, documentation);
                 const interactionPriorityPaths = new Set(this.extractInteractionPaths(baseUrl, documentation));
                 for (const nextPath of nextPaths) {
@@ -184,6 +197,23 @@ class DocBot {
         }
         return true;
     }
+    shouldCollapseTemplates(override) {
+        if (override === false) {
+            return false;
+        }
+        if (this.config.docs?.collapseTemplatePages === false) {
+            return false;
+        }
+        return true;
+    }
+    getTemplateSimilarity(override) {
+        const value = override ?? this.config.docs?.templateSimilarity;
+        if (value == null)
+            return undefined;
+        if (!Number.isFinite(value) || value <= 0 || value > 100)
+            return undefined;
+        return value;
+    }
     extractNextPaths(state, baseUrl, research, documentation) {
         const paths = [];
         const seen = new Set();
@@ -393,7 +423,8 @@ class DocBot {
     async savePageDocumentation(state, documentation, research) {
         const pagePath = this.getPageFilePath(state.url);
         const screenshots = await this.captureScreenshots(state, research, pagePath);
-        writeFileSync(pagePath, renderPageDocumentation(state, documentation, screenshots), 'utf8');
+        const evidence = await this.captureEvidence(state, documentation, research, pagePath);
+        writeFileSync(pagePath, renderPageDocumentation(state, documentation, screenshots, evidence), 'utf8');
         return pagePath;
     }
     async captureScreenshots(state, research, pagePath) {
@@ -406,6 +437,17 @@ class DocBot {
             config: this.config,
         });
     }
+    async captureEvidence(state, documentation, research, pagePath) {
+        if (!this.shouldUseScreenshots()) {
+            return documentation.can.map(() => null);
+        }
+        return captureEvidenceScreenshots(this.explorBot.getExplorer(), state, documentation, {
+            pageFilePath: pagePath,
+            screenshotsDir: this.getScreenshotsDir(),
+            config: this.config,
+            research,
+        });
+    }
     saveIndex(startPath, pages, skipped, maxPages) {
         const outputDir = this.configParser.getOutputDir();
         const indexPath = path.join(outputDir, 'index.md');

package/dist/boat/doc-collector/src/docs-renderer.js

@@ -3,7 +3,7 @@ import matter from 'gray-matter';
 import { APPLICATION_SPEC_FORMAT, APPLICATION_SPEC_VERSION } from "../../../src/application-spec-contract.js";
 import { normalizeInlineText } from "../../../src/utils/strings.js";
 import { buildStateGraph, renderMermaidFromGraph, renderPageStateDiagram, renderStateMapFromGraph } from "./state-diagram.js";
-function renderPageDocumentation(state, documentation, screenshots = []) {
+function renderPageDocumentation(state, documentation, screenshots = [], evidence = []) {
     const lines = [];
     lines.push(`# ${state.url}`);
     lines.push('');
@@ -15,6 +15,35 @@ function renderPageDocumentation(state, documentation, screenshots = []) {
     lines.push('');
     lines.push(ensureSentence(documentation.summary));
     lines.push('');
+    lines.push('## User Can');
+    lines.push('');
+    if (documentation.can.length === 0) {
+        lines.push('- No proven actions were identified from the collected research.');
+        lines.push('');
+    }
+    for (const [index, item] of documentation.can.entries()) {
+        lines.push(`- ${normalizeAction(item.action)} -> ${item.scope}`);
+        lines.push(`  Proof: ${ensureSentence(item.evidence)}`);
+        const shot = evidence[index];
+        if (shot) {
+            lines.push('');
+            lines.push(`  ![${normalizeInlineText(item.action)}](${shot.relativePath})`);
+        }
+        lines.push('');
+    }
+    lines.push('## User Might');
+    lines.push('');
+    if (documentation.might.length === 0) {
+        lines.push('- No assumption-based actions were identified.');
+        lines.push('');
+    }
+    for (const item of documentation.might) {
+        lines.push(`- ${normalizeAction(item.action, 'might')} -> ${item.scope}`);
+        lines.push(`  Signal: ${ensureSentence(item.evidence)}`);
+    }
+    if (documentation.might.length > 0) {
+        lines.push('');
+    }
     if (screenshots.length > 0) {
         lines.push('## Screenshots');
         lines.push('');
@@ -26,6 +55,24 @@ function renderPageDocumentation(state, documentation, screenshots = []) {
             lines.push('');
         }
     }
+    const navigationLinks = renderNavigationLinks(state);
+    if (navigationLinks.length > 0) {
+        lines.push('## Navigation');
+        lines.push('');
+        for (const link of navigationLinks) {
+            lines.push(`- ${link.title}: ${link.url}`);
+        }
+        lines.push('');
+    }
+    const qualityNotes = documentation.qualityNotes;
+    if (qualityNotes && qualityNotes.length > 0) {
+        lines.push('## Coverage Notes');
+        lines.push('');
+        for (const note of qualityNotes) {
+            lines.push(`- ${ensureSentence(note)}`);
+        }
+        lines.push('');
+    }
     const interactions = documentation.interactions;
     const pageStateDiagram = renderPageStateDiagram(state.title || state.url || 'page', state.url || '', interactions || []);
     if (pageStateDiagram) {
@@ -57,41 +104,6 @@ function renderPageDocumentation(state, documentation, screenshots = []) {
             }
         }
     }
-    lines.push('## User Can');
-    lines.push('');
-    if (documentation.can.length === 0) {
-        lines.push('- No proven actions were identified from the collected research.');
-        lines.push('');
-    }
-    for (const item of documentation.can) {
-        lines.push(`- ${normalizeAction(item.action)} -> ${item.scope}`);
-        lines.push(`  Proof: ${ensureSentence(item.evidence)}`);
-    }
-    if (documentation.can.length > 0) {
-        lines.push('');
-    }
-    lines.push('## User Might');
-    lines.push('');
-    if (documentation.might.length === 0) {
-        lines.push('- No assumption-based actions were identified.');
-        lines.push('');
-    }
-    for (const item of documentation.might) {
-        lines.push(`- ${normalizeAction(item.action, 'might')} -> ${item.scope}`);
-        lines.push(`  Signal: ${ensureSentence(item.evidence)}`);
-    }
-    if (documentation.might.length > 0) {
-        lines.push('');
-    }
-    const qualityNotes = documentation.qualityNotes;
-    if (qualityNotes && qualityNotes.length > 0) {
-        lines.push('## Coverage Notes');
-        lines.push('');
-        for (const note of qualityNotes) {
-            lines.push(`- ${ensureSentence(note)}`);
-        }
-        lines.push('');
-    }
     return matter.stringify(`${lines.join('\n').trimEnd()}\n`, {
         url: state.url,
         format: APPLICATION_SPEC_FORMAT,
@@ -111,17 +123,7 @@ function renderSpecIndex(outputDir, startPath, pages, skipped, maxPages) {
     lines.push('');
     const graph = buildStateGraph(outputDir, pages);
     const mermaid = renderMermaidFromGraph(graph, true);
-    lines.push('## State Transitions');
-    lines.push('');
-    lines.push(`\`\`\`mermaid\n${mermaid}\n\`\`\``);
-    lines.push('');
     const stateMap = renderStateMapFromGraph(graph);
-    if (stateMap) {
-        lines.push('### State Index');
-        lines.push('');
-        lines.push(stateMap);
-        lines.push('');
-    }
     lines.push('## Pages');
     lines.push('');
     if (pages.length === 0) {
@@ -179,8 +181,29 @@ function renderSpecIndex(outputDir, startPath, pages, skipped, maxPages) {
         }
         lines.push('');
     }
+    lines.push('## State Transitions');
+    lines.push('');
+    lines.push(`\`\`\`mermaid\n${mermaid}\n\`\`\``);
+    lines.push('');
+    if (stateMap) {
+        lines.push('### State Index');
+        lines.push('');
+        lines.push(stateMap);
+        lines.push('');
+    }
     return `${lines.join('\n').trimEnd()}\n`;
 }
+function renderNavigationLinks(state) {
+    const links = [];
+    const seen = new Set();
+    for (const link of state.links || []) {
+        if (!link.url || seen.has(link.url))
+            continue;
+        seen.add(link.url);
+        links.push({ title: normalizeInlineText(link.title) || link.url, url: link.url });
+    }
+    return links;
+}
 function normalizeAction(action, kind = 'can') {
     const trimmed = normalizeInlineText(action);
     if (!trimmed) {

package/dist/boat/doc-collector/src/interaction-screenshots.js

@@ -1,6 +1,7 @@
 import { writeFileSync } from 'node:fs';
 import pixelmatch from 'pixelmatch';
 import { PNG } from 'pngjs';
+import { removeVisualAnnotations } from "../../../src/ai/researcher/coordinates.js";
 const REGION_PADDING = 30;
 const SCREENSHOT_OPTIONS = { animations: 'disabled', caret: 'hide' };
 export async function captureInteractionBefore(page) {
@@ -43,7 +44,7 @@ export function findChangedRegion(beforeScreenshot, afterScreenshot, padding = R
     const changedPixels = findChangedPixelBounds(before, after);
     return changedPixels ? addPadding(changedPixels, before.width, before.height, padding) : null;
 }
-function saveRegion(after, region, filePath) {
+export function saveRegion(after, region, filePath) {
     const cropped = new PNG({ width: region.width, height: region.height });
     PNG.bitblt(after, cropped, region.x, region.y, region.width, region.height, 0, 0);
     writeFileSync(filePath, PNG.sync.write(cropped));
@@ -69,22 +70,28 @@ function findChangedPixelBounds(before, after) {
     }
     return { x: left, y: top, width: right - left + 1, height: bottom - top + 1 };
 }
-function addPadding(region, imageWidth, imageHeight, padding = REGION_PADDING) {
+export function regionAround(png, box, viewport, padding) {
+    let scaleX = 1;
+    let scaleY = 1;
+    if (viewport) {
+        scaleX = png.width / viewport.width;
+        scaleY = png.height / viewport.height;
+    }
+    const scaled = {
+        x: Math.round(box.x * scaleX),
+        y: Math.round(box.y * scaleY),
+        width: Math.round(box.width * scaleX),
+        height: Math.round(box.height * scaleY),
+    };
+    return addPadding(scaled, png.width, png.height, Math.round(padding * scaleX));
+}
+export function addPadding(region, imageWidth, imageHeight, padding = REGION_PADDING) {
     const x = Math.max(0, region.x - padding);
     const y = Math.max(0, region.y - padding);
     const maxX = Math.min(imageWidth, region.x + region.width + padding);
     const maxY = Math.min(imageHeight, region.y + region.height + padding);
     return { x, y, width: maxX - x, height: maxY - y };
 }
-async function removeVisualAnnotations(page) {
-    try {
-        await page.locator('[data-explorbot-annotation]').evaluateAll((elements) => {
-            for (const element of elements)
-                element.remove();
-        });
-    }
-    catch { }
-}
 async function findOverlayRegion(page, image, detectUnmarkedOverlay) {
     let box = null;
     try {

package/dist/boat/doc-collector/src/screenshots.js

@@ -1,14 +1,21 @@
 import { mkdirSync } from 'node:fs';
 import path from 'node:path';
+import { PNG } from 'pngjs';
+import { removeVisualAnnotations } from "../../../src/ai/researcher/coordinates.js";
 import { parseResearchSections } from "../../../src/ai/researcher/parser.js";
+import { parseAriaLocator } from "../../../src/utils/aria.js";
+import { normalizeUrl } from "../../../src/state-manager.js";
 import { safeFilename, sanitizeFilename } from "../../../src/utils/strings.js";
-import { captureInteractionAfter, captureInteractionBefore } from "./interaction-screenshots.js";
+import { captureInteractionAfter, captureInteractionBefore, regionAround, saveRegion } from "./interaction-screenshots.js";
 const DEFAULT_MAX_SECTION_SCREENSHOTS = 8;
+const EVIDENCE_PADDING = 250;
 export async function captureDocumentationScreenshots(explorer, state, research, options) {
     const page = explorer.page;
     if (!page) {
         return [];
     }
+    await dismissTransientOverlay(page);
+    await removeVisualAnnotations(page);
     mkdirSync(options.screenshotsDir, { recursive: true });
     const screenshots = [];
     const pageName = sanitizeFilename(state.url || 'page') || 'page';
@@ -26,6 +33,102 @@ export async function captureDocumentationScreenshots(explorer, state, research,
     }
     return screenshots;
 }
+export async function captureEvidenceScreenshots(explorer, state, documentation, options) {
+    const page = explorer.page;
+    if (!page) {
+        return documentation.can.map(() => null);
+    }
+    await dismissTransientOverlay(page);
+    await removeVisualAnnotations(page);
+    if (!isOnDocumentedPage(page, state)) {
+        return documentation.can.map(() => null);
+    }
+    mkdirSync(options.screenshotsDir, { recursive: true });
+    const pageName = sanitizeFilename(state.url || 'page') || 'page';
+    const shots = [];
+    for (const [index, item] of documentation.can.entries()) {
+        shots.push(await captureEvidenceScreenshot(page, pageName, index, item, options));
+    }
+    return shots;
+}
+async function captureEvidenceScreenshot(page, pageName, index, item, options) {
+    if (!item.element)
+        return null;
+    const element = resolveResearchLocator(item.element, options.research);
+    if (!element)
+        return null;
+    const locatorInfo = parseAriaLocator(element);
+    try {
+        const locator = resolveEvidenceLocator(page, element, locatorInfo);
+        if ((await locator.count()) !== 1)
+            return null;
+        await locator.scrollIntoViewIfNeeded({ timeout: 2000 });
+        const box = await locator.boundingBox();
+        if (!box || box.width <= 0 || box.height <= 0)
+            return null;
+        const image = await page.screenshot();
+        const png = PNG.sync.read(image);
+        const region = regionAround(png, box, await page.viewportSize(), EVIDENCE_PADDING);
+        const filePath = path.join(options.screenshotsDir, safeFilename(`${pageName}_can_${index + 1}`, '.png'));
+        saveRegion(png, region, filePath);
+        return {
+            title: item.action,
+            path: filePath,
+            relativePath: toMarkdownPath(options.pageFilePath, filePath),
+            kind: 'evidence',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function resolveResearchLocator(requested, research) {
+    if (!research)
+        return requested;
+    const requestedAria = parseAriaLocator(requested);
+    const requestedCss = unwrapLocator(requested);
+    for (const section of parseResearchSections(research)) {
+        for (const element of section.elements) {
+            if (requestedAria && element.aria?.role === requestedAria.role && element.aria.text === requestedAria.text) {
+                return `{ role: '${element.aria.role}', text: '${element.aria.text}' }`;
+            }
+            if (element.css && requestedCss === unwrapLocator(element.css))
+                return element.css;
+        }
+    }
+    return null;
+}
+function unwrapLocator(locator) {
+    const trimmed = locator.trim();
+    const first = trimmed.at(0);
+    const last = trimmed.at(-1);
+    if (first === last && (first === '`' || first === '"' || first === "'")) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function isOnDocumentedPage(page, state) {
+    try {
+        const current = new URL(page.url());
+        const expected = new URL(state.url || '', current.origin);
+        return current.origin === expected.origin && normalizeUrl(current.href) === normalizeUrl(expected.href);
+    }
+    catch {
+        return false;
+    }
+}
+function resolveEvidenceLocator(page, element, locatorInfo) {
+    if (locatorInfo?.text) {
+        return page.getByRole(locatorInfo.role, { name: locatorInfo.text, exact: true });
+    }
+    return page.locator(element);
+}
+async function dismissTransientOverlay(page) {
+    try {
+        await page.keyboard.press('Escape');
+    }
+    catch { }
+}
 export function getScreenshotSections(research) {
     const sections = [];
     const seen = new Set();

package/dist/boat/doc-collector/src/template-dedup.js

@@ -0,0 +1,27 @@
+import { ariaTemplateSignature } from "../../../src/utils/aria.js";
+import { diceSimilarity } from "../../../src/utils/similarity.js";
+const TEMPLATE_MIN_SIGNATURE_SIZE = 8;
+const TEMPLATE_SIMILARITY_THRESHOLD = 90;
+export function buildTemplateRecord(url, snapshot) {
+    const signature = ariaTemplateSignature(snapshot);
+    if (signature.size < TEMPLATE_MIN_SIGNATURE_SIZE)
+        return null;
+    return { url, signature };
+}
+export function findTemplateMatch(snapshot, known, threshold = TEMPLATE_SIMILARITY_THRESHOLD) {
+    const signature = ariaTemplateSignature(snapshot);
+    if (signature.size < TEMPLATE_MIN_SIGNATURE_SIZE)
+        return null;
+    let bestUrl = null;
+    let bestScore = 0;
+    for (const record of known) {
+        const score = diceSimilarity(signature, record.signature);
+        if (score < bestScore)
+            continue;
+        bestScore = score;
+        bestUrl = record.url;
+    }
+    if (bestScore < threshold)
+        return null;
+    return bestUrl;
+}

package/dist/boat/prima/bin/prima-cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { knowledgeOption } from "../../../src/commands/options/index.js";
 import { createPrimaCommands } from "../src/cli.js";
 const program = createPrimaCommands('prima');
+knowledgeOption.register(program);
 program.parse();

package/dist/boat/prima/src/cli.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import dedent from 'dedent';
 import { keepServerRunning } from "../../../src/browser-server.js";
+import { RecommendedModelsCommand } from "../../../src/commands/recommended-models-command.js";
 import { browserErrorMessage } from "../../../src/utils/browser-errors.js";
 import { isVerboseMode, setQuietMode } from "../../../src/utils/logger.js";
 import { clearActivityLine, trackActivityLine } from "./activity-line.js";
@@ -106,6 +107,7 @@ function addCommonOptions(cmd) {
         .option('--ephemeral', 'Keep no state between runs; applies to config-free runs, where output goes to a temp directory')
         .option('--framework <name>', 'Not active yet: framework the reported code targets, codeceptjs or playwright')
         .option('--url <url>', 'Page to open when the session has no page yet')
+        .option('--spec <path>', 'Docbot application spec directory or index.md to read as page knowledge')
         .option('--endpoint <ep>', 'Websocket endpoint of a browser server to attach to, skipping discovery')
         .option('--pw-session <title>', 'Title of the playwright-cli session to attach to')
         .addHelpText('after', `\n${sessionHelp}`);
@@ -118,6 +120,8 @@ function primaFor(options) {
         process.env.EXPLORBOT_AI_MODEL = options.model;
     if (options.visionModel)
         process.env.EXPLORBOT_VISION_MODEL = options.visionModel;
+    if (options.spec)
+        process.env.EXPLORBOT_SPEC = options.spec;
     return new Prima(buildOptions(options));
 }
 async function runPrima(options, command, run) {
@@ -196,6 +200,7 @@ export function createPrimaCommands(name = 'prima') {
         await prima.stop().catch(() => { });
         process.exit(0);
     });
+    RecommendedModelsCommand.register(cmd);
     addCommonOptions(cmd.command('status <hash>').description('Show the artifacts and page detail recorded for an earlier command'))
         .addHelpText('after', `\n${statusHelp}`)
         .action(async (hash, options) => {

package/dist/boat/prima/src/prima.js

@@ -14,7 +14,7 @@ import { getAliveEndpoint, launchServer, listInstances, stopServer } from "../..
 import { ConfigCommand } from "../../../src/commands/config-command.js";
 import { ConfigMissingError, ConfigParser, EXPLORBOT_ENV_VARS, outputPath } from "../../../src/config.js";
 import { ExplorBot } from "../../../src/explorbot.js";
-import { listSites } from "../../../src/global-config.js";
+import { findSiteWith, listSites } from "../../../src/global-config.js";
 import { Reporter } from "../../../src/reporter.js";
 import { Stats } from "../../../src/stats.js";
 import { Task, Test, TestResult } from "../../../src/test-plan.js";
@@ -1006,8 +1006,7 @@ export class Prima {
     }
     async status(hash) {
         if (!this.artifactsDir) {
-            const sites = listSites();
-            const site = sites.find((candidate) => existsSync(path.join(candidate.dir, 'output', 'prima', hash))) || sites[0];
+            const site = findSiteWith(path.join('output', 'prima', hash)) || listSites()[0];
             if (site && !this.configBaseUrl())
                 this.sessionUrl = site.url;
             await this.loadConfig();
@@ -1049,7 +1048,7 @@ export class Prima {
             aria: result.ariaSnapshot,
             html: await result.combinedHtml(),
             screenshot: result.screenshot,
-            requests: this.bot.requestStore().getRequests(),
+            requests: this.bot.requestStore().getMadeRequests(),
         });
     }
     statusHash() {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/dist/rules/planner/styles/normal.md

@@ -1,7 +1,7 @@
 Study the page and figure out its business purpose. What is this page FOR? What would a user come here to do?
 
 Based on the page type, propose tests for COMPLETE user workflows:
-- If this is a data page (lists, tables): test CRUD operations end-to-end (create item → verify in list, edit item → verify changes saved, delete item → verify removed)
+- If this is a data page (lists, tables): test create, edit and delete as separate tests, each preparing the item it acts on
 - If the page has inputs to fill in: test the full commit flow, not just that the controls render
 - If this has filters and search: test filtering AND verify results change, not just "filter tab clicked"
 - If this has modals/dropdowns: test the ACTION inside them, not just opening/closing them

package/dist/src/action-result.d.ts

@@ -2,7 +2,7 @@ import { type HtmlConfig } from './config.js';
 import type { Link, WebPageState } from './state-manager.js';
 import { TTLCache } from './utils/cache.js';
 import { type HtmlDiffPart, type HtmlDiffResult } from './utils/html-diff.js';
-import { Overlay } from './utils/overlay.js';
+import { Region } from './utils/region.js';
 interface ActionResultData extends WebPageState {
     html?: string;
     fullUrl?: string | undefined;
@@ -83,7 +83,7 @@ export declare class ActionResult implements ActionResultData {
     notes: string[];
     links: Link[];
     verifications?: Record<string, boolean>;
-    overlay: Overlay;
+    overlay: Region;
     _diffCache: {
         previousId: number | undefined;
         diff: Diff;