donobu 5.60.3 → 5.60.4

package/dist/cli/donobu-cli.js

@@ -1378,16 +1378,16 @@ async function attemptAutoHealRun(params) {
             envOverrides.DONOBU_PAGE_AI_CLEAR_CACHE_FILES =
                 JSON.stringify(clearCacheFiles);
         }
-        // The rerun plan drives the runtime gate in the test fixture: within the
-        // gated projects, only the heal targets (and their declared
-        // `describe.serial` siblings) execute. Projects outside the gate —
-        // declared dependencies of target projects, teardown projects — run in
-        // full, exactly as Playwright schedules them.
+        // The rerun plan drives the runtime gate in the test wrapper: within the
+        // target projects, only the heal targets (and their declared
+        // `describe.serial` siblings) execute; every other collected test skips.
+        // Declared dependency (setup) projects still run in full — the gate
+        // exempts any test whose project is not a heal-target project, so the
+        // storage-state auth and fixture seeding the targets rely on are produced
+        // (see healRerunGate). Each target carries its `projectName` so the gate
+        // can tell a target project apart from a dependency one.
         const healPlanPath = path.join(staging.rootDir, 'heal-rerun-plan.json');
-        await fs_1.promises.writeFile(healPlanPath, JSON.stringify({
-            targets: healTargets,
-            gatedProjects: (0, healRerunGate_1.computeGatedProjects)(healTargets.map((target) => target.projectName), params.initialReport?.metadata?.projectDependencies),
-        }), 'utf8');
+        await fs_1.promises.writeFile(healPlanPath, JSON.stringify({ targets: healTargets }), 'utf8');
         envOverrides.DONOBU_AUTO_HEAL_PLAN_PATH = healPlanPath;
         Logger_1.appLogger.info(`Auto-heal: re-running ${healTargets.length} targeted test(s) from ${evaluation.eligiblePlans.length} treatment plan(s)...`);
         const healJsonReportPath = path.join(staging.playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME);
@@ -2182,10 +2182,8 @@ async function runHealCommand(cliArgs) {
     applyJsonReportEnv(envOverrides, playwrightOutputDir);
     // Downstream hooks check this flag to avoid recursive auto-heal loops.
     envOverrides.DONOBU_AUTO_HEAL_ACTIVE = '1';
-    // Same runtime gating as the automatic rerun: only the plan's test (plus
-    // declared `describe.serial` siblings) executes within its own project;
-    // dependency projects run in full. Without an initial report there is no
-    // dependency graph, so the gate scopes to just the target's project.
+    // Same collection-time gating as the automatic rerun: only the plan's test
+    // (plus declared `describe.serial` siblings) executes.
     const healPlanPath = path.join(os.tmpdir(), `donobu-heal-rerun-plan-${Date.now()}.json`);
     await fs_1.promises.writeFile(healPlanPath, JSON.stringify({
         targets: [
@@ -2195,7 +2193,6 @@ async function runHealCommand(cliArgs) {
                 projectName: persisted.failure.testCase.projectName,
             },
         ],
-        gatedProjects: (0, healRerunGate_1.computeGatedProjects)([persisted.failure.testCase.projectName], undefined),
     }), 'utf8');
     envOverrides.DONOBU_AUTO_HEAL_PLAN_PATH = healPlanPath;
     Logger_1.appLogger.info(`Re-running Playwright using treatment plan at ${parsed.planPath}...`);

package/dist/esm/cli/donobu-cli.js

@@ -1378,16 +1378,16 @@ async function attemptAutoHealRun(params) {
             envOverrides.DONOBU_PAGE_AI_CLEAR_CACHE_FILES =
                 JSON.stringify(clearCacheFiles);
         }
-        // The rerun plan drives the runtime gate in the test fixture: within the
-        // gated projects, only the heal targets (and their declared
-        // `describe.serial` siblings) execute. Projects outside the gate —
-        // declared dependencies of target projects, teardown projects — run in
-        // full, exactly as Playwright schedules them.
+        // The rerun plan drives the runtime gate in the test wrapper: within the
+        // target projects, only the heal targets (and their declared
+        // `describe.serial` siblings) execute; every other collected test skips.
+        // Declared dependency (setup) projects still run in full — the gate
+        // exempts any test whose project is not a heal-target project, so the
+        // storage-state auth and fixture seeding the targets rely on are produced
+        // (see healRerunGate). Each target carries its `projectName` so the gate
+        // can tell a target project apart from a dependency one.
         const healPlanPath = path.join(staging.rootDir, 'heal-rerun-plan.json');
-        await fs_1.promises.writeFile(healPlanPath, JSON.stringify({
-            targets: healTargets,
-            gatedProjects: (0, healRerunGate_1.computeGatedProjects)(healTargets.map((target) => target.projectName), params.initialReport?.metadata?.projectDependencies),
-        }), 'utf8');
+        await fs_1.promises.writeFile(healPlanPath, JSON.stringify({ targets: healTargets }), 'utf8');
         envOverrides.DONOBU_AUTO_HEAL_PLAN_PATH = healPlanPath;
         Logger_1.appLogger.info(`Auto-heal: re-running ${healTargets.length} targeted test(s) from ${evaluation.eligiblePlans.length} treatment plan(s)...`);
         const healJsonReportPath = path.join(staging.playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME);
@@ -2182,10 +2182,8 @@ async function runHealCommand(cliArgs) {
     applyJsonReportEnv(envOverrides, playwrightOutputDir);
     // Downstream hooks check this flag to avoid recursive auto-heal loops.
     envOverrides.DONOBU_AUTO_HEAL_ACTIVE = '1';
-    // Same runtime gating as the automatic rerun: only the plan's test (plus
-    // declared `describe.serial` siblings) executes within its own project;
-    // dependency projects run in full. Without an initial report there is no
-    // dependency graph, so the gate scopes to just the target's project.
+    // Same collection-time gating as the automatic rerun: only the plan's test
+    // (plus declared `describe.serial` siblings) executes.
     const healPlanPath = path.join(os.tmpdir(), `donobu-heal-rerun-plan-${Date.now()}.json`);
     await fs_1.promises.writeFile(healPlanPath, JSON.stringify({
         targets: [
@@ -2195,7 +2193,6 @@ async function runHealCommand(cliArgs) {
                 projectName: persisted.failure.testCase.projectName,
             },
         ],
-        gatedProjects: (0, healRerunGate_1.computeGatedProjects)([persisted.failure.testCase.projectName], undefined),
     }), 'utf8');
     envOverrides.DONOBU_AUTO_HEAL_PLAN_PATH = healPlanPath;
     Logger_1.appLogger.info(`Re-running Playwright using treatment plan at ${parsed.planPath}...`);

package/dist/esm/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;

package/dist/esm/lib/test/healRerunGate.js

@@ -23,7 +23,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
@@ -41,7 +49,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPlanIndex = buildPlanIndex;
-exports.computeGatedProjects = computeGatedProjects;
 exports.shouldRunDuringHealRerun = shouldRunDuringHealRerun;
 exports.expandTargetsWithSerialCompanions = expandTargetsWithSerialCompanions;
 exports.resetHealRerunPlanCacheForTesting = resetHealRerunPlanCacheForTesting;
@@ -52,52 +59,47 @@ const envVars_1 = require("../../envVars");
 const model_1 = require("../../reporter/model");
 const Logger_1 = require("../../utils/Logger");
 function buildPlanIndex(plan) {
-    const index = new Map();
+    const byFile = new Map();
+    const targetProjects = new Set();
     for (const target of plan.targets ?? []) {
         if (!target?.file || !target?.title) {
             continue;
         }
         const file = path_1.default.resolve(target.file);
-        if (!index.has(file)) {
-            index.set(file, new Set());
+        if (!byFile.has(file)) {
+            byFile.set(file, new Set());
         }
-        index.get(file).add(target.title);
-    }
-    return index;
-}
-/**
- * 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.
- */
-function computeGatedProjects(targetProjects, projectDependencies) {
-    const targets = [
-        ...new Set(targetProjects.filter((name) => Boolean(name))),
-    ];
-    if (!projectDependencies) {
-        return targets;
-    }
-    // Every project reachable through any target's declared dependency chain.
-    const reachable = new Set();
-    const visit = (name) => {
-        for (const dependency of projectDependencies[name] ?? []) {
-            if (!reachable.has(dependency)) {
-                reachable.add(dependency);
-                visit(dependency);
-            }
+        byFile.get(file).add(target.title);
+        if (target.projectName) {
+            targetProjects.add(target.projectName);
         }
-    };
-    targets.forEach(visit);
-    return targets.filter((name) => !reachable.has(name));
+    }
+    return { byFile, targetProjects };
 }
 /**
- * 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.
  */
 function shouldRunDuringHealRerun(params) {
-    const titles = params.index.get(path_1.default.resolve(params.file));
+    const { index, projectName } = params;
+    if (projectName !== undefined &&
+        index.targetProjects.size > 0 &&
+        !index.targetProjects.has(projectName)) {
+        return true;
+    }
+    const titles = index.byFile.get(path_1.default.resolve(params.file));
     return titles?.has(params.title) ?? false;
 }
 /**
@@ -160,61 +162,47 @@ function expandTargetsWithSerialCompanions(targets, initialReport) {
     }
     return expanded;
 }
-let cachedPlan;
-function loadPlan(planPathOverride) {
-    if (planPathOverride === undefined && cachedPlan !== undefined) {
-        return cachedPlan;
+let cachedPlanIndex;
+function getPlanIndex(planPathOverride) {
+    if (planPathOverride === undefined && cachedPlanIndex !== undefined) {
+        return cachedPlanIndex;
     }
     const planPath = planPathOverride ?? envVars_1.env.data.DONOBU_AUTO_HEAL_PLAN_PATH;
-    let loaded = null;
+    let index = null;
     if (planPath) {
         try {
             const raw = fs_1.default.readFileSync(planPath, 'utf8');
-            const plan = JSON.parse(raw);
-            loaded = {
-                index: buildPlanIndex(plan),
-                gatedProjects: new Set(plan.gatedProjects ??
-                    // Older plans carry no project list — gate the targets' own
-                    // projects, leaving everything else (dependencies) untouched.
-                    plan.targets
-                        ?.map((target) => target.projectName)
-                        .filter((name) => Boolean(name)) ??
-                    []),
-            };
+            index = buildPlanIndex(JSON.parse(raw));
         }
         catch (error) {
             Logger_1.appLogger.warn(`Auto-heal rerun plan at ${planPath} could not be read; running all collected tests.`, error);
-            loaded = null;
+            index = null;
         }
     }
     if (planPathOverride === undefined) {
-        cachedPlan = loaded;
+        cachedPlanIndex = index;
     }
-    return loaded;
+    return index;
 }
 /** Test-only: reset the memoized plan so each test can load its own. */
 function resetHealRerunPlanCacheForTesting() {
-    cachedPlan = undefined;
+    cachedPlanIndex = undefined;
 }
 /**
  * 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.
  */
 function maybeSkipForHealRerun(testInfo, options) {
-    const plan = loadPlan(options?.planPath);
-    if (!plan) {
-        return;
-    }
-    if (!plan.gatedProjects.has(testInfo.project.name)) {
+    const index = getPlanIndex(options?.planPath);
+    if (!index) {
         return;
     }
     const shouldRun = shouldRunDuringHealRerun({
-        index: plan.index,
+        index,
         file: testInfo.file,
         title: testInfo.title,
+        projectName: testInfo.project?.name,
     });
     if (shouldRun) {
         return;

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/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;

package/dist/lib/test/healRerunGate.js

@@ -23,7 +23,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
@@ -41,7 +49,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPlanIndex = buildPlanIndex;
-exports.computeGatedProjects = computeGatedProjects;
 exports.shouldRunDuringHealRerun = shouldRunDuringHealRerun;
 exports.expandTargetsWithSerialCompanions = expandTargetsWithSerialCompanions;
 exports.resetHealRerunPlanCacheForTesting = resetHealRerunPlanCacheForTesting;
@@ -52,52 +59,47 @@ const envVars_1 = require("../../envVars");
 const model_1 = require("../../reporter/model");
 const Logger_1 = require("../../utils/Logger");
 function buildPlanIndex(plan) {
-    const index = new Map();
+    const byFile = new Map();
+    const targetProjects = new Set();
     for (const target of plan.targets ?? []) {
         if (!target?.file || !target?.title) {
             continue;
         }
         const file = path_1.default.resolve(target.file);
-        if (!index.has(file)) {
-            index.set(file, new Set());
+        if (!byFile.has(file)) {
+            byFile.set(file, new Set());
         }
-        index.get(file).add(target.title);
-    }
-    return index;
-}
-/**
- * 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.
- */
-function computeGatedProjects(targetProjects, projectDependencies) {
-    const targets = [
-        ...new Set(targetProjects.filter((name) => Boolean(name))),
-    ];
-    if (!projectDependencies) {
-        return targets;
-    }
-    // Every project reachable through any target's declared dependency chain.
-    const reachable = new Set();
-    const visit = (name) => {
-        for (const dependency of projectDependencies[name] ?? []) {
-            if (!reachable.has(dependency)) {
-                reachable.add(dependency);
-                visit(dependency);
-            }
+        byFile.get(file).add(target.title);
+        if (target.projectName) {
+            targetProjects.add(target.projectName);
         }
-    };
-    targets.forEach(visit);
-    return targets.filter((name) => !reachable.has(name));
+    }
+    return { byFile, targetProjects };
 }
 /**
- * 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.
  */
 function shouldRunDuringHealRerun(params) {
-    const titles = params.index.get(path_1.default.resolve(params.file));
+    const { index, projectName } = params;
+    if (projectName !== undefined &&
+        index.targetProjects.size > 0 &&
+        !index.targetProjects.has(projectName)) {
+        return true;
+    }
+    const titles = index.byFile.get(path_1.default.resolve(params.file));
     return titles?.has(params.title) ?? false;
 }
 /**
@@ -160,61 +162,47 @@ function expandTargetsWithSerialCompanions(targets, initialReport) {
     }
     return expanded;
 }
-let cachedPlan;
-function loadPlan(planPathOverride) {
-    if (planPathOverride === undefined && cachedPlan !== undefined) {
-        return cachedPlan;
+let cachedPlanIndex;
+function getPlanIndex(planPathOverride) {
+    if (planPathOverride === undefined && cachedPlanIndex !== undefined) {
+        return cachedPlanIndex;
     }
     const planPath = planPathOverride ?? envVars_1.env.data.DONOBU_AUTO_HEAL_PLAN_PATH;
-    let loaded = null;
+    let index = null;
     if (planPath) {
         try {
             const raw = fs_1.default.readFileSync(planPath, 'utf8');
-            const plan = JSON.parse(raw);
-            loaded = {
-                index: buildPlanIndex(plan),
-                gatedProjects: new Set(plan.gatedProjects ??
-                    // Older plans carry no project list — gate the targets' own
-                    // projects, leaving everything else (dependencies) untouched.
-                    plan.targets
-                        ?.map((target) => target.projectName)
-                        .filter((name) => Boolean(name)) ??
-                    []),
-            };
+            index = buildPlanIndex(JSON.parse(raw));
         }
         catch (error) {
             Logger_1.appLogger.warn(`Auto-heal rerun plan at ${planPath} could not be read; running all collected tests.`, error);
-            loaded = null;
+            index = null;
         }
     }
     if (planPathOverride === undefined) {
-        cachedPlan = loaded;
+        cachedPlanIndex = index;
     }
-    return loaded;
+    return index;
 }
 /** Test-only: reset the memoized plan so each test can load its own. */
 function resetHealRerunPlanCacheForTesting() {
-    cachedPlan = undefined;
+    cachedPlanIndex = undefined;
 }
 /**
  * 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.
  */
 function maybeSkipForHealRerun(testInfo, options) {
-    const plan = loadPlan(options?.planPath);
-    if (!plan) {
-        return;
-    }
-    if (!plan.gatedProjects.has(testInfo.project.name)) {
+    const index = getPlanIndex(options?.planPath);
+    if (!index) {
         return;
     }
     const shouldRun = shouldRunDuringHealRerun({
-        index: plan.index,
+        index,
         file: testInfo.file,
         title: testInfo.title,
+        projectName: testInfo.project?.name,
     });
     if (shouldRun) {
         return;

package/dist/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donobu",
-  "version": "5.60.3",
+  "version": "5.60.4",
   "description": "Create browser automations with an LLM agent and replay them as Playwright scripts.",
   "main": "dist/main.js",
   "module": "dist/esm/main.js",