@poleski/quality-tools 0.2.0 → 0.2.1

package/dist/cli/main.js

@@ -5,149 +5,544 @@ import fs from "node:fs";
 import path from "node:path";
 import { glob } from "glob";
 
+// src/acceptance/dryChecker.ts
+var NEAR_DUPLICATE_THRESHOLD = 0.72;
+var POSSIBLE_SYNONYM_THRESHOLD = 0.45;
+var IGNORED_TOKENS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "be",
+  "i",
+  "in",
+  "is",
+  "of",
+  "the",
+  "then",
+  "to",
+  "when"
+]);
+function analyzeAcceptanceIrDryness(document, options = {}) {
+  const occurrences = document.scenarios.flatMap(
+    (scenario, scenarioIndex) => scenario.steps.map((step, stepIndex) => ({
+      step,
+      location: createLocation(scenario, scenarioIndex, step, stepIndex)
+    }))
+  );
+  const scenarioShapeGroups = findRepeatedScenarioShapes(document.scenarios);
+  const repeatedStepPatterns = findRepeatedStepPatterns(occurrences);
+  const findings = [
+    ...findDuplicateInScenario(document.scenarios),
+    ...options.includeExact ? findExactDuplicates(occurrences) : [],
+    ...findPlaceholderVariants(occurrences),
+    ...repeatedStepPatterns,
+    ...options.includeSimilar ? findSimilarSteps(occurrences) : []
+  ];
+  return {
+    schema_version: 1,
+    source_path: document.source_path,
+    feature_name: document.feature.name,
+    summary: {
+      scenarios: document.scenarios.length,
+      step_occurrences: occurrences.length,
+      unique_steps: new Set(occurrences.map((occurrence) => occurrence.step.text)).size,
+      repeated_step_patterns: repeatedStepPatterns.length,
+      repeated_scenario_shapes: scenarioShapeGroups.length,
+      findings: findings.length
+    },
+    repeated_scenario_shapes: scenarioShapeGroups,
+    findings
+  };
+}
+function findDuplicateInScenario(scenarios) {
+  return scenarios.flatMap((scenario, scenarioIndex) => {
+    const groups = groupOccurrences(scenario.steps.map((step, stepIndex) => ({
+      step,
+      location: createLocation(scenario, scenarioIndex, step, stepIndex)
+    })), (occurrence) => occurrence.step.text);
+    return [...groups.entries()].filter(([, members]) => containsDuplicateWithoutInterveningAction(scenario.steps, members)).map(([text, members]) => createFinding({
+      kind: "duplicate-in-scenario",
+      confidence: "high",
+      canonicalCandidate: text,
+      members,
+      reason: "the same step text appears more than once in one scenario",
+      suggestedAction: "Review the scenario and remove the repeated step if it is accidental."
+    }));
+  });
+}
+function containsDuplicateWithoutInterveningAction(steps, members) {
+  const stepIndexes = members.map((member) => member.location.step_index).sort((left, right) => left - right);
+  return stepIndexes.some((stepIndex, index) => {
+    const nextStepIndex = stepIndexes[index + 1];
+    return nextStepIndex !== void 0 && !hasInterveningAction(steps, stepIndex, nextStepIndex);
+  });
+}
+function hasInterveningAction(steps, leftIndex, rightIndex) {
+  const effectiveKeywords = getEffectiveKeywords(steps);
+  return steps.slice(leftIndex + 1, rightIndex).some((_, offset) => {
+    const effectiveKeyword = effectiveKeywords[leftIndex + offset + 1];
+    return effectiveKeyword === "Given" || effectiveKeyword === "When";
+  });
+}
+function getEffectiveKeywords(steps) {
+  let currentKeyword = "Given";
+  return steps.map((step) => {
+    if (step.keyword !== "And" && step.keyword !== "But") {
+      currentKeyword = step.keyword;
+    }
+    return currentKeyword;
+  });
+}
+function findExactDuplicates(occurrences) {
+  return [...groupOccurrences(occurrences, (occurrence) => occurrence.step.text).entries()].filter(([, members]) => members.length > 1).map(([text, members]) => createFinding({
+    kind: "exact-duplicate",
+    confidence: "medium",
+    canonicalCandidate: text,
+    members,
+    reason: "the same step text appears more than once in the feature",
+    suggestedAction: "Keep repeated setup vocabulary when intentional; normalize only accidental drift."
+  }));
+}
+function findPlaceholderVariants(occurrences) {
+  return [...groupOccurrences(occurrences, (occurrence) => normalizePlaceholders(occurrence.step.text)).entries()].filter(([, members]) => members.length > 1 && new Set(members.map((member) => member.step.text)).size > 1).map(([text, members]) => createFinding({
+    kind: "placeholder-variant",
+    confidence: "high",
+    canonicalCandidate: text,
+    patternCandidate: patternFromPlaceholderText(text),
+    members,
+    reason: "step text is identical after replacing placeholder names with generic slots",
+    suggestedAction: "Normalize the Gherkin if the different placeholder names do not add reader meaning."
+  }));
+}
+function findRepeatedStepPatterns(occurrences) {
+  return [...groupOccurrences(occurrences, (occurrence) => normalizeStepPattern(occurrence.step.text)).entries()].filter(([, members]) => members.length > 1 && new Set(members.map((member) => member.step.text)).size > 1).map(([pattern, members]) => createFinding({
+    kind: "repeated-step-pattern",
+    confidence: "high",
+    canonicalCandidate: pattern,
+    patternCandidate: pattern,
+    members,
+    reason: "step text follows the same generalized pattern with different example values",
+    suggestedAction: "Consider a Scenario Outline, data table, or shared Background if the repeated shape is intentional."
+  }));
+}
+function findSimilarSteps(occurrences) {
+  return findSimilarStepCandidates(occurrences).map(createSimilarStepFinding);
+}
+function findSimilarStepCandidates(occurrences) {
+  return occurrences.flatMap(
+    (left, leftIndex) => occurrences.slice(leftIndex + 1).map((right) => createSimilarStepCandidate(left, right)).filter((candidate) => candidate !== void 0)
+  );
+}
+function createSimilarStepCandidate(left, right) {
+  if (!shouldCompareSimilarSteps(left, right)) {
+    return void 0;
+  }
+  const score = tokenSimilarity(left.step.text, right.step.text);
+  return score >= POSSIBLE_SYNONYM_THRESHOLD ? { left, right, score } : void 0;
+}
+function shouldCompareSimilarSteps(left, right) {
+  return left.step.text !== right.step.text && normalizePlaceholders(left.step.text) !== normalizePlaceholders(right.step.text);
+}
+function createSimilarStepFinding(candidate) {
+  return createFinding({
+    kind: similarStepKind(candidate.score),
+    confidence: similarStepConfidence(candidate.score),
+    canonicalCandidate: candidate.left.step.text,
+    members: [candidate.left, candidate.right],
+    reason: "step texts share similar normalized tokens",
+    score: Number(candidate.score.toFixed(3)),
+    suggestedAction: "Review whether these steps express the same behavior before changing feature wording."
+  });
+}
+function similarStepKind(score) {
+  return score >= NEAR_DUPLICATE_THRESHOLD ? "near-duplicate" : "possible-synonym";
+}
+function similarStepConfidence(score) {
+  return score >= NEAR_DUPLICATE_THRESHOLD ? "medium" : "low";
+}
+function createLocation(scenario, scenarioIndex, step, stepIndex) {
+  return {
+    section: "scenario",
+    scenario_index: scenarioIndex,
+    scenario_name: scenario.name,
+    step_index: stepIndex,
+    keyword: step.keyword,
+    line: step.line
+  };
+}
+function findRepeatedScenarioShapes(scenarios) {
+  const exactShapeGroups = [...groupOccurrences(
+    scenarios.map((scenario, scenarioIndex) => ({ scenario, scenarioIndex })),
+    ({ scenario }) => scenario.steps.map((step) => normalizeStepPattern(step.text)).join("\n")
+  ).entries()].filter(([, members]) => members.length > 1).map(([, members]) => createScenarioShapeGroup(members, members[0]?.scenario.steps.length ?? 0, "high"));
+  const prefixShapeGroups = [...groupOccurrences(
+    scenarios.map((scenario, scenarioIndex) => ({
+      scenario,
+      scenarioIndex,
+      prefix: longestSetupPrefix(scenario)
+    })).filter((entry) => entry.prefix.length >= 3),
+    ({ prefix }) => prefix.join("\n")
+  ).entries()].filter(([, members]) => members.length > 1).map(([, members]) => createScenarioShapeGroup(members, members[0]?.prefix.length ?? 0, "medium"));
+  return dedupeScenarioShapeGroups([...exactShapeGroups, ...prefixShapeGroups]);
+}
+function createScenarioShapeGroup(members, sharedStepCount, confidence) {
+  const pattern = members[0]?.prefix ?? members[0]?.scenario.steps.slice(0, sharedStepCount).map((step) => normalizeStepPattern(step.text)) ?? [];
+  return {
+    confidence,
+    scenario_count: members.length,
+    shared_step_count: sharedStepCount,
+    pattern,
+    scenarios: members.map(({ scenario, scenarioIndex }) => ({
+      scenario_index: scenarioIndex,
+      scenario_name: scenario.name,
+      line: scenario.line,
+      examples: scenario.examples.length
+    })),
+    reason: confidence === "high" ? "multiple scenarios have the same generalized step sequence" : "multiple scenarios share the same setup or action prefix before diverging into specific assertions",
+    suggested_action: confidence === "high" ? "Consider collapsing these scenarios into a Scenario Outline or a data-driven runner." : "Consider moving the shared prefix into Background or a host fixture if it does not need to be repeated in every scenario."
+  };
+}
+function longestSetupPrefix(scenario) {
+  const normalizedSteps = scenario.steps.map((step) => normalizeStepPattern(step.text));
+  const assertionIndex = scenario.steps.findIndex((step) => step.keyword === "Then");
+  const prefixLength = assertionIndex === -1 ? normalizedSteps.length : assertionIndex;
+  return normalizedSteps.slice(0, prefixLength);
+}
+function dedupeScenarioShapeGroups(groups) {
+  const seen = /* @__PURE__ */ new Set();
+  const sorted = groups.sort(
+    (left, right) => right.scenario_count - left.scenario_count || right.shared_step_count - left.shared_step_count || left.confidence.localeCompare(right.confidence)
+  );
+  return sorted.filter((group) => {
+    const scenarioKey = group.scenarios.map((scenario) => scenario.scenario_index).join(",");
+    const key = `${scenarioKey}:${group.shared_step_count}:${group.pattern.join("\n")}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function createFinding(input) {
+  return {
+    kind: input.kind,
+    confidence: input.confidence,
+    canonical_candidate: input.canonicalCandidate,
+    ...input.patternCandidate ? { pattern_candidate: input.patternCandidate } : {},
+    ...input.score === void 0 ? {} : { score: input.score },
+    members: [...groupOccurrences(input.members, (member) => member.step.text).entries()].map(([text, members]) => ({
+      text,
+      locations: members.map((member) => member.location)
+    })),
+    reason: input.reason,
+    suggested_action: input.suggestedAction
+  };
+}
+function groupOccurrences(values, keySelector) {
+  const groups = /* @__PURE__ */ new Map();
+  values.forEach((value) => {
+    const key = keySelector(value);
+    groups.set(key, [...groups.get(key) ?? [], value]);
+  });
+  return groups;
+}
+function normalizePlaceholders(text) {
+  let index = 0;
+  return text.replace(/<[^>]+>/g, () => {
+    index += 1;
+    return `<_${index}>`;
+  });
+}
+function normalizeStepPattern(text) {
+  return normalizePlaceholders(text).replace(/\b\d+\b/g, "<number>").replace(/\bexamples\/[A-Za-z0-9_-]+\b/g, "<workspace>").replace(/\b[A-Za-z0-9._/-]+\.[A-Za-z0-9]+\b/g, "<path>").replace(/\b(File|Folder|Package|Symbol|Namespace|Function|Callable|Method|Constructor|Prototype|Class|Interface|Record|Delegate|Property|Event|Type|Struct|Union|Enum|Alias|Template|Typedef|Variable|Constant|Global|Field|Parameter|Local|Godot class_name)\b/g, "<node-type>").replace(/\b(Include|Imports|References|Calls|Type imports|Inherits|Using|Call|Implements|Loads|Nests|Contains|Overrides|TypeScript Alias Import)\b/g, "<edge-type>").replace(/\s+/g, " ").trim();
+}
+function patternFromPlaceholderText(text) {
+  const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return `^${escaped.replace(/<_[0-9]+>/g, "(.+)")}$`;
+}
+function tokenSimilarity(left, right) {
+  const leftTokens = tokenize(left);
+  const rightTokens = tokenize(right);
+  const union = /* @__PURE__ */ new Set([...leftTokens, ...rightTokens]);
+  if (union.size === 0) {
+    return 0;
+  }
+  const intersection = [...leftTokens].filter((token) => rightTokens.has(token));
+  return intersection.length / union.size;
+}
+function tokenize(text) {
+  return new Set(
+    text.replace(/<[^>]+>/g, " ").toLowerCase().split(/[^a-z0-9]+/u).filter((token) => token.length > 0 && !IGNORED_TOKENS.has(token))
+  );
+}
+
+// src/acceptance/ir.ts
+function toAcceptanceIr(document) {
+  return {
+    schema_version: 1,
+    source_path: document.sourcePath,
+    feature: {
+      name: document.feature.name,
+      line: document.feature.line
+    },
+    ...document.background ? {
+      background: {
+        line: document.background.line,
+        steps: document.background.steps.map(toAcceptanceIrStep)
+      }
+    } : {},
+    scenarios: document.scenarios.map((scenario) => ({
+      name: scenario.name,
+      line: scenario.line,
+      steps: scenario.steps.map(toAcceptanceIrStep),
+      examples: scenario.examples.map((example) => ({
+        line: example.line,
+        values: example.values
+      }))
+    }))
+  };
+}
+function toAcceptanceIrStep(documentStep) {
+  return {
+    keyword: documentStep.keyword,
+    text: documentStep.text,
+    line: documentStep.line,
+    parameters: documentStep.parameters
+  };
+}
+
 // src/acceptance/parser.ts
 var FEATURE_PATTERN = /^#{0,6}\s*Feature:\s*(.+)$/;
+var BACKGROUND_PATTERN = /^#{0,6}\s*Background:\s*$/;
 var SCENARIO_PATTERN = /^#{0,6}\s*Scenario:\s*(.+)$/;
+var SCENARIO_OUTLINE_PATTERN = /^#{0,6}\s*Scenario Outline:\s*(.+)$/;
+var EXAMPLES_PATTERN = /^#{0,6}\s*Examples:\s*$/;
 var STEP_PATTERN = /^(Given|When|Then|And|But)\s+(.+)$/;
-function parseAcceptanceMarkdown(markdown, sourcePath) {
-  const lines = markdown.split(/\r?\n/);
-  let feature;
-  const scenarios = [];
-  lines.forEach((rawLine, index) => {
+var PARAMETER_PATTERN = /<([A-Za-z0-9_]+)>/g;
+var LINE_PARSERS = [
+  parseFeatureHeading,
+  parseBackgroundHeading,
+  parseScenarioHeading,
+  parseExamplesHeading,
+  parseExamplesRowLine,
+  parseStepLine
+];
+function parseAcceptanceFeature(featureSource, sourcePath) {
+  const state = createParserState(sourcePath);
+  parseFeatureLines(state, featureSource);
+  validateDocument(state);
+  return createDocument(state);
+}
+function createParserState(sourcePath) {
+  return {
+    sourcePath,
+    scenarios: [],
+    scenariosWithExamples: /* @__PURE__ */ new Set()
+  };
+}
+function parseFeatureLines(state, featureSource) {
+  featureSource.split(/\r?\n/).forEach((rawLine, index) => {
     const lineNumber = index + 1;
     const line = rawLine.trim();
-    if (line === "") {
-      return;
-    }
-    const featureMatch = FEATURE_PATTERN.exec(line);
-    if (featureMatch) {
-      feature = {
-        name: featureMatch[1].trim(),
-        line: lineNumber
-      };
-      return;
-    }
-    const scenarioMatch = SCENARIO_PATTERN.exec(line);
-    if (scenarioMatch) {
-      scenarios.push({
-        name: scenarioMatch[1].trim(),
-        line: lineNumber,
-        steps: []
-      });
+    parseFeatureLine(state, line, lineNumber);
+  });
+}
+function parseFeatureLine(state, line, lineNumber) {
+  if (line === "") {
+    return;
+  }
+  for (const parseLine of LINE_PARSERS) {
+    if (parseLine(state, line, lineNumber)) {
       return;
     }
-    const stepMatch = STEP_PATTERN.exec(line);
-    if (stepMatch) {
-      const scenario = scenarios.at(-1);
-      if (!scenario) {
-        throw new Error(`${sourcePath}:${lineNumber} Step appears before a Scenario`);
-      }
-      scenario.steps.push({
-        keyword: stepMatch[1],
-        text: stepMatch[2].trim(),
-        line: lineNumber
-      });
-    }
+  }
+}
+function parseFeatureHeading(state, line, lineNumber) {
+  const featureMatch = FEATURE_PATTERN.exec(line);
+  if (!featureMatch) {
+    return false;
+  }
+  state.feature = {
+    name: featureMatch[1].trim(),
+    line: lineNumber
+  };
+  clearActiveTargets(state);
+  return true;
+}
+function parseBackgroundHeading(state, line, lineNumber) {
+  if (!BACKGROUND_PATTERN.test(line)) {
+    return false;
+  }
+  if (state.background) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Feature has more than one Background`);
+  }
+  state.background = {
+    line: lineNumber,
+    steps: []
+  };
+  state.stepTarget = state.background;
+  clearExamplesTarget(state);
+  return true;
+}
+function parseScenarioHeading(state, line, lineNumber) {
+  const scenarioMatch = SCENARIO_PATTERN.exec(line) ?? SCENARIO_OUTLINE_PATTERN.exec(line);
+  if (!scenarioMatch) {
+    return false;
+  }
+  const scenario = {
+    name: scenarioMatch[1].trim(),
+    line: lineNumber,
+    steps: [],
+    examples: []
+  };
+  state.scenarios.push(scenario);
+  state.stepTarget = scenario;
+  clearExamplesTarget(state);
+  return true;
+}
+function parseExamplesHeading(state, line, lineNumber) {
+  if (!EXAMPLES_PATTERN.test(line)) {
+    return false;
+  }
+  const scenario = state.scenarios.at(-1);
+  if (!scenario) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Examples appear before a Scenario`);
+  }
+  state.examplesTarget = scenario;
+  state.scenariosWithExamples.add(scenario);
+  state.stepTarget = void 0;
+  state.examplesHeaders = void 0;
+  return true;
+}
+function parseExamplesRowLine(state, line, lineNumber) {
+  if (!line.startsWith("|")) {
+    return false;
+  }
+  if (!state.examplesTarget) {
+    return true;
+  }
+  const values = parseExamplesRow(line);
+  if (!state.examplesHeaders) {
+    setExamplesHeaders(state, values, lineNumber);
+    return true;
+  }
+  if (values.length !== state.examplesHeaders.length) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Examples row has ${values.length} cells; expected ${state.examplesHeaders.length}`);
+  }
+  state.examplesTarget.examples.push({
+    line: lineNumber,
+    values: Object.fromEntries(state.examplesHeaders.map((header, cellIndex) => [header, values[cellIndex] ?? ""]))
   });
-  if (!feature) {
-    throw new Error(`${sourcePath}: Expected a Feature heading`);
+  return true;
+}
+function setExamplesHeaders(state, values, lineNumber) {
+  state.examplesHeaders = values;
+  if (state.examplesHeaders.length === 0) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Examples header must contain at least one column`);
   }
-  if (scenarios.length === 0) {
-    throw new Error(`${sourcePath}: Expected at least one Scenario`);
+}
+function parseStepLine(state, line, lineNumber) {
+  const stepMatch = STEP_PATTERN.exec(line);
+  if (!stepMatch) {
+    return false;
   }
-  const emptyScenario = scenarios.find((scenario) => scenario.steps.length === 0);
+  if (!state.stepTarget) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Step appears before a Scenario or Background`);
+  }
+  const text = stepMatch[2].trim();
+  state.stepTarget.steps.push({
+    keyword: stepMatch[1],
+    text,
+    line: lineNumber,
+    parameters: extractParameters(text)
+  });
+  return true;
+}
+function clearActiveTargets(state) {
+  state.stepTarget = void 0;
+  clearExamplesTarget(state);
+}
+function clearExamplesTarget(state) {
+  state.examplesTarget = void 0;
+  state.examplesHeaders = void 0;
+}
+function validateDocument(state) {
+  assertFeatureExists(state);
+  assertHasScenarios(state);
+  assertBackgroundHasSteps(state);
+  assertScenariosHaveSteps(state);
+  assertExamplesHaveRows(state);
+}
+function assertFeatureExists(state) {
+  if (!state.feature) {
+    throw new Error(`${state.sourcePath}: Expected a Feature heading`);
+  }
+}
+function assertHasScenarios(state) {
+  if (state.scenarios.length === 0) {
+    throw new Error(`${state.sourcePath}: Expected at least one Scenario`);
+  }
+}
+function assertBackgroundHasSteps(state) {
+  if (state.background && state.background.steps.length === 0) {
+    throw new Error(`${state.sourcePath}:${state.background.line} Background must contain at least one step`);
+  }
+}
+function assertScenariosHaveSteps(state) {
+  const emptyScenario = state.scenarios.find((scenario) => scenario.steps.length === 0);
   if (emptyScenario) {
-    throw new Error(`${sourcePath}:${emptyScenario.line} Scenario "${emptyScenario.name}" must contain at least one step`);
+    throw new Error(`${state.sourcePath}:${emptyScenario.line} Scenario "${emptyScenario.name}" must contain at least one step`);
   }
+}
+function assertExamplesHaveRows(state) {
+  const emptyExamples = state.scenarios.find(
+    (scenario) => state.scenariosWithExamples.has(scenario) && scenario.examples.length === 0
+  );
+  if (emptyExamples) {
+    throw new Error(`${state.sourcePath}:${emptyExamples.line} Scenario "${emptyExamples.name}" has Examples without rows`);
+  }
+}
+function createDocument(state) {
   return {
-    sourcePath,
-    feature,
-    scenarios
+    sourcePath: state.sourcePath,
+    feature: state.feature,
+    ...state.background ? { background: state.background } : {},
+    scenarios: state.scenarios
   };
 }
+function extractParameters(text) {
+  return [...text.matchAll(PARAMETER_PATTERN)].map((match) => match[1] ?? "");
+}
+function parseExamplesRow(line) {
+  return line.slice(1, line.endsWith("|") ? -1 : void 0).split("|").map((cell) => cell.trim());
+}
 
 // src/acceptance/playwright/generator.ts
-function generatePlaywrightAcceptanceSpec(documents, options) {
-  const sections = documents.flatMap((document) => generateDocumentSections(document));
+import { readFileSync } from "node:fs";
+var runtimeTemplateUrl = new URL("./templates/playwright-acceptance-runtime.ts.template", import.meta.url);
+function generatePlaywrightAcceptanceSpec(options) {
   return [
-    "/* Generated by quality-tools acceptance compile. Do not edit. */",
-    "/* eslint-disable playwright/expect-expect */",
+    "/* Generated by quality-tools acceptance generate. Do not edit. */",
     "import { test } from '@playwright/test';",
     `import { acceptanceSteps, createAcceptanceContext } from ${quote(options.stepsImportPath)};`,
+    `import { loadAcceptanceIr, runAcceptanceFeature } from ${quote(options.runtimeImportPath)};`,
     "",
-    "type AcceptanceContext = Awaited<ReturnType<typeof createAcceptanceContext>> & { cleanup?: () => unknown | Promise<unknown> };",
-    "type AcceptanceRuntimeStep = { keyword: string; text: string; sourcePath: string; line: number };",
-    "type AcceptanceStepImplementation = (context: AcceptanceContext, step: AcceptanceRuntimeStep) => unknown | Promise<unknown>;",
-    "type AcceptanceStepRegistry = Record<string, AcceptanceStepImplementation>;",
-    "",
-    "async function runAcceptanceStep(",
-    "  context: AcceptanceContext,",
-    "  stepText: string,",
-    "  step: AcceptanceRuntimeStep",
-    "): Promise<void> {",
-    "  const registry = acceptanceSteps as AcceptanceStepRegistry;",
-    "  const implementation = registry[stepText] ?? registry[`${step.keyword} ${stepText}`];",
+    `const feature = loadAcceptanceIr(${quote(options.irImportPath)});`,
     "",
-    "  if (!implementation) {",
-    '    throw new Error(`Missing acceptance step "${step.keyword} ${step.text}" at ${step.sourcePath}:${step.line}`);',
-    "  }",
-    "",
-    "  await implementation(context, step);",
-    "}",
-    "",
-    ...sections,
-    ""
-  ].join("\n");
-}
-function generateDocumentSections(document) {
-  const scenarios = document.scenarios.flatMap((scenario) => generateScenario(document.sourcePath, scenario));
-  return [
-    `test.describe(${quote(document.feature.name)}, () => {`,
-    ...indentLines(scenarios, 2),
+    "runAcceptanceFeature(test, feature, {",
+    "  acceptanceSteps,",
+    "  createAcceptanceContext",
     "});",
     ""
-  ];
+  ].join("\n");
 }
-function generateScenario(sourcePath, scenario) {
-  const steps = indentLines(scenario.steps.flatMap((step) => generateStep(sourcePath, step)), 4);
-  return [
-    `test(${quote(scenario.name)}, async ({}, testInfo) => {`,
-    "  const context = await createAcceptanceContext({",
-    "    testInfo,",
-    `    sourcePath: ${quote(sourcePath)},`,
-    `    scenario: ${quote(scenario.name)}`,
-    "  });",
-    "",
-    "  try {",
-    ...steps,
-    "  } finally {",
-    "    await context.cleanup?.();",
-    "  }",
-    "});"
-  ];
-}
-function generateStep(sourcePath, step) {
-  const label = `${step.keyword} ${step.text}`;
-  return [
-    `// ${sourcePath}:${step.line}`,
-    `await test.step(${quote(label)}, async () => {`,
-    `  await runAcceptanceStep(context, ${quote(step.text)}, {`,
-    `    keyword: ${quote(step.keyword)},`,
-    `    text: ${quote(step.text)},`,
-    `    sourcePath: ${quote(sourcePath)},`,
-    `    line: ${step.line}`,
-    "  });",
-    "});",
-    ""
-  ];
+function generatePlaywrightAcceptanceRuntime() {
+  return readFileSync(runtimeTemplateUrl, "utf8");
 }
 function quote(value) {
   return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\r/g, "\\r").replace(/\n/g, "\\n")}'`;
 }
-function indentLines(lines, spaces) {
-  const prefix = " ".repeat(spaces);
-  return lines.map((line) => line === "" ? line : `${prefix}${line}`);
-}
 
 // src/shared/flagValue.ts
 function flagValue(args2, name) {
@@ -181,51 +576,191 @@ function cleanCliArgs(args2) {
 }
 
 // src/acceptance/command.ts
+var ACCEPTANCE_COMMANDS = /* @__PURE__ */ new Map([
+  ["parse", parseCommand],
+  ["dry-check", dryCheckCommand],
+  ["generate", generateCommand],
+  ["compile", compileCommand]
+]);
+var COMPILE_VALUE_FLAGS = [
+  "--steps",
+  "--ir",
+  "--dry",
+  "--spec",
+  "--out-dir",
+  "--ir-dir",
+  "--dry-report-dir"
+];
 async function runAcceptanceCli(rawArgs, options = {}) {
   const args2 = cleanCliArgs(rawArgs);
   const [command2, ...commandArgs] = args2;
-  if (command2 !== "compile") {
-    throw new Error("Usage: quality-tools acceptance compile --spec <glob> --steps <path> --out <path>");
+  const cwd = options.cwd ?? process.cwd();
+  if (isHelpCommand(command2)) {
+    console.log(acceptanceUsage());
+    return;
   }
-  await compileAcceptance(commandArgs, options.cwd ?? process.cwd());
+  await requireAcceptanceCommand(command2)(commandArgs, cwd);
+}
+function acceptanceUsage() {
+  return [
+    "Usage:",
+    "  quality-tools acceptance parse <feature-file> <json-output>",
+    "  quality-tools acceptance dry-check [--include-exact] [--include-similar] <json-ir> <report-output>",
+    "  quality-tools acceptance generate <json-ir> <generated-test-output> --steps <path>",
+    "  quality-tools acceptance compile <spec-glob> <generated-output-dir> --steps <path> [--ir <dir>] [--dry <dir>]"
+  ].join("\n");
 }
-async function compileAcceptance(args2, cwd) {
+function parseCommand(args2, cwd) {
+  const [featurePath, jsonOutputPath, ...extraArgs] = args2;
+  if (!featurePath || !jsonOutputPath || extraArgs.length > 0) {
+    throw new Error("Usage: quality-tools acceptance parse <feature-file> <json-output>");
+  }
+  const ir = parseIrFile(cwd, featurePath);
+  writeJsonFile(path.resolve(cwd, jsonOutputPath), ir);
+}
+function dryCheckCommand(args2, cwd) {
+  const options = parseDryCheckOptions(args2);
+  const report = analyzeAcceptanceIrDryness(readIrFile(cwd, options.irPath), {
+    includeExact: options.includeExact,
+    includeSimilar: options.includeSimilar
+  });
+  writeJsonFile(path.resolve(cwd, options.reportPath), report);
+}
+function generateCommand(args2, cwd) {
+  const options = parseGenerateOptions(args2);
+  writeGeneratedPlaywrightSpec(cwd, options.irPath, options.outPath, options.stepsPath);
+}
+async function compileCommand(args2, cwd) {
   const options = parseCompileOptions(args2);
   const specFiles = await findSpecFiles(cwd, options.specPatterns);
   if (specFiles.length === 0) {
     throw new Error(`No acceptance specs matched: ${options.specPatterns.join(", ")}`);
   }
-  const documents = specFiles.map((specFile) => {
-    const source = fs.readFileSync(specFile, "utf8");
-    return parseAcceptanceMarkdown(source, toPosixPath(path.relative(cwd, specFile)));
+  const generatedDir = path.resolve(cwd, options.generatedDir);
+  writePlaywrightRuntime(generatedDir);
+  specFiles.forEach((specFile) => {
+    const ir = parseIrFile(cwd, specFile);
+    const slug = sourcePathSlug(ir.source_path);
+    const irPath = path.join(path.resolve(cwd, options.irDir), `${slug}.json`);
+    const generatedPath = path.join(generatedDir, `${slug}.spec.ts`);
+    writeJsonFile(irPath, ir);
+    if (options.dryDir) {
+      writeJsonFile(path.join(path.resolve(cwd, options.dryDir), `${slug}.json`), analyzeAcceptanceIrDryness(ir, {
+        includeExact: options.includeExact,
+        includeSimilar: options.includeSimilar
+      }));
+    }
+    writeGeneratedPlaywrightSpec(cwd, irPath, generatedPath, options.stepsPath);
   });
-  const outPath = path.resolve(cwd, options.outPath);
-  const stepsImportPath = createStepsImportPath(outPath, path.resolve(cwd, options.stepsPath));
-  const generated = generatePlaywrightAcceptanceSpec(documents, { stepsImportPath });
-  fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  fs.writeFileSync(outPath, generated);
 }
-function parseCompileOptions(args2) {
-  const specPatterns = collectFlagValues(args2, "--spec");
-  const stepsPath = requireFlagValue(args2, "--steps");
-  const outPath = requireFlagValue(args2, "--out");
-  if (specPatterns.length === 0) {
-    throw new Error("Missing required --spec <glob>");
+function parseDryCheckOptions(args2) {
+  const positional = args2.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 2) {
+    throw new Error("Usage: quality-tools acceptance dry-check [--include-exact] [--include-similar] <json-ir> <report-output>");
+  }
+  return {
+    irPath: positional[0] ?? "",
+    reportPath: positional[1] ?? "",
+    includeExact: args2.includes("--include-exact"),
+    includeSimilar: args2.includes("--include-similar")
+  };
+}
+function parseGenerateOptions(args2) {
+  const positional = args2.filter((arg, index) => arg !== "--steps" && args2[index - 1] !== "--steps" && !arg.startsWith("--"));
+  if (positional.length !== 2) {
+    throw new Error("Usage: quality-tools acceptance generate <json-ir> <generated-test-output> --steps <path>");
   }
+  return {
+    irPath: positional[0] ?? "",
+    outPath: positional[1] ?? "",
+    stepsPath: requireFlagValue(args2, "--steps")
+  };
+}
+function parseCompileOptions(args2) {
+  const positional = collectPositionalArgs(args2, COMPILE_VALUE_FLAGS);
+  const specPatterns = resolveCompileSpecPatterns(args2, positional);
+  const generatedDir = requireCompileGeneratedDir(specPatterns, resolveGeneratedDir(args2, positional));
   return {
     specPatterns,
-    stepsPath,
-    outPath
+    stepsPath: requireFlagValue(args2, "--steps"),
+    generatedDir,
+    irDir: resolveIrDir(args2, generatedDir),
+    dryDir: resolveDryDir(args2),
+    includeExact: args2.includes("--include-exact"),
+    includeSimilar: args2.includes("--include-similar")
   };
 }
+function isHelpCommand(command2) {
+  return !command2 || command2 === "--help" || command2 === "-h";
+}
+function requireAcceptanceCommand(command2) {
+  const runner = command2 ? ACCEPTANCE_COMMANDS.get(command2) : void 0;
+  if (!runner) {
+    throw new Error(acceptanceUsage());
+  }
+  return runner;
+}
+function collectPositionalArgs(args2, valueFlags) {
+  return args2.filter(
+    (arg, index) => !arg.startsWith("--") && !isFlagValue(args2, index, valueFlags)
+  );
+}
+function resolveCompileSpecPatterns(args2, positional) {
+  const specFlags = collectFlagValues(args2, "--spec");
+  return specFlags.length > 0 ? specFlags : positional.slice(0, 1);
+}
+function resolveGeneratedDir(args2, positional) {
+  return collectFlagValues(args2, "--out-dir").at(0) ?? positional[1];
+}
+function requireCompileGeneratedDir(specPatterns, generatedDir) {
+  if (specPatterns.length === 0 || !generatedDir) {
+    throw new Error("Usage: quality-tools acceptance compile <spec-glob> <generated-output-dir> --steps <path> [--ir <dir>] [--dry <dir>]");
+  }
+  return generatedDir;
+}
+function resolveIrDir(args2, generatedDir) {
+  return collectFlagValues(args2, "--ir").at(0) ?? collectFlagValues(args2, "--ir-dir").at(0) ?? path.join(generatedDir, "..", "generated-ir");
+}
+function resolveDryDir(args2) {
+  return collectFlagValues(args2, "--dry").at(0) ?? collectFlagValues(args2, "--dry-report-dir").at(0);
+}
+function parseIrFile(cwd, featurePath) {
+  const resolvedPath = path.resolve(cwd, featurePath);
+  const source = fs.readFileSync(resolvedPath, "utf8");
+  return toAcceptanceIr(parseAcceptanceFeature(source, toPosixPath(path.relative(cwd, resolvedPath))));
+}
+function readIrFile(cwd, irPath) {
+  return JSON.parse(fs.readFileSync(path.resolve(cwd, irPath), "utf8"));
+}
+function writeGeneratedPlaywrightSpec(cwd, irPath, outPath, stepsPath) {
+  const resolvedOutPath = path.resolve(cwd, outPath);
+  const generatedDir = path.dirname(resolvedOutPath);
+  writePlaywrightRuntime(generatedDir);
+  writeFile(resolvedOutPath, generatePlaywrightAcceptanceSpec({
+    irImportPath: toPosixPath(path.relative(cwd, path.resolve(cwd, irPath))),
+    runtimeImportPath: createExtensionlessImportPath(resolvedOutPath, path.join(generatedDir, "runtime.ts")),
+    stepsImportPath: createExtensionlessImportPath(resolvedOutPath, path.resolve(cwd, stepsPath))
+  }));
+}
+function writePlaywrightRuntime(generatedDir) {
+  writeFile(path.join(generatedDir, "runtime.ts"), generatePlaywrightAcceptanceRuntime());
+}
+function writeJsonFile(filePath, data) {
+  writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`);
+}
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
 async function findSpecFiles(cwd, patterns) {
   const files = await Promise.all(
     patterns.map((pattern) => glob(pattern, { absolute: true, cwd, nodir: true }))
   );
-  return files.flat().sort((left, right) => left.localeCompare(right));
+  return [...new Set(files.flat())].sort((left, right) => left.localeCompare(right));
 }
-function createStepsImportPath(outPath, stepsPath) {
-  const relativePath = toPosixPath(path.relative(path.dirname(outPath), stepsPath));
+function createExtensionlessImportPath(outPath, targetPath) {
+  const relativePath = toPosixPath(path.relative(path.dirname(outPath), targetPath));
   const extension = path.extname(relativePath);
   const extensionlessPath = extension ? relativePath.slice(0, -extension.length) : relativePath;
   if (extensionlessPath.startsWith(".")) {
@@ -253,9 +788,15 @@ function requireFlagValue(args2, flag) {
   }
   return value;
 }
+function isFlagValue(args2, index, flags) {
+  return flags.includes(args2[index - 1] ?? "");
+}
 function toPosixPath(value) {
   return value.split(path.sep).join(path.posix.sep);
 }
+function sourcePathSlug(sourcePath) {
+  return sourcePath.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
 
 // src/shared/resolve/repoRoot.ts
 import { resolve as resolve3 } from "node:path";
@@ -364,12 +905,12 @@ import { existsSync as existsSync4, statSync } from "fs";
 import { isAbsolute, resolve as resolve4 } from "path";
 
 // src/shared/util/workspacePackages.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { basename, dirname as dirname4, join as join3 } from "path";
 import { globSync } from "glob";
 function workspacePackageFromPackageJson(repoRoot, relativePackageJson) {
   const packageJsonPath = join3(repoRoot, relativePackageJson);
-  const manifest = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
   const relativeRoot = toPosix(dirname4(relativePackageJson));
   return {
     ...manifest.name ? { manifestName: manifest.name } : {},
@@ -383,7 +924,7 @@ function pnpmWorkspaceGlobs(repoRoot) {
   if (!existsSync3(workspacePath)) {
     return [];
   }
-  const lines = readFileSync(workspacePath, "utf-8").split(/\r?\n/);
+  const lines = readFileSync2(workspacePath, "utf-8").split(/\r?\n/);
   const packageGlobs = [];
   let inPackagesBlock = false;
   for (const line of lines) {
@@ -409,7 +950,7 @@ function packageJsonWorkspaceGlobs(repoRoot) {
   if (!existsSync3(packageJsonPath)) {
     return [];
   }
-  const manifest = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
   if (Array.isArray(manifest.workspaces)) {
     return manifest.workspaces;
   }
@@ -442,7 +983,7 @@ function listWorkspacePackages(repoRoot) {
   const packages = [];
   const packageJsons = discoverWorkspacePackageJsons(repoRoot);
   if (shouldIncludeRootPackage(repoRoot, packageJsons)) {
-    const packageJson = JSON.parse(readFileSync(join3(repoRoot, "package.json"), "utf-8"));
+    const packageJson = JSON.parse(readFileSync2(join3(repoRoot, "package.json"), "utf-8"));
     packages.push({
       ...packageJson.name ? { manifestName: packageJson.name } : {},
       name: packageJson.name?.split("/").pop() ?? "root",
@@ -560,7 +1101,7 @@ import { basename as basename3, join as join8 } from "path";
 import { basename as basename2 } from "path";
 
 // src/organize/cohesion/imports/parse.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import * as ts2 from "typescript";
 
 // src/organize/cohesion/imports/scriptKind.ts
@@ -601,7 +1142,7 @@ function extractImports(sourceFile) {
 }
 function parseFileImports(filePath, fileName) {
   try {
-    const fileContent = readFileSync2(filePath, "utf-8");
+    const fileContent = readFileSync3(filePath, "utf-8");
     const scriptKind = getScriptKind(fileName);
     const sourceFile = ts2.createSourceFile(
       fileName,
@@ -638,7 +1179,7 @@ function resolveImportTarget(fromFile, specifier, candidatePaths) {
 }
 
 // src/config/quality.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { isAbsolute as isAbsolute2, join as join6, matchesGlob, relative as relative2, resolve as resolve5 } from "path";
 
 // src/config/patterns.ts
@@ -676,7 +1217,7 @@ var DEFAULT_REPORTS_DIR = "reports/quality-tools";
 function loadQualityConfig(repoRoot) {
   const configPath = join6(repoRoot, CONFIG_FILE);
   try {
-    return JSON.parse(readFileSync3(configPath, "utf-8"));
+    return JSON.parse(readFileSync4(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -1223,7 +1764,7 @@ function extractFunctions(sourceFile) {
 }
 
 // src/crap/analysis/fileSelection.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import * as path2 from "path";
 import * as ts7 from "typescript";
 function matchesFilterScope(relativePath, filterScope) {
@@ -1254,7 +1795,7 @@ function shouldIncludeFile(filePath, filterScope, repoRoot) {
 function createSourceFile3(filePath) {
   return ts7.createSourceFile(
     filePath,
-    readFileSync4(filePath, "utf-8"),
+    readFileSync5(filePath, "utf-8"),
     ts7.ScriptTarget.Latest,
     true,
     filePath.endsWith(".tsx") ? ts7.ScriptKind.TSX : ts7.ScriptKind.TS
@@ -1406,12 +1947,12 @@ function createCoverageProfiles(repoRoot, target) {
 }
 
 // src/crap/coverage/read.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 function readCoverageReport(path4) {
   if (!existsSync7(path4)) {
     throw new Error(`Coverage data not found: ${path4}`);
   }
-  return JSON.parse(readFileSync5(path4, "utf-8"));
+  return JSON.parse(readFileSync6(path4, "utf-8"));
 }
 
 // src/crap/report.ts
@@ -1592,9 +2133,9 @@ function copySharedMutationReports(reportKey, repoRoot = process.cwd()) {
 }
 
 // src/mutation/reporting/check.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 function findMutationSiteViolations(reportPath, threshold = 50) {
-  const report = JSON.parse(readFileSync6(reportPath, "utf-8"));
+  const report = JSON.parse(readFileSync7(reportPath, "utf-8"));
   return Object.entries(report.files ?? {}).map(([file, entry]) => ({ count: (entry.mutants ?? []).length, file })).filter((entry) => entry.count > threshold).sort((left, right) => right.count - left.count);
 }
 function reportMutationSiteViolations(reportPath, threshold = 50) {
@@ -1952,7 +2493,7 @@ import { join as join16 } from "path";
 import { relative as relative7 } from "path";
 
 // src/organize/rules.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { join as join14 } from "path";
 var DEFAULT_CONFIG2 = {
   lowInfoNames: {
@@ -1979,7 +2520,7 @@ function mergeConfig(defaults, overrides) {
 function loadOrganizeConfig(repoRoot, packageName) {
   const configPath = join14(repoRoot, CONFIG_FILE3);
   try {
-    const rawConfig = JSON.parse(readFileSync7(configPath, "utf-8"));
+    const rawConfig = JSON.parse(readFileSync8(configPath, "utf-8"));
     const defaultConfig = rawConfig.defaults?.organize;
     const packageConfig = packageName ? rawConfig.packages?.[packageName]?.organize : void 0;
     const mergedDefaults = defaultConfig ? mergeConfig(DEFAULT_CONFIG2, defaultConfig) : DEFAULT_CONFIG2;
@@ -2164,7 +2705,7 @@ function shouldStartNewToken(previous, current, next) {
 }
 
 // src/organize/naming/tokenize.ts
-function tokenize(name) {
+function tokenize2(name) {
   const withoutExtension = stripExtension(name);
   const characters = Array.from(withoutExtension);
   const tokens = [];
@@ -2195,7 +2736,7 @@ function tokenize(name) {
 function buildPrefixGroups(fileNames) {
   const groups = /* @__PURE__ */ new Map();
   for (const fileName of fileNames) {
-    const tokens = tokenize(fileName);
+    const tokens = tokenize2(fileName);
     if (tokens.length > 0) {
       const prefix = tokens[0];
       if (!groups.has(prefix)) {
@@ -2209,7 +2750,7 @@ function buildPrefixGroups(fileNames) {
 function countFirstTokens(fileNames) {
   const tokenCounts = /* @__PURE__ */ new Map();
   for (const fileName of fileNames) {
-    const tokens = tokenize(fileName);
+    const tokens = tokenize2(fileName);
     if (tokens.length > 0) {
       const token = tokens[0];
       tokenCounts.set(token, (tokenCounts.get(token) ?? 0) + 1);
@@ -2413,9 +2954,9 @@ function isConventionalEntryFile(filePath, ancestorFolders) {
     return false;
   }
   const hookName = fileStem.slice(3);
-  const hookTokens = tokenize(hookName);
+  const hookTokens = tokenize2(hookName);
   return hookTokens.some((hookToken) => ancestorFolders.some((folder) => {
-    const folderTokens = tokenize(folder);
+    const folderTokens = tokenize2(folder);
     return folderTokens.includes(hookToken);
   }));
 }
@@ -2426,13 +2967,13 @@ function pathRedundancy(filePath, ancestorFolders) {
     return 0;
   }
   const fileName = basename5(filePath);
-  const fileTokens = tokenize(fileName);
+  const fileTokens = tokenize2(fileName);
   if (fileTokens.length === 0) {
     return 0;
   }
   const ancestorTokens = /* @__PURE__ */ new Set();
   for (const folder of ancestorFolders) {
-    const folderTokens = tokenize(folder);
+    const folderTokens = tokenize2(folder);
     for (const token of folderTokens) {
       ancestorTokens.add(token);
     }
@@ -2458,7 +2999,7 @@ function computeAverageRedundancy(fileNames, ancestorFolders) {
 }
 
 // src/organize/analyze/issues.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 
 // src/organize/metric/naming/details.ts
 var LOW_INFO_NAME_DETAILS = {
@@ -2600,7 +3141,7 @@ function collectFileIssues(fileNames, directoryPath, ancestorFolders, lowInfoNam
     }
     try {
       const filePath = `${directoryPath}/${fileName}`;
-      const fileContent = readFileSync8(filePath, "utf-8");
+      const fileContent = readFileSync9(filePath, "utf-8");
       const barrelIssue = checkBarrelFile(fileName, fileContent);
       if (barrelIssue) {
         issues.push(barrelIssue);
@@ -2653,7 +3194,7 @@ function analyze(target) {
 }
 
 // src/organize/compare/baseline.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 
 // src/organize/compare/verdict.ts
 function verdictFromDeltas(fileFanOutDelta, folderFanOutDelta, clusterCountDelta, issueCountDelta, redundancyDelta) {
@@ -2689,7 +3230,7 @@ function baselineMetricsByPath(baseline2) {
   return new Map(baseline2.map((metric) => [metric.directoryPath, metric]));
 }
 function compareBaseline(current, baselinePath) {
-  const baselineData = JSON.parse(readFileSync9(baselinePath, "utf-8"));
+  const baselineData = JSON.parse(readFileSync10(baselinePath, "utf-8"));
   const previousByPath = baselineMetricsByPath(baselineData);
   const comparisons = /* @__PURE__ */ new Map();
   for (const metric of current) {
@@ -2984,7 +3525,7 @@ import * as fs2 from "fs";
 import * as ts25 from "typescript";
 
 // src/scrap/test/discovery/files.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 
 // src/scrap/test/discovery/globs.ts
 import { globSync as globSync2 } from "glob";
@@ -3092,7 +3633,7 @@ function discoverTestFiles(target) {
   return packageNamesForTarget(target, REPO_ROOT).flatMap((packageName) => discoverPackageTestFiles(packageName, REPO_ROOT)).filter((filePath) => isInsideTarget(target, REPO_ROOT, filePath));
 }
 function readBaselineMetrics(baselinePath) {
-  return JSON.parse(readFileSync10(baselinePath, "utf-8"));
+  return JSON.parse(readFileSync11(baselinePath, "utf-8"));
 }
 function baselineMetricsByPath2(baseline2) {
   return new Map(