explorbot 0.2.4 → 0.3.0

package/dist/src/config.js

@@ -157,7 +157,7 @@ export class ConfigParser {
         const config = this.getConfig();
         if (!this.configPath)
             throw new Error('Config path not found');
-        return path.join(this.getProjectRoot(), config.dirs?.output || 'output');
+        return this.resolveProjectDir(config.dirs?.output || 'output');
     }
     getProjectRoot() {
         if (this.site)
@@ -168,6 +168,8 @@ export class ConfigParser {
         return process.cwd();
     }
     resolveProjectDir(relativeDir) {
+        if (path.isAbsolute(relativeDir))
+            return relativeDir;
         if (!this.configPath)
             return relativeDir;
         return path.join(this.getProjectRoot(), relativeDir);
@@ -231,6 +233,7 @@ export class ConfigParser {
                 model: { modelId: 'test-model', provider: 'test' },
                 config: {},
                 vision: false,
+                langfuse: { enabled: false },
             },
             dirs: {
                 knowledge: join(testBaseDir, 'knowledge'),
@@ -358,6 +361,17 @@ export class ConfigParser {
             config.playwright = config.playwright || { browser: 'chromium', url: '' };
             config.playwright.url = options.baseUrl;
         }
+        if (config.ai) {
+            const langfuse = config.ai.langfuse;
+            const publicKey = langfuse?.publicKey || process.env.LANGFUSE_PUBLIC_KEY;
+            const secretKey = langfuse?.secretKey || process.env.LANGFUSE_SECRET_KEY;
+            config.ai.langfuse = {
+                enabled: langfuse?.enabled ?? Boolean(publicKey && secretKey),
+                publicKey,
+                secretKey,
+                baseUrl: langfuse?.baseUrl || process.env.LANGFUSE_BASE_URL || process.env.LANGFUSE_HOST,
+            };
+        }
         return config;
     }
     validateConfig(config) {
@@ -454,6 +468,34 @@ export function missingConfigMessage(configFile = 'explorbot.config.js') {
     Providers: ${Object.keys(PROVIDERS).join(', ')}
   `;
 }
+export function modelName(model) {
+    if (typeof model === 'string')
+        return model;
+    return model?.modelId || model?.model || 'unknown';
+}
+export function modelProvider(model) {
+    const provider = model?.provider;
+    if (typeof provider === 'string')
+        return provider.split('.')[0];
+    if (typeof model === 'string')
+        return model.split('/')[0];
+    return '';
+}
+export function configuredModels(ai) {
+    if (!ai?.model)
+        return {};
+    const describe = (model) => ({ name: modelName(model), provider: modelProvider(model) });
+    const models = { model: describe(ai.model) };
+    if (ai.agenticModel)
+        models.agenticModel = describe(ai.agenticModel);
+    if (ai.visionModel)
+        models.visionModel = describe(ai.visionModel);
+    for (const [agent, agentConfig] of Object.entries(ai.agents || {})) {
+        if (agentConfig?.model)
+            models[agent] = describe(agentConfig.model);
+    }
+    return models;
+}
 export async function resolveConfigModels(ai) {
     if (!ai)
         return;

package/dist/src/experience-tracker.d.ts

@@ -53,6 +53,7 @@ export declare class ExperienceTracker {
     getExperienceTableOfContents(state: ActionResult, options?: {
         includeDescendantExperience?: boolean;
     }): ExperienceTocEntry[];
+    renderExperienceFor(state: ActionResult): string;
     renderExperienceTocFor(state: ActionResult): string;
     getExperienceSection(fileTag: string, sectionIndex: number, state: ActionResult, options?: {
         includeDescendantExperience?: boolean;
@@ -77,6 +78,7 @@ export declare class ExperienceTracker {
         fileHash: string;
     } | null;
 }
+export declare function renderExperienceRecipes(recipes: string[]): string;
 export declare function renderExperienceToc(toc: ExperienceTocEntry[]): string;
 export interface ExperienceFile {
     filePath: string;

package/dist/src/experience-tracker.js

@@ -257,6 +257,13 @@ export class ExperienceTracker {
         });
         return this.buildToc(sorted);
     }
+    renderExperienceFor(state) {
+        const successful = this.getSuccessfulExperience(state);
+        if (!successful.length)
+            return '';
+        tag('operation').log(`Found ${successful.length} experience ${pluralize(successful.length, 'file')} for: ${state.url}`);
+        return renderExperienceRecipes(successful);
+    }
     renderExperienceTocFor(state) {
         const toc = this.getExperienceTableOfContents(state);
         if (toc.length === 0)
@@ -381,6 +388,11 @@ function indexToLetters(index) {
     }
     return result;
 }
+export function renderExperienceRecipes(recipes) {
+    if (recipes.length === 0)
+        return '';
+    return `<experience>\nPast successful recipes recorded from prior runs for this page. Prefer these solutions first if they match the goal.\n\n${recipes.join('\n\n')}\n</experience>`;
+}
 export function renderExperienceToc(toc) {
     if (toc.length === 0)
         return '';

package/dist/src/explorbot.js

@@ -199,7 +199,7 @@ export class ExplorBot {
             this.agents.tester = this.createAgent((deps) => {
                 const researcher = this.agentResearcher();
                 const navigator = this.agentNavigator();
-                const tools = createAgentTools({ ...deps, researcher, navigator });
+                const tools = createAgentTools({ ...deps, researcher, navigator, withExperience: false });
                 return new Tester(deps, researcher, navigator, tools);
             });
             const qm = this.agentQuartermaster();
@@ -418,9 +418,12 @@ export class ExplorBot {
     }
     setCurrentPlan(plan) {
         this.currentPlan = plan;
-        if (plan && !this.sessionPlans.includes(plan)) {
+        if (!plan)
+            return;
+        if (!this.sessionPlans.includes(plan)) {
             this.sessionPlans.push(plan);
         }
+        plan.notifyChange();
     }
     getSessionTests() {
         return this.sessionPlans.flatMap((p) => p.tests.filter((t) => t.startTime != null));

package/dist/src/playwright-recorder.js

@@ -6,7 +6,7 @@ const RECORDABLE = {
     Frame: new Set(['click', 'dblclick', 'fill', 'selectOption', 'press', 'type', 'check', 'uncheck', 'hover', 'tap', 'focus', 'setInputFiles', 'scrollIntoViewIfNeeded', 'dragTo', 'goto', 'setContent']),
     Page: new Set(['goBack', 'goForward', 'reload', 'keyboardPress', 'keyboardType', 'keyboardDown', 'keyboardUp', 'keyboardInsertText', 'mouseClick', 'mouseDblclick', 'mouseMove', 'mouseDown', 'mouseUp', 'mouseWheel']),
 };
-const PLAYWRIGHT_INCOMPATIBLE = "Playwright output is not compatible with this Playwright version (playwright-core/lib/utils does not expose asLocator). Use output.framework: 'codeceptjs' instead, or pin Playwright to a version shipping lib/utils/isomorphic/locatorGenerators.js.";
+const PLAYWRIGHT_INCOMPATIBLE = "Playwright output requires playwright-core 1.62 or newer (lib/coreBundle does not expose iso.asLocator). Use output.framework: 'codeceptjs' instead.";
 let cachedAsLocator = null;
 let asLocatorLoadAttempted = false;
 const nodeRequire = typeof require === 'function' ? require : createRequire(import.meta.url);
@@ -16,17 +16,11 @@ function getAsLocator() {
     if (asLocatorLoadAttempted)
         throw new Error(PLAYWRIGHT_INCOMPATIBLE);
     asLocatorLoadAttempted = true;
-    try {
-        const mod = nodeRequire('playwright-core/lib/utils');
-        if (typeof mod?.asLocator === 'function') {
-            cachedAsLocator = mod.asLocator;
-            return cachedAsLocator;
-        }
-    }
-    catch {
-        // Module not exported or not found
-    }
-    throw new Error(PLAYWRIGHT_INCOMPATIBLE);
+    const asLocator = nodeRequire('playwright-core/lib/coreBundle')?.iso?.asLocator;
+    if (typeof asLocator !== 'function')
+        throw new Error(PLAYWRIGHT_INCOMPATIBLE);
+    cachedAsLocator = asLocator;
+    return cachedAsLocator;
 }
 export class PlaywrightRecorder {
     context = null;

package/dist/src/remote.d.ts

@@ -6,8 +6,9 @@ import { type LogDestination, type TaggedLogEntry } from './utils/logger.js';
  * process and a CI bot are the same case.
  *
  * It **is** a LogDestination — that is the whole integration on the logger's
- * side — and it answers asks by installing itself as the execution
- * controller's input callback. Nothing else in explorbot knows it exists.
+ * side, messages and `data` alike — and it answers asks by installing itself
+ * as the execution controller's input callback. Nothing else in explorbot
+ * knows it exists.
  */
 export declare class Remote implements LogDestination {
     url: string | null;

package/dist/src/remote.js

@@ -13,8 +13,9 @@ const FLUSH_TIMEOUT_MS = 3000;
  * process and a CI bot are the same case.
  *
  * It **is** a LogDestination — that is the whole integration on the logger's
- * side — and it answers asks by installing itself as the execution
- * controller's input callback. Nothing else in explorbot knows it exists.
+ * side, messages and `data` alike — and it answers asks by installing itself
+ * as the execution controller's input callback. Nothing else in explorbot
+ * knows it exists.
  */
 export class Remote {
     url = null;
@@ -105,6 +106,11 @@ export class Remote {
     write(entry) {
         if (entry.type === 'html')
             return;
+        if (entry.type === 'data') {
+            const [kind, payload] = entry.originalArgs || [];
+            this.send(String(kind), payload);
+            return;
+        }
         let content = stripAnsi(entry.content ?? '');
         if (content.length > CONTENT_CAP)
             content = `${content.slice(0, CONTENT_CAP)}… (${content.length} chars)`;

package/dist/src/state-manager.d.ts

@@ -1,4 +1,4 @@
-import { type FocusedElement, ActionResult } from './action-result.js';
+import { ActionResult, type FocusedElement } from './action-result.js';
 import type { ExperienceTracker } from './experience-tracker.js';
 import type { Knowledge, KnowledgeTracker } from './knowledge-tracker.js';
 export interface Link {

package/dist/src/state-manager.js

@@ -1,6 +1,6 @@
 import { ActionResult } from './action-result.js';
 import { detectFocusArea } from './utils/aria.js';
-import { createDebug } from './utils/logger.js';
+import { createDebug, tag } from './utils/logger.js';
 import { slugify } from './utils/strings.js';
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:state');
@@ -40,6 +40,8 @@ export class StateManager {
      * Emit state change event to all listeners
      */
     emitStateChange(event) {
+        const state = event.toState;
+        tag('data').log('state', { url: state.fullUrl || state.url, path: state.url, title: state.title, h1: state.h1 });
         this.stateChangeListeners.forEach((listener) => {
             try {
                 listener(event);

package/dist/src/test-plan.d.ts

@@ -1,3 +1,4 @@
+import type { ActionResult } from './action-result.js';
 import { WebPageState } from './state-manager.js';
 export declare const TestResult: {
     readonly PASSED: "passed";
@@ -94,10 +95,13 @@ export declare class Test extends Task {
     startTime?: number;
     endTime?: number;
     resetCount: number;
+    appliedExperience: AppliedExperience[];
     constructor(scenario: string, priority: 'critical' | 'important' | 'high' | 'normal' | 'low', expectedOutcome: string | string[], startUrl: string, plannedSteps?: string[]);
     getVisitedUrls({ localOnly }?: {
         localOnly?: boolean;
     }): string[];
+    applyExperience(recipes: AppliedExperience[]): void;
+    getAppliedExperience(state: ActionResult): string[];
     addArtifact(artifact?: string): void;
     get hasFinished(): boolean;
     get isSuccessful(): boolean;
@@ -113,6 +117,7 @@ export declare class Test extends Task {
     finish(result?: TestResultType): void;
     getDurationMs(): number | null;
     getRemainingExpectations(): string[];
+    reportStatus(): void;
     getLog(): Array<{
         type: 'step' | 'note' | 'artifact';
         content: string;
@@ -165,4 +170,8 @@ interface UrlNoteState {
     h2?: string;
     screenshotFile?: string;
 }
+interface AppliedExperience {
+    url: string;
+    content: string;
+}
 export {};

package/dist/src/test-plan.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { tag } from "./utils/logger.js";
 import { parsePlanFromMarkdown, planToAiContext, savePlanToMarkdown, savePlansToMarkdown } from "./utils/test-plan-markdown.js";
 import { uniqSessionName } from "./utils/unique-names.js";
 export const TestResult = {
@@ -189,6 +190,7 @@ export class Test extends Task {
     startTime;
     endTime;
     resetCount = 0;
+    appliedExperience = [];
     constructor(scenario, priority, expectedOutcome, startUrl, plannedSteps = []) {
         super(scenario, startUrl);
         this.scenario = scenario;
@@ -207,6 +209,16 @@ export class Test extends Task {
         }
         return [...new Set([this.startUrl, ...this.states.map((s) => s.url)].filter((value) => Boolean(value) && value.trim() !== ''))];
     }
+    applyExperience(recipes) {
+        for (const recipe of recipes) {
+            if (this.appliedExperience.some((applied) => applied.content === recipe.content))
+                continue;
+            this.appliedExperience.push(recipe);
+        }
+    }
+    getAppliedExperience(state) {
+        return this.appliedExperience.filter((recipe) => state.isRelevantExperienceRecord({ url: recipe.url })).map((recipe) => recipe.content);
+    }
     addArtifact(artifact) {
         if (!artifact)
             return;
@@ -260,12 +272,14 @@ export class Test extends Task {
         this.startTime = performance.now();
         this.addNote(`Test started. Session name: ${this.sessionName}`);
         this.plan?.notifyChange();
+        this.reportStatus();
     }
     finish(result = TestResult.FAILED) {
         this.status = TestStatus.DONE;
         this.result = result;
         this.endTime = performance.now();
         this.plan?.notifyChange();
+        this.reportStatus();
     }
     getDurationMs() {
         if (this.startTime != null && this.endTime != null)
@@ -276,6 +290,17 @@ export class Test extends Task {
         const achieved = this.getCheckedExpectations();
         return this.expected.filter((e) => !achieved.includes(e));
     }
+    reportStatus() {
+        tag('data').log('test', {
+            scenario: this.scenario,
+            status: this.status,
+            result: this.result,
+            priority: this.priority,
+            sessionName: this.sessionName,
+            url: this.startUrl,
+            plan: this.plan?.title,
+        });
+    }
     getLog() {
         const merged = {};
         for (const [key, stepData] of Object.entries(this.steps)) {
@@ -338,6 +363,11 @@ export class Plan {
         for (const listener of this.changeListeners) {
             listener(this.tests);
         }
+        tag('data').log('plan', {
+            title: this.title,
+            url: this.url,
+            tests: this.tests.map((test) => ({ scenario: test.scenario, status: test.status, result: test.result, priority: test.priority })),
+        });
     }
     getAllTests() {
         if (!this.parentPlan)

package/dist/src/utils/html-diff.d.ts

@@ -11,9 +11,14 @@ export interface HtmlDiffResult {
     removed: string[];
     similarity: number;
     summary: string;
+    messages: string[];
 }
 export declare function computeHtmlFingerprint(html: string): string[];
 /**
  * Compares two HTML documents and returns differences along with a diff subtree.
  */
 export declare function htmlDiff(originalHtml: string, modifiedHtml: string, htmlConfig?: HtmlConfig): Promise<HtmlDiffResult>;
+/**
+ * Text the app announced across a navigation. Only live regions: everything else on a new page is its content, not a message.
+ */
+export declare function liveRegionMessages(originalHtml: string, modifiedHtml: string): string[];

package/dist/src/utils/html-diff.js

@@ -2,6 +2,10 @@ import { parse, serialize } from 'parse5';
 import { TAILWIND_CLASS_PATTERNS, TRASH_HTML_CLASSES, minifyHtml } from "./html.js";
 import { isDynamicId, isGenericClass } from "./xpath.js";
 const IGNORED_PATHS = new Set(['html[1]', 'html[1]/head[1]', 'html[1]/body[1]']);
+const LIVE_REGION_ROLES = new Set(['alert', 'alertdialog', 'status', 'log']);
+const TEXT_LINE_PREFIX = 'TEXT:';
+const MESSAGE_MAX_LENGTH = 200;
+const MESSAGE_LIMIT = 8;
 /**
  * Get text content from an element node.
  */
@@ -141,7 +145,9 @@ export async function htmlDiff(originalHtml, modifiedHtml, htmlConfig) {
     const modifiedLines = flattenHtml(modifiedRoot);
     const similarity = calculateSimilarity(originalLines, modifiedLines);
     const { added, removed } = findDifferences(originalLines, modifiedLines);
-    const parts = await buildDiffParts(originalDocument, modifiedDocument);
+    const originalMap = collectElementMap(originalDocument);
+    const modifiedMap = collectElementMap(modifiedDocument);
+    const parts = await buildDiffParts(originalMap, modifiedMap);
     const structuralAdditions = parts.flatMap((p) => p.added.filter((a) => a.startsWith('ELEMENT:')));
     const allAdded = [...added, ...structuralAdditions];
     const totalChanges = allAdded.length + removed.length;
@@ -152,8 +158,63 @@ export async function htmlDiff(originalHtml, modifiedHtml, htmlConfig) {
         removed,
         similarity,
         summary,
+        messages: collectMessages(originalMap, modifiedMap, allAdded),
     };
 }
+/**
+ * Text the app announced while the page stayed the same: live region content first, then any other text that appeared.
+ */
+function collectMessages(originalMap, modifiedMap, added) {
+    const appearedText = added.filter((line) => line.startsWith(TEXT_LINE_PREFIX)).map((line) => line.slice(TEXT_LINE_PREFIX.length));
+    return limitMessages([...collectLiveRegionTexts(originalMap, modifiedMap), ...appearedText]);
+}
+/**
+ * Text the app announced across a navigation. Only live regions: everything else on a new page is its content, not a message.
+ */
+export function liveRegionMessages(originalHtml, modifiedHtml) {
+    const originalMap = collectElementMap(parseDocument(originalHtml));
+    const modifiedMap = collectElementMap(parseDocument(modifiedHtml));
+    return limitMessages(collectLiveRegionTexts(originalMap, modifiedMap));
+}
+function limitMessages(candidates) {
+    const messages = [];
+    for (const candidate of candidates) {
+        const text = candidate.replace(/\s+/g, ' ').trim().slice(0, MESSAGE_MAX_LENGTH);
+        if (!text)
+            continue;
+        if (messages.some((message) => message.includes(text)))
+            continue;
+        messages.push(text);
+        if (messages.length === MESSAGE_LIMIT)
+            break;
+    }
+    return messages;
+}
+function collectLiveRegionTexts(originalMap, modifiedMap) {
+    const texts = [];
+    for (const [path, element] of modifiedMap) {
+        if (!isLiveRegion(element))
+            continue;
+        const text = getTextContent(element).trim();
+        if (!text)
+            continue;
+        const previous = originalMap.get(path);
+        if (previous && getTextContent(previous).trim() === text)
+            continue;
+        texts.push(text);
+    }
+    return texts;
+}
+function isLiveRegion(element) {
+    if (element.tagName?.toLowerCase() === 'output')
+        return true;
+    const attrs = element.attrs ?? [];
+    const role = attrs.find((attr) => attr.name === 'role')?.value.toLowerCase();
+    if (role && LIVE_REGION_ROLES.has(role))
+        return true;
+    const live = attrs.find((attr) => attr.name === 'aria-live')?.value.toLowerCase();
+    return live === 'polite' || live === 'assertive';
+}
 /**
  * Parse HTML into a document, wrapping fragments with html/body for consistency.
  * Uses custom sanitization that removes iframes for diff purposes.
@@ -354,9 +415,7 @@ function findStableContainer(topLevelPath, originalMap, modifiedMap) {
     }
     return { path: 'html[1]/body[1]', selector: 'body' };
 }
-async function buildDiffParts(originalDocument, modifiedDocument) {
-    const originalMap = collectElementMap(originalDocument);
-    const modifiedMap = collectElementMap(modifiedDocument);
+async function buildDiffParts(originalMap, modifiedMap) {
     const addedPaths = [];
     const changedPaths = [];
     for (const [path, element] of modifiedMap.entries()) {
@@ -624,7 +683,7 @@ function flattenHtml(node) {
     function process(n) {
         if (n.type === 'text' && n.content) {
             if (n.content.length >= 5) {
-                lines.push(`TEXT:${n.content}`);
+                lines.push(`${TEXT_LINE_PREFIX}${n.content}`);
             }
             return;
         }
@@ -643,7 +702,7 @@ function flattenHtml(node) {
                 return;
             }
             if (n.content && n.content.length >= 5) {
-                lines.push(`TEXT:${n.content}`);
+                lines.push(`${TEXT_LINE_PREFIX}${n.content}`);
             }
             if (n.children) {
                 n.children.forEach((child) => process(child));

package/dist/src/utils/logger.d.ts

@@ -1,5 +1,5 @@
 import { type Span } from '@opentelemetry/api';
-export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'operation' | 'step' | 'multiline' | 'details' | 'html' | 'input';
+export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'operation' | 'step' | 'multiline' | 'details' | 'html' | 'input' | 'data';
 export interface TaggedLogEntry {
     type: LogType;
     content: string;

package/dist/src/utils/logger.js

@@ -406,6 +406,14 @@ class Logger {
             }
             return;
         }
+        if (type === 'data') {
+            const entry = { type, content: String(args[0]), timestamp: new Date(), originalArgs: args };
+            for (const destination of this.extra) {
+                if (destination.isEnabled())
+                    destination.write(entry);
+            }
+            return;
+        }
         const options = this.extractLogOptions(type, args);
         let content = this.processArgs(args);
         if (type === 'step' && args[0]?.toCode) {

package/dist/src/utils/strings.d.ts

@@ -3,3 +3,5 @@ export declare function slugify(text: string): string;
 export declare function normalizeInlineText(text: string): string;
 export declare function sanitizeFilename(name: string): string;
 export declare function safeFilename(name: string, ext?: string, maxBytes?: number): string;
+export declare function truncate(text: string, max: number): string;
+export declare function compactErrorMessage(error: unknown): string;

package/dist/src/utils/strings.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import stripAnsi from 'strip-ansi';
 export function truncateJson(input) {
     if (!input)
         return '';
@@ -36,3 +37,34 @@ export function safeFilename(name, ext = '', maxBytes = 240) {
     }
     return truncated + suffix + ext;
 }
+export function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max - 3)}...`;
+}
+const MAX_COMPACT_ERROR = 400;
+export function compactErrorMessage(error) {
+    let text = stripAnsi(String(error));
+    for (const strip of STRIP_STRATEGIES) {
+        text = strip(text);
+    }
+    return truncate(text, MAX_COMPACT_ERROR);
+}
+function stripCallLog(text) {
+    const CALL_LOG = 'Call log:';
+    const NOISE = ['attempting', 'retrying', 'waiting'];
+    const [headline, ...log] = text.split(CALL_LOG);
+    if (!log.length)
+        return text;
+    const lines = new Set();
+    for (const line of log.join(CALL_LOG).split('\n')) {
+        const cleaned = normalizeInlineText(line);
+        if (!cleaned)
+            continue;
+        if (NOISE.some((noise) => cleaned.includes(noise)))
+            continue;
+        lines.add(cleaned);
+    }
+    return [headline.trim(), ...lines].join(' ');
+}
+const STRIP_STRATEGIES = [stripCallLog];

package/dist/src/utils/url-matcher.d.ts

@@ -1,5 +1,6 @@
 export declare function isDynamicSegment(segment: string): boolean;
 export declare function hasDynamicUrlSegment(url: string): boolean;
+export declare function isSamePageFamily(urlA: string, urlB: string): boolean;
 export declare function generalizeSegment(segment: string): string;
 export declare function generalizeUrl(url: string): string;
 export declare function matchesUrl(pattern: string, path: string): boolean;

package/dist/src/utils/url-matcher.js

@@ -32,6 +32,23 @@ export function isDynamicSegment(segment) {
 export function hasDynamicUrlSegment(url) {
     return url.split('/').some((seg) => seg.length > 0 && isDynamicSegment(seg));
 }
+export function isSamePageFamily(urlA, urlB) {
+    const partsA = new URL(urlA, 'http://localhost').pathname.toLowerCase().split('/').filter(Boolean);
+    const partsB = new URL(urlB, 'http://localhost').pathname.toLowerCase().split('/').filter(Boolean);
+    if (partsA.length !== partsB.length)
+        return false;
+    let diffCount = 0;
+    for (let i = 0; i < partsA.length; i++) {
+        if (partsA[i] === partsB[i])
+            continue;
+        diffCount++;
+        if (diffCount > 1)
+            return false;
+        if (!isDynamicSegment(partsA[i]) || !isDynamicSegment(partsB[i]))
+            return false;
+    }
+    return true;
+}
 export function generalizeSegment(segment) {
     if (/^\d+$/.test(segment))
         return '\\d+';
@@ -111,6 +128,18 @@ export function matchesNavigationUrl(expected, current) {
     if (!expectedPath.includes('?')) {
         currentPath = currentPath.split('?')[0];
     }
-    const normalize = (value) => value.replace(/^\/+|\/+$/g, '').toLowerCase();
-    return normalize(expectedPath) === normalize(currentPath);
+    const normalize = (value) => value.replace(/^\/+|\/+$/g, '');
+    const expectedNormalized = normalize(expectedPath);
+    const currentNormalized = normalize(currentPath);
+    const expectedKey = expectedNormalized.toLowerCase();
+    const currentKey = currentNormalized.toLowerCase();
+    if (expectedKey === currentKey)
+        return true;
+    if (!currentKey.startsWith(`${expectedKey}/`))
+        return false;
+    const recordSegments = currentNormalized
+        .slice(expectedKey.length + 1)
+        .split('/')
+        .filter(Boolean);
+    return recordSegments.length > 0 && recordSegments.every(isDynamicSegment);
 }