explorbot 0.5.7 → 0.5.9

package/dist/src/commands/init-command.js

@@ -1,24 +1,29 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, resolve } from 'node:path';
 import chalk from 'chalk';
+import figureSet from 'figures';
 import { ConfigParser, PROVIDERS, missingModelRoles } from "../config.js";
 import { findGlobalConfig, globalConfigPath, globalDir, globalEnvPath } from "../global-config.js";
 import { getCliName } from "../utils/cli-name.js";
 import { log, tag } from '../utils/logger.js';
-import { relativeToCwd } from "../utils/next-steps.js";
-function defaultConfigTemplate(provider) {
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
+function defaultConfigTemplate(provider, url) {
+    const appUrl = url || 'http://<your-app-host-here>';
     return `// 'provider/model-id' uses a bundled provider.
 // It is also possible to import provider as a module from Vercel AI SDK.
-// https://github.com/testomatio/explorbot/blob/main/docs/basics/providers.md
+// https://testomat.ai/docs/explorbot
 
 const config = {
   web: {
     // use application host without path prefix (e.g., http://localhost:3000)
-    url: 'http://<your-app-host-here>',
+    url: '${appUrl}',
   },
 
   ai: {
-${modelLines(provider)}
+    // every role (model, visionModel, agenticModel) takes the recommended ${provider} models bundled with this version
+    // override a single role as 'provider/model-id':
+    // model: '${provider}/<model-id>',
+    recommendedModels: '${provider}',
   },
 
   reporter: {
@@ -35,9 +40,10 @@ export default config;
 `;
 }
 export function envTemplate(provider) {
+    const { keyUrl } = PROVIDERS[provider];
     const keyLines = Object.entries(PROVIDERS).map(([name, { envKey }]) => {
         if (name === provider)
-            return `${envKey}=`;
+            return `# Create a key at ${keyUrl} and paste it after '='\n${envKey}=`;
         return `# ${envKey}=`;
     });
     return `# AI provider API keys
@@ -64,10 +70,10 @@ export async function runInit(options) {
     const choice = await renderInitWizard('choose');
     if (choice !== 'local')
         return;
-    const provider = await renderLocalProviderWizard();
-    if (!provider)
+    const setup = await renderLocalSetupWizard();
+    if (!setup)
         return;
-    runInitCommand({ ...options, provider });
+    runInitCommand({ ...options, ...setup });
 }
 export function writeGlobalConfig(provider, apiKey) {
     if (!PROVIDERS[provider]) {
@@ -75,21 +81,25 @@ export function writeGlobalConfig(provider, apiKey) {
     }
     mkdirSync(globalDir(), { recursive: true });
     writeFileSync(globalConfigPath(), globalConfigTemplate(provider), 'utf8');
-    log(`Created global config: ${globalConfigPath()}`);
+    tag('success').log(`${figureSet.tick} Created global config: ${globalConfigPath()}`);
     const envKey = PROVIDERS[provider].envKey;
     writeEnvKey(envKey, apiKey || '');
-    log(`Stored ${envKey} in ${globalEnvPath()}`);
+    tag('success').log(`${figureSet.tick} Stored ${envKey} in ${globalEnvPath()}`);
     const missing = missingModelRoles(provider);
     if (missing.length) {
         tag('warning').log(`No recommended ${missing.join(' and ')} for ${provider} — set the model ids in ${globalConfigPath()}`);
     }
     if (!apiKey && !process.env[envKey]) {
-        tag('warning').log(`Add your API key to ${globalEnvPath()}`);
+        printApiKeySteps(provider, globalEnvPath());
     }
     log('');
-    log('Explorbot now runs from any directory:');
-    tag('substep').log(chalk.yellow(`${getCliName()} explore https://your-app.example.com`));
-    tag('substep').log(chalk.yellow(`${getCliName()} sites`));
+    log(`${figureSet.star} What's next:`);
+    printInitNextSteps({
+        siteCommands: [
+            { label: 'Any site', command: `${getCliName()} explore https://your-app.example.com` },
+            { label: 'Saved sites', command: `${getCliName()} sites` },
+        ],
+    });
 }
 export function runInitCommand(options) {
     const provider = options.provider || 'openrouter';
@@ -125,34 +135,38 @@ export function runInitCommand(options) {
             log('Use --force to overwrite existing file');
             process.exit(1);
         }
-        writeFileSync(outPath, defaultConfigTemplate(provider), 'utf8');
-        log(`Created config file: ${relativeToCwd(outPath)}`);
+        writeFileSync(outPath, defaultConfigTemplate(provider, options.url), 'utf8');
+        tag('success').log(`${figureSet.tick} Created config file: ${relativeToCwd(outPath)}`);
         const envPath = resolve(process.cwd(), '.env');
         if (!existsSync(envPath)) {
             writeFileSync(envPath, `${envTemplate(provider)}\n`, 'utf8');
-            log(`Created env file: ${relativeToCwd(envPath)}`);
+            tag('success').log(`${figureSet.tick} Created env file: ${relativeToCwd(envPath)}`);
         }
         else {
             log(`Env file already exists: ${relativeToCwd(envPath)}`);
         }
+        const envKey = PROVIDERS[provider].envKey;
+        if (options.apiKey) {
+            writeEnvKey(envKey, options.apiKey, envPath);
+            tag('success').log(`${figureSet.tick} Stored ${envKey} in ${relativeToCwd(envPath)}`);
+        }
+        if (!options.apiKey && !process.env[envKey]) {
+            printApiKeySteps(provider, relativeToCwd(envPath));
+        }
+        if (!options.url) {
+            tag('warning').log(`Set your application URL in web.url: ${relativeToCwd(outPath)}`);
+        }
         const missing = missingModelRoles(provider);
         if (missing.length) {
             tag('warning').log(`No recommended ${missing.join(' and ')} for ${provider} — set the model ids in ${relativeToCwd(outPath)}`);
         }
-        log('');
-        log('Next steps:');
-        log('1. Configure AI provider in .env');
-        log('2. Set AI models config file');
-        log('3. Set web application URL in the config file');
-        log('4. Add initial knowledge (how to authorize to the application, etc.)');
-        tag('substep').log(chalk.yellow(`${getCliName()} learn '*' 'to authorize use these credentials: admin@example.com / secret123'`));
-        tag('substep').log('You can use ${env.LOGIN} and ${env.PASSWORD} to reference environment variables.');
-        log('5. Launch application on a relative URL');
-        tag('substep').log(chalk.yellow(`${getCliName()} start /dashboard`));
         if (!existsSync('./output')) {
             mkdirSync('./output', { recursive: true });
-            log('Created directory: output');
+            tag('success').log(`${figureSet.tick} Created directory: output`);
         }
+        log('');
+        log(`${figureSet.star} What's next:`);
+        printInitNextSteps({ url: options.url });
     }
     catch (error) {
         log('Failed to create config file:', error);
@@ -198,12 +212,12 @@ async function renderInitWizard(mode) {
         }), { exitOnCtrlC: false, patchConsole: false });
     });
 }
-async function renderLocalProviderWizard() {
+async function renderLocalSetupWizard() {
     const [{ render }, React, InitWizard] = await Promise.all([import('ink'), import('react'), import('../components/InitWizard.js').then((m) => m.default)]);
     return new Promise((resolve) => {
-        const finish = (provider) => {
+        const finish = (setup) => {
             unmount();
-            resolve(provider);
+            resolve(setup);
         };
         const { unmount } = render(React.createElement(InitWizard, {
             mode: 'local',
@@ -211,7 +225,7 @@ async function renderLocalProviderWizard() {
             onLocal: () => finish(null),
             onComplete: () => finish(null),
             onCancel: () => finish(null),
-            onLocalProvider: (provider) => finish(provider),
+            onLocalSetup: (setup) => finish(setup),
         }), { exitOnCtrlC: false, patchConsole: false });
     });
 }
@@ -238,7 +252,7 @@ function globalConfigTemplate(provider) {
 // Models are written as 'provider/model-id' so they resolve without a local node_modules.
 // The key is read from ${envKey} in ~/.explorbot/.env
 // Model ids are snapshotted from the recommendations of this Explorbot version.
-// https://github.com/testomatio/explorbot/blob/main/docs/basics/providers.md
+// https://testomat.ai/docs/explorbot
 const config = {
   ai: {
 ${modelLines(provider)}
@@ -255,8 +269,39 @@ ${modelLines(provider)}
 export default config;
 `;
 }
-function writeEnvKey(key, value) {
-    const envPath = globalEnvPath();
+function printInitNextSteps(options) {
+    const cli = getCliName();
+    const sections = [
+        {
+            label: 'Try the demo on a sample app',
+            commands: [{ command: `${cli} explore https://todomvc.com/examples/react/dist/` }],
+        },
+    ];
+    if (options.url) {
+        sections.push({
+            label: 'Explore your app',
+            commands: [
+                { label: 'Whole site', command: `${cli} explore ${options.url}` },
+                { label: 'One page', command: `${cli} explore /dashboard` },
+            ],
+        });
+    }
+    if (options.siteCommands)
+        sections.push({ label: 'Explore any site', commands: options.siteCommands });
+    sections.push({
+        label: 'Run it from VS Code',
+        commands: [{ command: 'https://testomat.ai/explorbot' }],
+    }, {
+        label: 'Docs',
+        commands: [{ command: 'https://testomat.ai/docs/explorbot' }],
+    });
+    printNextSteps(sections);
+    log('');
+    log('Add knowledge (logins, credentials) — created on first use in ./knowledge:');
+    tag('substep').log(chalk.yellow(`${cli} learn '*' 'to authorize use these credentials: admin@example.com / secret123'`));
+    tag('substep').log('You can use ${env.LOGIN} and ${env.PASSWORD} to reference environment variables.');
+}
+function writeEnvKey(key, value, envPath = globalEnvPath()) {
     let content = '# AI provider API keys';
     if (existsSync(envPath))
         content = readFileSync(envPath, 'utf8').trimEnd();
@@ -268,3 +313,9 @@ function writeEnvKey(key, value) {
         lines[index] = `${key}=${value}`;
     writeFileSync(envPath, `${lines.join('\n').trimEnd()}\n`, 'utf8');
 }
+function printApiKeySteps(provider, envPath) {
+    const { envKey, keyUrl } = PROVIDERS[provider];
+    tag('warning').log(`No API key yet — explorbot needs one to connect to ${provider}`);
+    tag('substep').log(`1. Create a key at ${keyUrl}`);
+    tag('substep').log(`2. Paste it into ${envPath}: ${envKey}=<your-key>`);
+}

package/dist/src/components/InitWizard.d.ts

@@ -5,7 +5,11 @@ interface InitWizardProps {
     onLocal: () => void;
     onComplete: () => void;
     onCancel: () => void;
-    onLocalProvider?: (provider: string) => void;
+    onLocalSetup?: (setup: {
+        provider: string;
+        apiKey: string;
+        url: string;
+    }) => void;
 }
 declare const InitWizard: React.FC<InitWizardProps>;
 export default InitWizard;

package/dist/src/components/InitWizard.js

@@ -7,16 +7,23 @@ import { ConfigParser, PROVIDERS, createModel } from '../config.js';
 import { globalDir } from '../global-config.js';
 import InputReadline from './InputReadline.js';
 const PROVIDER_NAMES = Object.keys(PROVIDERS);
-const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel, onLocalProvider }) => {
+const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel, onLocalSetup }) => {
     const [step, setStep] = useState(mode === 'choose' ? 'target' : 'provider');
     const [targetIndex, setTargetIndex] = useState(0);
     const [providerIndex, setProviderIndex] = useState(0);
     const [apiKey, setApiKey] = useState('');
+    const [url, setUrl] = useState('');
+    const [urlError, setUrlError] = useState('');
     const [status, setStatus] = useState('');
     const [error, setError] = useState('');
     const provider = PROVIDER_NAMES[providerIndex];
     const envKey = PROVIDERS[provider].envKey;
     const save = () => {
+        if (mode === 'local') {
+            setStatus('');
+            setStep('url');
+            return;
+        }
         writeGlobalConfig(provider, apiKey.trim());
         onComplete();
     };
@@ -45,7 +52,7 @@ const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel, o
             onCancel();
             return;
         }
-        if (step === 'key')
+        if (step === 'key' || step === 'url')
             return;
         if (key.escape) {
             onCancel();
@@ -67,12 +74,8 @@ const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel, o
                 setProviderIndex((index) => Math.max(0, index - 1));
             if (key.downArrow)
                 setProviderIndex((index) => Math.min(PROVIDER_NAMES.length - 1, index + 1));
-            if (key.return) {
-                if (mode === 'local')
-                    onLocalProvider?.(provider);
-                else
-                    setStep('key');
-            }
+            if (key.return)
+                setStep('key');
             return;
         }
         if (status)
@@ -109,10 +112,12 @@ const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel, o
             React.createElement(Text, null,
                 "Enter the API key for ",
                 provider,
-                " ",
+                ' ',
                 React.createElement(Text, { dimColor: true },
                     "(stored as ",
                     envKey,
+                    ", create one at ",
+                    PROVIDERS[provider].keyUrl,
                     ")")),
             React.createElement(Box, { borderStyle: "single", borderColor: "blue", paddingX: 1 },
                 React.createElement(InputReadline, { value: apiKey, onChange: setApiKey, onSubmit: () => setStep('validate'), placeholder: process.env[envKey] ? 'leave empty to keep the key from your environment' : 'paste the key', isActive: true, showPrompt: false, mask: true })))),
@@ -121,13 +126,26 @@ const InitWizard = ({ mode, globalConfigExists, onLocal, onComplete, onCancel, o
             status && React.createElement(Text, { color: "yellow" }, status),
             error && (React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, { color: "red" }, error),
-                React.createElement(Text, { dimColor: true }, "r: re-enter the key | n: save anyway"))))),
+                React.createElement(Text, { dimColor: true }, "r: re-enter the key | n: continue anyway"))))),
+        step === 'url' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null,
+                "What is the URL of the web application to test? ",
+                React.createElement(Text, { dimColor: true }, "(written to web.url in the config)")),
+            React.createElement(Box, { borderStyle: "single", borderColor: "blue", paddingX: 1 },
+                React.createElement(InputReadline, { value: url, onChange: setUrl, onSubmit: () => {
+                        if (!URL.canParse(url.trim())) {
+                            setUrlError('Enter a full URL, e.g. http://localhost:3000');
+                            return;
+                        }
+                        onLocalSetup?.({ provider, apiKey: apiKey.trim(), url: url.trim() });
+                    }, placeholder: "http://localhost:3000", isActive: true, showPrompt: false })),
+            urlError && React.createElement(Text, { color: "red" }, urlError))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Config goes to ",
                 mode === 'local' ? 'the current directory' : globalDir(),
                 " | ",
-                step === 'key' ? 'Enter: continue' : '↑↓: select | Enter: confirm',
+                step === 'key' || step === 'url' ? 'Enter: continue' : '↑↓: select | Enter: confirm',
                 " | Ctrl+C: exit"))));
 };
 function defaultModelId(provider) {

package/dist/src/config.d.ts

@@ -141,6 +141,7 @@ interface AgentsConfig {
 }
 interface AIConfig {
     model: any;
+    recommendedModels?: string;
     apiKey?: string;
     config?: Record<string, any>;
     langfuse?: {
@@ -315,6 +316,7 @@ interface ConfiguredModel {
 }
 interface ProviderInfo {
     envKey: string;
+    keyUrl: string;
     load: () => Promise<(modelId: string) => any>;
 }
 interface EnvVar {

package/dist/src/config.js

@@ -18,13 +18,13 @@ import { getCliName } from './utils/cli-name.js';
 import { deepMerge } from './utils/merge.js';
 import { log, tag } from './utils/logger.js';
 export const PROVIDERS = {
-    openai: { envKey: 'OPENAI_API_KEY', load: async () => (await import('@ai-sdk/openai')).createOpenAI() },
-    anthropic: { envKey: 'ANTHROPIC_API_KEY', load: async () => (await import('@ai-sdk/anthropic')).createAnthropic() },
-    google: { envKey: 'GOOGLE_GENERATIVE_AI_API_KEY', load: async () => (await import('@ai-sdk/google')).createGoogleGenerativeAI() },
-    groq: { envKey: 'GROQ_API_KEY', load: async () => (await import('@ai-sdk/groq')).createGroq() },
-    mistral: { envKey: 'MISTRAL_API_KEY', load: async () => (await import('@ai-sdk/mistral')).createMistral() },
-    openrouter: { envKey: 'OPENROUTER_API_KEY', load: async () => (await import('@openrouter/ai-sdk-provider')).createOpenRouter() },
-    sambanova: { envKey: 'SAMBANOVA_API_KEY', load: async () => (await import('sambanova-ai-provider')).createSambaNova() },
+    openai: { envKey: 'OPENAI_API_KEY', keyUrl: 'https://platform.openai.com/api-keys', load: async () => (await import('@ai-sdk/openai')).createOpenAI() },
+    anthropic: { envKey: 'ANTHROPIC_API_KEY', keyUrl: 'https://console.anthropic.com/settings/keys', load: async () => (await import('@ai-sdk/anthropic')).createAnthropic() },
+    google: { envKey: 'GOOGLE_GENERATIVE_AI_API_KEY', keyUrl: 'https://aistudio.google.com/apikey', load: async () => (await import('@ai-sdk/google')).createGoogleGenerativeAI() },
+    groq: { envKey: 'GROQ_API_KEY', keyUrl: 'https://console.groq.com/keys', load: async () => (await import('@ai-sdk/groq')).createGroq() },
+    mistral: { envKey: 'MISTRAL_API_KEY', keyUrl: 'https://console.mistral.ai/api-keys', load: async () => (await import('@ai-sdk/mistral')).createMistral() },
+    openrouter: { envKey: 'OPENROUTER_API_KEY', keyUrl: 'https://openrouter.ai/keys', load: async () => (await import('@openrouter/ai-sdk-provider')).createOpenRouter() },
+    sambanova: { envKey: 'SAMBANOVA_API_KEY', keyUrl: 'https://cloud.sambanova.ai/apis', load: async () => (await import('sambanova-ai-provider')).createSambaNova() },
 };
 export const MODEL_ROLES = ['model', 'visionModel', 'agenticModel'];
 let cachedOutputRoot = null;
@@ -572,11 +572,33 @@ export async function resolveConfigModels(ai) {
         if (typeof ai[role] === 'string')
             ai[role] = await resolveModel(ai[role], role);
     }
+    await fillRecommendedModels(ai);
     for (const agent of Object.values(ai.agents || {})) {
         if (typeof agent?.model === 'string')
             agent.model = await resolveModel(agent.model);
     }
 }
+async function fillRecommendedModels(ai) {
+    const provider = ai.recommendedModels;
+    if (!provider)
+        return;
+    const recommended = ConfigParser.recommendedModels()[provider];
+    if (!recommended) {
+        throw new Error(`No recommended models for "${provider}". Use a provider with recommendations: ${Object.keys(ConfigParser.recommendedModels()).join(', ')}`);
+    }
+    for (const role of MODEL_ROLES) {
+        if (ai[role])
+            continue;
+        if (!recommended[role])
+            continue;
+        ai[role] = await resolveModel(provider, role);
+    }
+    if (!ai.decisionModel && recommended.decisionModel)
+        ai.decisionModel = { provider, model: recommended.decisionModel };
+    const missing = missingModelRoles(provider);
+    if (missing.length)
+        tag('warning').log(`No recommended ${missing.join(' and ')} for ${provider} — set them explicitly as "provider/model-id"`);
+}
 export function resolveLangfuse(ai) {
     if (!ai)
         return;

package/dist/src/explorbot.d.ts

@@ -97,7 +97,7 @@ export declare class ExplorBot {
     agentTester(): Tester;
     agentCaptain(): Captain;
     agentExperienceCompactor(): ExperienceCompactor;
-    agentQuartermaster(): Quartermaster | null;
+    agentQuartermaster(): Quartermaster;
     agentHistorian(): Historian;
     agentRerunner(): Rerunner;
     agentDriller(): Driller;

package/dist/src/explorbot.js

@@ -111,6 +111,7 @@ export class ExplorBot {
         if (this.options.optionalAi)
             return this.bootstrapOptionalProvider();
         this.provider = new AIProvider(this.config.ai);
+        this.provider.setJudge(this.judge());
         await this.provider.validateConnection();
     }
     aiFailureReason() {
@@ -217,9 +218,11 @@ export class ExplorBot {
                 const tools = createAgentTools({ ...deps, researcher, navigator, withExperience: false });
                 return new Tester(deps, researcher, navigator, tools);
             });
-            const qm = this.agentQuartermaster();
-            if (qm)
-                this.agents.tester.setQuartermaster(qm);
+            if (this.config.ai?.agents?.quartermaster?.enabled === true) {
+                const quartermaster = this.agentQuartermaster();
+                quartermaster.start(this.stateManager());
+                this.agents.tester.setQuartermaster(quartermaster);
+            }
             if (this.isHistorianEnabled())
                 this.agents.tester.setHistorian(this.agentHistorian());
             this.agents.tester.setPilot(this.agentPilot());
@@ -240,16 +243,7 @@ export class ExplorBot {
         return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.experienceTracker()));
     }
     agentQuartermaster() {
-        const config = this.config.ai?.agents?.quartermaster;
-        if (config?.enabled !== true)
-            return null;
-        if (!this.agents.quartermaster) {
-            this.agents.quartermaster = new Quartermaster(this.provider, {
-                model: config?.model,
-            });
-            this.agents.quartermaster.start(this.explorer, this.stateManager());
-        }
-        return this.agents.quartermaster;
+        return (this.agents.quartermaster ||= new Quartermaster(this.provider, this.explorer, { model: this.config.ai?.agents?.quartermaster?.model }));
     }
     agentHistorian() {
         return (this.agents.historian ||= this.createAgent(({ ai, explorer, config, stateManager, playwrightRecorder }) => {
@@ -500,6 +494,7 @@ export class ExplorBot {
     async bootstrapOptionalProvider() {
         try {
             const provider = new AIProvider(this.config.ai);
+            provider.setJudge(this.judge());
             await provider.validateConnection();
             this.provider = provider;
         }

package/dist/src/explorer.js

@@ -74,6 +74,7 @@ class Explorer {
             throw new Error('Playwright helper not available');
         }
         this.applyBasePathToHelper();
+        codeceptjs.store.visibleLocator = this.playwrightHelper.options?.visibleLocator;
         await this.connectOrLaunchBrowser();
         const hasSession = !this.options?.attachedBrowser && this.options?.session && existsSync(this.options.session);
         await this.openContextPage();

package/dist/src/global-config.js

@@ -13,6 +13,7 @@ import { pathToFileURL } from 'node:url';
 import dedent from 'dedent';
 const GLOBAL_CONFIG_NAMES = ['config.js', 'config.mjs', 'config.ts'];
 const SITE_DIRS = ['knowledge', 'experience', 'output'];
+const LOOPBACK_HOSTS = ['localhost', '127.0.0.1', '[::1]'];
 export const EXPLORBOT_CONFIG_PATHS = ['explorbot.config.js', 'explorbot.config.mjs', 'explorbot.config.ts'];
 export function globalDir() {
     return join(os.homedir(), '.explorbot');
@@ -33,7 +34,10 @@ export function sitesDir() {
     return join(globalDir(), 'sites');
 }
 export function siteFolderName(url) {
-    return new URL(url).host.toLowerCase().replace(/[^a-z0-9._-]/g, '_');
+    const parsed = new URL(url);
+    if (LOOPBACK_HOSTS.includes(parsed.hostname))
+        parsed.hostname = 'localhost';
+    return parsed.host.toLowerCase().replace(/[^a-z0-9._-]/g, '_');
 }
 export function listSites() {
     if (!existsSync(sitesDir()))
@@ -74,7 +78,7 @@ function validateSiteConfig(config, configPath, baseUrl) {
     `);
     }
     const declared = URL.parse(url)?.origin;
-    if (declared === baseUrl)
+    if (declared && siteFolderName(declared) === siteFolderName(baseUrl))
         return;
     throw new Error(dedent `
     Site config declares a different site.

package/dist/src/utils/ux-probe.d.ts

@@ -0,0 +1,25 @@
+export declare const UX_FOCUS_ATTR = "data-explorbot-ux";
+declare const UX_LIMITS: {
+    touchTarget: number;
+    pointerTarget: number;
+    touchWidth: number;
+    targetGap: number;
+    minFontSize: number;
+    minLineHeight: number;
+    maxEntries: number;
+    minOpacity: 0.1;
+};
+export declare function uxProbeArgs(scope: string): UxProbeArgs;
+export declare function renderUxMeasurements(measurements: UxMeasurements): string;
+export declare function measureUx({ scope, controlsSelector, limits }: UxProbeArgs): UxMeasurements;
+export declare function countRunningAnimations(scope: string): number;
+interface UxProbeArgs {
+    scope: string;
+    controlsSelector: string;
+    limits: typeof UX_LIMITS;
+}
+export interface UxMeasurements {
+    width: number;
+    checks: Record<string, string[]>;
+}
+export {};