@selfcure/analyzer 0.1.0

package/dist/index.js

@@ -0,0 +1,1483 @@
+// src/tml/schema.ts
+var TML_LABELS = {
+  0: "unusable",
+  1: "fragile",
+  2: "usable",
+  3: "stable",
+  4: "governed"
+};
+
+// src/tml/score.ts
+function computeStaticCeiling(input) {
+  const { testabilityScore, ambiguous, bestStrategy, inventory } = input;
+  if (testabilityScore <= 10) return 0;
+  if (ambiguous) return 1;
+  if (bestStrategy === "css" || bestStrategy === "xpath") return 1;
+  if (bestStrategy === "id" || bestStrategy === "aria-label" || bestStrategy === "name") return 2;
+  if (bestStrategy === "data-testid") {
+    if (!inventory) return 3;
+    if (inventory.isDuplicate || inventory.isDeprecated || !inventory.namingValid) return 2;
+    if (inventory.hasOwner && inventory.hasIntent) return 4;
+    return 3;
+  }
+  return 1;
+}
+function computeCeilingLevel(input) {
+  let level = computeStaticCeiling(input);
+  if (input.runtime) {
+    if (!input.runtime.observed) {
+      if (level > 2) level = 2;
+    } else if (!input.runtime.unique) {
+      if (level > 1) level = 1;
+    }
+  }
+  return level;
+}
+function buildReasons(input, level) {
+  const { testabilityScore, ambiguous, bestStrategy, inventory, runtime } = input;
+  const reasons = [];
+  if (bestStrategy === "data-testid" && !ambiguous) {
+    reasons.push({
+      code: "stable-testid",
+      severity: "info",
+      message: "Governed data-testid provides a stable, refactor-proof locator."
+    });
+  } else if (bestStrategy === "aria-label" || bestStrategy === "id" || bestStrategy === "name") {
+    reasons.push({
+      code: "strong-role-name",
+      severity: "info",
+      message: `Selector uses ${bestStrategy} \u2014 stable but can drift on copy-changes.`
+    });
+  }
+  if (bestStrategy !== "data-testid") {
+    reasons.push({
+      code: "missing-testid",
+      severity: level <= 1 ? "error" : "warning",
+      message: "No data-testid found. Adding one raises the ceiling to TML 3."
+    });
+  }
+  if (bestStrategy === "css" || bestStrategy === "xpath") {
+    reasons.push({
+      code: "weak-css-selector",
+      severity: "error",
+      message: `Best available selector is ${bestStrategy} (score ${testabilityScore}) \u2014 brittle under refactoring.`
+    });
+  }
+  if (ambiguous) {
+    reasons.push({
+      code: "ambiguous-selector",
+      severity: "error",
+      message: "Best selector matches multiple siblings \u2014 Playwright would resolve to several nodes."
+    });
+  }
+  if (testabilityScore <= 10) {
+    reasons.push({
+      code: "missing-accessible-name",
+      severity: "error",
+      message: "Element has no accessible name, role, or identifier \u2014 not reliably targetable."
+    });
+  }
+  if (inventory) {
+    if (inventory.isDuplicate) {
+      reasons.push({ code: "duplicate-testid", severity: "error", message: "data-testid is shared with another element \u2014 violates the stable selector contract." });
+    }
+    if (inventory.isDeprecated) {
+      reasons.push({ code: "deprecated-testid", severity: "warning", message: "data-testid is marked deprecated in the inventory." });
+    }
+    if (!inventory.namingValid) {
+      reasons.push({ code: "invalid-testid-name", severity: "warning", message: "data-testid does not follow the configured naming convention." });
+    }
+    if (!inventory.hasOwner) {
+      reasons.push({ code: "missing-owner", severity: "info", message: "No owner in inventory \u2014 add to enable TML 4 governance." });
+    }
+    if (!inventory.hasIntent) {
+      reasons.push({ code: "missing-intent", severity: "info", message: "No intent in inventory \u2014 add to enable TML 4 governance." });
+    }
+  }
+  if (runtime) {
+    if (!runtime.observed) {
+      reasons.push({ code: "runtime-not-observed", severity: "warning", message: "Element was not found in the rendered DOM during runtime discovery." });
+    } else if (runtime.unique) {
+      reasons.push({ code: "runtime-unique", severity: "info", message: "Locator resolved to exactly one element in the rendered DOM." });
+    }
+  }
+  return reasons;
+}
+function buildChanges(input, level) {
+  const { bestStrategy, ambiguous, inventory, label, elementType } = input;
+  const changes = [];
+  if (bestStrategy !== "data-testid") {
+    const suggestion = deriveTestIdSuggestion(label, elementType);
+    changes.push({
+      type: "add-testid",
+      priority: level === 0 ? "high" : level === 1 ? "high" : "medium",
+      description: "Add a governed data-testid to raise the ceiling to TML 3.",
+      suggestedValue: suggestion,
+      patchAvailable: true
+    });
+  }
+  if (ambiguous) {
+    changes.push({
+      type: "add-testid",
+      priority: "high",
+      description: "Selector is ambiguous. Add a unique data-testid to resolve to a single element.",
+      patchAvailable: true
+    });
+  }
+  if (!inventory || !inventory.hasOwner && !inventory.hasIntent) {
+    changes.push({
+      type: "add-inventory-entry",
+      priority: level >= 3 ? "medium" : "low",
+      description: "Register in .selfcure/testid-inventory.json (with owner + intent) to reach TML 4."
+    });
+  }
+  if (inventory) {
+    if (!inventory.hasOwner) {
+      changes.push({ type: "add-owner", priority: "medium", description: "Add owner field to the inventory entry." });
+    }
+    if (!inventory.hasIntent) {
+      changes.push({ type: "add-intent", priority: "medium", description: "Add intent field to the inventory entry." });
+    }
+    if (inventory.isDuplicate) {
+      changes.push({ type: "dedupe-testid", priority: "high", description: "Rename or scope the data-testid so it is unique across the codebase." });
+    }
+    if (inventory.isDeprecated) {
+      changes.push({ type: "rename-testid", priority: "high", description: "Replace the deprecated data-testid with a current one from the inventory." });
+    }
+  }
+  return changes;
+}
+function toKebab(s) {
+  return s.trim().replace(/([A-Z])/g, "-$1").replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function deriveTestIdSuggestion(label, elementType) {
+  if (label) return toKebab(label);
+  return `${elementType}-1`;
+}
+function computeConfidence(input) {
+  let c = 0.9;
+  if (!input.runtime) c -= 0.1;
+  if (!input.inventory) c -= 0.05;
+  if (input.ambiguous) c += 0.05;
+  return Math.min(1, Math.max(0.5, Math.round(c * 100) / 100));
+}
+function assessTagMaturity(input) {
+  const level = computeCeilingLevel(input);
+  const label = TML_LABELS[level];
+  const reasons = buildReasons(input, level);
+  const changes = buildChanges(input, level);
+  const confidence = computeConfidence(input);
+  return {
+    level,
+    label,
+    score: input.testabilityScore,
+    reasons,
+    requiredChanges: changes,
+    confidence
+  };
+}
+
+// src/testids/inventory.ts
+import { readFile } from "fs/promises";
+var VALID_STATUSES = ["active", "deprecated", "removed"];
+var VALID_STABILITIES = ["stable", "unstable", "dynamic"];
+function parseInventory(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return { ok: false, errors: ["Invalid JSON: could not parse inventory file"] };
+  }
+  const errors = validateInventory(data);
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, inventory: normalizeInventory(data) };
+}
+async function loadInventory(filePath) {
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, errors: [`Cannot read inventory file: ${msg}`] };
+  }
+  return parseInventory(raw);
+}
+function allTestIds(inventory) {
+  const seen = /* @__PURE__ */ new Set();
+  const ids = [];
+  for (const route of inventory.routes) {
+    for (const el of route.elements) {
+      if (!seen.has(el.testId)) {
+        seen.add(el.testId);
+        ids.push(el.testId);
+      }
+    }
+  }
+  return ids;
+}
+function validateInventory(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return ["Root must be a JSON object"];
+  }
+  const obj = data;
+  const errors = [];
+  if (typeof obj["version"] !== "string" || !obj["version"]) {
+    errors.push('"version" must be a non-empty string');
+  }
+  if (typeof obj["app"] !== "string" || !obj["app"]) {
+    errors.push('"app" must be a non-empty string');
+  }
+  if (!Array.isArray(obj["routes"])) {
+    errors.push('"routes" must be an array');
+    return errors;
+  }
+  for (let i = 0; i < obj["routes"].length; i++) {
+    errors.push(...validateRoute(obj["routes"][i], i));
+  }
+  return errors;
+}
+function validateRoute(data, index) {
+  const prefix = `routes[${index}]`;
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return [`${prefix} must be an object`];
+  }
+  const obj = data;
+  const errors = [];
+  if (typeof obj["path"] !== "string" || !obj["path"]) {
+    errors.push(`${prefix}.path must be a non-empty string`);
+  }
+  if (!Array.isArray(obj["elements"])) {
+    errors.push(`${prefix}.elements must be an array`);
+    return errors;
+  }
+  for (let j = 0; j < obj["elements"].length; j++) {
+    errors.push(...validateElement(obj["elements"][j], index, j));
+  }
+  return errors;
+}
+function validateElement(data, ri, ei) {
+  const prefix = `routes[${ri}].elements[${ei}]`;
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return [`${prefix} must be an object`];
+  }
+  const obj = data;
+  const errors = [];
+  if (typeof obj["testId"] !== "string" || !obj["testId"].trim()) {
+    errors.push(`${prefix}.testId must be a non-empty string`);
+  }
+  if (obj["status"] !== void 0 && !VALID_STATUSES.includes(obj["status"])) {
+    errors.push(`${prefix}.status must be one of: ${VALID_STATUSES.join(", ")}`);
+  }
+  if (obj["stability"] !== void 0 && !VALID_STABILITIES.includes(obj["stability"])) {
+    errors.push(`${prefix}.stability must be one of: ${VALID_STABILITIES.join(", ")}`);
+  }
+  return errors;
+}
+function normalizeInventory(raw) {
+  return {
+    version: raw.version,
+    app: raw.app,
+    generatedAt: raw.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    routes: (raw.routes ?? []).map(normalizeRoute)
+  };
+}
+function normalizeRoute(raw) {
+  const result = {
+    path: raw.path,
+    elements: (raw.elements ?? []).map(normalizeElement)
+  };
+  if (raw.screen !== void 0) result.screen = raw.screen;
+  if (raw.owner !== void 0) result.owner = raw.owner;
+  return result;
+}
+function normalizeElement(raw) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = {
+    testId: raw.testId.trim(),
+    status: raw.status ?? "active",
+    stability: raw.stability ?? "stable",
+    firstSeenAt: raw.firstSeenAt ?? now,
+    lastSeenAt: raw.lastSeenAt ?? now
+  };
+  if (raw.component !== void 0) result.component = raw.component;
+  if (raw.elementType !== void 0) result.elementType = raw.elementType;
+  if (raw.intent !== void 0) result.intent = raw.intent;
+  if (raw.label !== void 0) result.label = raw.label;
+  if (raw.sourceFile !== void 0) result.sourceFile = raw.sourceFile;
+  if (raw.pattern !== void 0) result.pattern = raw.pattern;
+  if (raw.owner !== void 0) result.owner = raw.owner;
+  return result;
+}
+
+// src/testids/naming.ts
+var SEGMENT_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var GENERIC_SINGLE_SEGMENTS = /* @__PURE__ */ new Set([
+  "button",
+  "submit",
+  "close",
+  "open",
+  "cancel",
+  "confirm",
+  "save",
+  "input",
+  "form",
+  "link",
+  "modal",
+  "dialog",
+  "dropdown",
+  "menu",
+  "tab",
+  "panel",
+  "card",
+  "item",
+  "row",
+  "cell",
+  "table",
+  "list"
+]);
+var GENERIC_MULTI = /* @__PURE__ */ new Set([
+  "button-submit",
+  "modal-close",
+  "input-email",
+  "submit-button",
+  "close-button",
+  "cancel-button",
+  "confirm-button",
+  "save-button"
+]);
+function checkNaming(testId) {
+  const segments = testId.split(".");
+  if (segments.length === 1) {
+    if (GENERIC_SINGLE_SEGMENTS.has(testId) || GENERIC_MULTI.has(testId)) {
+      return { testId, rule: "generic-name", reason: "Single-segment name is too generic to be stable" };
+    }
+    return { testId, rule: "invalid-name", reason: "Must use dot-separated segments: <domain>.<screen>.<element>" };
+  }
+  for (const segment of segments) {
+    if (!SEGMENT_RE.test(segment)) {
+      return {
+        testId,
+        rule: "invalid-name",
+        reason: `Segment "${segment}" is invalid \u2014 use lowercase letters, digits, and hyphens only`
+      };
+    }
+  }
+  if (GENERIC_MULTI.has(testId)) {
+    return { testId, rule: "generic-name", reason: "Name is too generic to be stable" };
+  }
+  return null;
+}
+function isValidTestId(testId) {
+  return checkNaming(testId) === null;
+}
+
+// src/testids/audit.ts
+var SEVERITY = {
+  "duplicate-testid": "error",
+  "test-only-selector": "error",
+  "deprecated-used": "error",
+  "missing-inventory": "warning",
+  "orphaned-inventory": "warning",
+  "invalid-name": "warning",
+  "generic-name": "warning",
+  "missing-owner": "warning"
+};
+function audit(inventory, usages) {
+  const issues = [];
+  const frontendMap = /* @__PURE__ */ new Map();
+  const testMap = /* @__PURE__ */ new Map();
+  for (const u of usages) {
+    const loc = `${u.filePath}:${u.line}`;
+    const map = u.kind === "frontend" ? frontendMap : testMap;
+    const locs = map.get(u.value) ?? [];
+    locs.push(loc);
+    map.set(u.value, locs);
+  }
+  const inventoryMeta = /* @__PURE__ */ new Map();
+  for (const route of inventory.routes) {
+    for (const el of route.elements) {
+      inventoryMeta.set(el.testId, {
+        status: el.status,
+        owner: el.owner ?? route.owner
+      });
+    }
+  }
+  for (const [testId, locs] of frontendMap) {
+    if (locs.length > 1) {
+      issues.push({
+        rule: "duplicate-testid",
+        severity: SEVERITY["duplicate-testid"],
+        testId,
+        locations: locs
+      });
+    }
+  }
+  for (const [testId, locs] of testMap) {
+    if (!frontendMap.has(testId)) {
+      issues.push({
+        rule: "test-only-selector",
+        severity: SEVERITY["test-only-selector"],
+        testId,
+        locations: locs
+      });
+    }
+  }
+  for (const [testId, locs] of frontendMap) {
+    if (!inventoryMeta.has(testId)) {
+      issues.push({
+        rule: "missing-inventory",
+        severity: SEVERITY["missing-inventory"],
+        testId,
+        locations: locs
+      });
+    }
+  }
+  for (const [testId, meta] of inventoryMeta) {
+    if (meta.status === "removed") continue;
+    if (!frontendMap.has(testId)) {
+      issues.push({
+        rule: "orphaned-inventory",
+        severity: SEVERITY["orphaned-inventory"],
+        testId
+      });
+    }
+  }
+  for (const [testId, locs] of frontendMap) {
+    const meta = inventoryMeta.get(testId);
+    if (meta?.status === "deprecated") {
+      issues.push({
+        rule: "deprecated-used",
+        severity: SEVERITY["deprecated-used"],
+        testId,
+        locations: locs
+      });
+    }
+  }
+  const allObserved = /* @__PURE__ */ new Set([...frontendMap.keys(), ...testMap.keys()]);
+  for (const testId of allObserved) {
+    const violation = checkNaming(testId);
+    if (violation) {
+      issues.push({
+        rule: violation.rule,
+        severity: SEVERITY[violation.rule],
+        testId,
+        message: violation.reason
+      });
+    }
+  }
+  for (const [testId, meta] of inventoryMeta) {
+    if (!meta.owner) {
+      issues.push({
+        rule: "missing-owner",
+        severity: SEVERITY["missing-owner"],
+        testId
+      });
+    }
+  }
+  const summary = {
+    totalObserved: frontendMap.size,
+    duplicates: count(issues, "duplicate-testid"),
+    missingInventory: count(issues, "missing-inventory"),
+    orphaned: count(issues, "orphaned-inventory"),
+    testOnlySelectors: count(issues, "test-only-selector"),
+    invalidNames: count(issues, "invalid-name") + count(issues, "generic-name")
+  };
+  return { summary, issues };
+}
+function count(issues, rule) {
+  return issues.filter((i) => i.rule === rule).length;
+}
+
+// src/a11y/rules.ts
+var SEVERITY_ORDER = ["info", "minor", "major", "critical"];
+var LEVEL_HIERARCHY = {
+  A: ["A"],
+  AA: ["A", "AA"],
+  AAA: ["A", "AA", "AAA"]
+};
+var accessibilityRules = [
+  // ── Level A — perceivable ─────────────────────────────────────────────────
+  {
+    id: "a11y.img-alt-text",
+    wcag: ["1.1.1"],
+    level: "A",
+    category: "perceivable",
+    severity: "major",
+    source: "static",
+    paid: true,
+    title: "Image must have alternative text",
+    description: 'Images must have an alt attribute. Informative images need descriptive alt text. Decorative images must use alt="" so assistive technology skips them.',
+    remediation: 'Add an alt attribute with descriptive text for informative images (alt="User profile photo") or alt="" for decorative images.'
+  },
+  {
+    id: "a11y.input-associated-label",
+    wcag: ["1.3.1", "3.3.2", "4.1.2"],
+    level: "A",
+    category: "perceivable",
+    severity: "critical",
+    source: "static",
+    paid: true,
+    title: "Input must have an associated label",
+    description: "Form inputs must be associated with a label element via htmlFor/for or element wrapping, or provide aria-label/aria-labelledby so assistive technology can identify the field.",
+    remediation: 'Add <label htmlFor="inputId">, wrap the input inside a <label>, or add an aria-label or aria-labelledby attribute.'
+  },
+  // ── Level A — operable ────────────────────────────────────────────────────
+  {
+    id: "a11y.positive-tabindex",
+    wcag: ["2.4.3"],
+    level: "A",
+    category: "operable",
+    severity: "major",
+    source: "static",
+    paid: true,
+    title: "tabIndex must not be positive",
+    description: "Positive tabIndex values (tabIndex > 0) disrupt the natural focus order of the page and create a confusing keyboard navigation experience for keyboard-only users.",
+    remediation: "Remove the positive tabIndex or use tabIndex={0} to include the element in the natural tab order. Control focus sequence with DOM order and CSS instead."
+  },
+  {
+    id: "a11y.noninteractive-click-handler",
+    wcag: ["2.1.1", "4.1.2"],
+    level: "A",
+    category: "operable",
+    severity: "major",
+    source: "static",
+    paid: true,
+    title: "Non-interactive element must not have a click handler without keyboard support",
+    description: "Adding onClick to a non-interactive element (div, span, p) without a keyboard equivalent means keyboard-only users and screen reader users cannot trigger the action.",
+    remediation: 'Use an interactive element like <button> or <a>. If a div must be clickable, also add role="button", tabIndex={0}, and an onKeyDown handler for Enter and Space.'
+  },
+  {
+    id: "a11y.link-accessible-name",
+    wcag: ["4.1.2", "2.4.4"],
+    level: "A",
+    category: "operable",
+    severity: "critical",
+    source: "static",
+    paid: true,
+    title: "Link must have an accessible name",
+    description: "Anchor elements used for navigation must have descriptive link text, aria-label, or aria-labelledby so users understand where the link leads.",
+    remediation: 'Add descriptive text content inside the <a> element, or use aria-label to provide an accessible name. Avoid generic text like "click here" or "read more".'
+  },
+  // ── Level A — robust ──────────────────────────────────────────────────────
+  {
+    id: "a11y.button-accessible-name",
+    wcag: ["4.1.2", "2.5.3"],
+    level: "A",
+    category: "robust",
+    severity: "critical",
+    source: "static",
+    paid: true,
+    title: "Button must have an accessible name",
+    description: "Interactive buttons need visible text, aria-label, aria-labelledby, or an equivalent accessible name so screen readers and voice control users can identify and activate them.",
+    remediation: "Add visible text inside the button element, or an explicit aria-label or aria-labelledby attribute that matches the visible label or user-facing intent."
+  },
+  {
+    id: "a11y.aria-invalid-reference",
+    wcag: ["4.1.2"],
+    level: "A",
+    category: "robust",
+    severity: "critical",
+    source: "static",
+    paid: true,
+    title: "ARIA attribute must reference a valid element ID",
+    description: "Attributes like aria-labelledby, aria-describedby, and aria-controls must reference IDs that exist in the DOM. Broken references are silently ignored by assistive technology.",
+    remediation: "Ensure the referenced ID exists and is spelled correctly. If the referenced element is conditionally rendered, handle the absent case explicitly."
+  },
+  {
+    id: "a11y.missing-dialog-name",
+    wcag: ["4.1.2"],
+    level: "A",
+    category: "robust",
+    severity: "critical",
+    source: "static",
+    paid: true,
+    title: "Dialog must have an accessible name",
+    description: 'Elements with role="dialog" or role="alertdialog" must have aria-label or aria-labelledby so screen reader users understand the purpose of the dialog when it opens.',
+    remediation: "Add aria-labelledby pointing to the dialog title element, or add aria-label with a descriptive name."
+  },
+  {
+    id: "a11y.duplicate-id",
+    wcag: ["4.1.1"],
+    level: "A",
+    category: "robust",
+    severity: "critical",
+    source: "static",
+    paid: true,
+    title: "ID attribute must be unique within a page",
+    description: "Duplicate IDs break ARIA references, label associations, and fragment links. Assistive technology behaviour when encountering duplicate IDs is undefined.",
+    remediation: "Ensure all id attributes are unique within a rendered page. Generate IDs dynamically (e.g. useId()) for list items and reusable components."
+  },
+  // ── Level AA — perceivable ────────────────────────────────────────────────
+  {
+    id: "a11y.heading-order",
+    wcag: ["1.3.1", "2.4.6"],
+    level: "AA",
+    category: "perceivable",
+    severity: "minor",
+    source: "static",
+    paid: true,
+    title: "Headings must follow a logical order",
+    description: "Heading levels (h1\u2013h6) must not skip levels. An h4 following an h2 without an h3 in between breaks the document outline that screen readers use for navigation.",
+    remediation: "Ensure headings follow a sequential order. Never use heading elements purely for visual styling \u2014 use CSS instead."
+  }
+];
+function getRuleById(id) {
+  return accessibilityRules.find((r) => r.id === id);
+}
+function getRulesByLevel(targetLevel) {
+  const included = LEVEL_HIERARCHY[targetLevel];
+  return accessibilityRules.filter((r) => included.includes(r.level));
+}
+function getRulesBySeverity(minSeverity) {
+  const minIdx = SEVERITY_ORDER.indexOf(minSeverity);
+  return accessibilityRules.filter((r) => SEVERITY_ORDER.indexOf(r.severity) >= minIdx);
+}
+function filterRules(opts = {}) {
+  let rules = [...accessibilityRules];
+  if (opts.level !== void 0) {
+    const included = LEVEL_HIERARCHY[opts.level];
+    rules = rules.filter((r) => included.includes(r.level));
+  }
+  if (opts.minSeverity !== void 0) {
+    const minIdx = SEVERITY_ORDER.indexOf(opts.minSeverity);
+    rules = rules.filter((r) => SEVERITY_ORDER.indexOf(r.severity) >= minIdx);
+  }
+  if (opts.paid !== void 0) {
+    rules = rules.filter((r) => r.paid === opts.paid);
+  }
+  if (opts.source !== void 0) {
+    rules = rules.filter((r) => r.source === opts.source);
+  }
+  if (opts.category !== void 0) {
+    rules = rules.filter((r) => r.category === opts.category);
+  }
+  return rules;
+}
+
+// src/a11y/static.ts
+var _seq = 0;
+function makeFindingId() {
+  _seq += 1;
+  const ts = Date.now().toString(36);
+  const seq = _seq.toString(36).padStart(4, "0");
+  return `a11y_${ts}${seq}`;
+}
+var NON_INTERACTIVE_TAGS = /* @__PURE__ */ new Set([
+  "div",
+  "span",
+  "p",
+  "section",
+  "article",
+  "main",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "ul",
+  "ol",
+  "li",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "td",
+  "th",
+  "figure",
+  "figcaption",
+  "blockquote"
+]);
+var HEADING_TAGS = ["h1", "h2", "h3", "h4", "h5", "h6"];
+function hasAccessibleName(el) {
+  return Boolean(
+    el.hasTextChildren || el.attrs["aria-label"] || el.attrs["aria-labelledby"] || el.attrs["title"]
+  );
+}
+function buildSelector(el) {
+  if (el.attrs["data-testid"]) return `[data-testid="${el.attrs["data-testid"]}"]`;
+  if (el.attrs["id"]) return `#${el.attrs["id"]}`;
+  if (el.attrs["aria-label"]) return `${el.tag}[aria-label="${el.attrs["aria-label"]}"]`;
+  return el.tag;
+}
+function finding(ruleId, el, message) {
+  const rule = getRuleById(ruleId);
+  if (!rule) return null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: makeFindingId(),
+    ruleId,
+    wcag: rule.wcag,
+    level: rule.level,
+    severity: rule.severity,
+    status: "open",
+    sourceFile: el.filePath,
+    line: el.line,
+    column: el.column,
+    selector: buildSelector(el),
+    message,
+    remediation: rule.remediation,
+    firstSeenAt: now,
+    lastSeenAt: now
+  };
+}
+function runAllRules(evidence) {
+  const { elements, allIds } = evidence;
+  const results = [];
+  const idSet = new Set(allIds);
+  const labelHtmlFors = new Set(
+    elements.filter((e) => e.tag === "label" && e.attrs["htmlFor"] && e.attrs["htmlFor"] !== "__dynamic__").map((e) => e.attrs["htmlFor"])
+  );
+  const seenIds = /* @__PURE__ */ new Map();
+  const headingStack = [];
+  for (const el of elements) {
+    if (el.tag === "button" && !hasAccessibleName(el)) {
+      const f = finding("a11y.button-accessible-name", el, "Button has no accessible name.");
+      if (f) results.push(f);
+    }
+    if (el.tag === "a" && !hasAccessibleName(el)) {
+      const f = finding("a11y.link-accessible-name", el, "Link has no accessible name.");
+      if (f) results.push(f);
+    }
+    if (el.tag === "input" && el.attrs["type"] !== "hidden") {
+      const hasDirectName = el.attrs["aria-label"] || el.attrs["aria-labelledby"];
+      const linkedByLabel = el.attrs["id"] && labelHtmlFors.has(el.attrs["id"]);
+      if (!hasDirectName && !linkedByLabel) {
+        const f = finding("a11y.input-associated-label", el, "Input has no associated label.");
+        if (f) results.push(f);
+      }
+    }
+    if (el.tag === "img" && !("alt" in el.attrs)) {
+      const f = finding("a11y.img-alt-text", el, "Image is missing an alt attribute.");
+      if (f) results.push(f);
+    }
+    for (const ariaAttr of ["aria-labelledby", "aria-describedby", "aria-controls"]) {
+      const val = el.attrs[ariaAttr];
+      if (val && val !== "__dynamic__") {
+        for (const refId of val.split(/\s+/).filter(Boolean)) {
+          if (!idSet.has(refId)) {
+            const f = finding(
+              "a11y.aria-invalid-reference",
+              el,
+              `${ariaAttr}="${refId}" references an ID that does not exist in this file.`
+            );
+            if (f) results.push(f);
+          }
+        }
+      }
+    }
+    const rawTab = el.attrs["tabIndex"] ?? el.attrs["tabindex"];
+    if (rawTab !== void 0 && rawTab !== "__dynamic__" && rawTab !== "") {
+      const idx = Number(rawTab);
+      if (!isNaN(idx) && idx > 0) {
+        const f = finding(
+          "a11y.positive-tabindex",
+          el,
+          `tabIndex="${rawTab}" disrupts natural focus order \u2014 use 0 or -1 instead.`
+        );
+        if (f) results.push(f);
+      }
+    }
+    if (NON_INTERACTIVE_TAGS.has(el.tag) && el.attrs["onClick"] !== void 0) {
+      const hasRole = el.attrs["role"] !== void 0;
+      const hasTabIndex = el.attrs["tabIndex"] !== void 0 || el.attrs["tabindex"] !== void 0;
+      if (!hasRole || !hasTabIndex) {
+        const f = finding(
+          "a11y.noninteractive-click-handler",
+          el,
+          `<${el.tag}> has onClick but lacks role and/or tabIndex \u2014 keyboard users cannot activate it.`
+        );
+        if (f) results.push(f);
+      }
+    }
+    const role = el.attrs["role"];
+    if (role === "dialog" || role === "alertdialog") {
+      if (!el.attrs["aria-label"] && !el.attrs["aria-labelledby"]) {
+        const f = finding(
+          "a11y.missing-dialog-name",
+          el,
+          `Dialog (role="${role}") has no accessible name \u2014 add aria-label or aria-labelledby.`
+        );
+        if (f) results.push(f);
+      }
+    }
+    if (HEADING_TAGS.includes(el.tag)) {
+      const level = parseInt(el.tag[1], 10);
+      if (headingStack.length > 0) {
+        const prev = headingStack[headingStack.length - 1];
+        if (level > prev + 1) {
+          const f = finding(
+            "a11y.heading-order",
+            el,
+            `Heading level skipped: <${el.tag}> follows <h${prev}> (expected at most h${prev + 1}).`
+          );
+          if (f) results.push(f);
+        }
+      }
+      headingStack.push(level);
+    }
+    const elId = el.attrs["id"];
+    if (elId && elId !== "__dynamic__" && elId !== "") {
+      if (seenIds.has(elId)) {
+        const f = finding(
+          "a11y.duplicate-id",
+          el,
+          `ID "${elId}" is already used at line ${seenIds.get(elId)} \u2014 IDs must be unique.`
+        );
+        if (f) results.push(f);
+      } else {
+        seenIds.set(elId, el.line);
+      }
+    }
+  }
+  return results;
+}
+function runStaticAnalysis(evidenceList, opts = {}) {
+  const { level = "AA" } = opts;
+  const enabledIds = new Set(getRulesByLevel(level).map((r) => r.id));
+  return evidenceList.flatMap(runAllRules).filter((f) => enabledIds.has(f.ruleId)).sort((a, b) => a.sourceFile.localeCompare(b.sourceFile) || a.line - b.line);
+}
+
+// src/discovery/testability.ts
+function issuesForElement(el) {
+  const issues = [];
+  if (!el.testId && !el.name && !el.role) {
+    issues.push("No accessible name, role, or data-testid \u2014 selector is unstable");
+  }
+  if (!el.testId && el.score < 75) {
+    issues.push("Missing data-testid \u2014 add one for a stable 100-score locator");
+  }
+  if (el.tag === "div" || el.tag === "span") {
+    issues.push("Non-semantic interactive element \u2014 prefer <button> or <a>");
+  }
+  return issues;
+}
+function averageScore(elements) {
+  if (elements.length === 0) return 100;
+  const sum = elements.reduce((acc, el) => acc + el.score, 0);
+  return Math.round(sum / elements.length);
+}
+function buildTestabilityReport(result, minimumScore = 80) {
+  const routeResults = [];
+  for (const evidence of result.routes) {
+    const interactive = evidence.interactiveElements;
+    const findings = [];
+    for (const el of interactive) {
+      if (el.score < minimumScore) {
+        findings.push({
+          route: evidence.route,
+          url: evidence.url,
+          element: el,
+          score: el.score,
+          issues: issuesForElement(el)
+        });
+      }
+    }
+    routeResults.push({
+      route: evidence.route,
+      url: evidence.url,
+      status: evidence.status,
+      score: averageScore(interactive),
+      totalElements: interactive.length,
+      flaggedCount: findings.length,
+      findings
+    });
+  }
+  const totalElements = routeResults.reduce((s, r) => s + r.totalElements, 0);
+  const flaggedCount = routeResults.reduce((s, r) => s + r.flaggedCount, 0);
+  const overallScore = routeResults.length === 0 ? 100 : Math.round(routeResults.reduce((s, r) => s + r.score, 0) / routeResults.length);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    minimumScore,
+    routes: routeResults,
+    overall: { score: overallScore, totalElements, flaggedCount }
+  };
+}
+function summarizeReport(report) {
+  const reachable = report.routes.filter((r) => r.status === "reachable");
+  return {
+    critical: reachable.filter((r) => r.score < 60),
+    warning: reachable.filter((r) => r.score >= 60 && r.score < report.minimumScore),
+    healthy: reachable.filter((r) => r.score >= report.minimumScore)
+  };
+}
+
+// src/tml/inventory.ts
+function buildDuplicateSet(inventory) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const route of inventory.routes) {
+    for (const el of route.elements) {
+      counts.set(el.testId, (counts.get(el.testId) ?? 0) + 1);
+    }
+  }
+  return new Set([...counts.entries()].filter(([, n]) => n > 1).map(([id]) => id));
+}
+function isValidTmlNaming(testId) {
+  return /^[a-z][a-z0-9]*(\.[a-z][a-z0-9-]*){1,4}$/.test(testId);
+}
+function buildTmlInventoryEntry(testId, inventory, duplicateIds) {
+  for (const route of inventory.routes) {
+    const invEl = route.elements.find((e) => e.testId === testId);
+    if (invEl) {
+      return {
+        hasOwner: Boolean(invEl.owner ?? route.owner),
+        hasIntent: Boolean(invEl.intent),
+        hasRoute: Boolean(route.path),
+        isDeprecated: invEl.status === "deprecated" || invEl.status === "removed",
+        isDuplicate: duplicateIds.has(testId),
+        namingValid: isValidTmlNaming(testId)
+      };
+    }
+  }
+  return void 0;
+}
+function extractTestIdValue(dataTestIdSelector) {
+  if (!dataTestIdSelector) return void 0;
+  const m = dataTestIdSelector.match(/\[data-testid=["']([^"']+)["']\]/);
+  return m ? m[1] : void 0;
+}
+function enrichTmlWithInventory(results, inventory) {
+  const duplicates = buildDuplicateSet(inventory);
+  for (const { interactiveElements } of results) {
+    for (const el of interactiveElements) {
+      const rawTestId = extractTestIdValue(el.selectors.dataTestId);
+      const invEntry = rawTestId ? buildTmlInventoryEntry(rawTestId, inventory, duplicates) : void 0;
+      const best = el.selectorRanking[0];
+      el.tml = assessTagMaturity({
+        testabilityScore: el.testabilityScore,
+        ambiguous: el.ambiguous,
+        bestStrategy: best?.strategy ?? "css",
+        label: el.label,
+        elementType: el.type,
+        inventory: invEntry
+      });
+    }
+  }
+}
+
+// src/tml/runtime.ts
+function extractTestId(sel) {
+  if (!sel) return void 0;
+  const m = sel.match(/\[data-testid=["']([^"']+)["']\]/);
+  return m ? m[1] : void 0;
+}
+function extractId(sel) {
+  if (!sel) return void 0;
+  const m = sel.match(/^#(.+)$/);
+  return m ? m[1] : void 0;
+}
+function extractAriaLabel(sel) {
+  if (!sel) return void 0;
+  const m = sel.match(/\[aria-label=["']([^"']+)["']\]/);
+  return m ? m[1] : void 0;
+}
+function matchRuntime(el, routes) {
+  const reachable = routes.filter((r) => r.status === "reachable");
+  const allRt = reachable.flatMap((r) => r.interactiveElements);
+  const testId = extractTestId(el.selectors.dataTestId);
+  if (testId) {
+    const hits = allRt.filter((r) => r.testId === testId);
+    if (hits.length > 0) return { found: true, unique: hits.length === 1 };
+  }
+  const idVal = extractId(el.selectors.id);
+  if (idVal) {
+    const hits = allRt.filter((r) => r.selector === `#${idVal}`);
+    if (hits.length > 0) return { found: true, unique: hits.length === 1 };
+  }
+  const ariaLabel = extractAriaLabel(el.selectors.ariaLabel);
+  const nameToMatch = ariaLabel ?? el.label;
+  if (nameToMatch) {
+    const hits = allRt.filter(
+      (r) => r.name === nameToMatch || r.selector === `[aria-label="${nameToMatch}"]`
+    );
+    if (hits.length > 0) return { found: true, unique: hits.length === 1 };
+  }
+  return { found: false, unique: false };
+}
+function enrichTmlWithRuntime(results, runtimeMap, inventory) {
+  const duplicates = inventory ? buildDuplicateSet(inventory) : /* @__PURE__ */ new Set();
+  for (const { interactiveElements } of results) {
+    for (const el of interactiveElements) {
+      const match = matchRuntime(el, runtimeMap.routes);
+      const testId = extractTestId(el.selectors.dataTestId);
+      let invEntry;
+      if (inventory && testId) {
+        invEntry = buildTmlInventoryEntry(testId, inventory, duplicates);
+      }
+      const best = el.selectorRanking[0];
+      el.tml = assessTagMaturity({
+        testabilityScore: el.testabilityScore,
+        ambiguous: el.ambiguous,
+        bestStrategy: best?.strategy ?? "css",
+        label: el.label,
+        elementType: el.type,
+        inventory: invEntry,
+        runtime: {
+          observed: match.found,
+          unique: match.unique
+        }
+      });
+    }
+  }
+}
+async function loadRuntimeMap(filePath) {
+  const { readFile: readFile3 } = await import("fs/promises");
+  const raw = await readFile3(filePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed["routes"])) {
+    throw new Error(`Invalid route-map.json at ${filePath}`);
+  }
+  return parsed;
+}
+
+// src/a11y/findings.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import path from "path";
+function parseFindings(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return { ok: false, errors: ["Invalid JSON: could not parse findings file"] };
+  }
+  const errors = validateFindings(data);
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, inventory: data };
+}
+function validateFindings(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return ["Root must be a JSON object"];
+  }
+  const obj = data;
+  const errors = [];
+  if (typeof obj["version"] !== "string") errors.push('"version" must be a string');
+  if (typeof obj["app"] !== "string") errors.push('"app" must be a string');
+  if (obj["standard"] !== "WCAG") errors.push('"standard" must be "WCAG"');
+  if (!Array.isArray(obj["findings"])) errors.push('"findings" must be an array');
+  return errors;
+}
+async function loadFindings(filePath) {
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, errors: [`Cannot read findings file: ${msg}`] };
+  }
+  return parseFindings(raw);
+}
+async function saveFindings(filePath, inventory) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(inventory, null, 2), "utf-8");
+}
+function emptyInventory(opts) {
+  return {
+    version: "1.0",
+    app: opts.app,
+    standard: "WCAG",
+    targetLevel: opts.targetLevel ?? "AA",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    findings: []
+  };
+}
+function mergeFindings(existing, newFindings) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newByKey = /* @__PURE__ */ new Map();
+  for (const f of newFindings) {
+    newByKey.set(findingKey(f), f);
+  }
+  const merged = [];
+  for (const f of existing.findings) {
+    if (f.status === "suppressed") {
+      merged.push(f);
+      newByKey.delete(findingKey(f));
+      continue;
+    }
+    const key = findingKey(f);
+    if (newByKey.has(key)) {
+      merged.push({ ...f, status: "open", lastSeenAt: now });
+      newByKey.delete(key);
+    } else if (f.status === "open") {
+      merged.push({ ...f, status: "resolved", lastSeenAt: now });
+    } else {
+      merged.push(f);
+    }
+  }
+  for (const f of newByKey.values()) {
+    merged.push({ ...f, status: "open", firstSeenAt: now, lastSeenAt: now });
+  }
+  return { ...existing, generatedAt: now, findings: merged };
+}
+function findingKey(f) {
+  return `${f.ruleId}::${f.sourceFile}::${f.line}::${f.column}`;
+}
+
+// src/a11y/audit.ts
+function runAudit(inventory, opts = {}) {
+  const { failOn = "major" } = opts;
+  const failOnIdx = SEVERITY_ORDER.indexOf(failOn);
+  const open = inventory.findings.filter((f) => f.status === "open");
+  const resolved = inventory.findings.filter((f) => f.status === "resolved");
+  const suppressed = inventory.findings.filter((f) => f.status === "suppressed");
+  const bySeverity = { critical: 0, major: 0, minor: 0, info: 0 };
+  for (const f of open) bySeverity[f.severity]++;
+  const wouldFailCI = open.some(
+    (f) => SEVERITY_ORDER.indexOf(f.severity) >= failOnIdx
+  );
+  return {
+    findings: inventory.findings,
+    counts: {
+      open: open.length,
+      resolved: resolved.length,
+      suppressed: suppressed.length,
+      bySeverity
+    },
+    wouldFailCI
+  };
+}
+
+// src/ide-prompt.ts
+var DEFAULT_CONVENTION = "[component]-[type]-[purpose] in kebab-case (e.g. checkout-select-payment-method)";
+function relPath(filePath, baseDir) {
+  let p = filePath;
+  if (baseDir && p.startsWith(baseDir)) {
+    p = p.slice(baseDir.length).replace(/^[/\\]+/, "");
+  }
+  return p.replace(/\\/g, "/");
+}
+function lineFor(issue) {
+  const loc = issue.line ? `L${issue.line} \xB7 ` : "";
+  const where = issue.selector ? ` matched by \`${issue.selector}\`` : "";
+  const reason = issue.kind === "ambiguous" ? issue.ambiguityReason ? `ambiguous \u2014 ${issue.ambiguityReason.replace(/\.\s*$/, "")}` : "ambiguous \u2014 its best selector also matches a sibling" : "no stable selector (low testability)";
+  return `- ${loc}the \`${issue.elementType}\` element${where} \u2014 ${reason}. Add \`data-testid="${issue.suggestedTestId}"\`.`;
+}
+function buildIdePrompt(issues, opts = {}) {
+  if (issues.length === 0) return "";
+  const convention = opts.convention ?? DEFAULT_CONVENTION;
+  const byFile = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const key = relPath(issue.filePath, opts.baseDir);
+    if (!byFile.has(key)) byFile.set(key, []);
+    byFile.get(key).push(issue);
+  }
+  const fileBlocks = [];
+  for (const [file, fileIssues] of byFile) {
+    fileBlocks.push(`### ${file}
+${fileIssues.map(lineFor).join("\n")}`);
+  }
+  return [
+    "You are working in a frontend codebase. Add stable `data-testid` attributes to the",
+    "interactive elements listed below so automated tests can target them reliably.",
+    "Change nothing else \u2014 do not alter behavior, styling, or unrelated markup.",
+    "",
+    `Naming convention: ${convention}.`,
+    "Keep every `data-testid` value unique within its file. For elements flagged as",
+    "ambiguous, make sure the new value disambiguates it from its siblings.",
+    "",
+    `Elements to fix (${issues.length} across ${byFile.size} file(s)):`,
+    "",
+    fileBlocks.join("\n\n"),
+    "",
+    "After editing, the listed elements should each be addressable by a unique",
+    "`data-testid`. Then I can open a pull request with the changes."
+  ].join("\n");
+}
+
+// src/index.ts
+function walkAST(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (typeof n["type"] === "string") visitor(n);
+  for (const key of Object.keys(n)) {
+    const child = n[key];
+    if (Array.isArray(child)) {
+      for (const item of child) walkAST(item, visitor);
+    } else if (child && typeof child === "object") {
+      walkAST(child, visitor);
+    }
+  }
+}
+var TAG_TYPE = {
+  button: "button",
+  input: "input",
+  select: "input",
+  textarea: "input",
+  a: "link",
+  form: "form"
+};
+var ACTIONS = {
+  button: ["click"],
+  input: ["fill", "press", "clear"],
+  link: ["click"],
+  form: ["submit"],
+  custom: ["click"]
+};
+var CLICK_HANDLER_ATTRS = ["ng-click", "(click)", "onclick", "@click", "v-on:click", "data-ng-click", "click"];
+var INTERACTIVE_ROLE_TYPE = {
+  button: "button",
+  tab: "button",
+  menuitem: "button",
+  menuitemcheckbox: "button",
+  menuitemradio: "button",
+  checkbox: "button",
+  radio: "button",
+  switch: "button",
+  option: "button",
+  link: "link",
+  combobox: "input",
+  slider: "input",
+  spinbutton: "input"
+};
+function classifyElementType(tag, attrs) {
+  if (TAG_TYPE[tag]) return TAG_TYPE[tag];
+  const role = (attrs["role"] ?? "").toLowerCase();
+  if (role && INTERACTIVE_ROLE_TYPE[role]) return INTERACTIVE_ROLE_TYPE[role];
+  const hasClick = CLICK_HANDLER_ATTRS.some((a) => a in attrs);
+  const hasTab = "tabindex" in attrs;
+  const hasTestId = "data-testid" in attrs || "testid" in attrs;
+  if (hasClick || hasTab || hasTestId || role) return "custom";
+  return null;
+}
+function normalizeTestId(attrs) {
+  if (!attrs["data-testid"] && attrs["testid"]) {
+    return { ...attrs, "data-testid": attrs["testid"] };
+  }
+  return attrs;
+}
+function attrStringValue(valueNode) {
+  if (!valueNode || typeof valueNode !== "object") return void 0;
+  const v = valueNode;
+  if (v["type"] === "Literal") return String(v["value"] ?? "");
+  if (v["type"] === "JSXExpressionContainer") {
+    const expr = v["expression"];
+    if (expr?.["type"] === "Literal") return String(expr["value"] ?? "");
+  }
+  return void 0;
+}
+function buildSelector2(tag, attrs) {
+  if (attrs["data-testid"]) return `[data-testid="${attrs["data-testid"]}"]`;
+  if (attrs["aria-label"]) return `${tag}[aria-label="${attrs["aria-label"]}"]`;
+  if (attrs["id"]) return `#${attrs["id"]}`;
+  if (attrs["name"]) return `${tag}[name="${attrs["name"]}"]`;
+  if (attrs["type"] && tag === "input") return `input[type="${attrs["type"]}"]`;
+  return tag;
+}
+function buildXPath(tag, attrs) {
+  if (attrs["id"]) return `//${tag}[@id='${attrs["id"]}']`;
+  if (attrs["data-testid"]) return `//${tag}[@data-testid='${attrs["data-testid"]}']`;
+  if (attrs["aria-label"]) return `//${tag}[@aria-label='${attrs["aria-label"]}']`;
+  if (attrs["name"]) return `//${tag}[@name='${attrs["name"]}']`;
+  if (attrs["type"]) return `//${tag}[@type='${attrs["type"]}']`;
+  return `//${tag}`;
+}
+function buildElementSelectors(tag, attrs) {
+  return {
+    dataTestId: attrs["data-testid"] ? `[data-testid="${attrs["data-testid"]}"]` : void 0,
+    id: attrs["id"] ? `#${attrs["id"]}` : void 0,
+    ariaLabel: attrs["aria-label"] ? `${tag}[aria-label="${attrs["aria-label"]}"]` : void 0,
+    name: attrs["name"] ? `${tag}[name="${attrs["name"]}"]` : void 0,
+    cssSelector: buildSelector2(tag, attrs),
+    xpath: buildXPath(tag, attrs)
+  };
+}
+function buildSelectorRanking(tag, attrs) {
+  const candidates = [];
+  if (attrs["data-testid"]) {
+    candidates.push({ strategy: "data-testid", value: `[data-testid="${attrs["data-testid"]}"]`, score: 100 });
+  }
+  if (attrs["id"]) {
+    candidates.push({ strategy: "id", value: `#${attrs["id"]}`, score: 85 });
+  }
+  if (attrs["aria-label"]) {
+    candidates.push({ strategy: "aria-label", value: `${tag}[aria-label="${attrs["aria-label"]}"]`, score: 75 });
+  }
+  if (attrs["name"]) {
+    candidates.push({ strategy: "name", value: `${tag}[name="${attrs["name"]}"]`, score: 65 });
+  }
+  const cssVal = buildSelector2(tag, attrs);
+  if (!candidates.some((c) => c.value === cssVal)) {
+    const cssScore = attrs["type"] && tag === "input" ? 35 : 10;
+    candidates.push({ strategy: "css", value: cssVal, score: cssScore });
+  }
+  candidates.push({ strategy: "xpath", value: buildXPath(tag, attrs), score: 20 });
+  return candidates.sort((a, b) => b.score - a.score);
+}
+function elementTestabilityScore(attrs) {
+  if (attrs["data-testid"]) return 100;
+  if (attrs["id"]) return 85;
+  if (attrs["aria-label"]) return 75;
+  if (attrs["name"]) return 65;
+  if (attrs["type"]) return 35;
+  return 10;
+}
+function buildLabel(attrs) {
+  return attrs["aria-label"] ?? attrs["placeholder"] ?? attrs["name"] ?? attrs["id"];
+}
+function extractInteractiveElements(ast) {
+  const elements = [];
+  walkAST(ast, (node) => {
+    if (node["type"] !== "JSXOpeningElement") return;
+    const nameNode = node["name"];
+    if (!nameNode || nameNode["type"] !== "JSXIdentifier") return;
+    const tag = String(nameNode["name"] ?? "");
+    if (!TAG_TYPE[tag]) return;
+    const attrs = {};
+    for (const attr of node["attributes"] ?? []) {
+      if (attr["type"] !== "JSXAttribute") continue;
+      const attrName = attr["name"]?.["name"] ?? "";
+      attrs[attrName] = attrStringValue(attr["value"]);
+    }
+    const selector = buildSelector2(tag, attrs);
+    const type = TAG_TYPE[tag];
+    const ranking = buildSelectorRanking(tag, attrs);
+    elements.push({
+      type,
+      selector,
+      label: buildLabel(attrs),
+      actions: ACTIONS[type],
+      selectors: buildElementSelectors(tag, attrs),
+      selectorRanking: ranking,
+      testabilityScore: elementTestabilityScore(attrs),
+      ambiguous: false
+    });
+  });
+  return elements;
+}
+function extractInteractiveElementsFromHtml(htmlElements) {
+  const elements = [];
+  for (const raw of htmlElements) {
+    const tag = raw.tag;
+    const attrs = normalizeTestId(raw.attrs);
+    const type = classifyElementType(tag, attrs);
+    if (!type) continue;
+    const selector = buildSelector2(tag, attrs);
+    const ranking = buildSelectorRanking(tag, attrs);
+    elements.push({
+      type,
+      selector,
+      label: buildLabel(attrs),
+      actions: ACTIONS[type],
+      selectors: buildElementSelectors(tag, attrs),
+      selectorRanking: ranking,
+      testabilityScore: elementTestabilityScore(attrs),
+      ambiguous: false
+    });
+  }
+  return elements;
+}
+var INTRA_AMBIGUITY_PENALTY = 0.4;
+var STRONG_STRATEGIES = /* @__PURE__ */ new Set([
+  "data-testid",
+  "id",
+  "aria-label",
+  "name"
+]);
+function countSelectorValues(elements) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const el of elements) {
+    for (const cand of el.selectorRanking) {
+      counts.set(cand.value, (counts.get(cand.value) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function applyAmbiguity(elements, intraCounts, crossCounts) {
+  for (const el of elements) {
+    for (const cand of el.selectorRanking) {
+      const intra = intraCounts.get(cand.value) ?? 1;
+      const cross = crossCounts.get(cand.value) ?? intra;
+      cand.matchCount = intra;
+      cand.crossMatchCount = cross;
+      if (intra > 1) {
+        cand.ambiguous = true;
+        cand.score = Math.round(cand.score * INTRA_AMBIGUITY_PENALTY);
+      }
+    }
+    el.selectorRanking.sort((a, b) => b.score - a.score);
+    const best = el.selectorRanking[0];
+    if (best) {
+      el.selector = best.value;
+      el.testabilityScore = best.score;
+      el.ambiguous = best.ambiguous === true;
+      if (el.ambiguous && STRONG_STRATEGIES.has(best.strategy)) {
+        el.ambiguityReason = `Selector \`${best.value}\` (${best.strategy}) matches ${best.matchCount} elements in this component \u2014 Playwright will resolve to multiple nodes.`;
+      } else if (el.ambiguous) {
+        el.ambiguityReason = `No unique selector available \u2014 best candidate \`${best.value}\` matches ${best.matchCount} elements in this component.`;
+      }
+    }
+  }
+}
+function computeScore(elements) {
+  if (elements.length === 0) return 40;
+  const avg = elements.reduce((s, e) => s + e.testabilityScore, 0) / elements.length;
+  return Math.round(avg);
+}
+function classifyComplexity(elements) {
+  if (elements.length <= 2) return "low";
+  if (elements.length <= 6) return "medium";
+  return "high";
+}
+async function analyze(components) {
+  const perComponent = components.map((component) => ({
+    component,
+    interactiveElements: component.htmlElements ? extractInteractiveElementsFromHtml(component.htmlElements) : extractInteractiveElements(component.ast)
+  }));
+  const crossCounts = countSelectorValues(perComponent.flatMap((p) => p.interactiveElements));
+  for (const { interactiveElements } of perComponent) {
+    const intraCounts = countSelectorValues(interactiveElements);
+    applyAmbiguity(interactiveElements, intraCounts, crossCounts);
+  }
+  for (const { interactiveElements } of perComponent) {
+    for (const el of interactiveElements) {
+      const best = el.selectorRanking[0];
+      el.tml = assessTagMaturity({
+        testabilityScore: el.testabilityScore,
+        ambiguous: el.ambiguous,
+        bestStrategy: best?.strategy ?? "css",
+        label: el.label,
+        elementType: el.type
+      });
+    }
+  }
+  return perComponent.map(({ component, interactiveElements }) => ({
+    component,
+    score: computeScore(interactiveElements),
+    interactiveElements,
+    complexity: classifyComplexity(interactiveElements)
+  }));
+}
+var index_default = analyze;
+export {
+  LEVEL_HIERARCHY,
+  SEVERITY_ORDER,
+  TML_LABELS,
+  accessibilityRules,
+  allTestIds,
+  analyze,
+  assessTagMaturity,
+  audit,
+  buildDuplicateSet,
+  buildIdePrompt,
+  buildTestabilityReport,
+  buildTmlInventoryEntry,
+  checkNaming,
+  index_default as default,
+  deriveTestIdSuggestion,
+  emptyInventory,
+  enrichTmlWithInventory,
+  enrichTmlWithRuntime,
+  filterRules,
+  getRuleById,
+  getRulesByLevel,
+  getRulesBySeverity,
+  isValidTestId,
+  isValidTmlNaming,
+  loadFindings,
+  loadInventory,
+  loadRuntimeMap,
+  mergeFindings,
+  parseFindings,
+  parseInventory,
+  runAudit,
+  runStaticAnalysis,
+  saveFindings,
+  summarizeReport
+};