donobu 5.60.3 → 5.60.5

package/dist/esm/managers/InteractionVisualizer.js

@@ -6,11 +6,22 @@ const PlaywrightUtils_1 = require("../utils/PlaywrightUtils");
 class InteractionVisualizer {
     constructor(defaultMessageDurationMillis) {
         this.defaultMessageDurationMillis = defaultMessageDurationMillis;
-        this.cursorPos = { x: 150, y: 150 };
+        /**
+         * Per-page cursor state. Keyed weakly so closed/GC'd pages drop out without
+         * us tracking page lifecycles.
+         */
+        this.states = new WeakMap();
     }
     /* ------------------------------------------------------------------ */
     /*  Public API                                                        */
     /* ------------------------------------------------------------------ */
+    static escapeHtml(text) {
+        return text
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+    }
     /**
      * Moves the virtual cursor to the center of the specified element and optionally displays a message.
      *
@@ -23,26 +34,29 @@ class InteractionVisualizer {
      * @returns Promise that resolves when the cursor movement and message display are complete
      *
      * @remarks
-     * - The target element will be scrolled into view if necessary
      * - The cursor animates smoothly to the element's center point
      * - Messages are positioned automatically to avoid viewport edges
-     * - The virtual cursor does not interfere with actual page interactions
+     * - Overlays are `pointer-events: none`, so they never intercept real interactions
      */
     async pointAt(page, locator, message, duration = this.defaultMessageDurationMillis) {
         if (!duration || duration <= 0) {
             return;
         }
         try {
-            let target = { x: this.cursorPos.x, y: this.cursorPos.y };
+            const state = this.getState(page);
+            const from = { ...state.pos };
+            let target = from;
             if (locator) {
                 const box = await locator.boundingBox();
                 if (box) {
                     target = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
                 }
             }
-            await this.ensureContainer(page);
+            state.pos = target;
             await Promise.all([
-                this.moveCursor(page, target, duration / 2),
+                state.visible
+                    ? this.renderCursor(page, state, from, target, duration / 2)
+                    : Promise.resolve(),
                 message?.trim()
                     ? this.showMessage(page, target, message.trim(), duration)
                     : Promise.resolve(),
@@ -55,28 +69,16 @@ class InteractionVisualizer {
         }
     }
     /**
-     * Shows the virtual mouse cursor on the page.
+     * Shows the virtual mouse cursor on the page at its current position.
      *
      * @param page - The Playwright page instance where the cursor will be displayed.
-     *
      * @returns Promise that resolves when the cursor is shown.
-     *
-     * @remarks
-     * - If the cursor doesn't exist yet, it will be created.
-     * - The cursor will be made visible with a smooth opacity transition.
      */
     async showMouse(page) {
         try {
-            await this.ensureContainer(page);
-            await this.ensureCursor(page);
-            await page.evaluate(([containerId]) => {
-                const root = document.getElementById(containerId)
-                    .shadowRoot;
-                const cursor = root.querySelector('.donobu-virtual-mouse');
-                if (cursor) {
-                    cursor.classList.remove('hidden');
-                }
-            }, [InteractionVisualizer.CONTAINER_ID]);
+            const state = this.getState(page);
+            state.visible = true;
+            await this.renderCursor(page, state, state.pos, state.pos, 0);
         }
         catch (error) {
             if (!PlaywrightUtils_1.PlaywrightUtils.isPageClosedError(error)) {
@@ -84,30 +86,22 @@ class InteractionVisualizer {
             }
         }
     }
+    /* ------------------------------------------------------------------ */
+    /*  Private helpers                                                   */
+    /* ------------------------------------------------------------------ */
     /**
      * Hides the virtual mouse cursor on the page.
      *
      * @param page - The Playwright page instance where the cursor is displayed.
-     *
-     * @returns Promise that resolves when the cursor is hidden
-     *
-     * @remarks
-     * - The cursor will be hidden with a smooth opacity transition
-     * - The cursor element remains in the DOM but becomes invisible
+     * @returns Promise that resolves when the cursor is hidden.
      */
     async hideMouse(page) {
         try {
-            const id = InteractionVisualizer.CONTAINER_ID;
-            await page.evaluate(([containerId]) => {
-                const container = document.getElementById(containerId);
-                if (!container?.shadowRoot) {
-                    return;
-                }
-                const cursor = container.shadowRoot.querySelector('.donobu-virtual-mouse');
-                if (cursor) {
-                    cursor.classList.add('hidden');
-                }
-            }, [id]);
+            const state = this.getState(page);
+            state.visible = false;
+            const cursor = state.cursor;
+            state.cursor = undefined;
+            await cursor?.dispose();
         }
         catch (error) {
             if (!PlaywrightUtils_1.PlaywrightUtils.isPageClosedError(error)) {
@@ -115,138 +109,110 @@ class InteractionVisualizer {
             }
         }
     }
-    /* ------------------------------------------------------------------ */
-    /*  Private helpers                                                   */
-    /* ------------------------------------------------------------------ */
-    async ensureContainer(page) {
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, css]) => {
-            if (document.getElementById(containerId)) {
-                return;
-            }
-            const el = document.createElement('div');
-            el.id = containerId;
-            Object.assign(el.style, {
-                position: 'fixed',
-                top: '0',
-                left: '0',
-                width: '100vw',
-                height: '100vh',
-                pointerEvents: 'none',
-                zIndex: '2147483646', // just below the message itself
-            });
-            const shadow = el.attachShadow({ mode: 'open' });
-            const style = document.createElement('style');
-            style.textContent = css;
-            shadow.appendChild(style);
-            // Append to <html> so it is not clipped by overflow/transform on <body>
-            (document.documentElement || document.body).appendChild(el);
-        }, [id, InteractionVisualizer.CSS]);
+    getState(page) {
+        let state = this.states.get(page);
+        if (!state) {
+            state = { pos: { x: 150, y: 150 }, visible: false };
+            this.states.set(page, state);
+        }
+        return state;
     }
-    async ensureCursor(page) {
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, position, svg, svgAttrs, tipX, tipY]) => {
-            const root = document.getElementById(containerId).shadowRoot;
-            let cursor = root.querySelector('.donobu-virtual-mouse');
-            if (cursor) {
-                return;
-            }
-            cursor = document.createElement('div');
-            cursor.className = 'donobu-virtual-mouse hidden';
-            // Hybrid approach: try insertAdjacentHTML first, fallback to createElementNS
+    /**
+     * Replaces the sticky cursor overlay with one positioned at `to`, gliding
+     * from `from` when `animMs > 0`. We show the new overlay before disposing
+     * the old one to avoid a visible flicker, and tolerate a stale disposable
+     * (e.g. cleared by a navigation) by swallowing its dispose error.
+     */
+    async renderCursor(page, state, from, to, animMs) {
+        const previous = state.cursor;
+        state.cursor = await page.screencast.showOverlay(this.buildCursorHtml(from, to, animMs));
+        if (previous) {
             try {
-                cursor.insertAdjacentHTML('beforeend', svg);
+                await previous.dispose();
             }
-            catch (_error) {
-                // Fallback: create SVG programmatically using attributes object
-                const attrs = JSON.parse(svgAttrs);
-                const svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-                // Set SVG attributes
-                Object.entries(attrs.svg).forEach(([key, value]) => {
-                    svgElement.setAttribute(key, value);
-                });
-                // Create and add path element
-                const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-                Object.entries(attrs.path).forEach(([key, value]) => {
-                    path.setAttribute(key, value);
-                });
-                svgElement.appendChild(path);
-                cursor.appendChild(svgElement);
+            catch {
+                // Stale overlay (page navigated/closed) — the fresh one already replaced it.
             }
-            const pos = position;
-            cursor.style.transitionDuration = '0s';
-            cursor.style.transform = `translate(${pos.x - tipX}px, ${pos.y - tipY}px)`;
-            root.appendChild(cursor);
-        }, [
-            id,
-            this.cursorPos,
-            InteractionVisualizer.SVG_MOUSE,
-            JSON.stringify(InteractionVisualizer.SVG_MOUSE_JSON),
-            InteractionVisualizer.TIP_X,
-            InteractionVisualizer.TIP_Y,
-        ]);
-    }
-    async moveCursor(page, target, duration) {
-        await this.ensureCursor(page);
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, end, duration, tipX, tipY]) => {
-            const root = document.getElementById(containerId).shadowRoot;
-            const cursor = root.querySelector('.donobu-virtual-mouse');
-            cursor.style.transitionDuration = `${duration}ms`;
-            const endPos = end;
-            cursor.style.transform = `translate(${endPos.x - tipX}px, ${endPos.y - tipY}px)`;
-            cursor.classList.add('rippling');
-            const done = new Promise((resolve) => {
-                const finish = () => {
-                    cursor.removeEventListener('transitionend', finish);
-                    cursor.classList.remove('rippling');
-                    resolve();
-                };
-                cursor.addEventListener('transitionend', finish);
-                setTimeout(finish, duration + 50);
+        }
+        // showOverlay resolves the moment the overlay is added, before the CSS
+        // glide plays. Callers (e.g. ClickTool) await pointAt expecting the cursor
+        // to reach the element *before* they act, so block for the animation here.
+        if (animMs > 0) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, animMs);
             });
-            return done;
-        }, [
-            id,
-            target,
-            duration,
-            InteractionVisualizer.TIP_X,
-            InteractionVisualizer.TIP_Y,
-        ]);
-        this.cursorPos = target;
+        }
     }
     async showMessage(page, target, text, duration) {
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, target, text, duration]) => {
-            containerId = containerId;
-            target = target;
-            text = text;
-            duration = duration;
-            const root = document.getElementById(containerId)
-                .shadowRoot;
-            const msg = document.createElement('div');
-            msg.className = 'donobu-message';
-            msg.textContent = text;
-            root.appendChild(msg);
-            /* ── compute final coordinates ────────────────────────────────── */
-            const { width, height } = msg.getBoundingClientRect();
-            let x = target.x - width / 2;
-            let y = target.y + 24; // default - below cursor
-            /* clamp horizontally inside viewport */
-            x = Math.max(8, Math.min(window.innerWidth - width - 8, x));
-            /* if it overflows bottom, flip above the element */
-            if (y + height + 8 > window.innerHeight) {
-                y = target.y - height - 24;
-            }
-            /* if still off-screen at the top, clamp to 8 px margin */
-            if (y < 8) {
-                y = 8;
-            }
-            msg.style.left = `${x}px`;
-            msg.style.top = `${y}px`;
-            /* auto-remove after the requested duration */
-            setTimeout(() => msg.remove(), duration);
-        }, [id, target, text, duration]);
+        // Sticky overlay + self-managed removal. The `duration` option on
+        // showOverlay only composites into the recorded screencast stream, not the
+        // live page render layer (so it would be invisible in headed/screenshots);
+        // a no-duration overlay renders everywhere, matching the cursor.
+        const handle = await page.screencast.showOverlay(this.buildMessageHtml(page, target, text));
+        const timer = setTimeout(() => {
+            handle.dispose().catch(() => {
+                // Page navigated/closed before the message expired — nothing to clean up.
+            });
+        }, duration);
+        // Don't let a pending message removal keep the process alive on shutdown.
+        timer.unref?.();
+    }
+    /**
+     * Builds the cursor overlay markup: the arrow SVG plus a `@keyframes` glide
+     * from the previous position and a one-shot ripple at the arrow tip.
+     */
+    buildCursorHtml(from, to, animMs) {
+        const tipX = InteractionVisualizer.TIP_X;
+        const tipY = InteractionVisualizer.TIP_Y;
+        const fx = from.x - tipX;
+        const fy = from.y - tipY;
+        const tx = to.x - tipX;
+        const ty = to.y - tipY;
+        const animate = animMs > 0 && (from.x !== to.x || from.y !== to.y);
+        return `
+<style>
+  @keyframes donobu-glide { from { transform: translate(${fx}px, ${fy}px); } to { transform: translate(${tx}px, ${ty}px); } }
+  @keyframes donobu-ripple { 0% { transform: translate(-50%,-50%) scale(.5); opacity:0; } 40% { transform: translate(-50%,-50%) scale(1); opacity:.5; } 100% { transform: translate(-50%,-50%) scale(2); opacity:0; } }
+  .donobu-cursor { position:fixed; left:0; top:0; width:32px; height:32px; z-index:2147483646; pointer-events:none; filter:drop-shadow(1px 1px 1px rgba(0,0,0,.5)); transform: translate(${tx}px, ${ty}px); ${animate ? `animation: donobu-glide ${animMs}ms ease-in-out;` : ''} }
+  .donobu-cursor svg { width:100%; height:100%; display:block; }
+  ${animate ? `.donobu-cursor::after { content:""; position:absolute; left:${tipX}px; top:${tipY}px; width:24px; height:24px; border-radius:50%; background:#FF781B; opacity:0; animation: donobu-ripple .6s ease-out ${animMs}ms both; }` : ''}
+</style>
+<div class="donobu-cursor">${InteractionVisualizer.SVG_MOUSE}</div>`;
+    }
+    /**
+     * Builds the message tooltip markup, positioned near `target` and clamped
+     * inside the viewport. Without being able to measure the rendered box, we
+     * keep it on-screen with a conservative max-width clamp and anchor it above
+     * the cursor (via `translateY(-100%)`) when the cursor sits low in the page.
+     */
+    buildMessageHtml(page, target, text) {
+        const maxW = InteractionVisualizer.MESSAGE_MAX_WIDTH;
+        const margin = InteractionVisualizer.MESSAGE_MARGIN;
+        const vp = page.viewportSize() ?? { width: 1280, height: 720 };
+        // Clamp the (centered) anchor so a max-width box can't overflow either edge.
+        const centerX = Math.max(maxW / 2 + margin, Math.min(vp.width - maxW / 2 - margin, target.x));
+        const placeAbove = target.y > vp.height * 0.6;
+        const top = placeAbove ? Math.max(margin, target.y - 24) : target.y + 24;
+        const translate = placeAbove
+            ? 'translate(-50%, -100%)'
+            : 'translate(-50%, 0)';
+        const style = [
+            'position:fixed',
+            `left:${centerX}px`,
+            `top:${top}px`,
+            `transform:${translate}`,
+            `max-width:${maxW}px`,
+            'z-index:2147483647',
+            'pointer-events:none',
+            'background:#000',
+            'color:#fff',
+            'padding:8px 10px',
+            'border-radius:5px',
+            "font:12px/1 'Source Sans Pro','Helvetica Neue',Helvetica,Arial,sans-serif",
+            'white-space:pre-wrap',
+            'box-shadow:2px 2px 10px rgba(0,0,0,.2)',
+        ].join(';');
+        return `<div style="${style}">${InteractionVisualizer.escapeHtml(text)}</div>`;
     }
 }
 exports.InteractionVisualizer = InteractionVisualizer;
@@ -269,29 +235,7 @@ InteractionVisualizer.SVG_MOUSE = `
      stroke-linejoin="round">
   <path d="${InteractionVisualizer.RAW_MOUSE_D}" />
 </svg>`;
-InteractionVisualizer.SVG_MOUSE_JSON = {
-    svg: {
-        xmlns: 'http://www.w3.org/2000/svg',
-        width: '32',
-        height: '32',
-        viewBox: '0 0 24 24',
-        fill: 'oklch(13.09% 0.005 165.18)',
-        stroke: '#FF781B',
-        'stroke-width': '2',
-        'stroke-linecap': 'round',
-        'stroke-linejoin': 'round',
-    },
-    path: {
-        d: InteractionVisualizer.RAW_MOUSE_D,
-    },
-};
-InteractionVisualizer.CSS = `
-  .donobu-message{position:absolute;z-index:2147483647;background:#000;color:#fff;padding:8px 10px;border-radius:5px;font:12px/1 'Source Sans Pro','Helvetica Neue',Helvetica,Arial,sans-serif;max-width:300px;white-space:pre-wrap;box-shadow:2px 2px 10px rgba(0,0,0,.2);pointer-events:none}
-  .donobu-virtual-mouse{width:24px;height:24px;position:absolute;z-index:2147483646;filter:drop-shadow(1px 1px 1px rgba(0,0,0,.5));transition:transform .15s ease-in-out;pointer-events:none;opacity:1;visibility:visible}
-  .donobu-virtual-mouse.hidden{opacity:0;visibility:hidden}
-  .donobu-virtual-mouse svg{width:100%;height:100%;display:block}
-  .donobu-virtual-mouse.rippling::after{content:"";position:absolute;left:${InteractionVisualizer.TIP_X}px;top:${InteractionVisualizer.TIP_Y}px;width:24px;height:24px;border-radius:50%;background:#FF781B;transform:translate(-50%,-50%) scale(.5);opacity:.4;animation:ripple-pop .6s ease-out forwards}
-  @keyframes ripple-pop{40%{transform:translate(-50%,-50%) scale(1);opacity:.5}100%{transform:translate(-50%,-50%) scale(2);opacity:0}}
-`;
-InteractionVisualizer.CONTAINER_ID = 'donobu-iv-overlay';
+/** Message tooltip box styling — mirrors the legacy `.donobu-message` rule. */
+InteractionVisualizer.MESSAGE_MAX_WIDTH = 300;
+InteractionVisualizer.MESSAGE_MARGIN = 8;
 //# sourceMappingURL=InteractionVisualizer.js.map

package/dist/esm/reporter/buildReport.js

@@ -41,27 +41,6 @@ function buildDonobuReport(resultsByTest, rootDir) {
         }
         byTitle.get(test.title).push(test);
     }
-    // Declared project dependency graph (`FullProject.dependencies`), keyed by
-    // project name. The auto-heal orchestrator uses it to keep the rerun gate
-    // away from projects that are declared dependencies of heal targets — those
-    // must run in full, exactly as Playwright schedules them.
-    const projectDependencies = {};
-    for (const test of resultsByTest.keys()) {
-        try {
-            let suite = test.parent;
-            while (suite && suite.type !== 'project') {
-                suite = suite.parent;
-            }
-            const project = suite?.project();
-            if (project?.name && !(project.name in projectDependencies)) {
-                projectDependencies[project.name] = [...(project.dependencies ?? [])];
-            }
-        }
-        catch {
-            // Reporter shape drift — omit the entry; the orchestrator degrades to
-            // gating only the heal targets' own projects.
-        }
-    }
     const suites = [];
     for (const [file, titleMap] of byFile) {
         const specs = [];
@@ -137,7 +116,7 @@ function buildDonobuReport(resultsByTest, rootDir) {
         }
         suites.push({ file, specs });
     }
-    return { suites, metadata: { projectDependencies } };
+    return { suites, metadata: {} };
 }
 /**
  * Whether any enclosing suite is in serial mode (`test.describe.serial` or

package/dist/esm/reporter/model.d.ts

@@ -57,13 +57,6 @@ export interface DonobuReportMetadata {
     /** True on reports that are the result of merging an initial + heal run. */
     donobuMergedReport?: boolean;
     mergedAtIso?: string;
-    /**
-     * Declared Playwright project dependency graph (`FullProject.dependencies`)
-     * keyed by project name, recorded by the reporter. The auto-heal
-     * orchestrator uses it to exclude declared dependencies of heal targets
-     * from the rerun gate — they must run in full.
-     */
-    projectDependencies?: Record<string, string[]>;
     sources?: {
         initial?: string | null;
         autoHeal?: string | null;

package/dist/esm/utils/BrowserUtils.js

@@ -199,22 +199,7 @@ class BrowserUtils {
                     // If the entry exists but doesn't have sessionStorage yet, add the property
                     originEntry.sessionStorage = [];
                 }
-                // Extract sessionStorage from the page
-                const sessionStorageItems = await page.evaluate(() => {
-                    const items = [];
-                    for (let i = 0; i < sessionStorage.length; i++) {
-                        const name = sessionStorage.key(i);
-                        if (name) {
-                            items.push({
-                                name,
-                                value: sessionStorage.getItem(name) || '',
-                            });
-                        }
-                    }
-                    return items;
-                });
-                // Add sessionStorage items to the origin entry
-                originEntry.sessionStorage = sessionStorageItems;
+                originEntry.sessionStorage = await page.sessionStorage.items();
             }
             catch (error) {
                 Logger_1.appLogger.warn(`Failed to extract sessionStorage for page: ${pageUrl}`, error);

package/dist/lib/test/healRerunGate.d.ts

@@ -22,7 +22,15 @@
  *     `expandTargetsWithSerialCompanions`) using the `serialScoped` flags the
  *     Donobu reporter recorded during the initial run — the runner process
  *     sees the suite tree; the worker (where this gate runs) does not.
- *   - Declared dependency projects, which Playwright always runs in full.
+ *   - Declared dependency (setup) projects, in full. Playwright schedules them
+ *     because a target project lists them in `dependencies`, and the rerun
+ *     command only ever passes `--project=<target>`, so any project that runs
+ *     and is NOT a heal-target project is, by construction, such a dependency
+ *     project. The gate exempts every test whose project is not a target
+ *     project, so the auth/storage-state and fixture seeding those projects
+ *     perform actually runs. (A prior version skipped them too — every test
+ *     not literally in the plan — which broke targets that depend on the
+ *     `.auth` storage state a setup project produces.)
  *
  * Implicit ordering (checkpoint files between plain tests, cross-file state
  * with `workers: 1`) is deliberately NOT honored: tests relying on it will
@@ -44,34 +52,43 @@ export interface HealRerunPlan {
         title: string;
         projectName?: string;
     }>;
-    /**
-     * Projects the gate applies to. Tests in any other project — declared
-     * dependency projects (auth/setup), teardown projects — run untouched,
-     * exactly as Playwright schedules them. Computed by the orchestrator via
-     * `computeGatedProjects`; when absent, the gate falls back to the targets'
-     * own project names.
-     */
-    gatedProjects?: string[];
 }
-/** Targets indexed by absolute spec path for O(1) per-test decisions. */
-export type HealRerunPlanIndex = Map<string, Set<string>>;
-export declare function buildPlanIndex(plan: HealRerunPlan): HealRerunPlanIndex;
 /**
- * The projects the rerun gate should apply to: the heal targets' own
- * projects, minus any project that is a declared (transitive) dependency of
- * another target project — the dependency declaration wins, and that project
- * runs in full.
+ * Heal-rerun targets indexed for O(1) per-test decisions.
+ *
+ * `byFile` maps an absolute spec path to the heal-target titles in that file.
+ * `targetProjects` is the set of projects that own those targets; the rerun is
+ * launched with `--project=<target>` only, so any project Playwright also runs
+ * is there purely as a declared dependency (setup) project — see
+ * `shouldRunDuringHealRerun`. Empty when no target carries a project name, in
+ * which case the gate degrades to pure file+title matching.
  */
-export declare function computeGatedProjects(targetProjects: Array<string | undefined>, projectDependencies: Record<string, string[]> | undefined): string[];
+export interface HealRerunPlanIndex {
+    byFile: Map<string, Set<string>>;
+    targetProjects: Set<string>;
+}
+export declare function buildPlanIndex(plan: HealRerunPlan): HealRerunPlanIndex;
 /**
- * Pure decision: should the test in `file` with `title` actually execute
- * during the heal rerun? The plan is fully explicit — serial companions were
- * already expanded into it by the orchestrator.
+ * Pure decision: should the test in `file` with `title` (owned by project
+ * `projectName`) actually execute during the heal rerun? The plan is fully
+ * explicit — serial companions were already expanded into it by the
+ * orchestrator.
+ *
+ * Dependency/setup projects (auth login, fixture seeding, …) are pulled in by
+ * Playwright because a target project declares them in `dependencies`. They
+ * are never themselves heal targets, but their tests MUST run so the state the
+ * targets depend on (storage-state auth files, seeded documents) is in place
+ * before the rerun. The rerun command only ever passes `--project=<target>`,
+ * so any project Playwright runs that is not a target project is, by
+ * construction, such a dependency project — run it in full. Guarded on a
+ * non-empty target-project set so the gate degrades to pure file+title
+ * matching when project names are unavailable.
  */
 export declare function shouldRunDuringHealRerun(params: {
     index: HealRerunPlanIndex;
     file: string;
     title: string;
+    projectName?: string;
 }): boolean;
 /**
  * Expand heal targets with their `describe.serial` siblings, using the
@@ -91,10 +108,8 @@ export declare function expandTargetsWithSerialCompanions(targets: HealRerunPlan
 export declare function resetHealRerunPlanCacheForTesting(): void;
 /**
  * Called from the Donobu auto fixture before any browser fixture initializes.
- * Outside heal reruns this is a no-op. During a rerun, tests in gated
- * projects that are outside the plan are annotated and skipped on the spot —
- * no context, no page, no cost. Tests in ungated projects (declared
- * dependencies of the targets, teardown projects) always run.
+ * Outside heal reruns this is a no-op. During a rerun, tests outside the plan
+ * are annotated and skipped on the spot — no context, no page, no cost.
  */
 export declare function maybeSkipForHealRerun(testInfo: TestInfo, options?: {
     planPath?: string;