explorbot 0.1.32-beta.1 → 0.2.1

package/dist/boat/doc-collector/src/ai/documentarian.js

@@ -6,19 +6,21 @@ class Documentarian {
     provider;
     config;
     explorer;
-    constructor(provider, config = {}, explorer) {
+    stateManager;
+    constructor(provider, config = {}, explorer, stateManager) {
         this.provider = provider;
         this.config = config;
         this.explorer = explorer;
+        this.stateManager = stateManager;
     }
-    async document(state, research) {
+    async document(state, research, captureState) {
         const interactiveEnabled = this.config.docs?.interactive === true && this.explorer;
         if (!interactiveEnabled) {
             tag('info').log('Documentarian: Using static mode (interactive disabled or no explorer)');
             return this.documentStatic(state, research);
         }
         tag('info').log('Documentarian: Using interactive mode with tools');
-        return this.documentWithInteraction(state, research);
+        return this.documentWithInteraction(state, research, captureState);
     }
     async documentStatic(state, research) {
         try {
@@ -31,11 +33,12 @@ class Documentarian {
             return this.generateDocumentation(state, this.sanitizeResearch(research), true);
         }
     }
-    async documentWithInteraction(state, research) {
+    async documentWithInteraction(state, research, captureState) {
+        let meaningfulInteractions = [];
         try {
             tag('info').log('Starting interactive exploration...');
-            const deterministicInteractions = await collectDocInteractions(this.explorer, state, research, this.config);
-            const meaningfulInteractions = this.getMeaningfulInteractions(deterministicInteractions);
+            const deterministicInteractions = await collectDocInteractions(this.explorer, this.stateManager, state, research, this.config, captureState);
+            meaningfulInteractions = this.getMeaningfulInteractions(deterministicInteractions);
             if (meaningfulInteractions.length > 0) {
                 tag('success').log(`Collected ${meaningfulInteractions.length} deterministic interactions`);
                 return await this.generateDocumentationWithInteractions(state, research, meaningfulInteractions);
@@ -50,7 +53,16 @@ class Documentarian {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            tag('warning').log(`Interactive documentation failed: ${message}. Falling back to static.`);
+            tag('warning').log(`Interactive documentation failed: ${message}.`);
+            if (meaningfulInteractions.length > 0) {
+                tag('info').log(`Preserving ${meaningfulInteractions.length} observed interaction(s) without AI summary.`);
+                return this.normalizeDocumentation({
+                    summary: `Observed ${meaningfulInteractions.length} interaction(s); AI-generated summary was unavailable.`,
+                    can: [],
+                    might: [],
+                    interactions: meaningfulInteractions,
+                }, state, research);
+            }
             return this.documentStatic(state, research);
         }
     }

package/dist/boat/doc-collector/src/ai/tools.js

@@ -1,23 +1,24 @@
 import { parseResearchSections } from "../../../../src/ai/researcher/parser.js";
+import { detectFocusArea } from "../../../../src/utils/aria.js";
 const DEFAULT_MAX_PRIMARY_CANDIDATES = 3;
 const DEFAULT_MAX_INTERACTIONS = 5;
 const MAX_LINKS = 15;
 const DEFAULT_WAIT_MS = 700;
 const TAB_WAIT_MS = 500;
 const DEFAULT_DENIED_ACTION_LABELS = ['delete', 'remove', 'destroy', 'archive', 'discard', 'logout', 'sign out', 'signout', 'sign_out', 'erase', 'drop'];
-export async function collectDocInteractions(explorer, state, research, config = {}) {
+export async function collectDocInteractions(explorer, stateManager, state, research, config = {}, captureState) {
     const sections = parseResearchSections(research);
     const transitions = [];
     const maxInteractions = getPositiveConfigNumber(config.docs?.maxInteractions, DEFAULT_MAX_INTERACTIONS);
     const tabGroup = findTabGroup(sections);
     if (tabGroup) {
-        transitions.push(...(await exploreTabGroup(explorer, tabGroup, state.url, maxInteractions)));
+        transitions.push(...(await exploreTabGroup(explorer, stateManager, tabGroup, state.url, maxInteractions, captureState)));
     }
     for (const candidate of findActionCandidates(sections, config)) {
         if (transitions.length >= maxInteractions) {
             break;
         }
-        const transition = await executeInteraction(explorer, candidate, state.url, DEFAULT_WAIT_MS);
+        const transition = await executeInteraction(explorer, stateManager, candidate, state.url, DEFAULT_WAIT_MS, captureState);
         if (!transition) {
             continue;
         }
@@ -32,18 +33,18 @@ export function pickDocActionCandidates(research, config = {}) {
         section: candidate.sectionName,
     }));
 }
-async function exploreTabGroup(explorer, tabGroup, restoreUrl, maxInteractions) {
+async function exploreTabGroup(explorer, stateManager, tabGroup, restoreUrl, maxInteractions, captureState) {
     const transitions = [];
     for (const element of tabGroup.elements) {
         if (transitions.length >= maxInteractions) {
             break;
         }
-        const transition = await executeInteraction(explorer, {
+        const transition = await executeInteraction(explorer, stateManager, {
             element,
             container: tabGroup.container,
             role: 'tab',
             sectionName: tabGroup.sectionName,
-        }, restoreUrl, TAB_WAIT_MS);
+        }, restoreUrl, TAB_WAIT_MS, captureState);
         if (!transition) {
             continue;
         }
@@ -52,8 +53,8 @@ async function exploreTabGroup(explorer, tabGroup, restoreUrl, maxInteractions)
     await restoreInteractionState(explorer, restoreUrl, buildPrimaryCommand(tabGroup.elements[0], tabGroup.container));
     return transitions;
 }
-async function executeInteraction(explorer, candidate, restoreUrl, waitMs) {
-    const beforeState = explorer.getStateManager().getCurrentState();
+async function executeInteraction(explorer, stateManager, candidate, restoreUrl, waitMs, captureState) {
+    const beforeState = stateManager.getCurrentState();
     if (!beforeState) {
         return null;
     }
@@ -62,7 +63,7 @@ async function executeInteraction(explorer, candidate, restoreUrl, waitMs) {
         return null;
     }
     await wait(waitMs);
-    const afterState = explorer.getStateManager().getCurrentState();
+    const afterState = stateManager.getCurrentState();
     if (!afterState) {
         return null;
     }
@@ -73,15 +74,21 @@ async function executeInteraction(explorer, candidate, restoreUrl, waitMs) {
         newElements: ariaChanges.newCount,
         removedElements: ariaChanges.removedCount,
     });
-    if (urlChanged) {
+    if (captureState && isMeaningfulStateTransition(transition)) {
+        const screenshot = await captureState(afterState, transition);
+        if (screenshot) {
+            transition.screenshot = screenshot;
+        }
+    }
+    if (urlChanged || ariaChanges.newCount > 0) {
         await restoreInteractionState(explorer, restoreUrl);
     }
     return transition;
 }
 async function attemptInteraction(explorer, candidate) {
-    const action = explorer.createAction();
+    const action = explorer.action();
     for (const command of buildClickCommands(candidate.element, candidate.container)) {
-        const success = await action.attempt(command, buildPurpose(candidate), false);
+        const success = await action.attempt(command, buildPurpose(candidate));
         if (success) {
             return true;
         }
@@ -90,15 +97,15 @@ async function attemptInteraction(explorer, candidate) {
 }
 async function restoreInteractionState(explorer, restoreUrl, primaryCommand) {
     if (primaryCommand) {
-        const action = explorer.createAction();
-        const restored = await action.attempt(primaryCommand, `Restore initial state on ${restoreUrl}`, false);
+        const action = explorer.action();
+        const restored = await action.attempt(primaryCommand, `Restore initial state on ${restoreUrl}`);
         if (restored) {
             await wait(TAB_WAIT_MS);
             return;
         }
     }
-    const action = explorer.createAction();
-    await action.attempt(`I.amOnPage(${JSON.stringify(restoreUrl)})`, `Restore page ${restoreUrl}`, false);
+    const action = explorer.action();
+    await action.attempt(`I.amOnPage(${JSON.stringify(restoreUrl)})`, `Restore page ${restoreUrl}`);
 }
 function buildTransition(candidate, beforeState, afterState, changes) {
     const transition = {
@@ -109,12 +116,42 @@ function buildTransition(candidate, beforeState, afterState, changes) {
         newCapabilities: collectDiscoveryNotes(afterState, changes),
         element: buildInteractionElement(candidate),
         changes,
+        targetState: describeTargetState(beforeState, afterState, candidate),
     };
     if (changes.urlChanged) {
         transition.targetUrl = afterState.url;
     }
     return transition;
 }
+function describeTargetState(beforeState, afterState, candidate) {
+    const beforeFocus = detectFocusArea(beforeState.ariaSnapshot || null);
+    const afterFocus = detectFocusArea(afterState.ariaSnapshot || null);
+    if (afterFocus.detected && (!beforeFocus.detected || beforeFocus.name !== afterFocus.name)) {
+        return {
+            kind: afterFocus.type || 'dialog',
+            label: afterFocus.name || candidate.element.name.trim(),
+            url: afterState.url,
+        };
+    }
+    const beforePath = beforeState.url.split('?')[0].split('#')[0];
+    const afterPath = afterState.url.split('?')[0].split('#')[0];
+    const headings = collectHeadings(afterState);
+    let kind = 'page';
+    if (beforePath === afterPath) {
+        kind = 'section';
+    }
+    return {
+        kind,
+        label: headings[0] || afterState.title || candidate.element.name.trim(),
+        url: afterState.url,
+    };
+}
+function isMeaningfulStateTransition(transition) {
+    if (transition.targetUrl || transition.changes?.urlChanged) {
+        return true;
+    }
+    return (transition.changes?.newElements || 0) > 0;
+}
 function buildInteractionElement(candidate) {
     const element = {
         role: candidate.role,

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

@@ -4,10 +4,6 @@ import { Command } from 'commander';
 import { setPreserveConsoleLogs } from "../../../src/utils/logger.js";
 import { DocBot } from "./docbot.js";
 function buildOptions(options) {
-    let session = options.session;
-    if (options.session === true) {
-        session = 'output/session.json';
-    }
     return {
         verbose: options.verbose || options.debug,
         config: options.config,
@@ -15,7 +11,7 @@ function buildOptions(options) {
         show: options.show,
         headless: options.headless,
         incognito: options.incognito,
-        session,
+        session: options.session,
         docsConfig: options.docsConfig,
     };
 }

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

@@ -9,7 +9,8 @@ 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 { captureDocumentationScreenshots } from "./screenshots.js";
+import { captureDocumentationScreenshots, captureInteractionScreenshot } from "./screenshots.js";
+import { renderMermaidBody } from "./state-diagram.js";
 class DocBot {
     explorBot;
     configParser;
@@ -38,7 +39,7 @@ class DocBot {
             config: this.options.docsConfig,
             path: this.options.path,
         });
-        this.documentarian = new Documentarian(this.explorBot.getProvider(), this.config, this.explorBot.getExplorer());
+        this.documentarian = new Documentarian(this.explorBot.getProvider(), this.config, this.explorBot.getExplorer(), this.explorBot.stateManager());
         this.ensureDirectory(this.configParser.getOutputDir());
         this.ensureDirectory(this.getPagesDir());
     }
@@ -65,7 +66,7 @@ class DocBot {
             if (documented.has(targetKey)) {
                 continue;
             }
-            const stateManager = this.explorBot.getExplorer().getStateManager();
+            const stateManager = this.explorBot.stateManager();
             if (stateManager.hasVisitedState(target)) {
                 continue;
             }
@@ -96,7 +97,17 @@ class DocBot {
                     screenshot: this.shouldUseScreenshots(),
                     force: true,
                 });
-                const documentation = await this.documentarian.document(state, research);
+                const pagePath = this.getPageFilePath(state.url);
+                const documentation = await this.documentarian.document(state, research, async (interactionState, transition) => {
+                    if (!this.shouldUseScreenshots()) {
+                        return null;
+                    }
+                    return captureInteractionScreenshot(this.explorBot.getExplorer(), interactionState, transition, {
+                        pageFilePath: pagePath,
+                        screenshotsDir: this.getScreenshotsDir(),
+                        config: this.config,
+                    });
+                });
                 const lowSignalReason = this.getLowSignalReason(documentation, research);
                 if (lowSignalReason) {
                     skipped.push({
@@ -118,6 +129,7 @@ class DocBot {
                     mightActions: documentation.might.map((item) => item.action),
                     interactionActions: (documentation.interactions || []).map((item) => item.action),
                     qualityNotes: documentation.qualityNotes || [],
+                    interactions: documentation.interactions || [],
                     filePath,
                 });
                 documented.add(pageKey);
@@ -142,11 +154,12 @@ class DocBot {
                 });
             }
         }
-        const indexPath = this.saveIndex(effectiveStartPath, pages, skipped, effectiveMaxPages);
+        const { indexPath, diagramPath } = this.saveIndex(effectiveStartPath, pages, skipped, effectiveMaxPages);
         return {
             pages,
             skipped,
             indexPath,
+            diagramPath,
             outputDir: this.configParser.getOutputDir(),
         };
     }
@@ -338,6 +351,9 @@ class DocBot {
         if (documentation.can.length >= minCanActions) {
             return null;
         }
+        if ((documentation.interactions || []).length > 0) {
+            return null;
+        }
         const interactiveCount = this.countInteractiveElements(research);
         if (interactiveCount >= minInteractiveElements) {
             return null;
@@ -365,9 +381,12 @@ class DocBot {
         });
     }
     saveIndex(startPath, pages, skipped, maxPages) {
-        const indexPath = path.join(this.configParser.getOutputDir(), 'spec.md');
-        writeFileSync(indexPath, renderSpecIndex(this.configParser.getOutputDir(), startPath, pages, skipped, maxPages), 'utf8');
-        return indexPath;
+        const outputDir = this.configParser.getOutputDir();
+        const indexPath = path.join(outputDir, 'index.md');
+        writeFileSync(indexPath, renderSpecIndex(outputDir, startPath, pages, skipped, maxPages), 'utf8');
+        const diagramPath = path.join(outputDir, 'state-diagram.mmd');
+        writeFileSync(diagramPath, renderMermaidBody(outputDir, pages), 'utf8');
+        return { indexPath, diagramPath };
     }
     getPagesDir() {
         return path.join(this.configParser.getOutputDir(), 'pages');

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

@@ -1,4 +1,6 @@
 import path from 'node:path';
+import { buildStateGraph, renderMermaidFromGraph, renderStateMapFromGraph } from "./state-diagram.js";
+import { normalizeInlineText } from "../../../src/utils/strings.js";
 function renderPageDocumentation(state, documentation, screenshots = []) {
     const lines = [];
     lines.push(`# ${state.url}`);
@@ -40,6 +42,10 @@ function renderPageDocumentation(state, documentation, screenshots = []) {
                 }
                 lines.push('');
             }
+            if (transition.screenshot) {
+                lines.push(`![${normalizeInlineText(transition.screenshot.title)}](${transition.screenshot.relativePath})`);
+                lines.push('');
+            }
         }
     }
     lines.push('## User Can');
@@ -90,6 +96,18 @@ function renderSpecIndex(outputDir, startPath, pages, skipped, maxPages) {
     lines.push(`Pages skipped: ${skipped.length}`);
     lines.push(`Max pages: ${maxPages}`);
     lines.push('');
+    const graph = buildStateGraph(outputDir, pages);
+    lines.push('## State Transitions');
+    lines.push('');
+    lines.push(`\`\`\`mermaid\n${renderMermaidFromGraph(graph)}\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) {
@@ -192,7 +210,4 @@ function ensureSentence(text) {
     }
     return `${trimmed}.`;
 }
-function normalizeInlineText(text) {
-    return text.normalize('NFKC').replace(/\s+/g, ' ').trim();
-}
 export { renderPageDocumentation, renderSpecIndex, ensureSentence, normalizeAction };

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

@@ -1,10 +1,11 @@
 import { mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { parseResearchSections } from "../../../src/ai/researcher/parser.js";
+import { detectFocusArea } from "../../../src/utils/aria.js";
 import { safeFilename, sanitizeFilename } from "../../../src/utils/strings.js";
 const DEFAULT_MAX_SECTION_SCREENSHOTS = 8;
 export async function captureDocumentationScreenshots(explorer, state, research, options) {
-    const page = explorer.playwrightHelper?.page;
+    const page = explorer.page;
     if (!page) {
         return [];
     }
@@ -46,6 +47,34 @@ export function getScreenshotSections(research) {
     }
     return sections;
 }
+export async function captureInteractionScreenshot(explorer, state, transition, options) {
+    const page = explorer.page;
+    if (!page) {
+        return null;
+    }
+    mkdirSync(options.screenshotsDir, { recursive: true });
+    const pageName = sanitizeFilename(state.url || 'page') || 'page';
+    const stateName = sanitizeFilename(transition.targetState?.label || transition.action) || 'state';
+    const filePath = path.join(options.screenshotsDir, safeFilename(`${pageName}_${stateName}`, '.png'));
+    const focus = detectFocusArea(state.ariaSnapshot || null);
+    try {
+        if (focus.detected) {
+            await page.locator('[role="dialog"], [role="alertdialog"], [aria-modal="true"]').last().screenshot({ path: filePath });
+        }
+        else {
+            await page.screenshot({ path: filePath });
+        }
+    }
+    catch {
+        return null;
+    }
+    return {
+        title: transition.targetState?.label || transition.action,
+        path: filePath,
+        relativePath: toMarkdownPath(options.pageFilePath, filePath),
+        kind: 'state',
+    };
+}
 async function captureFullPageScreenshot(page, pageName, options) {
     const filePath = path.join(options.screenshotsDir, safeFilename(`${pageName}_page`, '.png'));
     try {

package/dist/boat/doc-collector/src/state-diagram.js

@@ -0,0 +1,200 @@
+import path from 'node:path';
+import { normalizeUrl } from "../../../src/state-manager.js";
+import { normalizeInlineText } from "../../../src/utils/strings.js";
+function buildStateGraph(outputDir, pages) {
+    const pageIds = new Map();
+    const pageNodes = [];
+    const adjacency = new Map();
+    const classAssignment = new Map([
+        ['page', []],
+        ['dialog', []],
+        ['section', []],
+    ]);
+    for (const [index, page] of pages.entries()) {
+        const id = `page${index}`;
+        pageIds.set(normalizeUrl(page.url), id);
+        adjacency.set(id, new Set());
+        classAssignment.get('page')?.push(id);
+        pageNodes.push({ id, kind: 'page', label: page.title || page.url, subLabel: page.url, filePath: page.filePath });
+    }
+    const stateKeys = new Map();
+    const transientByPage = new Map();
+    const clicks = [];
+    const edges = [];
+    const drawnBack = new Set();
+    let stateIndex = 0;
+    for (const [pageIndex, page] of pages.entries()) {
+        const sourceId = `page${pageIndex}`;
+        for (const transition of page.interactions || []) {
+            const targetState = transition.targetState;
+            if (!targetState) {
+                continue;
+            }
+            const normalizedTarget = normalizeUrl(targetState.url);
+            const isPageTarget = targetState.kind === 'page';
+            let pageTargetId;
+            if (isPageTarget) {
+                pageTargetId = pageIds.get(normalizedTarget);
+            }
+            let targetId;
+            if (pageTargetId && pageTargetId !== sourceId) {
+                targetId = pageTargetId;
+            }
+            if (!targetId) {
+                const stateKey = `${sourceId}:${targetState.kind}:${normalizeInlineText(targetState.label)}:${normalizedTarget}`;
+                targetId = stateKeys.get(stateKey);
+                if (!targetId) {
+                    targetId = `state${stateIndex++}`;
+                    stateKeys.set(stateKey, targetId);
+                    adjacency.set(targetId, new Set());
+                    classAssignment.get(classForKind(targetState.kind))?.push(targetId);
+                    const list = transientByPage.get(sourceId) ?? [];
+                    list.push({ id: targetId, kind: targetState.kind, label: targetState.label, subLabel: targetState.kind, parentPageId: sourceId });
+                    transientByPage.set(sourceId, list);
+                    if (transition.screenshot) {
+                        const screenshotPath = path.resolve(path.dirname(page.filePath), transition.screenshot.relativePath);
+                        clicks.push({ node: targetId, target: path.relative(outputDir, screenshotPath).replaceAll('\\', '/'), tooltip: 'Open state screenshot' });
+                    }
+                }
+            }
+            if (!targetId) {
+                continue;
+            }
+            const pairKey = `${sourceId}>${targetId}`;
+            if (adjacency.get(targetId)?.has(sourceId)) {
+                if (drawnBack.has(pairKey)) {
+                    continue;
+                }
+                drawnBack.add(pairKey);
+                edges.push({ source: sourceId, target: targetId, action: transition.action, isBack: true });
+                continue;
+            }
+            if (adjacency.get(sourceId)?.has(targetId) || createsCycle(sourceId, targetId, adjacency)) {
+                continue;
+            }
+            adjacency.get(sourceId)?.add(targetId);
+            edges.push({ source: sourceId, target: targetId, action: transition.action, isBack: false });
+        }
+    }
+    const pageClicks = [];
+    for (const pageNode of pageNodes) {
+        const filePath = pageNode.filePath;
+        if (!filePath) {
+            continue;
+        }
+        const relativeFile = path.relative(outputDir, filePath).replaceAll('\\', '/');
+        pageClicks.push({ node: pageNode.id, target: relativeFile, tooltip: `Open ${pageNode.label}` });
+    }
+    return { pages: pageNodes, transientByPage, edges, clicks: [...pageClicks, ...clicks], classAssignment };
+}
+function renderMermaidBody(outputDir, pages) {
+    return renderMermaidFromGraph(buildStateGraph(outputDir, pages));
+}
+function renderMermaidFromGraph(graph) {
+    const lines = ['flowchart TD'];
+    if (graph.pages.length === 0) {
+        lines.push('  empty["No documented states"]');
+        return lines.join('\n');
+    }
+    for (const page of graph.pages) {
+        lines.push(`  ${renderNodeLine(page)}`);
+        const children = graph.transientByPage.get(page.id);
+        if (!children || children.length === 0) {
+            continue;
+        }
+        lines.push(`  subgraph sg_${page.id} ["${escapeMermaidLabel(page.label)} — transient states"]`);
+        for (const child of children) {
+            lines.push(`    ${renderNodeLine(child)}`);
+        }
+        lines.push('  end');
+    }
+    for (const edge of graph.edges) {
+        let arrow = '-->';
+        if (edge.isBack) {
+            arrow = '-.->';
+        }
+        lines.push(`  ${edge.source} ${arrow}|"${escapeMermaidLabel(edge.action)}"| ${edge.target}`);
+    }
+    lines.push('  classDef page fill:#dbeafe,stroke:#2563eb,color:#0f172a;');
+    lines.push('  classDef dialog fill:#ffedd5,stroke:#ea580c,color:#0f172a;');
+    lines.push('  classDef section fill:#f3e8ff,stroke:#9333ea,color:#0f172a;');
+    for (const [className, ids] of graph.classAssignment) {
+        if (ids.length === 0) {
+            continue;
+        }
+        lines.push(`  class ${ids.join(',')} ${className};`);
+    }
+    for (const click of graph.clicks) {
+        lines.push(`  click ${click.node} "${click.target}" "${escapeMermaidLabel(click.tooltip)}"`);
+    }
+    return lines.join('\n');
+}
+function renderStateMapFromGraph(graph) {
+    if (graph.pages.length === 0) {
+        return '';
+    }
+    const clickByNode = new Map(graph.clicks.map((click) => [click.node, click]));
+    const rows = ['| State | Type | Open |', '| --- | --- | --- |'];
+    for (const pageNode of graph.pages) {
+        const pageClick = clickByNode.get(pageNode.id);
+        let openCell = '—';
+        if (pageClick) {
+            openCell = `[open page](${pageClick.target})`;
+        }
+        rows.push(`| ${escapeTable(pageNode.label)} | page | ${openCell} |`);
+        for (const child of graph.transientByPage.get(pageNode.id) ?? []) {
+            const childClick = clickByNode.get(child.id);
+            let childCell = '—';
+            if (childClick) {
+                childCell = `[view screenshot](${childClick.target})`;
+            }
+            rows.push(`| ${escapeTable(child.label)} | ${child.kind} | ${childCell} |`);
+        }
+    }
+    return rows.join('\n');
+}
+function renderNodeLine(node) {
+    const label = `${escapeMermaidLabel(node.label)}<br/>${escapeMermaidLabel(node.subLabel)}`;
+    if (node.kind === 'dialog' || node.kind === 'modal') {
+        return `${node.id}{{"${label}"}}`;
+    }
+    if (node.kind === 'section') {
+        return `${node.id}("${label}")`;
+    }
+    return `${node.id}["${label}"]`;
+}
+function createsCycle(sourceId, targetId, adjacency) {
+    if (sourceId === targetId) {
+        return true;
+    }
+    const pending = [targetId];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const nodeId = pending.pop();
+        if (!nodeId || visited.has(nodeId)) {
+            continue;
+        }
+        if (nodeId === sourceId) {
+            return true;
+        }
+        visited.add(nodeId);
+        pending.push(...(adjacency.get(nodeId) || []));
+    }
+    return false;
+}
+function escapeMermaidLabel(value) {
+    return normalizeInlineText(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('|', '&#124;');
+}
+function escapeTable(value) {
+    return normalizeInlineText(value).replaceAll('|', '\\|');
+}
+function classForKind(kind) {
+    if (kind === 'section') {
+        return 'section';
+    }
+    if (kind === 'page') {
+        return 'page';
+    }
+    return 'dialog';
+}
+export { buildStateGraph, renderMermaidBody, renderMermaidFromGraph, renderStateMapFromGraph };

package/dist/models.json

@@ -0,0 +1,30 @@
+{
+  "openrouter": {
+    "model": "openai/gpt-oss-20b:nitro",
+    "visionModel": "google/gemma-4-31b-it:nitro",
+    "agenticModel": "google/gemma-4-31b-it:nitro"
+  },
+  "groq": {
+    "model": "openai/gpt-oss-20b",
+    "visionModel": "qwen/qwen3.6-27b",
+    "agenticModel": "qwen/qwen3.6-27b"
+  },
+  "openai": {
+    "model": "gpt-5.4-nano",
+    "visionModel": "gpt-5.4-nano",
+    "agenticModel": "gpt-5.6-luna"
+  },
+  "anthropic": {
+    "agenticModel": "claude-haiku-4-5-20251001"
+  },
+  "mistral": {
+    "model": "mistral-small-latest",
+    "visionModel": "mistral-small-latest",
+    "agenticModel": "mistral-large-latest"
+  },
+  "google": {
+    "model": "gemini-3.1-flash-lite",
+    "visionModel": "gemini-3.1-flash-lite",
+    "agenticModel": "gemini-3.5-flash"
+  }
+}