@reticular/speakable 1.2.0 → 1.4.0

package/dist/index.js

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/model/types.ts
 var SUPPORTED_ROLES = [
   // Original roles (22)
@@ -329,10 +335,10 @@ function describeChange(change) {
     case "removed":
       return `Removed ${change.node?.role} "${change.node?.name}" from ${change.path}`;
     case "changed": {
-      const descriptions = change.changes?.map((pc) => {
-        const oldVal = formatValue(pc.oldValue);
-        const newVal = formatValue(pc.newValue);
-        return `${pc.property}: ${oldVal} \u2192 ${newVal}`;
+      const descriptions = change.changes?.map((pc2) => {
+        const oldVal = formatValue(pc2.oldValue);
+        const newVal = formatValue(pc2.newValue);
+        return `${pc2.property}: ${oldVal} \u2192 ${newVal}`;
       }) || [];
       return `Changed at ${change.path}: ${descriptions.join(", ")}`;
     }
@@ -438,7 +444,7 @@ function formatDiffForCI(diff) {
         break;
       case "changed":
         const props = change.changes?.map(
-          (pc) => `${pc.property}:${formatValue2(pc.oldValue)}->${formatValue2(pc.newValue)}`
+          (pc2) => `${pc2.property}:${formatValue2(pc2.oldValue)}->${formatValue2(pc2.newValue)}`
         ).join(" | ") || "";
         lines.push(`CHANGED: ${change.path} | ${props}`);
         break;
@@ -489,21 +495,4725 @@ function hasAccessibilityRegression(diff) {
   }
   return false;
 }
+
+// src/cli/colors.ts
+import pc from "picocolors";
+var identity = (s) => s;
+function createColors(enabled) {
+  if (!enabled) {
+    return {
+      error: identity,
+      warning: identity,
+      info: identity,
+      success: identity,
+      heading: identity,
+      title: identity,
+      dim: identity,
+      roleName: identity,
+      stateName: identity,
+      elementName: identity,
+      sectionHeader: identity,
+      description: identity,
+      bold: identity,
+      enabled: false
+    };
+  }
+  return {
+    error: pc.red,
+    warning: pc.yellow,
+    info: pc.blue,
+    success: pc.green,
+    heading: (s) => pc.bold(pc.cyan(s)),
+    title: (s) => pc.bold(pc.cyan(s)),
+    dim: pc.dim,
+    roleName: pc.cyan,
+    stateName: pc.yellow,
+    elementName: (s) => pc.bold(pc.white(s)),
+    sectionHeader: (s) => pc.bold(pc.white(s)),
+    description: pc.dim,
+    bold: pc.bold,
+    enabled: true
+  };
+}
+
+// src/renderer/nvda-renderer.ts
+function renderNVDA(model, colorize) {
+  const c = createColors(colorize ?? false);
+  const announcements = [];
+  renderNodeNVDA(model.root, announcements, c);
+  return announcements.join("\n");
+}
+function renderNodeNVDA(node, announcements, c) {
+  const announcement = formatNodeNVDA(node, c);
+  if (announcement) {
+    announcements.push(announcement);
+  }
+  for (const child of node.children) {
+    if (child.name && child.name === node.name && node.children.length === 1) {
+      for (const grandchild of child.children) {
+        renderNodeNVDA(grandchild, announcements, c);
+      }
+      continue;
+    }
+    renderNodeNVDA(child, announcements, c);
+  }
+}
+function formatNodeNVDA(node, c) {
+  const parts = [];
+  if (node.name) {
+    parts.push(c.elementName(node.name));
+  }
+  const roleText = formatRoleNVDA(node);
+  if (roleText) {
+    parts.push(c.roleName(roleText));
+  }
+  const stateText = formatStatesNVDA(node);
+  if (stateText) {
+    parts.push(c.stateName(stateText));
+  }
+  if (node.value) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) {
+      parts.push(valueText);
+    }
+  }
+  if (node.description) {
+    parts.push(c.description(node.description));
+  }
+  return parts.join(", ");
+}
+function formatRoleNVDA(node) {
+  const role = node.role;
+  switch (role) {
+    case "button":
+      return "button";
+    case "link":
+      return "link";
+    case "heading":
+      if (node.state.level) {
+        return `heading level ${node.state.level}`;
+      }
+      return "heading";
+    case "textbox":
+      return "edit";
+    case "checkbox":
+      return "checkbox";
+    case "radio":
+      return "radio button";
+    case "combobox":
+      return "combo box";
+    case "listbox":
+      return "list box";
+    case "option":
+      return "option";
+    case "list":
+      return "list";
+    case "listitem":
+      return "list item";
+    case "navigation":
+      return "navigation landmark";
+    case "main":
+      return "main landmark";
+    case "banner":
+      return "banner landmark";
+    case "contentinfo":
+      return "content information landmark";
+    case "region":
+      return "region landmark";
+    case "complementary":
+      return "complementary landmark";
+    case "form":
+      return "form landmark";
+    case "search":
+      return "search landmark";
+    case "img":
+      return "graphic";
+    case "article":
+      return "article";
+    case "generic":
+      return "";
+    case "staticText":
+    case "paragraph":
+    case "cell":
+    case "term":
+    case "definition":
+    case "caption":
+      return "";
+    case "blockquote":
+      return "block quote";
+    case "code":
+      return "code";
+    case "table":
+      return "table";
+    case "row":
+      return "row";
+    case "columnheader":
+      return "column header";
+    case "rowheader":
+      return "row header";
+    case "figure":
+      return "figure";
+    case "dialog":
+      return "dialog";
+    case "meter":
+      return "meter";
+    case "progressbar":
+      return "progress bar";
+    case "status":
+      return "status";
+    case "group":
+      return node.name ? "grouping" : "";
+    case "document":
+      return "document";
+    case "application":
+      return "embedded object";
+    case "separator":
+      return "separator";
+    default:
+      return role;
+  }
+}
+function formatStatesNVDA(node) {
+  const states = [];
+  if (node.state.expanded !== void 0) {
+    states.push(node.state.expanded ? "expanded" : "collapsed");
+  }
+  if (node.state.checked !== void 0) {
+    if (node.state.checked === "mixed") {
+      states.push("half checked");
+    } else {
+      states.push(node.state.checked ? "checked" : "not checked");
+    }
+  }
+  if (node.state.pressed !== void 0) {
+    if (node.state.pressed === "mixed") {
+      states.push("half pressed");
+    } else {
+      states.push(node.state.pressed ? "pressed" : "not pressed");
+    }
+  }
+  if (node.state.selected !== void 0) {
+    states.push(node.state.selected ? "selected" : "not selected");
+  }
+  if (node.state.disabled) {
+    states.push("unavailable");
+  }
+  if (node.state.invalid) {
+    states.push("invalid entry");
+  }
+  if (node.state.required) {
+    states.push("required");
+  }
+  if (node.state.readonly) {
+    states.push("read only");
+  }
+  if (node.state.busy) {
+    states.push("busy");
+  }
+  if (node.state.current) {
+    if (node.state.current === "page") {
+      states.push("current page");
+    } else if (node.state.current === "step") {
+      states.push("current step");
+    } else if (node.state.current === "location") {
+      states.push("current location");
+    } else if (node.state.current === "date") {
+      states.push("current date");
+    } else if (node.state.current === "time") {
+      states.push("current time");
+    } else if (node.state.current === "true") {
+      states.push("current");
+    }
+  }
+  if (node.state.grabbed !== void 0) {
+    states.push(node.state.grabbed ? "grabbed" : "not grabbed");
+  }
+  return states.join(", ");
+}
+
+// src/renderer/jaws-renderer.ts
+function renderJAWS(model, colorize) {
+  const c = createColors(colorize ?? false);
+  const announcements = [];
+  renderNodeJAWS(model.root, announcements, c);
+  return announcements.join("\n");
+}
+function renderNodeJAWS(node, announcements, c) {
+  const announcement = formatNodeJAWS(node, c);
+  if (announcement) {
+    announcements.push(announcement);
+  }
+  for (const child of node.children) {
+    if (child.name && child.name === node.name && node.children.length === 1) {
+      for (const grandchild of child.children) {
+        renderNodeJAWS(grandchild, announcements, c);
+      }
+      continue;
+    }
+    renderNodeJAWS(child, announcements, c);
+  }
+}
+function formatNodeJAWS(node, c) {
+  const parts = [];
+  if (node.name) {
+    parts.push(c.elementName(node.name));
+  }
+  const roleText = formatRoleJAWS(node);
+  if (roleText) {
+    parts.push(c.roleName(roleText));
+  }
+  const stateText = formatStatesJAWS(node);
+  if (stateText) {
+    parts.push(c.stateName(stateText));
+  }
+  if (node.value) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) {
+      parts.push(valueText);
+    }
+  }
+  if (node.description) {
+    parts.push(c.description(node.description));
+  }
+  return parts.join(", ");
+}
+function formatRoleJAWS(node) {
+  const role = node.role;
+  switch (role) {
+    case "button":
+      return "button";
+    case "link":
+      return "clickable";
+    case "heading":
+      if (node.state.level) {
+        return `heading ${node.state.level}`;
+      }
+      return "heading";
+    case "textbox":
+      return "edit";
+    case "checkbox":
+      return "check box";
+    case "radio":
+      return "radio button";
+    case "combobox":
+      return "combo box";
+    case "listbox":
+      return "list box";
+    case "option":
+      return "option";
+    case "list":
+      return "list";
+    case "listitem":
+      return "list item";
+    case "navigation":
+      return "navigation region";
+    case "main":
+      return "main region";
+    case "banner":
+      return "banner region";
+    case "contentinfo":
+      return "content information region";
+    case "region":
+      return "region";
+    case "img":
+      return "graphic";
+    case "article":
+      return "article";
+    case "complementary":
+      return "complementary region";
+    case "form":
+      return "form";
+    case "search":
+      return "search region";
+    case "generic":
+      return "";
+    case "staticText":
+    case "paragraph":
+    case "term":
+    case "definition":
+    case "caption":
+      return "";
+    case "blockquote":
+      return "block quote";
+    case "code":
+      return "code";
+    case "table": {
+      const rows = node.children.filter((c) => c.role === "row");
+      const rowCount = rows.length;
+      const colCount = rows.length > 0 ? rows[0].children.length : 0;
+      return `table with ${rowCount} rows and ${colCount} columns`;
+    }
+    case "row": {
+      const pos = node.state.posinset ?? 0;
+      return `row ${pos}`;
+    }
+    case "cell": {
+      const pos = node.state.posinset ?? 0;
+      return `column ${pos}`;
+    }
+    case "columnheader":
+      return "column header";
+    case "rowheader":
+      return "row header";
+    case "figure":
+      return "figure";
+    case "dialog":
+      return "dialog";
+    case "meter":
+      return "meter";
+    case "progressbar":
+      return "progress bar";
+    case "status":
+      return "status";
+    case "group":
+      return node.name ? "group" : "";
+    case "document":
+      return "frame";
+    case "application":
+      return "embedded object";
+    case "separator":
+      return "separator";
+    default:
+      return role;
+  }
+}
+function formatStatesJAWS(node) {
+  const states = [];
+  if (node.state.expanded !== void 0) {
+    states.push(node.state.expanded ? "expanded" : "collapsed");
+  }
+  if (node.state.checked !== void 0) {
+    if (node.state.checked === "mixed") {
+      states.push("partially checked");
+    } else if (node.state.checked) {
+      states.push("checked");
+    } else {
+      states.push("not checked");
+    }
+  }
+  if (node.state.pressed !== void 0) {
+    if (node.state.pressed === "mixed") {
+      states.push("partially pressed");
+    } else if (node.state.pressed) {
+      states.push("pressed");
+    } else {
+      states.push("not pressed");
+    }
+  }
+  if (node.state.selected !== void 0) {
+    states.push(node.state.selected ? "selected" : "not selected");
+  }
+  if (node.state.disabled) {
+    states.push("unavailable");
+  }
+  if (node.state.invalid) {
+    states.push("invalid entry");
+  }
+  if (node.state.required) {
+    states.push("required");
+  }
+  if (node.state.readonly) {
+    states.push("read only");
+  }
+  if (node.state.busy) {
+    states.push("busy");
+  }
+  if (node.state.current) {
+    switch (node.state.current) {
+      case "page":
+        states.push("current page");
+        break;
+      case "step":
+        states.push("current step");
+        break;
+      case "location":
+        states.push("current location");
+        break;
+      case "date":
+        states.push("current date");
+        break;
+      case "time":
+        states.push("current time");
+        break;
+      case "true":
+        states.push("current");
+        break;
+    }
+  }
+  if (node.state.grabbed !== void 0) {
+    states.push(node.state.grabbed ? "grabbed" : "not grabbed");
+  }
+  return states.join(", ");
+}
+
+// src/renderer/voiceover-renderer.ts
+function renderVoiceOver(model, colorize) {
+  const c = createColors(colorize ?? false);
+  const announcements = [];
+  renderNodeVoiceOver(model.root, announcements, c);
+  return announcements.join("\n");
+}
+function renderNodeVoiceOver(node, announcements, c) {
+  const announcement = formatNodeVoiceOver(node, c);
+  if (announcement) {
+    announcements.push(announcement);
+  }
+  for (const child of node.children) {
+    if (child.name && child.name === node.name && node.children.length === 1) {
+      for (const grandchild of child.children) {
+        renderNodeVoiceOver(grandchild, announcements, c);
+      }
+      continue;
+    }
+    renderNodeVoiceOver(child, announcements, c);
+  }
+}
+function formatNodeVoiceOver(node, c) {
+  const parts = [];
+  const roleFirst = shouldAnnounceRoleFirst(node.role);
+  if (roleFirst) {
+    const roleText = formatRoleVoiceOver(node);
+    if (roleText) {
+      parts.push(c.roleName(roleText));
+    }
+    if (node.name) {
+      parts.push(c.elementName(node.name));
+    }
+  } else {
+    if (node.name) {
+      parts.push(c.elementName(node.name));
+    }
+    const roleText = formatRoleVoiceOver(node);
+    if (roleText) {
+      parts.push(c.roleName(roleText));
+    }
+  }
+  const stateText = formatStatesVoiceOver(node);
+  if (stateText) {
+    parts.push(c.stateName(stateText));
+  }
+  if (node.value) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) {
+      parts.push(valueText);
+    }
+  }
+  if (node.description) {
+    parts.push(c.description(node.description));
+  }
+  return parts.join(", ");
+}
+function shouldAnnounceRoleFirst(role) {
+  return role === "heading" || role === "navigation" || role === "main" || role === "banner" || role === "contentinfo" || role === "complementary" || role === "region" || role === "form" || role === "search" || role === "blockquote" || role === "figure" || role === "dialog" || role === "group" || role === "document";
+}
+function formatRoleVoiceOver(node) {
+  const role = node.role;
+  switch (role) {
+    case "button":
+      return "button";
+    case "link":
+      return "link";
+    case "heading":
+      if (node.state.level) {
+        return `heading level ${node.state.level}`;
+      }
+      return "heading";
+    case "textbox":
+      return "edit text";
+    case "checkbox":
+      return "checkbox";
+    case "radio":
+      return "radio button";
+    case "combobox":
+      return "combo box";
+    case "listbox":
+      return "list box";
+    case "option":
+      return "option";
+    case "list":
+      return "list";
+    case "listitem":
+      return "item";
+    case "navigation":
+      return "navigation";
+    case "main":
+      return "main";
+    case "banner":
+      return "banner";
+    case "contentinfo":
+      return "content information";
+    case "region":
+      return "region";
+    case "complementary":
+      return "complementary";
+    case "form":
+      return "form";
+    case "search":
+      return "search";
+    case "img":
+      return "image";
+    case "article":
+      return "article";
+    case "generic":
+      return "";
+    case "staticText":
+    case "paragraph":
+    case "cell":
+    case "term":
+    case "definition":
+    case "caption":
+      return "";
+    case "blockquote":
+      return "blockquote";
+    case "code":
+      return "code";
+    case "table": {
+      const rows = node.children.filter((c) => c.role === "row");
+      const rowCount = rows.length;
+      const colCount = rows.length > 0 ? rows[0].children.length : 0;
+      return `table, ${rowCount} rows, ${colCount} columns`;
+    }
+    case "row":
+      return "row";
+    case "columnheader":
+      return "column header";
+    case "rowheader":
+      return "row header";
+    case "figure":
+      return "figure";
+    case "dialog":
+      return "web dialog";
+    case "meter":
+      return "level indicator";
+    case "progressbar":
+      return "progress indicator";
+    case "status":
+      return "status";
+    case "group":
+      return node.name ? "group" : "";
+    case "document":
+      return "frame";
+    case "application":
+      return "embedded object";
+    case "separator":
+      return "separator";
+    default:
+      return role;
+  }
+}
+function formatStatesVoiceOver(node) {
+  const states = [];
+  if (node.state.expanded !== void 0) {
+    states.push(node.state.expanded ? "expanded" : "collapsed");
+  }
+  if (node.state.checked !== void 0) {
+    if (node.state.checked === "mixed") {
+      states.push("mixed");
+    } else {
+      states.push(node.state.checked ? "checked" : "unchecked");
+    }
+  }
+  if (node.state.pressed !== void 0) {
+    if (node.state.pressed === "mixed") {
+      states.push("mixed");
+    } else {
+      states.push(node.state.pressed ? "pressed" : "not pressed");
+    }
+  }
+  if (node.state.selected !== void 0) {
+    states.push(node.state.selected ? "selected" : "unselected");
+  }
+  if (node.state.disabled) {
+    states.push("dimmed");
+  }
+  if (node.state.invalid) {
+    states.push("invalid data");
+  }
+  if (node.state.required) {
+    states.push("required");
+  }
+  if (node.state.readonly) {
+    states.push("read only");
+  }
+  if (node.state.busy) {
+    states.push("busy");
+  }
+  if (node.state.current) {
+    if (node.state.current === "page") {
+      states.push("current page");
+    } else if (node.state.current === "step") {
+      states.push("current step");
+    } else if (node.state.current === "location") {
+      states.push("current location");
+    } else if (node.state.current === "date") {
+      states.push("current date");
+    } else if (node.state.current === "time") {
+      states.push("current time");
+    } else if (node.state.current === "true") {
+      states.push("current");
+    }
+  }
+  if (node.state.grabbed !== void 0) {
+    states.push(node.state.grabbed ? "grabbed" : "not grabbed");
+  }
+  return states.join(", ");
+}
+
+// src/renderer/narrator-renderer.ts
+function renderNarrator(model, colorize) {
+  const c = createColors(colorize ?? false);
+  const announcements = [];
+  renderNodeNarrator(model.root, announcements, c);
+  return announcements.join("\n");
+}
+function renderNodeNarrator(node, announcements, c) {
+  const announcement = formatNodeNarrator(node, c);
+  if (announcement) {
+    announcements.push(announcement);
+  }
+  for (const child of node.children) {
+    if (child.name && child.name === node.name && node.children.length === 1) {
+      for (const grandchild of child.children) {
+        renderNodeNarrator(grandchild, announcements, c);
+      }
+      continue;
+    }
+    renderNodeNarrator(child, announcements, c);
+  }
+}
+function formatNodeNarrator(node, c) {
+  const parts = [];
+  const roleFirst = shouldAnnounceRoleFirst2(node.role);
+  if (roleFirst) {
+    const roleText = formatRoleNarrator(node);
+    if (roleText) {
+      parts.push(c.roleName(roleText));
+    }
+    if (node.name) {
+      parts.push(c.elementName(node.name));
+    }
+  } else {
+    if (node.name) {
+      parts.push(c.elementName(node.name));
+    }
+    const roleText = formatRoleNarrator(node);
+    if (roleText) {
+      parts.push(c.roleName(roleText));
+    }
+  }
+  const stateText = formatStatesNarrator(node);
+  if (stateText) {
+    parts.push(c.stateName(stateText));
+  }
+  if (node.value) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) {
+      parts.push(valueText);
+    }
+  }
+  if (node.description) {
+    parts.push(c.description(node.description));
+  }
+  return parts.join(", ");
+}
+function shouldAnnounceRoleFirst2(role) {
+  const roleFirstRoles = [
+    "link",
+    "heading",
+    "navigation",
+    "main",
+    "banner",
+    "contentinfo",
+    "complementary",
+    "region",
+    "form",
+    "search",
+    "blockquote",
+    "figure",
+    "dialog",
+    "group",
+    "document"
+  ];
+  return roleFirstRoles.includes(role);
+}
+function formatRoleNarrator(node) {
+  const role = node.role;
+  switch (role) {
+    case "button":
+      return "button";
+    case "link":
+      return "link";
+    case "heading":
+      if (node.state.level) {
+        return `Heading level ${node.state.level}`;
+      }
+      return "Heading";
+    case "textbox":
+      return "edit";
+    case "checkbox":
+      return "check box";
+    case "radio":
+      return "radio button";
+    case "combobox":
+      return "combo box";
+    case "listbox":
+      return "list box";
+    case "option":
+      return "option";
+    case "list":
+      return "list";
+    case "listitem":
+      return "list item";
+    case "navigation":
+      return "navigation";
+    case "main":
+      return "main";
+    case "banner":
+      return "banner";
+    case "contentinfo":
+      return "content info";
+    case "complementary":
+      return "complementary";
+    case "form":
+      return "form";
+    case "search":
+      return "search";
+    case "region":
+      return "region";
+    case "img":
+      return "image";
+    case "article":
+      return "article";
+    case "generic":
+      return "";
+    case "staticText":
+    case "paragraph":
+    case "cell":
+    case "term":
+    case "definition":
+    case "caption":
+      return "";
+    case "blockquote":
+      return "block quote";
+    case "code":
+      return "code";
+    case "table": {
+      const rows = node.children.filter((c) => c.role === "row");
+      const rowCount = rows.length;
+      const colCount = rows.length > 0 ? rows[0].children.length : 0;
+      return `table, ${rowCount} rows, ${colCount} columns`;
+    }
+    case "row":
+      return "row";
+    case "columnheader":
+      return "column header";
+    case "rowheader":
+      return "row header";
+    case "figure":
+      return "figure";
+    case "dialog":
+      return "dialog";
+    case "meter":
+      return "meter";
+    case "progressbar":
+      return "progress bar";
+    case "status":
+      return "status";
+    case "group":
+      return node.name ? "group" : "";
+    case "document":
+      return "document";
+    case "application":
+      return "application";
+    case "separator":
+      return "separator";
+    default:
+      return role;
+  }
+}
+function formatStatesNarrator(node) {
+  const states = [];
+  if (node.state.expanded !== void 0) {
+    states.push(node.state.expanded ? "expanded" : "collapsed");
+  }
+  if (node.state.checked !== void 0) {
+    if (node.state.checked === "mixed") {
+      states.push("partially selected");
+    } else {
+      states.push(node.state.checked ? "checked" : "unchecked");
+    }
+  }
+  if (node.state.pressed !== void 0) {
+    if (node.state.pressed === "mixed") {
+      states.push("partially pressed");
+    } else {
+      states.push(node.state.pressed ? "pressed" : "not pressed");
+    }
+  }
+  if (node.state.selected !== void 0) {
+    states.push(node.state.selected ? "selected" : "not selected");
+  }
+  if (node.state.disabled) {
+    states.push("disabled");
+  }
+  if (node.state.invalid) {
+    states.push("invalid");
+  }
+  if (node.state.required) {
+    states.push("required");
+  }
+  if (node.state.readonly) {
+    states.push("read only");
+  }
+  if (node.state.busy) {
+    states.push("busy");
+  }
+  if (node.state.current) {
+    if (node.state.current === "page") {
+      states.push("current page");
+    } else if (node.state.current === "step") {
+      states.push("current step");
+    } else if (node.state.current === "location") {
+      states.push("current location");
+    } else if (node.state.current === "date") {
+      states.push("current date");
+    } else if (node.state.current === "time") {
+      states.push("current time");
+    } else if (node.state.current === "true") {
+      states.push("current");
+    }
+  }
+  if (node.state.grabbed !== void 0) {
+    states.push(node.state.grabbed ? "grabbed" : "not grabbed");
+  }
+  return states.join(", ");
+}
+
+// src/renderer/audit-renderer.ts
+function renderAuditReport(model, colorize) {
+  const report = generateAuditReport(model);
+  return formatAuditReport(report, model, colorize);
+}
+function generateAuditReport(model) {
+  const statistics = {
+    totalElements: 0,
+    roleDistribution: {},
+    landmarkCount: 0,
+    headingCount: 0,
+    interactiveCount: 0,
+    focusableCount: 0,
+    statesUsed: /* @__PURE__ */ new Set()
+  };
+  const landmarks = [];
+  const headings = [];
+  const interactiveElements = [];
+  const issues = [];
+  collectAuditData(model.root, statistics, landmarks, headings, interactiveElements);
+  detectLandmarkIssues(landmarks, issues);
+  detectHeadingIssues(headings, issues);
+  detectInteractiveIssues(interactiveElements, issues);
+  return {
+    statistics,
+    landmarks,
+    headings,
+    interactiveElements,
+    issues
+  };
+}
+function collectAuditData(node, statistics, landmarks, headings, interactiveElements) {
+  if (node.role !== "generic") {
+    statistics.totalElements++;
+    statistics.roleDistribution[node.role] = (statistics.roleDistribution[node.role] || 0) + 1;
+    if (isLandmark(node.role)) {
+      statistics.landmarkCount++;
+      landmarks.push(node);
+    }
+    if (node.role === "heading") {
+      statistics.headingCount++;
+      headings.push(node);
+    }
+    if (isInteractive(node.role)) {
+      statistics.interactiveCount++;
+      interactiveElements.push(node);
+    }
+    if (node.focus.focusable) {
+      statistics.focusableCount++;
+    }
+    Object.keys(node.state).forEach((state) => {
+      if (node.state[state] !== void 0) {
+        statistics.statesUsed.add(state);
+      }
+    });
+  }
+  for (const child of node.children) {
+    collectAuditData(child, statistics, landmarks, headings, interactiveElements);
+  }
+}
+function isLandmark(role) {
+  return [
+    "navigation",
+    "main",
+    "banner",
+    "contentinfo",
+    "region",
+    "complementary",
+    "form",
+    "search"
+  ].includes(role);
+}
+function isInteractive(role) {
+  return [
+    "button",
+    "link",
+    "textbox",
+    "checkbox",
+    "radio",
+    "combobox",
+    "listbox",
+    "option"
+  ].includes(role);
+}
+function detectLandmarkIssues(landmarks, issues) {
+  if (landmarks.length === 0) {
+    issues.push({
+      severity: "info",
+      message: "No landmarks found",
+      suggestion: "Consider adding semantic landmarks (main, nav, aside, etc.)"
+    });
+  }
+  landmarks.forEach((landmark) => {
+    if (!landmark.name && ["navigation", "region", "complementary", "form"].includes(landmark.role)) {
+      issues.push({
+        severity: "warning",
+        message: `${landmark.role} landmark has no accessible name`,
+        suggestion: `Add aria-label="${landmark.role === "navigation" ? "Main navigation" : "Descriptive name"}" to the ${landmark.role} element`,
+        element: {
+          role: landmark.role,
+          name: landmark.name
+        }
+      });
+    }
+  });
+  const landmarksByRole = /* @__PURE__ */ new Map();
+  landmarks.forEach((landmark) => {
+    if (!landmarksByRole.has(landmark.role)) {
+      landmarksByRole.set(landmark.role, []);
+    }
+    landmarksByRole.get(landmark.role).push(landmark);
+  });
+  landmarksByRole.forEach((nodes, role) => {
+    if (nodes.length > 1) {
+      const allUnnamed = nodes.every((n) => !n.name);
+      const allSameName = nodes.every((n) => n.name === nodes[0].name);
+      if (allUnnamed || allSameName) {
+        issues.push({
+          severity: "warning",
+          message: `Multiple ${role} landmarks without distinguishing names`,
+          suggestion: `Add unique aria-label attributes to distinguish between ${role} landmarks`
+        });
+      }
+    }
+  });
+}
+function detectHeadingIssues(headings, issues) {
+  if (headings.length === 0) {
+    return;
+  }
+  const firstHeading = headings[0];
+  if (firstHeading.state.level && firstHeading.state.level !== 1) {
+    issues.push({
+      severity: "error",
+      message: `First heading is h${firstHeading.state.level} (should be h1)`,
+      suggestion: `Change <h${firstHeading.state.level}> to <h1> or add h1 before it`,
+      element: {
+        role: firstHeading.role,
+        name: firstHeading.name
+      }
+    });
+  }
+  for (let i = 1; i < headings.length; i++) {
+    const prevLevel = headings[i - 1].state.level || 1;
+    const currLevel = headings[i].state.level || 1;
+    if (currLevel > prevLevel + 1) {
+      issues.push({
+        severity: "error",
+        message: `Heading hierarchy violation: h${prevLevel} followed by h${currLevel} (skipped h${prevLevel + 1})`,
+        suggestion: `Change h${currLevel} to h${prevLevel + 1} or add intermediate heading levels`,
+        element: {
+          role: headings[i].role,
+          name: headings[i].name
+        }
+      });
+    }
+  }
+}
+function detectInteractiveIssues(elements, issues) {
+  elements.forEach((element) => {
+    if (!element.name) {
+      issues.push({
+        severity: "error",
+        message: `${element.role} has no accessible name`,
+        suggestion: element.role === "button" ? "Add text content or aria-label to button" : element.role === "link" ? "Add text content or aria-label to link" : `Add aria-label to ${element.role}`,
+        element: {
+          role: element.role,
+          name: element.name
+        }
+      });
+    }
+    if (element.role === "textbox" && !element.name) {
+      issues.push({
+        severity: "error",
+        message: "Input has no associated label",
+        suggestion: "Add <label> element or aria-label attribute",
+        element: {
+          role: element.role,
+          name: element.name
+        }
+      });
+    }
+  });
+}
+function formatAuditReport(report, model, colorize) {
+  const c = createColors(colorize ?? false);
+  const lines = [];
+  lines.push(c.title("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  lines.push(c.title("\u2551                      ACCESSIBILITY AUDIT REPORT                              \u2551"));
+  lines.push(c.title("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  lines.push("");
+  lines.push(c.dim(`Analyzed: ${model.metadata.extractedAt}`));
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F4CD} LANDMARK STRUCTURE"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  if (report.landmarks.length === 0) {
+    lines.push(c.error("\u2717 No landmarks found"));
+  } else {
+    lines.push(c.success(`\u2713 ${report.landmarks.length} landmark(s) found`));
+    lines.push("");
+    report.landmarks.forEach((landmark) => {
+      const name = landmark.name ? `"${landmark.name}"` : "(unnamed)";
+      lines.push(`${landmark.role} ${name}`);
+    });
+  }
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F4D1} HEADING HIERARCHY"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  if (report.headings.length === 0) {
+    lines.push(c.info("\u2139 No headings found"));
+  } else {
+    const hasHierarchyIssues = report.issues.some(
+      (i) => i.message.includes("heading") || i.message.includes("h1") || i.message.includes("h2")
+    );
+    lines.push(`${hasHierarchyIssues ? c.error("\u2717") : c.success("\u2713")} ${report.headings.length} heading(s) found ${hasHierarchyIssues ? "(HIERARCHY VIOLATION)" : "(proper hierarchy)"}`);
+    lines.push("");
+    report.headings.forEach((heading) => {
+      const level = heading.state.level || 1;
+      const indent = "  ".repeat(level - 1);
+      lines.push(`${indent}h${level} "${heading.name}"`);
+    });
+  }
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F3AF} INTERACTIVE ELEMENTS"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  if (report.interactiveElements.length === 0) {
+    lines.push(c.info("\u2139 No interactive elements found"));
+  } else {
+    lines.push(c.success(`\u2713 ${report.interactiveElements.length} interactive element(s) found`));
+    lines.push("");
+    const byRole = /* @__PURE__ */ new Map();
+    report.interactiveElements.forEach((el) => {
+      if (!byRole.has(el.role)) {
+        byRole.set(el.role, []);
+      }
+      byRole.get(el.role).push(el);
+    });
+    byRole.forEach((elements, role) => {
+      lines.push(`${role}s (${elements.length}):`);
+      elements.forEach((el) => {
+        const name = el.name ? `"${el.name}"` : "(unnamed)";
+        const states = Object.keys(el.state).filter((k) => el.state[k] !== void 0);
+        const stateStr = states.length > 0 ? ` [${states.join(", ")}]` : "";
+        lines.push(`  \u2022 ${name}${stateStr}`);
+      });
+    });
+  }
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F4CA} SUMMARY STATISTICS"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  lines.push(`Total accessible elements: ${report.statistics.totalElements}`);
+  lines.push("");
+  lines.push("Role distribution:");
+  Object.entries(report.statistics.roleDistribution).sort((a, b) => b[1] - a[1]).forEach(([role, count]) => {
+    lines.push(c.dim(`  \u2022 ${role}: ${count}`));
+  });
+  lines.push("");
+  lines.push(c.dim(`Focusable elements: ${report.statistics.focusableCount}`));
+  lines.push("");
+  if (report.issues.length > 0) {
+    lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    lines.push(c.heading("\u26A0\uFE0F  ACCESSIBILITY ISSUES"));
+    lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    lines.push("");
+    const errors = report.issues.filter((i) => i.severity === "error");
+    const warnings = report.issues.filter((i) => i.severity === "warning");
+    const infos = report.issues.filter((i) => i.severity === "info");
+    if (errors.length > 0) {
+      lines.push(c.error(`\u2717 Error (${errors.length}):`));
+      errors.forEach((issue) => {
+        lines.push(c.error(`  \u2022 ${issue.message}`));
+        if (issue.suggestion) {
+          lines.push(`    \u2192 ${issue.suggestion}`);
+        }
+      });
+      lines.push("");
+    }
+    if (warnings.length > 0) {
+      lines.push(c.warning(`\u26A0 Warning (${warnings.length}):`));
+      warnings.forEach((issue) => {
+        lines.push(c.warning(`  \u2022 ${issue.message}`));
+        if (issue.suggestion) {
+          lines.push(`    \u2192 ${issue.suggestion}`);
+        }
+      });
+      lines.push("");
+    }
+    if (infos.length > 0) {
+      lines.push(c.info(`\u2139 Info (${infos.length}):`));
+      infos.forEach((issue) => {
+        lines.push(c.info(`  \u2022 ${issue.message}`));
+        if (issue.suggestion) {
+          lines.push(`    \u2192 ${issue.suggestion}`);
+        }
+      });
+      lines.push("");
+    }
+  }
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.success("\u2705 OVERALL ASSESSMENT"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  const errorCount = report.issues.filter((i) => i.severity === "error").length;
+  const warningCount = report.issues.filter((i) => i.severity === "warning").length;
+  if (errorCount === 0 && warningCount === 0) {
+    lines.push(c.success("Excellent! No critical issues found."));
+  } else if (errorCount > 0) {
+    lines.push(`Critical accessibility issues found:`);
+    lines.push(c.error(`  \u2717 ${errorCount} error(s)`));
+    if (warningCount > 0) {
+      lines.push(c.warning(`  \u26A0 ${warningCount} warning(s)`));
+    }
+    lines.push("");
+    lines.push("Recommendation: Address errors before deployment");
+  } else {
+    lines.push(`Good structure with minor improvements needed:`);
+    lines.push(c.warning(`  \u26A0 ${warningCount} warning(s)`));
+  }
+  return lines.join("\n");
+}
+
+// src/parser/html-parser.ts
+import { JSDOM } from "jsdom";
+var ParsingError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ParsingError";
+  }
+};
+var MAX_INPUT_SIZE = 10 * 1024 * 1024;
+function parseHTML(html) {
+  const warnings = [];
+  const inputSize = Buffer.byteLength(html, "utf-8");
+  if (inputSize > MAX_INPUT_SIZE) {
+    throw new ParsingError(
+      `Input exceeds maximum size of ${MAX_INPUT_SIZE / (1024 * 1024)} MB (received ${(inputSize / (1024 * 1024)).toFixed(1)} MB). Use CSS selectors to analyze specific sections of large documents.`
+    );
+  }
+  try {
+    const dom = new JSDOM(html, {
+      contentType: "text/html",
+      // Include useful defaults for accessibility tree extraction
+      includeNodeLocations: false,
+      storageQuota: 0
+    });
+    const document = dom.window.document;
+    if (!document.documentElement) {
+      warnings.push({
+        message: "Document has no root element. HTML may be severely malformed."
+      });
+    }
+    if (!document.body) {
+      warnings.push({
+        message: "Document has no body element. HTML may be malformed."
+      });
+    }
+    return {
+      document,
+      warnings
+    };
+  } catch (error) {
+    throw new ParsingError(
+      `Failed to parse HTML: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function parseHTMLStrict(html) {
+  const result = parseHTML(html);
+  if (result.warnings.length > 0) {
+    const warningMessages = result.warnings.map((w) => w.message).join("; ");
+    throw new ParsingError(`HTML parsing warnings: ${warningMessages}`);
+  }
+  return result.document;
+}
+function validateHTMLNotEmpty(html) {
+  if (!html || html.trim().length === 0) {
+    throw new ParsingError("HTML input is empty or contains only whitespace");
+  }
+}
+
+// src/extractor/aria-name.ts
+function computeAccessibleName(element, visited = /* @__PURE__ */ new Set()) {
+  const warnings = [];
+  if (visited.has(element)) {
+    warnings.push({
+      message: "Circular reference detected in aria-labelledby chain",
+      element
+    });
+    return { name: "", warnings };
+  }
+  visited.add(element);
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const name = computeNameFromLabelledBy(element, labelledBy, visited, warnings);
+    return { name, warnings };
+  }
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.trim()) {
+    return { name: ariaLabel.trim(), warnings };
+  }
+  if (isFormControl(element)) {
+    const labelName = computeNameFromLabel(element);
+    if (labelName) {
+      return { name: labelName, warnings };
+    }
+  }
+  if (element.tagName.toLowerCase() === "img") {
+    const alt = element.getAttribute("alt");
+    if (alt !== null) {
+      return { name: alt.trim(), warnings };
+    }
+  }
+  if (supportsNameFromContent(element)) {
+    const textName = computeNameFromContent(element, visited);
+    if (textName) {
+      return { name: textName, warnings };
+    }
+  }
+  const title = element.getAttribute("title");
+  if (title && title.trim()) {
+    return { name: title.trim(), warnings };
+  }
+  return { name: "", warnings };
+}
+function computeNameFromLabelledBy(element, labelledBy, visited, warnings) {
+  const document = element.ownerDocument;
+  if (!document) {
+    return "";
+  }
+  const ids = labelledBy.trim().split(/\s+/);
+  const names = [];
+  for (const id of ids) {
+    if (!id) continue;
+    const referencedElement = document.getElementById(id);
+    if (!referencedElement) {
+      warnings.push({
+        message: `aria-labelledby references non-existent ID: ${id}`,
+        element
+      });
+      continue;
+    }
+    const result = computeAccessibleName(referencedElement, new Set(visited));
+    warnings.push(...result.warnings);
+    const name = result.name || getTextContent(referencedElement);
+    if (name) {
+      names.push(name);
+    }
+  }
+  return names.join(" ").trim();
+}
+function computeNameFromLabel(element) {
+  const document = element.ownerDocument;
+  if (!document) {
+    return "";
+  }
+  const id = element.getAttribute("id");
+  if (id) {
+    const label = document.querySelector(`label[for="${id}"]`);
+    if (label) {
+      return getTextContent(label);
+    }
+  }
+  const parentLabel = element.closest("label");
+  if (parentLabel) {
+    return getTextContent(parentLabel);
+  }
+  return "";
+}
+function computeNameFromContent(element, _visited) {
+  return getTextContent(element);
+}
+function getTextContent(element) {
+  if (element.getAttribute("aria-hidden") === "true") {
+    return "";
+  }
+  let text = "";
+  for (const node of Array.from(element.childNodes)) {
+    if (node.nodeType === 3) {
+      text += node.textContent || "";
+    } else if (node.nodeType === 1) {
+      const childElement = node;
+      if (childElement.getAttribute("aria-hidden") === "true") {
+        continue;
+      }
+      text += getTextContent(childElement);
+    }
+  }
+  return text.trim();
+}
+function isFormControl(element) {
+  const tagName = element.tagName.toLowerCase();
+  return tagName === "input" || tagName === "textarea" || tagName === "select" || tagName === "button";
+}
+function supportsNameFromContent(element) {
+  const tagName = element.tagName.toLowerCase();
+  const role = element.getAttribute("role");
+  const contentElements = [
+    "button",
+    "a",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "summary",
+    "figcaption",
+    "legend",
+    "caption",
+    "th",
+    "td",
+    "li",
+    "dt",
+    "dd"
+  ];
+  if (contentElements.includes(tagName)) {
+    return true;
+  }
+  const contentRoles = [
+    "button",
+    "link",
+    "heading",
+    "tab",
+    "treeitem",
+    "option",
+    "row",
+    "cell",
+    "columnheader",
+    "rowheader",
+    "tooltip",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio"
+  ];
+  if (role && contentRoles.includes(role)) {
+    return true;
+  }
+  return false;
+}
+function computeAccessibleDescription(element) {
+  const warnings = [];
+  const describedBy = element.getAttribute("aria-describedby");
+  if (describedBy) {
+    const description = computeDescriptionFromDescribedBy(
+      element,
+      describedBy,
+      warnings
+    );
+    if (description) {
+      return { description, warnings };
+    }
+  }
+  const title = element.getAttribute("title");
+  if (title && title.trim()) {
+    return { description: title.trim(), warnings };
+  }
+  return { description: "", warnings };
+}
+function computeDescriptionFromDescribedBy(element, describedBy, warnings) {
+  const document = element.ownerDocument;
+  if (!document) {
+    return "";
+  }
+  const ids = describedBy.trim().split(/\s+/);
+  const descriptions = [];
+  for (const id of ids) {
+    if (!id) continue;
+    const referencedElement = document.getElementById(id);
+    if (!referencedElement) {
+      warnings.push({
+        message: `aria-describedby references non-existent ID: ${id}`,
+        element
+      });
+      continue;
+    }
+    const text = getTextContent(referencedElement);
+    if (text) {
+      descriptions.push(text);
+    }
+  }
+  return descriptions.join(" ").trim();
+}
+
+// src/extractor/role-mapper.ts
+var IMPLICIT_ROLE_MAP = {
+  // Interactive elements
+  "button": "button",
+  "a": "link",
+  // Only if href attribute present
+  // Form controls
+  "input": "textbox",
+  // Default, varies by type
+  "textarea": "textbox",
+  "select": "listbox",
+  // Headings
+  "h1": "heading",
+  "h2": "heading",
+  "h3": "heading",
+  "h4": "heading",
+  "h5": "heading",
+  "h6": "heading",
+  // Landmarks
+  "nav": "navigation",
+  "main": "main",
+  "header": "banner",
+  // Only if not nested in article/section
+  "footer": "contentinfo",
+  // Only if not nested in article/section
+  "aside": "complementary",
+  "form": "form",
+  "section": "region",
+  // Only if has accessible name
+  // Lists
+  "ul": "list",
+  "ol": "list",
+  "li": "listitem",
+  // Images
+  "img": "img",
+  // Articles
+  "article": "article",
+  // Static content (new)
+  "p": "paragraph",
+  "blockquote": "blockquote",
+  "code": "code",
+  "pre": "code",
+  // Tables (new)
+  "table": "table",
+  "tr": "row",
+  "td": "cell",
+  "th": "columnheader",
+  // Default; scope="row" handled in computeImplicitRole
+  // Definition lists (new)
+  "dl": "list",
+  "dt": "term",
+  "dd": "definition",
+  // Figures (new)
+  "figure": "figure",
+  "figcaption": "caption",
+  // Disclosure (new)
+  "details": "group",
+  "summary": "button",
+  // Dialogs and widgets (new)
+  "dialog": "dialog",
+  "meter": "meter",
+  "progress": "progressbar",
+  "output": "status",
+  // Forms (new)
+  "fieldset": "group",
+  "legend": "caption",
+  // Embedded content (new)
+  "iframe": "document",
+  "video": "application",
+  "audio": "application",
+  // Separators (new)
+  "hr": "separator",
+  // Table caption (new)
+  "caption": "caption"
+};
+var INPUT_TYPE_ROLE_MAP = {
+  "button": "button",
+  "submit": "button",
+  "reset": "button",
+  "checkbox": "checkbox",
+  "radio": "radio",
+  "text": "textbox",
+  "email": "textbox",
+  "password": "textbox",
+  "search": "textbox",
+  "tel": "textbox",
+  "url": "textbox",
+  "number": "textbox"
+};
+function computeRole(element) {
+  const warnings = [];
+  const explicitRole = element.getAttribute("role");
+  if (explicitRole) {
+    const role = validateAndNormalizeRole(explicitRole, element, warnings);
+    if (role) {
+      return { role, warnings };
+    }
+  }
+  const implicitRole = computeImplicitRole(element, warnings);
+  return { role: implicitRole, warnings };
+}
+function validateAndNormalizeRole(roleAttr, element, warnings) {
+  const role = roleAttr.trim().toLowerCase();
+  if (role === "presentation" || role === "none") {
+    return null;
+  }
+  if (SUPPORTED_ROLES.includes(role)) {
+    return role;
+  }
+  warnings.push({
+    message: `Invalid or unsupported role: "${roleAttr}". Falling back to implicit role.`,
+    element
+  });
+  return null;
+}
+function computeImplicitRole(element, _warnings) {
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input") {
+    return computeInputRole(element);
+  }
+  if (tagName === "a") {
+    return element.hasAttribute("href") ? "link" : null;
+  }
+  if (tagName === "header") {
+    return isTopLevelLandmark(element) ? "banner" : null;
+  }
+  if (tagName === "footer") {
+    return isTopLevelLandmark(element) ? "contentinfo" : null;
+  }
+  if (tagName === "th") {
+    const scope = element.getAttribute("scope");
+    return scope === "row" ? "rowheader" : "columnheader";
+  }
+  if (tagName === "section") {
+    return element.hasAttribute("aria-label") || element.hasAttribute("aria-labelledby") ? "region" : null;
+  }
+  const implicitRole = IMPLICIT_ROLE_MAP[tagName];
+  return implicitRole || null;
+}
+function computeInputRole(input) {
+  const type = (input.getAttribute("type") || "text").toLowerCase();
+  return INPUT_TYPE_ROLE_MAP[type] || "textbox";
+}
+function isTopLevelLandmark(element) {
+  let parent = element.parentElement;
+  while (parent) {
+    const tagName = parent.tagName.toLowerCase();
+    if (tagName === "article" || tagName === "section") {
+      return false;
+    }
+    parent = parent.parentElement;
+  }
+  return true;
+}
+function isAccessible(element) {
+  if (element.getAttribute("aria-hidden") === "true") {
+    return false;
+  }
+  const role = element.getAttribute("role");
+  if (role === "presentation" || role === "none") {
+    return false;
+  }
+  const roleResult = computeRole(element);
+  return roleResult.role !== null;
+}
+
+// src/extractor/state-extractor.ts
+function extractState(element) {
+  const warnings = [];
+  const state = {};
+  const expanded = extractBooleanAttribute(element, "aria-expanded", warnings);
+  if (expanded !== void 0) {
+    state.expanded = expanded;
+  }
+  const checked = extractTriStateAttribute(element, "aria-checked", warnings);
+  if (checked !== void 0) {
+    state.checked = checked;
+  }
+  const pressed = extractTriStateAttribute(element, "aria-pressed", warnings);
+  if (pressed !== void 0) {
+    state.pressed = pressed;
+  }
+  const selected = extractBooleanAttribute(element, "aria-selected", warnings);
+  if (selected !== void 0) {
+    state.selected = selected;
+  }
+  const disabled = extractBooleanAttribute(element, "aria-disabled", warnings);
+  if (disabled !== void 0) {
+    state.disabled = disabled;
+  }
+  const invalid = extractBooleanAttribute(element, "aria-invalid", warnings);
+  if (invalid !== void 0) {
+    state.invalid = invalid;
+  }
+  const required = extractBooleanAttribute(element, "aria-required", warnings);
+  if (required !== void 0) {
+    state.required = required;
+  }
+  const readonly = extractBooleanAttribute(element, "aria-readonly", warnings);
+  if (readonly !== void 0) {
+    state.readonly = readonly;
+  }
+  const busy = extractBooleanAttribute(element, "aria-busy", warnings);
+  if (busy !== void 0) {
+    state.busy = busy;
+  }
+  const current = extractCurrentAttribute(element, warnings);
+  if (current !== void 0) {
+    state.current = current;
+  }
+  const grabbed = extractBooleanAttribute(element, "aria-grabbed", warnings);
+  if (grabbed !== void 0) {
+    state.grabbed = grabbed;
+  }
+  const hidden = extractBooleanAttribute(element, "aria-hidden", warnings);
+  if (hidden !== void 0) {
+    state.hidden = hidden;
+  }
+  const level = extractLevelAttribute(element, warnings);
+  if (level !== void 0) {
+    state.level = level;
+  }
+  const posinset = extractNumberAttribute(element, "aria-posinset", warnings);
+  if (posinset !== void 0) {
+    state.posinset = posinset;
+  }
+  const setsize = extractNumberAttribute(element, "aria-setsize", warnings);
+  if (setsize !== void 0) {
+    state.setsize = setsize;
+  }
+  extractNativeStates(element, state, warnings);
+  return { state, warnings };
+}
+function extractValue(element) {
+  const warnings = [];
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input") {
+    return extractInputValue(element, warnings);
+  }
+  if (tagName === "textarea") {
+    return extractTextareaValue(element, warnings);
+  }
+  if (tagName === "select") {
+    return extractSelectValue(element, warnings);
+  }
+  const valueNow = element.getAttribute("aria-valuenow");
+  if (valueNow !== null) {
+    const current = parseFloat(valueNow);
+    if (!isNaN(current)) {
+      const valueMin = element.getAttribute("aria-valuemin");
+      const valueMax = element.getAttribute("aria-valuemax");
+      const valueText = element.getAttribute("aria-valuetext");
+      return {
+        value: {
+          current,
+          min: valueMin !== null ? parseFloat(valueMin) : void 0,
+          max: valueMax !== null ? parseFloat(valueMax) : void 0,
+          text: valueText || void 0
+        },
+        warnings
+      };
+    }
+  }
+  return { value: void 0, warnings };
+}
+function extractBooleanAttribute(element, attrName, warnings) {
+  const value = element.getAttribute(attrName);
+  if (value === null) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  warnings.push({
+    message: `Invalid ${attrName} value: "${value}". Expected "true" or "false".`,
+    element
+  });
+  return void 0;
+}
+function extractTriStateAttribute(element, attrName, warnings) {
+  const value = element.getAttribute(attrName);
+  if (value === null) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  if (normalized === "mixed") {
+    return "mixed";
+  }
+  warnings.push({
+    message: `Invalid ${attrName} value: "${value}". Expected "true", "false", or "mixed".`,
+    element
+  });
+  return void 0;
+}
+function extractCurrentAttribute(element, warnings) {
+  const value = element.getAttribute("aria-current");
+  if (value === null) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase().trim();
+  const validValues = ["page", "step", "location", "date", "time", "true", "false"];
+  if (validValues.includes(normalized)) {
+    return normalized === "false" ? false : normalized;
+  }
+  warnings.push({
+    message: `Invalid aria-current value: "${value}". Expected one of: ${validValues.join(", ")}.`,
+    element
+  });
+  return void 0;
+}
+function extractLevelAttribute(element, warnings) {
+  const ariaLevel = element.getAttribute("aria-level");
+  if (ariaLevel !== null) {
+    const level = parseInt(ariaLevel, 10);
+    if (!isNaN(level) && level >= 1 && level <= 6) {
+      return level;
+    }
+    warnings.push({
+      message: `Invalid aria-level value: "${ariaLevel}". Expected integer 1-6.`,
+      element
+    });
+    return void 0;
+  }
+  const tagName = element.tagName.toLowerCase();
+  const match = tagName.match(/^h([1-6])$/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return void 0;
+}
+function extractNumberAttribute(element, attrName, warnings) {
+  const value = element.getAttribute(attrName);
+  if (value === null) {
+    return void 0;
+  }
+  const num = parseInt(value, 10);
+  if (isNaN(num) || num < 1) {
+    warnings.push({
+      message: `Invalid ${attrName} value: "${value}". Expected positive integer.`,
+      element
+    });
+    return void 0;
+  }
+  return num;
+}
+function extractNativeStates(element, state, _warnings) {
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input") {
+    const input = element;
+    const type = input.type.toLowerCase();
+    if (type === "checkbox" || type === "radio") {
+      if (state.checked === void 0) {
+        state.checked = input.checked;
+      }
+    }
+  }
+  if ("disabled" in element) {
+    const htmlElement = element;
+    if (state.disabled === void 0 && htmlElement.disabled) {
+      state.disabled = true;
+    }
+  }
+  if ("required" in element) {
+    const htmlElement = element;
+    if (state.required === void 0 && htmlElement.required) {
+      state.required = true;
+    }
+  }
+  if ("readOnly" in element) {
+    const htmlElement = element;
+    if (state.readonly === void 0 && htmlElement.readOnly) {
+      state.readonly = true;
+    }
+  }
+}
+function extractInputValue(input, warnings) {
+  const type = input.type.toLowerCase();
+  if (type === "checkbox" || type === "radio") {
+    return { value: void 0, warnings };
+  }
+  if (type === "button" || type === "submit" || type === "reset") {
+    return { value: void 0, warnings };
+  }
+  const value = input.value;
+  if (value) {
+    return {
+      value: {
+        current: value,
+        text: value
+      },
+      warnings
+    };
+  }
+  return { value: void 0, warnings };
+}
+function extractTextareaValue(textarea, warnings) {
+  const value = textarea.value;
+  if (value) {
+    return {
+      value: {
+        current: value,
+        text: value
+      },
+      warnings
+    };
+  }
+  return { value: void 0, warnings };
+}
+function extractSelectValue(select, warnings) {
+  const value = select.value;
+  const selectedOption = select.options[select.selectedIndex];
+  const text = selectedOption?.textContent || value;
+  if (value) {
+    return {
+      value: {
+        current: value,
+        text
+      },
+      warnings
+    };
+  }
+  return { value: void 0, warnings };
+}
+
+// src/extractor/focus-extractor.ts
+var NATIVELY_FOCUSABLE_ELEMENTS = [
+  "a",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "area",
+  "iframe",
+  "object",
+  "embed",
+  "audio",
+  "video"
+];
+function extractFocusInfo(element) {
+  const tabindexAttr = element.getAttribute("tabindex");
+  const tabindex = tabindexAttr !== null ? parseInt(tabindexAttr, 10) : void 0;
+  const focusable = isFocusable(element, tabindex);
+  return {
+    focusable,
+    ...tabindexAttr !== null && !isNaN(tabindex) && { tabindex }
+  };
+}
+function isFocusable(element, tabindex) {
+  const tagName = element.tagName.toLowerCase();
+  if (isDisabled(element)) {
+    return false;
+  }
+  if (tabindex !== void 0 && !isNaN(tabindex)) {
+    return true;
+  }
+  if (isNativelyFocusable(element, tagName)) {
+    return true;
+  }
+  return false;
+}
+function isNativelyFocusable(element, tagName) {
+  if (tagName === "a" || tagName === "area") {
+    return element.hasAttribute("href");
+  }
+  if (NATIVELY_FOCUSABLE_ELEMENTS.includes(tagName)) {
+    return true;
+  }
+  return false;
+}
+function isDisabled(element) {
+  if ("disabled" in element) {
+    const htmlElement = element;
+    if (htmlElement.disabled) {
+      return true;
+    }
+  }
+  const ariaDisabled = element.getAttribute("aria-disabled");
+  if (ariaDisabled === "true") {
+    return true;
+  }
+  return false;
+}
+
+// src/extractor/tree-builder.ts
+var SelectorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SelectorError";
+  }
+};
+function isHidden(element) {
+  if (element.getAttribute("aria-hidden") === "true") return true;
+  if (typeof getComputedStyle === "function") {
+    try {
+      const style = getComputedStyle(element);
+      if (style.display === "none") return true;
+      if (style.visibility === "hidden") return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function processChildNode(node, children, warnings) {
+  if (node.nodeType === 3) {
+    const text = (node.textContent || "").trim();
+    if (text.length > 0) {
+      children.push({
+        role: "staticText",
+        name: text,
+        state: {},
+        focus: { focusable: false },
+        children: []
+      });
+    }
+    return;
+  }
+  if (node.nodeType === 1) {
+    const element = node;
+    if (isHidden(element)) return;
+    if (!isAccessible(element)) {
+      const grandchildren = collectChildrenFromRolelessElement(element, warnings);
+      children.push(...grandchildren);
+      return;
+    }
+    const childNode = buildNodeRecursive(element, warnings);
+    if (childNode) children.push(childNode);
+  }
+}
+function collectChildrenFromRolelessElement(element, warnings) {
+  const children = [];
+  if (element.shadowRoot) {
+    for (const child of Array.from(element.shadowRoot.childNodes)) {
+      processChildNode(child, children, warnings);
+    }
+  }
+  for (const child of Array.from(element.childNodes)) {
+    processChildNode(child, children, warnings);
+  }
+  return children;
+}
+function buildAccessibilityTree(rootElement, sourceHash) {
+  const warnings = [];
+  if (isHidden(rootElement)) {
+    const model2 = {
+      version: CURRENT_MODEL_VERSION,
+      root: {
+        role: "generic",
+        name: "",
+        state: {},
+        focus: { focusable: false },
+        children: []
+      },
+      metadata: {
+        extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...sourceHash && { sourceHash }
+      }
+    };
+    return { model: model2, warnings };
+  }
+  const rootNode = buildNodeRecursive(rootElement, warnings);
+  const accessibleRoot = rootNode || createGenericContainer(rootElement, warnings);
+  const model = {
+    version: CURRENT_MODEL_VERSION,
+    root: accessibleRoot,
+    metadata: {
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...sourceHash && { sourceHash }
+    }
+  };
+  return { model, warnings };
+}
+function buildAccessibilityTreeWithSelector(rootElement, selector, sourceHash) {
+  const document = rootElement.ownerDocument;
+  if (!document) {
+    throw new SelectorError("Element has no owner document");
+  }
+  let matchingElements;
+  try {
+    if (rootElement.matches(selector)) {
+      matchingElements = [rootElement];
+    } else {
+      matchingElements = Array.from(rootElement.querySelectorAll(selector));
+    }
+  } catch (error) {
+    throw new SelectorError(`Invalid CSS selector: "${selector}". ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (matchingElements.length === 0) {
+    throw new SelectorError(`No elements match selector: "${selector}"`);
+  }
+  const results = [];
+  for (const element of matchingElements) {
+    const result = buildAccessibilityTree(element, sourceHash);
+    results.push(result);
+  }
+  return results;
+}
+function buildNodeRecursive(element, warnings) {
+  if (isHidden(element)) {
+    return null;
+  }
+  if (!isAccessible(element)) {
+    return null;
+  }
+  const roleResult = computeRole(element);
+  warnings.push(...roleResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  if (!roleResult.role) {
+    return null;
+  }
+  const nameResult = computeAccessibleName(element);
+  warnings.push(...nameResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const descResult = computeAccessibleDescription(element);
+  warnings.push(...descResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const stateResult = extractState(element);
+  warnings.push(...stateResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const valueResult = extractValue(element);
+  warnings.push(...valueResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const focusInfo = extractFocusInfo(element);
+  const children = [];
+  if (element.shadowRoot) {
+    for (const child of Array.from(element.shadowRoot.childNodes)) {
+      processChildNode(child, children, warnings);
+    }
+  }
+  for (const child of Array.from(element.childNodes)) {
+    processChildNode(child, children, warnings);
+  }
+  const node = {
+    role: roleResult.role,
+    name: nameResult.name,
+    ...descResult.description && { description: descResult.description },
+    ...valueResult.value && { value: valueResult.value },
+    state: stateResult.state,
+    focus: focusInfo,
+    children
+  };
+  return node;
+}
+function createGenericContainer(rootElement, warnings) {
+  const children = [];
+  if (rootElement.shadowRoot) {
+    for (const child of Array.from(rootElement.shadowRoot.childNodes)) {
+      processChildNode(child, children, warnings);
+    }
+  }
+  for (const child of Array.from(rootElement.childNodes)) {
+    processChildNode(child, children, warnings);
+  }
+  return {
+    role: "generic",
+    name: "",
+    state: {},
+    focus: {
+      focusable: false
+    },
+    children
+  };
+}
+
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  classifyDiff: () => classifyDiff,
+  createBaselineStorage: () => createBaselineStorage,
+  createEngine: () => createEngine,
+  createHeuristicAnalyzer: () => createHeuristicAnalyzer,
+  createTimelineGenerator: () => createTimelineGenerator,
+  deserializeEvent: () => deserializeEvent,
+  deserializeInteractionSequence: () => deserializeInteractionSequence,
+  deserializeTimeline: () => deserializeTimeline,
+  diffTimelines: () => diffTimelines,
+  executeAction: () => executeAction,
+  executeSequence: () => executeSequence,
+  generateSelector: () => generateSelector,
+  getBuiltinPattern: () => getBuiltinPattern,
+  serializeEvent: () => serializeEvent,
+  serializeInteractionSequence: () => serializeInteractionSequence,
+  serializeTimeline: () => serializeTimeline,
+  timelinesEqual: () => timelinesEqual
+});
+
+// src/runtime/selector.ts
+function generateSelector(element) {
+  if (element.id) {
+    return `#${escapeCSSIdentifier(element.id)}`;
+  }
+  const document = element.ownerDocument;
+  if (!document) {
+    return getTagName(element);
+  }
+  const segments = [];
+  let current = element;
+  while (current && current !== document.documentElement) {
+    const segment = buildSegment(current, document);
+    segments.unshift(segment);
+    const partialSelector = segments.join(" > ");
+    try {
+      const matches = document.querySelectorAll(partialSelector);
+      if (matches.length === 1 && matches[0] === element) {
+        return partialSelector;
+      }
+    } catch {
+    }
+    current = current.parentElement;
+  }
+  if (segments.length === 0) {
+    return getTagName(element);
+  }
+  const fullSelector = segments.join(" > ");
+  return fullSelector;
+}
+function buildSegment(element, _document) {
+  const tag = getTagName(element);
+  const parent = element.parentElement;
+  if (parent) {
+    const siblingsWithSameTag = Array.from(parent.children).filter(
+      (child) => getTagName(child) === tag
+    );
+    if (siblingsWithSameTag.length === 1) {
+      return tag;
+    }
+  } else {
+    return tag;
+  }
+  const classes = getStableClasses(element);
+  if (classes.length > 0) {
+    const tagWithClasses = `${tag}.${classes.join(".")}`;
+    if (parent) {
+      const siblingsMatchingClasses = Array.from(parent.children).filter(
+        (child) => {
+          if (getTagName(child) !== tag) return false;
+          return classes.every((cls) => child.classList.contains(cls));
+        }
+      );
+      if (siblingsMatchingClasses.length === 1) {
+        return tagWithClasses;
+      }
+    }
+  }
+  const index = getNthChildIndex(element);
+  return `${tag}:nth-child(${index})`;
+}
+function getTagName(element) {
+  return element.tagName.toLowerCase();
+}
+function getStableClasses(element) {
+  const classes = Array.from(element.classList);
+  if (classes.length === 0) return [];
+  const stableClasses = classes.filter((cls) => !looksLikeDynamicClass(cls));
+  return stableClasses.sort().map(escapeCSSIdentifier);
+}
+function looksLikeDynamicClass(className) {
+  if (/^[a-f0-9]{5,}$/i.test(className)) return true;
+  if (/[_-][a-f0-9]{5,}$/i.test(className)) return true;
+  if (/_{2,}[A-Za-z0-9]{4,}$/.test(className)) return true;
+  return false;
+}
+function getNthChildIndex(element) {
+  const parent = element.parentElement;
+  if (!parent) return 1;
+  const children = Array.from(parent.children);
+  const index = children.indexOf(element);
+  return index + 1;
+}
+function escapeCSSIdentifier(value) {
+  if (!value) return value;
+  let result = "";
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    const code = char.charCodeAt(0);
+    if (i === 0 && code >= 48 && code <= 57) {
+      result += `\\3${char} `;
+      continue;
+    }
+    if (char === "!" || char === '"' || char === "#" || char === "$" || char === "%" || char === "&" || char === "'" || char === "(" || char === ")" || char === "*" || char === "+" || char === "," || char === "." || char === "/" || char === ":" || char === ";" || char === "<" || char === "=" || char === ">" || char === "?" || char === "@" || char === "[" || char === "\\" || char === "]" || char === "^" || char === "`" || char === "{" || char === "|" || char === "}" || char === "~" || char === " ") {
+      result += `\\${char}`;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+
+// src/runtime/observers/focus-observer.ts
+function computeAccessibleName2(element, document) {
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.trim()) {
+    return ariaLabel.trim();
+  }
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy && labelledBy.trim()) {
+    const ids = labelledBy.trim().split(/\s+/);
+    const parts = [];
+    for (const id of ids) {
+      const referenced = document.getElementById(id);
+      if (referenced && referenced.textContent) {
+        parts.push(referenced.textContent.trim());
+      }
+    }
+    const combined = parts.join(" ");
+    if (combined) {
+      return combined;
+    }
+  }
+  const textContent = element.textContent;
+  if (textContent && textContent.trim()) {
+    return textContent.trim();
+  }
+  return "";
+}
+function getElementRole(element) {
+  const explicitRole = element.getAttribute("role");
+  if (explicitRole && explicitRole.trim()) {
+    return explicitRole.trim();
+  }
+  const tagName = element.tagName.toLowerCase();
+  switch (tagName) {
+    case "button":
+      return "button";
+    case "a":
+      return element.hasAttribute("href") ? "link" : "generic";
+    case "input": {
+      const type = (element.getAttribute("type") || "text").toLowerCase();
+      switch (type) {
+        case "button":
+        case "submit":
+        case "reset":
+        case "image":
+          return "button";
+        case "checkbox":
+          return "checkbox";
+        case "radio":
+          return "radio";
+        case "range":
+          return "slider";
+        case "search":
+          return "searchbox";
+        default:
+          return "textbox";
+      }
+    }
+    case "textarea":
+      return "textbox";
+    case "select":
+      return element.hasAttribute("multiple") ? "listbox" : "combobox";
+    case "nav":
+      return "navigation";
+    case "main":
+      return "main";
+    case "header":
+      return "banner";
+    case "footer":
+      return "contentinfo";
+    case "aside":
+      return "complementary";
+    case "form":
+      return "form";
+    case "section":
+      return element.hasAttribute("aria-label") || element.hasAttribute("aria-labelledby") ? "region" : "generic";
+    case "article":
+      return "article";
+    case "dialog":
+      return "dialog";
+    case "table":
+      return "table";
+    case "ul":
+    case "ol":
+      return "list";
+    case "li":
+      return "listitem";
+    case "img":
+      return element.getAttribute("alt") === "" ? "presentation" : "img";
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return "heading";
+    case "option":
+      return "option";
+    case "progress":
+      return "progressbar";
+    case "output":
+      return "status";
+    case "menu":
+      return "menu";
+    default:
+      return "generic";
+  }
+}
+function createFocusObserver(options) {
+  const { document: doc, onEvent, getTimestamp } = options;
+  let active = false;
+  let previousTarget = null;
+  function buildEventTarget2(element) {
+    return {
+      role: getElementRole(element),
+      accessibleName: computeAccessibleName2(element, doc),
+      selector: generateSelector(element)
+    };
+  }
+  function handleFocusIn(event) {
+    if (!active) return;
+    const target = event.target;
+    if (!target || !(target instanceof doc.defaultView.Element)) {
+      return;
+    }
+    const currentTarget = buildEventTarget2(target);
+    const a11yEvent = {
+      type: "FOCUS_CHANGED",
+      timestamp: getTimestamp(),
+      target: currentTarget,
+      payload: {
+        kind: "focus_changed",
+        previousTarget
+      }
+    };
+    onEvent(a11yEvent);
+    previousTarget = currentTarget;
+  }
+  return {
+    start() {
+      if (active) return;
+      active = true;
+      previousTarget = null;
+      doc.addEventListener("focusin", handleFocusIn);
+    },
+    stop() {
+      if (!active) return;
+      active = false;
+      doc.removeEventListener("focusin", handleFocusIn);
+    },
+    get isActive() {
+      return active;
+    }
+  };
+}
+
+// src/runtime/observers/mutation-observer.ts
+var ROLE_ATTRIBUTE = "role";
+var NAME_ATTRIBUTES = /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]);
+var STATE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "aria-expanded",
+  "aria-selected",
+  "aria-checked",
+  "aria-disabled",
+  "aria-hidden"
+]);
+var OBSERVED_ATTRIBUTES = [
+  ROLE_ATTRIBUTE,
+  "aria-label",
+  "aria-labelledby",
+  "aria-expanded",
+  "aria-selected",
+  "aria-checked",
+  "aria-disabled",
+  "aria-hidden"
+];
+function computeAccessibleName3(element, document) {
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.trim()) {
+    return ariaLabel.trim();
+  }
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy && labelledBy.trim()) {
+    const ids = labelledBy.trim().split(/\s+/);
+    const parts = [];
+    for (const id of ids) {
+      const referenced = document.getElementById(id);
+      if (referenced && referenced.textContent) {
+        parts.push(referenced.textContent.trim());
+      }
+    }
+    const combined = parts.join(" ");
+    if (combined) {
+      return combined;
+    }
+  }
+  const textContent = element.textContent;
+  if (textContent && textContent.trim()) {
+    return textContent.trim();
+  }
+  return "";
+}
+function getElementRole2(element) {
+  const explicitRole = element.getAttribute("role");
+  if (explicitRole && explicitRole.trim()) {
+    return explicitRole.trim();
+  }
+  const tagName = element.tagName.toLowerCase();
+  switch (tagName) {
+    case "button":
+      return "button";
+    case "a":
+      return element.hasAttribute("href") ? "link" : "generic";
+    case "input": {
+      const type = (element.getAttribute("type") || "text").toLowerCase();
+      switch (type) {
+        case "button":
+        case "submit":
+        case "reset":
+        case "image":
+          return "button";
+        case "checkbox":
+          return "checkbox";
+        case "radio":
+          return "radio";
+        case "range":
+          return "slider";
+        case "search":
+          return "searchbox";
+        default:
+          return "textbox";
+      }
+    }
+    case "textarea":
+      return "textbox";
+    case "select":
+      return element.hasAttribute("multiple") ? "listbox" : "combobox";
+    case "nav":
+      return "navigation";
+    case "main":
+      return "main";
+    case "header":
+      return "banner";
+    case "footer":
+      return "contentinfo";
+    case "aside":
+      return "complementary";
+    case "form":
+      return "form";
+    case "section":
+      return element.hasAttribute("aria-label") || element.hasAttribute("aria-labelledby") ? "region" : "generic";
+    case "article":
+      return "article";
+    case "dialog":
+      return "dialog";
+    case "table":
+      return "table";
+    case "ul":
+    case "ol":
+      return "list";
+    case "li":
+      return "listitem";
+    case "img":
+      return element.getAttribute("alt") === "" ? "presentation" : "img";
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return "heading";
+    case "option":
+      return "option";
+    case "progress":
+      return "progressbar";
+    case "output":
+      return "status";
+    case "menu":
+      return "menu";
+    default:
+      return "generic";
+  }
+}
+function createMutationObserver(options) {
+  const { document: doc, onEvent, getTimestamp } = options;
+  let observer = null;
+  let active = false;
+  function handleMutations(mutations) {
+    if (!active) return;
+    for (const mutation of mutations) {
+      if (mutation.type !== "attributes") {
+        continue;
+      }
+      const attributeName = mutation.attributeName;
+      if (!attributeName) {
+        continue;
+      }
+      const target = mutation.target;
+      if (!(target instanceof Element)) {
+        continue;
+      }
+      if (attributeName === ROLE_ATTRIBUTE) {
+        handleRoleChange(target, mutation.oldValue);
+      } else if (NAME_ATTRIBUTES.has(attributeName)) {
+        handleNameChange(target, attributeName, mutation.oldValue);
+      } else if (STATE_ATTRIBUTES.has(attributeName)) {
+        handleStateChange(target, attributeName, mutation.oldValue);
+      }
+    }
+  }
+  function handleRoleChange(element, oldValue) {
+    const previousRole = oldValue?.trim() || getImplicitRole(element);
+    const newRole = element.getAttribute("role")?.trim() || getImplicitRole(element);
+    if (previousRole === newRole) {
+      return;
+    }
+    const eventTarget = buildEventTarget2(element);
+    const payload = {
+      kind: "role_changed",
+      previousRole,
+      newRole
+    };
+    onEvent({
+      type: "ROLE_CHANGED",
+      timestamp: getTimestamp(),
+      target: eventTarget,
+      payload
+    });
+  }
+  function handleNameChange(element, attributeName, oldValue) {
+    let previousName;
+    let newName;
+    if (attributeName === "aria-label") {
+      previousName = oldValue?.trim() || "";
+      newName = computeAccessibleName3(element, doc);
+      if (!previousName && oldValue === null) {
+        const labelledBy = element.getAttribute("aria-labelledby");
+        if (labelledBy) {
+          previousName = resolveAriaLabelledBy(element, labelledBy);
+        } else {
+          previousName = element.textContent?.trim() || "";
+        }
+      }
+    } else {
+      previousName = oldValue ? resolveAriaLabelledBy(element, oldValue) : "";
+      if (!previousName && oldValue === null) {
+        const ariaLabel = element.getAttribute("aria-label");
+        if (ariaLabel) {
+          previousName = ariaLabel.trim();
+        } else {
+          previousName = element.textContent?.trim() || "";
+        }
+      }
+      newName = computeAccessibleName3(element, doc);
+    }
+    if (previousName === newName) {
+      return;
+    }
+    const eventTarget = buildEventTarget2(element);
+    const payload = {
+      kind: "accessible_name_changed",
+      previousName,
+      newName
+    };
+    onEvent({
+      type: "ACCESSIBLE_NAME_CHANGED",
+      timestamp: getTimestamp(),
+      target: eventTarget,
+      payload
+    });
+  }
+  function handleStateChange(element, attributeName, oldValue) {
+    const currentValue = element.getAttribute(attributeName);
+    const normalizedOld = normalizeStateValue(oldValue);
+    const normalizedNew = normalizeStateValue(currentValue);
+    if (normalizedOld === normalizedNew) {
+      return;
+    }
+    const eventTarget = buildEventTarget2(element);
+    const payload = {
+      kind: "state_changed",
+      attribute: attributeName,
+      previousValue: normalizedOld,
+      newValue: normalizedNew
+    };
+    onEvent({
+      type: "STATE_CHANGED",
+      timestamp: getTimestamp(),
+      target: eventTarget,
+      payload
+    });
+  }
+  function buildEventTarget2(element) {
+    return {
+      role: getElementRole2(element),
+      accessibleName: computeAccessibleName3(element, doc),
+      selector: generateSelector(element)
+    };
+  }
+  function getImplicitRole(element) {
+    const tagName = element.tagName.toLowerCase();
+    switch (tagName) {
+      case "button":
+        return "button";
+      case "a":
+        return element.hasAttribute("href") ? "link" : "generic";
+      case "input": {
+        const type = (element.getAttribute("type") || "text").toLowerCase();
+        switch (type) {
+          case "button":
+          case "submit":
+          case "reset":
+          case "image":
+            return "button";
+          case "checkbox":
+            return "checkbox";
+          case "radio":
+            return "radio";
+          default:
+            return "textbox";
+        }
+      }
+      default:
+        return "generic";
+    }
+  }
+  function resolveAriaLabelledBy(element, idRefs) {
+    const ownerDoc = element.ownerDocument;
+    if (!ownerDoc) {
+      return "";
+    }
+    const ids = idRefs.trim().split(/\s+/).filter(Boolean);
+    const parts = [];
+    for (const id of ids) {
+      const referenced = ownerDoc.getElementById(id);
+      if (referenced && referenced.textContent) {
+        parts.push(referenced.textContent.trim());
+      }
+    }
+    return parts.join(" ");
+  }
+  function normalizeStateValue(value) {
+    if (value === null) {
+      return null;
+    }
+    if (value === "true") {
+      return true;
+    }
+    if (value === "false") {
+      return false;
+    }
+    return value;
+  }
+  return {
+    start() {
+      if (active) return;
+      active = true;
+      observer = new MutationObserver(handleMutations);
+      observer.observe(doc.body ?? doc.documentElement, {
+        attributes: true,
+        attributeOldValue: true,
+        attributeFilter: OBSERVED_ATTRIBUTES,
+        subtree: true
+      });
+    },
+    stop() {
+      if (!active) return;
+      active = false;
+      if (observer) {
+        observer.disconnect();
+        observer = null;
+      }
+    },
+    get isActive() {
+      return active;
+    }
+  };
+}
+
+// src/runtime/observers/live-region-observer.ts
+var IMPLICIT_LIVE_ROLES = /* @__PURE__ */ new Set(["alert", "status", "log", "marquee", "timer"]);
+var ROLE_POLITENESS_MAP = {
+  alert: "assertive",
+  status: "polite",
+  log: "polite",
+  marquee: "polite",
+  timer: "polite"
+};
+function createLiveRegionObserver(document, callback) {
+  let contentObserver = null;
+  let documentObserver = null;
+  const trackedRegions = /* @__PURE__ */ new Set();
+  function getLiveRegionPoliteness(element) {
+    const ariaLive = element.getAttribute("aria-live");
+    if (ariaLive === "assertive") return "assertive";
+    if (ariaLive === "polite") return "polite";
+    if (ariaLive === "off") return null;
+    const role = element.getAttribute("role");
+    if (role && IMPLICIT_LIVE_ROLES.has(role)) {
+      return ROLE_POLITENESS_MAP[role] || "polite";
+    }
+    if (ariaLive && ariaLive !== "off") return "polite";
+    return null;
+  }
+  function isAtomic(element) {
+    return element.getAttribute("aria-atomic") === "true";
+  }
+  function buildEventTarget2(element) {
+    const role = element.getAttribute("role") || "region";
+    const accessibleName = element.getAttribute("aria-label") || element.getAttribute("aria-labelledby") || "";
+    const selector = generateSelector(element);
+    return { role, accessibleName, selector };
+  }
+  function getTextFromNodes(nodes) {
+    const parts = [];
+    nodes.forEach((node) => {
+      if (node.nodeType === Node.TEXT_NODE) {
+        const text = node.textContent?.trim();
+        if (text) parts.push(text);
+      } else if (node.nodeType === Node.ELEMENT_NODE) {
+        const text = node.textContent?.trim();
+        if (text) parts.push(text);
+      }
+    });
+    return parts.join(" ").trim();
+  }
+  function emitAnnouncement(liveRegion, text, politeness) {
+    if (!text) return;
+    const target = buildEventTarget2(liveRegion);
+    callback({
+      type: "ANNOUNCEMENT",
+      target,
+      payload: {
+        kind: "announcement",
+        politeness,
+        text
+      }
+    });
+  }
+  function findLiveRegionAncestor(node) {
+    let current = node;
+    while (current) {
+      if (current.nodeType === Node.ELEMENT_NODE && trackedRegions.has(current)) {
+        return current;
+      }
+      current = current.parentNode;
+    }
+    return null;
+  }
+  function handleContentMutations(mutations) {
+    const regionChanges = /* @__PURE__ */ new Map();
+    for (const mutation of mutations) {
+      const liveRegion = findLiveRegionAncestor(mutation.target);
+      if (!liveRegion) continue;
+      if (!regionChanges.has(liveRegion)) {
+        regionChanges.set(liveRegion, { addedText: [], charDataChanged: false });
+      }
+      const changes = regionChanges.get(liveRegion);
+      if (mutation.type === "childList" && mutation.addedNodes.length > 0) {
+        const text = getTextFromNodes(mutation.addedNodes);
+        if (text) {
+          changes.addedText.push(text);
+        }
+      } else if (mutation.type === "characterData") {
+        changes.charDataChanged = true;
+      }
+    }
+    for (const [region, changes] of regionChanges) {
+      const politeness = getLiveRegionPoliteness(region);
+      if (!politeness) continue;
+      let text;
+      if (isAtomic(region)) {
+        text = region.textContent?.trim() || "";
+      } else {
+        if (changes.addedText.length > 0) {
+          text = changes.addedText.join(" ").trim();
+        } else if (changes.charDataChanged) {
+          text = region.textContent?.trim() || "";
+        } else {
+          text = "";
+        }
+      }
+      emitAnnouncement(region, text, politeness);
+    }
+  }
+  function handleDocumentMutations(mutations) {
+    for (const mutation of mutations) {
+      if (mutation.type !== "childList") continue;
+      mutation.addedNodes.forEach((node) => {
+        if (node.nodeType !== Node.ELEMENT_NODE) return;
+        const element = node;
+        if (getLiveRegionPoliteness(element) !== null && !trackedRegions.has(element)) {
+          trackRegion(element);
+        }
+        const descendants = element.querySelectorAll("[aria-live], [role]");
+        descendants.forEach((desc) => {
+          if (getLiveRegionPoliteness(desc) !== null && !trackedRegions.has(desc)) {
+            trackRegion(desc);
+          }
+        });
+      });
+      mutation.removedNodes.forEach((node) => {
+        if (node.nodeType !== Node.ELEMENT_NODE) return;
+        const element = node;
+        if (trackedRegions.has(element)) {
+          trackedRegions.delete(element);
+        }
+        const descendants = element.querySelectorAll("[aria-live], [role]");
+        descendants.forEach((desc) => {
+          trackedRegions.delete(desc);
+        });
+      });
+    }
+  }
+  function trackRegion(element) {
+    trackedRegions.add(element);
+  }
+  function discoverExistingRegions() {
+    const ariaLiveElements = document.querySelectorAll("[aria-live]");
+    ariaLiveElements.forEach((el) => {
+      if (getLiveRegionPoliteness(el) !== null) {
+        trackRegion(el);
+      }
+    });
+    IMPLICIT_LIVE_ROLES.forEach((role) => {
+      const roleElements = document.querySelectorAll(`[role="${role}"]`);
+      roleElements.forEach((el) => {
+        if (!trackedRegions.has(el)) {
+          trackRegion(el);
+        }
+      });
+    });
+  }
+  function start() {
+    discoverExistingRegions();
+    contentObserver = new MutationObserver(handleContentMutations);
+    const body = document.body;
+    if (body) {
+      contentObserver.observe(body, {
+        childList: true,
+        characterData: true,
+        subtree: true,
+        characterDataOldValue: true
+      });
+    }
+    documentObserver = new MutationObserver(handleDocumentMutations);
+    if (body) {
+      documentObserver.observe(body, {
+        childList: true,
+        subtree: true
+      });
+    }
+  }
+  function stop() {
+    if (contentObserver) {
+      contentObserver.disconnect();
+      contentObserver = null;
+    }
+    if (documentObserver) {
+      documentObserver.disconnect();
+      documentObserver = null;
+    }
+    trackedRegions.clear();
+  }
+  return { start, stop };
+}
+
+// src/runtime/observers/dialog-observer.ts
+function computeDialogAccessibleName(element, document) {
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.trim()) {
+    return ariaLabel.trim();
+  }
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy && labelledBy.trim()) {
+    const ids = labelledBy.trim().split(/\s+/);
+    const parts = [];
+    for (const id of ids) {
+      const referenced = document.getElementById(id);
+      if (referenced && referenced.textContent) {
+        parts.push(referenced.textContent.trim());
+      }
+    }
+    const combined = parts.join(" ");
+    if (combined) {
+      return combined;
+    }
+  }
+  const title = element.getAttribute("title");
+  if (title && title.trim()) {
+    return title.trim();
+  }
+  const heading = element.querySelector("h1, h2, h3, h4, h5, h6");
+  if (heading && heading.textContent && heading.textContent.trim()) {
+    return heading.textContent.trim();
+  }
+  return "";
+}
+function getDialogRole(element) {
+  const explicitRole = element.getAttribute("role");
+  if (explicitRole && explicitRole.trim()) {
+    return explicitRole.trim();
+  }
+  if (element.tagName.toLowerCase() === "dialog") {
+    return "dialog";
+  }
+  return "generic";
+}
+function isDialogElement(element) {
+  if (element.tagName.toLowerCase() === "dialog") {
+    return true;
+  }
+  const role = element.getAttribute("role");
+  return role === "dialog" || role === "alertdialog";
+}
+function isDialogModal(element) {
+  const ariaModal = element.getAttribute("aria-modal");
+  if (ariaModal === "true") {
+    return true;
+  }
+  return false;
+}
+function createDialogObserver(options) {
+  const { document: doc, onEvent, getTimestamp } = options;
+  let active = false;
+  let mutationObserver = null;
+  const openDialogStack = [];
+  function buildEventTarget2(element) {
+    return {
+      role: getDialogRole(element),
+      accessibleName: computeDialogAccessibleName(element, doc),
+      selector: generateSelector(element)
+    };
+  }
+  function emitDialogOpened(element) {
+    const name = computeDialogAccessibleName(element, doc);
+    const isModal = isDialogModal(element);
+    const target = buildEventTarget2(element);
+    openDialogStack.push({
+      element,
+      name,
+      selector: target.selector
+    });
+    const a11yEvent = {
+      type: "DIALOG_OPENED",
+      timestamp: getTimestamp(),
+      target,
+      payload: {
+        kind: "dialog_opened",
+        dialogName: name,
+        isModal
+      }
+    };
+    onEvent(a11yEvent);
+  }
+  function emitDialogClosed(element) {
+    const name = computeDialogAccessibleName(element, doc);
+    const target = buildEventTarget2(element);
+    const index = openDialogStack.findIndex((d) => d.element === element);
+    if (index !== -1) {
+      openDialogStack.splice(index, 1);
+    }
+    const a11yEvent = {
+      type: "DIALOG_CLOSED",
+      timestamp: getTimestamp(),
+      target,
+      payload: {
+        kind: "dialog_closed",
+        dialogName: name
+      }
+    };
+    onEvent(a11yEvent);
+  }
+  function isTrackedAsOpen(element) {
+    return openDialogStack.some((d) => d.element === element);
+  }
+  function handleMutations(mutations) {
+    if (!active) return;
+    for (const mutation of mutations) {
+      if (mutation.type === "attributes") {
+        const target = mutation.target;
+        if (!(target instanceof doc.defaultView.Element)) continue;
+        if (mutation.attributeName === "open" && target.tagName.toLowerCase() === "dialog") {
+          if (target.hasAttribute("open")) {
+            if (!isTrackedAsOpen(target)) {
+              emitDialogOpened(target);
+            }
+          } else {
+            if (isTrackedAsOpen(target)) {
+              emitDialogClosed(target);
+            }
+          }
+        }
+        if (mutation.attributeName === "aria-modal" && isDialogElement(target)) {
+          if (!isTrackedAsOpen(target) && isVisibleDialog(target)) {
+            emitDialogOpened(target);
+          }
+        }
+        if (mutation.attributeName === "role") {
+          const oldRole = mutation.oldValue;
+          const newRole = target.getAttribute("role");
+          const wasDialog = oldRole === "dialog" || oldRole === "alertdialog";
+          const isNowDialog = newRole === "dialog" || newRole === "alertdialog";
+          if (!wasDialog && isNowDialog && isVisibleDialog(target)) {
+            emitDialogOpened(target);
+          } else if (wasDialog && !isNowDialog && isTrackedAsOpen(target)) {
+            emitDialogClosed(target);
+          }
+        }
+      }
+      if (mutation.type === "childList") {
+        for (let i = 0; i < mutation.addedNodes.length; i++) {
+          const node = mutation.addedNodes[i];
+          if (!(node instanceof doc.defaultView.Element)) continue;
+          if (isDialogElement(node) && isVisibleDialog(node)) {
+            if (!isTrackedAsOpen(node)) {
+              emitDialogOpened(node);
+            }
+          }
+          const dialogDescendants = node.querySelectorAll(
+            'dialog[open], [role="dialog"], [role="alertdialog"]'
+          );
+          for (let j = 0; j < dialogDescendants.length; j++) {
+            const dialog = dialogDescendants[j];
+            if (isVisibleDialog(dialog) && !isTrackedAsOpen(dialog)) {
+              emitDialogOpened(dialog);
+            }
+          }
+        }
+        for (let i = 0; i < mutation.removedNodes.length; i++) {
+          const node = mutation.removedNodes[i];
+          if (!(node instanceof doc.defaultView.Element)) continue;
+          if (isTrackedAsOpen(node)) {
+            emitDialogClosed(node);
+          }
+          const trackedInRemoved = openDialogStack.filter(
+            (d) => node.contains(d.element)
+          );
+          for (const tracked of trackedInRemoved) {
+            emitDialogClosed(tracked.element);
+          }
+        }
+      }
+    }
+  }
+  function isVisibleDialog(element) {
+    if (element.tagName.toLowerCase() === "dialog") {
+      return element.hasAttribute("open");
+    }
+    return true;
+  }
+  return {
+    start() {
+      if (active) return;
+      active = true;
+      openDialogStack.length = 0;
+      const existingDialogs = doc.querySelectorAll(
+        'dialog[open], [role="dialog"], [role="alertdialog"]'
+      );
+      for (let i = 0; i < existingDialogs.length; i++) {
+        const dialog = existingDialogs[i];
+        if (isVisibleDialog(dialog)) {
+          openDialogStack.push({
+            element: dialog,
+            name: computeDialogAccessibleName(dialog, doc),
+            selector: generateSelector(dialog)
+          });
+        }
+      }
+      mutationObserver = new MutationObserver(handleMutations);
+      mutationObserver.observe(doc.body || doc.documentElement, {
+        attributes: true,
+        attributeFilter: ["open", "role", "aria-modal"],
+        attributeOldValue: true,
+        childList: true,
+        subtree: true
+      });
+    },
+    stop() {
+      if (!active) return;
+      active = false;
+      if (mutationObserver) {
+        mutationObserver.disconnect();
+        mutationObserver = null;
+      }
+      openDialogStack.length = 0;
+    },
+    get isActive() {
+      return active;
+    },
+    getOpenDialogs() {
+      return openDialogStack.map((d) => d.name);
+    }
+  };
+}
+
+// src/runtime/engine.ts
+function createEngine(options) {
+  const { document: doc } = options;
+  let attached = false;
+  let sessionStart = 0;
+  let events = [];
+  function getTimestamp() {
+    return Date.now() - sessionStart;
+  }
+  function collectEvent(event) {
+    events.push(event);
+  }
+  function collectLiveRegionEvent(event) {
+    const fullEvent = {
+      ...event,
+      timestamp: getTimestamp()
+    };
+    events.push(fullEvent);
+  }
+  const focusObs = createFocusObserver({
+    document: doc,
+    onEvent: collectEvent,
+    getTimestamp
+  });
+  const mutationObs = createMutationObserver({
+    document: doc,
+    onEvent: collectEvent,
+    getTimestamp
+  });
+  const liveRegionObs = createLiveRegionObserver(
+    doc,
+    collectLiveRegionEvent
+  );
+  const dialogObs = createDialogObserver({
+    document: doc,
+    onEvent: collectEvent,
+    getTimestamp
+  });
+  return {
+    attach() {
+      if (attached) return;
+      attached = true;
+      sessionStart = Date.now();
+      events = [];
+      focusObs.start();
+      mutationObs.start();
+      liveRegionObs.start();
+      dialogObs.start();
+    },
+    detach() {
+      if (!attached) return;
+      attached = false;
+      focusObs.stop();
+      mutationObs.stop();
+      liveRegionObs.stop();
+      dialogObs.stop();
+    },
+    getEvents() {
+      return [...events];
+    },
+    reset() {
+      events = [];
+    },
+    get isAttached() {
+      return attached;
+    },
+    get dialogObserver() {
+      return {
+        getOpenDialogs() {
+          return dialogObs.getOpenDialogs();
+        }
+      };
+    }
+  };
+}
+
+// src/runtime/interactions.ts
+var KEY_MAP = {
+  Tab: { key: "Tab", code: "Tab", keyCode: 9 },
+  Escape: { key: "Escape", code: "Escape", keyCode: 27 },
+  Enter: { key: "Enter", code: "Enter", keyCode: 13 },
+  " ": { key: " ", code: "Space", keyCode: 32 },
+  ArrowUp: { key: "ArrowUp", code: "ArrowUp", keyCode: 38 },
+  ArrowDown: { key: "ArrowDown", code: "ArrowDown", keyCode: 40 },
+  ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft", keyCode: 37 },
+  ArrowRight: { key: "ArrowRight", code: "ArrowRight", keyCode: 39 }
+};
+var FOCUSABLE_SELECTOR = [
+  "button:not([disabled])",
+  "a[href]",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])'
+].join(", ");
+function getFocusableElements(document) {
+  return Array.from(document.querySelectorAll(FOCUSABLE_SELECTOR));
+}
+function computeAccessibleName4(element, document) {
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.trim()) {
+    return ariaLabel.trim();
+  }
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy && labelledBy.trim()) {
+    const ids = labelledBy.trim().split(/\s+/);
+    const parts = [];
+    for (const id of ids) {
+      const referenced = document.getElementById(id);
+      if (referenced && referenced.textContent) {
+        parts.push(referenced.textContent.trim());
+      }
+    }
+    const combined = parts.join(" ");
+    if (combined) return combined;
+  }
+  const textContent = element.textContent;
+  if (textContent && textContent.trim()) {
+    return textContent.trim();
+  }
+  return "";
+}
+function getElementRole3(element) {
+  const explicitRole = element.getAttribute("role");
+  if (explicitRole && explicitRole.trim()) {
+    return explicitRole.trim();
+  }
+  const tagName = element.tagName.toLowerCase();
+  switch (tagName) {
+    case "button":
+      return "button";
+    case "a":
+      return element.hasAttribute("href") ? "link" : "generic";
+    case "input": {
+      const type = (element.getAttribute("type") || "text").toLowerCase();
+      switch (type) {
+        case "button":
+        case "submit":
+        case "reset":
+        case "image":
+          return "button";
+        case "checkbox":
+          return "checkbox";
+        case "radio":
+          return "radio";
+        case "range":
+          return "slider";
+        case "search":
+          return "searchbox";
+        default:
+          return "textbox";
+      }
+    }
+    case "textarea":
+      return "textbox";
+    case "select":
+      return element.hasAttribute("multiple") ? "listbox" : "combobox";
+    case "dialog":
+      return "dialog";
+    default:
+      return "generic";
+  }
+}
+function buildEventTarget(element, document) {
+  return {
+    role: getElementRole3(element),
+    accessibleName: computeAccessibleName4(element, document),
+    selector: generateSelector(element)
+  };
+}
+function dispatchKeyboardEvent(document, options) {
+  const target = document.activeElement || document.body;
+  const commonProps = {
+    key: options.key,
+    code: options.code,
+    keyCode: options.keyCode,
+    which: options.keyCode,
+    shiftKey: options.shiftKey || false,
+    ctrlKey: options.ctrlKey || false,
+    altKey: options.altKey || false,
+    metaKey: options.metaKey || false,
+    bubbles: true,
+    cancelable: true
+  };
+  target.dispatchEvent(new KeyboardEvent("keydown", commonProps));
+  if (options.key.length === 1) {
+    target.dispatchEvent(new KeyboardEvent("keypress", commonProps));
+  }
+  target.dispatchEvent(new KeyboardEvent("keyup", commonProps));
+}
+function parseKeyCombo(combo) {
+  const parts = combo.split("+");
+  const modifiers = [];
+  let shiftKey = false;
+  let ctrlKey = false;
+  let altKey = false;
+  let metaKey = false;
+  const key = parts[parts.length - 1];
+  for (let i = 0; i < parts.length - 1; i++) {
+    const mod = parts[i].toLowerCase();
+    switch (mod) {
+      case "shift":
+        shiftKey = true;
+        modifiers.push("Shift");
+        break;
+      case "control":
+      case "ctrl":
+        ctrlKey = true;
+        modifiers.push("Control");
+        break;
+      case "alt":
+        altKey = true;
+        modifiers.push("Alt");
+        break;
+      case "meta":
+      case "cmd":
+      case "command":
+        metaKey = true;
+        modifiers.push("Meta");
+        break;
+    }
+  }
+  return { key, modifiers, shiftKey, ctrlKey, altKey, metaKey };
+}
+function getKeyInfo(key) {
+  if (KEY_MAP[key]) {
+    return KEY_MAP[key];
+  }
+  if (key.length === 1) {
+    return {
+      key,
+      code: `Key${key.toUpperCase()}`,
+      keyCode: key.toUpperCase().charCodeAt(0)
+    };
+  }
+  return {
+    key,
+    code: key,
+    keyCode: 0
+  };
+}
+function executeClick(selector, document, onEvent, getTimestamp) {
+  const element = document.querySelector(selector);
+  if (!element) {
+    const warningEvent = {
+      type: "WARNING",
+      timestamp: getTimestamp(),
+      target: {
+        role: "generic",
+        accessibleName: "",
+        selector
+      },
+      payload: {
+        kind: "warning",
+        message: `Element not found: ${selector}`
+      }
+    };
+    onEvent(warningEvent);
+    return;
+  }
+  const eventProps = { bubbles: true, cancelable: true };
+  element.dispatchEvent(new MouseEvent("mousedown", eventProps));
+  element.dispatchEvent(new MouseEvent("mouseup", eventProps));
+  element.dispatchEvent(new MouseEvent("click", eventProps));
+  if ("focus" in element && typeof element.focus === "function") {
+    element.focus();
+  }
+}
+function executeTab(document, onEvent, getTimestamp) {
+  const focusableElements = getFocusableElements(document);
+  if (focusableElements.length === 0) return;
+  const activeElement = document.activeElement;
+  let currentIndex = -1;
+  if (activeElement) {
+    currentIndex = focusableElements.indexOf(activeElement);
+  }
+  const nextIndex = (currentIndex + 1) % focusableElements.length;
+  const nextElement = focusableElements[nextIndex];
+  dispatchKeyboardEvent(document, {
+    ...KEY_MAP["Tab"],
+    shiftKey: false
+  });
+  if (nextElement && typeof nextElement.focus === "function") {
+    nextElement.focus();
+  }
+  const target = document.activeElement || document.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document),
+    payload: {
+      kind: "keyboard_action",
+      key: "Tab",
+      modifiers: []
+    }
+  };
+  onEvent(keyboardEvent);
+}
+function executeShiftTab(document, onEvent, getTimestamp) {
+  const focusableElements = getFocusableElements(document);
+  if (focusableElements.length === 0) return;
+  const activeElement = document.activeElement;
+  let currentIndex = -1;
+  if (activeElement) {
+    currentIndex = focusableElements.indexOf(activeElement);
+  }
+  const prevIndex = currentIndex <= 0 ? focusableElements.length - 1 : currentIndex - 1;
+  const prevElement = focusableElements[prevIndex];
+  dispatchKeyboardEvent(document, {
+    ...KEY_MAP["Tab"],
+    shiftKey: true
+  });
+  if (prevElement && typeof prevElement.focus === "function") {
+    prevElement.focus();
+  }
+  const target = document.activeElement || document.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document),
+    payload: {
+      kind: "keyboard_action",
+      key: "Tab",
+      modifiers: ["Shift"]
+    }
+  };
+  onEvent(keyboardEvent);
+}
+function executeKeyAction(keyName, document, onEvent, getTimestamp) {
+  const keyInfo = KEY_MAP[keyName];
+  if (!keyInfo) return;
+  dispatchKeyboardEvent(document, {
+    ...keyInfo
+  });
+  const target = document.activeElement || document.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document),
+    payload: {
+      kind: "keyboard_action",
+      key: keyName,
+      modifiers: []
+    }
+  };
+  onEvent(keyboardEvent);
+}
+function executeKeyCombo(combo, document, onEvent, getTimestamp) {
+  const parsed = parseKeyCombo(combo);
+  const keyInfo = getKeyInfo(parsed.key);
+  dispatchKeyboardEvent(document, {
+    ...keyInfo,
+    shiftKey: parsed.shiftKey,
+    ctrlKey: parsed.ctrlKey,
+    altKey: parsed.altKey,
+    metaKey: parsed.metaKey
+  });
+  const target = document.activeElement || document.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document),
+    payload: {
+      kind: "keyboard_action",
+      key: parsed.key,
+      modifiers: parsed.modifiers
+    }
+  };
+  onEvent(keyboardEvent);
+}
+async function executeAction(action, document, onEvent, getTimestamp) {
+  switch (action.type) {
+    case "click":
+      executeClick(action.selector, document, onEvent, getTimestamp);
+      break;
+    case "tab":
+      executeTab(document, onEvent, getTimestamp);
+      break;
+    case "shiftTab":
+      executeShiftTab(document, onEvent, getTimestamp);
+      break;
+    case "escape":
+      executeKeyAction("Escape", document, onEvent, getTimestamp);
+      break;
+    case "enter":
+      executeKeyAction("Enter", document, onEvent, getTimestamp);
+      break;
+    case "space":
+      executeKeyAction(" ", document, onEvent, getTimestamp);
+      break;
+    case "arrowUp":
+      executeKeyAction("ArrowUp", document, onEvent, getTimestamp);
+      break;
+    case "arrowDown":
+      executeKeyAction("ArrowDown", document, onEvent, getTimestamp);
+      break;
+    case "arrowLeft":
+      executeKeyAction("ArrowLeft", document, onEvent, getTimestamp);
+      break;
+    case "arrowRight":
+      executeKeyAction("ArrowRight", document, onEvent, getTimestamp);
+      break;
+    case "key":
+      executeKeyCombo(action.combo, document, onEvent, getTimestamp);
+      break;
+    case "wait":
+      await new Promise((resolve) => setTimeout(resolve, action.ms));
+      break;
+  }
+}
+async function executeSequence(sequence, document, onEvent, getTimestamp, settleTime = 100) {
+  for (let i = 0; i < sequence.actions.length; i++) {
+    const action = sequence.actions[i];
+    await executeAction(action, document, onEvent, getTimestamp);
+    if (i < sequence.actions.length - 1) {
+      await new Promise((resolve) => setTimeout(resolve, settleTime));
+    }
+  }
+}
+
+// src/runtime/heuristics.ts
+var DEFAULT_CONFIG = {
+  dialogFocusTimeout: 100,
+  rapidAnnouncementWindow: 500,
+  rapidAnnouncementThreshold: 3,
+  keyboardResponseTimeout: 200
+};
+function createHeuristicAnalyzer(config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const trackedDialogs = [];
+  const pendingDialogFocusChecks = [];
+  const pendingKeyboardResponses = [];
+  const announcementTimestamps = [];
+  let lastFocusedSelector = null;
+  function createWarning(timestamp, message, target, relatedEvent) {
+    const payload = {
+      kind: "warning",
+      message,
+      relatedEvent
+    };
+    return {
+      type: "WARNING",
+      timestamp,
+      target,
+      payload
+    };
+  }
+  function checkExpiredDialogFocusTimeouts(currentTimestamp) {
+    const warnings = [];
+    for (let i = pendingDialogFocusChecks.length - 1; i >= 0; i--) {
+      const pending = pendingDialogFocusChecks[i];
+      if (pending.resolved) continue;
+      const elapsed = currentTimestamp - pending.openedAt;
+      if (elapsed > cfg.dialogFocusTimeout) {
+        if (pending.isModal) {
+          warnings.push(
+            createWarning(
+              currentTimestamp,
+              "Focus was not moved into modal dialog",
+              {
+                role: "dialog",
+                accessibleName: pending.dialogName,
+                selector: pending.dialogSelector
+              }
+            )
+          );
+        }
+        pending.resolved = true;
+      }
+    }
+    return warnings;
+  }
+  function checkExpiredKeyboardResponses(currentTimestamp) {
+    const warnings = [];
+    for (let i = pendingKeyboardResponses.length - 1; i >= 0; i--) {
+      const pending = pendingKeyboardResponses[i];
+      if (pending.resolved) continue;
+      const elapsed = currentTimestamp - pending.timestamp;
+      if (elapsed > cfg.keyboardResponseTimeout) {
+        warnings.push(
+          createWarning(
+            currentTimestamp,
+            "Keyboard action produced no accessibility response",
+            pending.event.target,
+            pending.event
+          )
+        );
+        pending.resolved = true;
+      }
+    }
+    return warnings;
+  }
+  function checkRapidAnnouncements(currentTimestamp) {
+    const warnings = [];
+    const windowStart = currentTimestamp - cfg.rapidAnnouncementWindow;
+    while (announcementTimestamps.length > 0 && announcementTimestamps[0] < windowStart) {
+      announcementTimestamps.shift();
+    }
+    if (announcementTimestamps.length > cfg.rapidAnnouncementThreshold) {
+      warnings.push(
+        createWarning(
+          currentTimestamp,
+          "Rapid announcements detected: assistive technology users may miss content",
+          {
+            role: "region",
+            accessibleName: "",
+            selector: "body"
+          }
+        )
+      );
+      announcementTimestamps.length = 0;
+    }
+    return warnings;
+  }
+  function checkFocusEscape(event) {
+    const warnings = [];
+    if (event.type !== "FOCUS_CHANGED") return warnings;
+    const modalDialogs = trackedDialogs.filter((d) => d.isModal);
+    if (modalDialogs.length === 0) return warnings;
+    const focusedSelector = event.target.selector;
+    for (const dialog of modalDialogs) {
+      if (!isSelectorInside(focusedSelector, dialog.selector)) {
+        warnings.push(
+          createWarning(
+            event.timestamp,
+            "Focus escaped modal dialog",
+            event.target,
+            event
+          )
+        );
+        break;
+      }
+    }
+    return warnings;
+  }
+  function checkFocusedElementRemoved(event) {
+    const warnings = [];
+    if (event.type === "DOM_MUTATION" && lastFocusedSelector !== null) {
+      if (event.target.selector === lastFocusedSelector) {
+        warnings.push(
+          createWarning(
+            event.timestamp,
+            "Focused element removed without focus management",
+            event.target,
+            event
+          )
+        );
+      }
+    }
+    return warnings;
+  }
+  function isSelectorInside(childSelector, containerSelector) {
+    if (childSelector === containerSelector) return true;
+    if (childSelector.startsWith(containerSelector + " ")) return true;
+    if (childSelector.startsWith(containerSelector + " > ")) return true;
+    if (childSelector.startsWith(containerSelector + ">")) return true;
+    return false;
+  }
+  function processEvent(event) {
+    const warnings = [];
+    warnings.push(...checkExpiredDialogFocusTimeouts(event.timestamp));
+    warnings.push(...checkExpiredKeyboardResponses(event.timestamp));
+    switch (event.type) {
+      case "DIALOG_OPENED": {
+        const payload = event.payload;
+        const dialog = {
+          selector: event.target.selector,
+          name: payload.dialogName,
+          isModal: payload.isModal
+        };
+        trackedDialogs.push(dialog);
+        if (payload.isModal) {
+          pendingDialogFocusChecks.push({
+            dialogSelector: event.target.selector,
+            dialogName: payload.dialogName,
+            openedAt: event.timestamp,
+            isModal: true,
+            resolved: false
+          });
+        }
+        break;
+      }
+      case "DIALOG_CLOSED": {
+        const closedSelector = event.target.selector;
+        const idx = trackedDialogs.findIndex(
+          (d) => d.selector === closedSelector
+        );
+        if (idx !== -1) {
+          trackedDialogs.splice(idx, 1);
+        }
+        for (const pending of pendingDialogFocusChecks) {
+          if (pending.dialogSelector === closedSelector && !pending.resolved) {
+            pending.resolved = true;
+          }
+        }
+        break;
+      }
+      case "FOCUS_CHANGED": {
+        for (const pending of pendingDialogFocusChecks) {
+          if (pending.resolved) continue;
+          if (isSelectorInside(event.target.selector, pending.dialogSelector)) {
+            pending.resolved = true;
+          }
+        }
+        for (const pending of pendingKeyboardResponses) {
+          if (!pending.resolved) {
+            pending.resolved = true;
+          }
+        }
+        warnings.push(...checkFocusEscape(event));
+        lastFocusedSelector = event.target.selector;
+        break;
+      }
+      case "ANNOUNCEMENT": {
+        announcementTimestamps.push(event.timestamp);
+        for (const pending of pendingKeyboardResponses) {
+          if (!pending.resolved) {
+            pending.resolved = true;
+          }
+        }
+        warnings.push(...checkRapidAnnouncements(event.timestamp));
+        break;
+      }
+      case "KEYBOARD_ACTION": {
+        pendingKeyboardResponses.push({
+          event,
+          timestamp: event.timestamp,
+          resolved: false
+        });
+        break;
+      }
+      case "DOM_MUTATION": {
+        warnings.push(...checkFocusedElementRemoved(event));
+        for (const pending of pendingKeyboardResponses) {
+          if (!pending.resolved) {
+            pending.resolved = true;
+          }
+        }
+        break;
+      }
+      case "STATE_CHANGED":
+      case "ROLE_CHANGED":
+      case "ACCESSIBLE_NAME_CHANGED": {
+        for (const pending of pendingKeyboardResponses) {
+          if (!pending.resolved) {
+            pending.resolved = true;
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    cleanupResolvedChecks();
+    return warnings;
+  }
+  function cleanupResolvedChecks() {
+    for (let i = pendingDialogFocusChecks.length - 1; i >= 0; i--) {
+      if (pendingDialogFocusChecks[i].resolved) {
+        pendingDialogFocusChecks.splice(i, 1);
+      }
+    }
+    for (let i = pendingKeyboardResponses.length - 1; i >= 0; i--) {
+      if (pendingKeyboardResponses[i].resolved) {
+        pendingKeyboardResponses.splice(i, 1);
+      }
+    }
+  }
+  return {
+    process(event) {
+      return processEvent(event);
+    },
+    get openDialogs() {
+      return trackedDialogs.map((d) => d.selector);
+    }
+  };
+}
+
+// src/runtime/timeline-generator.ts
+var SPEAKABLE_VERSION = "1.3.0";
+var TIMELINE_FORMAT_VERSION = "1.0";
+var DEFAULT_SETTLE_PERIOD = 500;
+var DEFAULT_LOAD_TIMEOUT = 1e4;
+var DOM_STABILITY_WAIT = 100;
+function createTimelineGenerator(options) {
+  const {
+    document: doc,
+    componentName,
+    storyName,
+    settlePeriod = DEFAULT_SETTLE_PERIOD,
+    loadTimeout = DEFAULT_LOAD_TIMEOUT,
+    heuristics: enableHeuristics = true
+  } = options;
+  let aborted = false;
+  let currentEngine = null;
+  return {
+    async capture(sequence) {
+      aborted = false;
+      await waitForDocumentReady(doc, loadTimeout);
+      if (aborted) {
+        return buildAbortedTimeline(componentName, storyName, sequence);
+      }
+      const engine = createEngine({ document: doc });
+      currentEngine = engine;
+      const heuristicAnalyzer = enableHeuristics ? createHeuristicAnalyzer() : null;
+      const interactionEvents = [];
+      const sessionStart = Date.now();
+      engine.attach();
+      if (aborted) {
+        engine.detach();
+        currentEngine = null;
+        return buildAbortedTimeline(componentName, storyName, sequence);
+      }
+      function getTimestamp() {
+        return Date.now() - sessionStart;
+      }
+      await executeSequence(
+        sequence,
+        doc,
+        (event) => {
+          interactionEvents.push(event);
+        },
+        getTimestamp,
+        DOM_STABILITY_WAIT
+      );
+      if (aborted) {
+        engine.detach();
+        currentEngine = null;
+        return buildAbortedTimeline(componentName, storyName, sequence);
+      }
+      await delay(settlePeriod);
+      engine.detach();
+      currentEngine = null;
+      const duration = Date.now() - sessionStart;
+      const engineEvents = engine.getEvents();
+      const allEvents = mergeEvents(engineEvents, interactionEvents);
+      if (heuristicAnalyzer) {
+        const heuristicWarnings = [];
+        for (const event of allEvents) {
+          const warnings = heuristicAnalyzer.process(event);
+          heuristicWarnings.push(...warnings);
+        }
+        for (const warning of heuristicWarnings) {
+          allEvents.push(warning);
+        }
+        allEvents.sort((a, b) => a.timestamp - b.timestamp);
+      }
+      const allWarnings = allEvents.filter((e) => e.type === "WARNING");
+      const metadata = {
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        speakableVersion: SPEAKABLE_VERSION,
+        sourceUrl: getSourceUrl(doc),
+        userAgent: getUserAgent()
+      };
+      const timeline = {
+        version: TIMELINE_FORMAT_VERSION,
+        component: componentName,
+        story: storyName || null,
+        interactionSequence: sequence.description,
+        duration,
+        events: allEvents,
+        warnings: allWarnings,
+        metadata
+      };
+      return timeline;
+    },
+    abort() {
+      aborted = true;
+      if (currentEngine && currentEngine.isAttached) {
+        currentEngine.detach();
+        currentEngine = null;
+      }
+    }
+  };
+}
+async function waitForDocumentReady(doc, timeout) {
+  if (doc.body) return;
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(
+        new Error(
+          `Document load timeout (${timeout}ms): ${getSourceUrl(doc)}`
+        )
+      );
+    }, timeout);
+    const interval = setInterval(() => {
+      if (doc.body) {
+        clearTimeout(timeoutId);
+        clearInterval(interval);
+        resolve();
+      }
+    }, 50);
+  });
+}
+function mergeEvents(engineEvents, interactionEvents) {
+  const all = [...engineEvents, ...interactionEvents];
+  all.sort((a, b) => a.timestamp - b.timestamp);
+  return all;
+}
+function getSourceUrl(doc) {
+  try {
+    const url = doc.URL;
+    if (url && url !== "about:blank" && url !== "") {
+      return url;
+    }
+  } catch {
+  }
+  return "local";
+}
+function getUserAgent() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.userAgent) {
+      return navigator.userAgent;
+    }
+  } catch {
+  }
+  return "jsdom";
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildAbortedTimeline(componentName, storyName, sequence) {
+  return {
+    version: TIMELINE_FORMAT_VERSION,
+    component: componentName,
+    story: storyName || null,
+    interactionSequence: sequence.description,
+    duration: 0,
+    events: [],
+    warnings: [],
+    metadata: {
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      speakableVersion: SPEAKABLE_VERSION,
+      sourceUrl: "local",
+      userAgent: getUserAgent()
+    }
+  };
+}
+
+// src/runtime/patterns.ts
+var MODAL_DIALOG_DEFAULTS = {
+  trigger: "button",
+  container: '[role="dialog"], dialog'
+};
+var COMBOBOX_DEFAULTS = {
+  input: '[role="combobox"], input[type="text"]',
+  items: '[role="option"]'
+};
+var TABS_DEFAULTS = {
+  container: '[role="tablist"]',
+  items: '[role="tab"]'
+};
+var ACCORDION_DEFAULTS = {
+  trigger: "button[aria-expanded]"
+};
+function buildModalDialogPattern(selectors) {
+  const trigger = selectors?.trigger ?? MODAL_DIALOG_DEFAULTS.trigger;
+  const actions = [
+    { type: "click", selector: trigger },
+    { type: "tab" },
+    { type: "tab" },
+    { type: "tab" },
+    { type: "escape" }
+  ];
+  return {
+    description: "Modal dialog: click trigger to open, tab through dialog content, press Escape to close, verify focus returns to trigger",
+    actions
+  };
+}
+function buildComboboxPattern(selectors) {
+  const input = selectors?.input ?? COMBOBOX_DEFAULTS.input;
+  const actions = [
+    { type: "click", selector: input },
+    { type: "key", combo: "a" },
+    { type: "arrowDown" },
+    { type: "arrowDown" },
+    { type: "enter" }
+  ];
+  return {
+    description: "Combobox: focus input, type to filter, navigate options with arrow keys, select with Enter",
+    actions
+  };
+}
+function buildTabsPattern(selectors) {
+  const container = selectors?.container ?? TABS_DEFAULTS.container;
+  const actions = [
+    { type: "click", selector: container },
+    { type: "arrowRight" },
+    { type: "arrowRight" },
+    { type: "enter" },
+    { type: "arrowLeft" },
+    { type: "space" }
+  ];
+  return {
+    description: "Tabs: focus tablist, navigate between tabs with arrow keys, activate with Enter/Space",
+    actions
+  };
+}
+function buildAccordionPattern(selectors) {
+  const trigger = selectors?.trigger ?? ACCORDION_DEFAULTS.trigger;
+  const actions = [
+    { type: "click", selector: trigger },
+    { type: "enter" },
+    { type: "arrowDown" },
+    { type: "space" },
+    { type: "arrowDown" },
+    { type: "enter" }
+  ];
+  return {
+    description: "Accordion: focus header, toggle with Enter/Space, navigate between headers with arrow keys",
+    actions
+  };
+}
+function getBuiltinPattern(name, selectors) {
+  switch (name) {
+    case "modal-dialog":
+      return buildModalDialogPattern(selectors);
+    case "combobox":
+      return buildComboboxPattern(selectors);
+    case "tabs":
+      return buildTabsPattern(selectors);
+    case "accordion":
+      return buildAccordionPattern(selectors);
+  }
+}
+
+// src/runtime/serialization.ts
+var VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "FOCUS_CHANGED",
+  "ANNOUNCEMENT",
+  "DOM_MUTATION",
+  "ROLE_CHANGED",
+  "ACCESSIBLE_NAME_CHANGED",
+  "STATE_CHANGED",
+  "KEYBOARD_ACTION",
+  "DIALOG_OPENED",
+  "DIALOG_CLOSED",
+  "WARNING",
+  "REGRESSION"
+]);
+var VALID_PAYLOAD_KINDS = /* @__PURE__ */ new Set([
+  "focus_changed",
+  "announcement",
+  "role_changed",
+  "accessible_name_changed",
+  "state_changed",
+  "dialog_opened",
+  "dialog_closed",
+  "keyboard_action",
+  "warning"
+]);
+var VALID_ACTION_TYPES = /* @__PURE__ */ new Set([
+  "click",
+  "tab",
+  "shiftTab",
+  "escape",
+  "enter",
+  "space",
+  "arrowUp",
+  "arrowDown",
+  "arrowLeft",
+  "arrowRight",
+  "key",
+  "wait"
+]);
+function sortKeysDeep(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (typeof value === "object") {
+    const sorted = {};
+    const keys = Object.keys(value).sort();
+    for (const key of keys) {
+      sorted[key] = sortKeysDeep(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function serializeEvent(event) {
+  const sorted = sortKeysDeep(event);
+  return JSON.stringify(sorted, null, 2);
+}
+function deserializeEvent(json) {
+  const parsed = JSON.parse(json);
+  validateEvent(parsed);
+  return parsed;
+}
+function serializeTimeline(timeline) {
+  const sorted = sortKeysDeep(timeline);
+  return JSON.stringify(sorted, null, 2);
+}
+function deserializeTimeline(json) {
+  const parsed = JSON.parse(json);
+  validateTimeline(parsed);
+  return parsed;
+}
+function serializeInteractionSequence(seq) {
+  const sorted = sortKeysDeep(seq);
+  return JSON.stringify(sorted, null, 2);
+}
+function deserializeInteractionSequence(json) {
+  const parsed = JSON.parse(json);
+  validateInteractionSequence(parsed);
+  return parsed;
+}
+function timelinesEqual(a, b) {
+  return serializeTimeline(a) === serializeTimeline(b);
+}
+function validateEvent(obj) {
+  if (obj === null || typeof obj !== "object") {
+    throw new Error("Event must be a non-null object");
+  }
+  const event = obj;
+  if (typeof event.type !== "string" || !VALID_EVENT_TYPES.has(event.type)) {
+    throw new Error(
+      `Event "type" must be one of: ${[...VALID_EVENT_TYPES].join(", ")}. Got: ${String(event.type)}`
+    );
+  }
+  if (typeof event.timestamp !== "number" || !Number.isFinite(event.timestamp)) {
+    throw new Error('Event "timestamp" must be a finite number');
+  }
+  validateEventTarget(event.target, 'Event "target"');
+  validatePayload(event.payload);
+}
+function validateEventTarget(obj, label) {
+  if (obj === null || typeof obj !== "object") {
+    throw new Error(`${label} must be a non-null object`);
+  }
+  const target = obj;
+  if (typeof target.role !== "string") {
+    throw new Error(`${label}.role must be a string`);
+  }
+  if (typeof target.accessibleName !== "string") {
+    throw new Error(`${label}.accessibleName must be a string`);
+  }
+  if (typeof target.selector !== "string") {
+    throw new Error(`${label}.selector must be a string`);
+  }
+}
+function validatePayload(obj) {
+  if (obj === null || typeof obj !== "object") {
+    throw new Error('Event "payload" must be a non-null object');
+  }
+  const payload = obj;
+  if (typeof payload.kind !== "string" || !VALID_PAYLOAD_KINDS.has(payload.kind)) {
+    throw new Error(
+      `Payload "kind" must be one of: ${[...VALID_PAYLOAD_KINDS].join(", ")}. Got: ${String(payload.kind)}`
+    );
+  }
+  switch (payload.kind) {
+    case "focus_changed":
+      if (payload.previousTarget !== null) {
+        validateEventTarget(payload.previousTarget, "FocusChangedPayload.previousTarget");
+      }
+      break;
+    case "announcement":
+      if (payload.politeness !== "polite" && payload.politeness !== "assertive") {
+        throw new Error('AnnouncementPayload.politeness must be "polite" or "assertive"');
+      }
+      if (typeof payload.text !== "string") {
+        throw new Error("AnnouncementPayload.text must be a string");
+      }
+      break;
+    case "role_changed":
+      if (typeof payload.previousRole !== "string") {
+        throw new Error("RoleChangedPayload.previousRole must be a string");
+      }
+      if (typeof payload.newRole !== "string") {
+        throw new Error("RoleChangedPayload.newRole must be a string");
+      }
+      break;
+    case "accessible_name_changed":
+      if (typeof payload.previousName !== "string") {
+        throw new Error("AccessibleNameChangedPayload.previousName must be a string");
+      }
+      if (typeof payload.newName !== "string") {
+        throw new Error("AccessibleNameChangedPayload.newName must be a string");
+      }
+      break;
+    case "state_changed":
+      if (typeof payload.attribute !== "string") {
+        throw new Error("StateChangedPayload.attribute must be a string");
+      }
+      validateStateValue(payload.previousValue, "StateChangedPayload.previousValue");
+      validateStateValue(payload.newValue, "StateChangedPayload.newValue");
+      break;
+    case "dialog_opened":
+      if (typeof payload.dialogName !== "string") {
+        throw new Error("DialogOpenedPayload.dialogName must be a string");
+      }
+      if (typeof payload.isModal !== "boolean") {
+        throw new Error("DialogOpenedPayload.isModal must be a boolean");
+      }
+      break;
+    case "dialog_closed":
+      if (typeof payload.dialogName !== "string") {
+        throw new Error("DialogClosedPayload.dialogName must be a string");
+      }
+      break;
+    case "keyboard_action":
+      if (typeof payload.key !== "string") {
+        throw new Error("KeyboardActionPayload.key must be a string");
+      }
+      if (!Array.isArray(payload.modifiers)) {
+        throw new Error("KeyboardActionPayload.modifiers must be an array");
+      }
+      for (const mod of payload.modifiers) {
+        if (typeof mod !== "string") {
+          throw new Error("KeyboardActionPayload.modifiers must contain only strings");
+        }
+      }
+      break;
+    case "warning":
+      if (typeof payload.message !== "string") {
+        throw new Error("WarningPayload.message must be a string");
+      }
+      if (payload.relatedEvent !== void 0 && payload.relatedEvent !== null) {
+        validateEvent(payload.relatedEvent);
+      }
+      break;
+  }
+}
+function validateStateValue(value, label) {
+  if (value !== null && typeof value !== "string" && typeof value !== "boolean") {
+    throw new Error(`${label} must be a string, boolean, or null`);
+  }
+}
+function validateTimeline(obj) {
+  if (obj === null || typeof obj !== "object") {
+    throw new Error("Timeline must be a non-null object");
+  }
+  const timeline = obj;
+  if (typeof timeline.version !== "string") {
+    throw new Error('Timeline "version" must be a string');
+  }
+  if (typeof timeline.component !== "string") {
+    throw new Error('Timeline "component" must be a string');
+  }
+  if (timeline.story !== null && typeof timeline.story !== "string") {
+    throw new Error('Timeline "story" must be a string or null');
+  }
+  if (typeof timeline.interactionSequence !== "string") {
+    throw new Error('Timeline "interactionSequence" must be a string');
+  }
+  if (typeof timeline.duration !== "number" || !Number.isFinite(timeline.duration)) {
+    throw new Error('Timeline "duration" must be a finite number');
+  }
+  if (!Array.isArray(timeline.events)) {
+    throw new Error('Timeline "events" must be an array');
+  }
+  for (let i = 0; i < timeline.events.length; i++) {
+    try {
+      validateEvent(timeline.events[i]);
+    } catch (err) {
+      throw new Error(
+        `Timeline events[${i}]: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (!Array.isArray(timeline.warnings)) {
+    throw new Error('Timeline "warnings" must be an array');
+  }
+  for (let i = 0; i < timeline.warnings.length; i++) {
+    try {
+      validateEvent(timeline.warnings[i]);
+    } catch (err) {
+      throw new Error(
+        `Timeline warnings[${i}]: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  validateTimelineMetadata(timeline.metadata);
+}
+function validateTimelineMetadata(obj) {
+  if (obj === null || typeof obj !== "object") {
+    throw new Error('Timeline "metadata" must be a non-null object');
+  }
+  const meta = obj;
+  if (typeof meta.capturedAt !== "string") {
+    throw new Error("Timeline metadata.capturedAt must be a string");
+  }
+  if (typeof meta.speakableVersion !== "string") {
+    throw new Error("Timeline metadata.speakableVersion must be a string");
+  }
+  if (typeof meta.sourceUrl !== "string") {
+    throw new Error("Timeline metadata.sourceUrl must be a string");
+  }
+  if (typeof meta.userAgent !== "string") {
+    throw new Error("Timeline metadata.userAgent must be a string");
+  }
+}
+function validateInteractionSequence(obj) {
+  if (obj === null || typeof obj !== "object") {
+    throw new Error("InteractionSequence must be a non-null object");
+  }
+  const seq = obj;
+  if (typeof seq.description !== "string") {
+    throw new Error('InteractionSequence "description" must be a string');
+  }
+  if (!Array.isArray(seq.actions)) {
+    throw new Error('InteractionSequence "actions" must be an array');
+  }
+  for (let i = 0; i < seq.actions.length; i++) {
+    validateAction(seq.actions[i], i);
+  }
+}
+function validateAction(obj, index) {
+  if (obj === null || typeof obj !== "object") {
+    throw new Error(`InteractionSequence actions[${index}] must be a non-null object`);
+  }
+  const action = obj;
+  if (typeof action.type !== "string" || !VALID_ACTION_TYPES.has(action.type)) {
+    throw new Error(
+      `InteractionSequence actions[${index}].type must be one of: ${[...VALID_ACTION_TYPES].join(", ")}. Got: ${String(action.type)}`
+    );
+  }
+  switch (action.type) {
+    case "click":
+      if (typeof action.selector !== "string") {
+        throw new Error(
+          `InteractionSequence actions[${index}].selector must be a string for click actions`
+        );
+      }
+      break;
+    case "key":
+      if (typeof action.combo !== "string") {
+        throw new Error(
+          `InteractionSequence actions[${index}].combo must be a string for key actions`
+        );
+      }
+      break;
+    case "wait":
+      if (typeof action.ms !== "number" || !Number.isFinite(action.ms)) {
+        throw new Error(
+          `InteractionSequence actions[${index}].ms must be a finite number for wait actions`
+        );
+      }
+      break;
+  }
+}
+
+// src/runtime/diff-engine.ts
+function matchingKey(event) {
+  return `${event.type}::${event.target.selector}`;
+}
+function payloadsEqual(a, b) {
+  if (a.type !== b.type) return false;
+  if (!targetsEqual(a.target, b.target)) return false;
+  return deepEqual(a.payload, b.payload);
+}
+function targetsEqual(a, b) {
+  return a.role === b.role && a.accessibleName === b.accessibleName && a.selector === b.selector;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return a === b;
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj).sort();
+  const bKeys = Object.keys(bObj).sort();
+  if (aKeys.length !== bKeys.length) return false;
+  for (let i = 0; i < aKeys.length; i++) {
+    if (aKeys[i] !== bKeys[i]) return false;
+    if (!deepEqual(aObj[aKeys[i]], bObj[bKeys[i]])) return false;
+  }
+  return true;
+}
+function buildModifiedMessage(baseline, current) {
+  const type = current.type;
+  const selector = current.target.selector;
+  if (baseline.target.accessibleName !== current.target.accessibleName) {
+    return `${type} on "${selector}": accessible name changed from "${baseline.target.accessibleName}" to "${current.target.accessibleName}"`;
+  }
+  if (baseline.target.role !== current.target.role) {
+    return `${type} on "${selector}": role changed from "${baseline.target.role}" to "${current.target.role}"`;
+  }
+  return `${type} on "${selector}": payload values differ`;
+}
+function diffTimelines(baseline, current) {
+  const added = [];
+  const removed = [];
+  const modified = [];
+  const currentByKey = /* @__PURE__ */ new Map();
+  for (const event of current.events) {
+    const key = matchingKey(event);
+    const existing = currentByKey.get(key);
+    if (existing) {
+      existing.push(event);
+    } else {
+      currentByKey.set(key, [event]);
+    }
+  }
+  const matchedCurrentIndices = /* @__PURE__ */ new Set();
+  for (const baselineEvent of baseline.events) {
+    const key = matchingKey(baselineEvent);
+    const candidates = currentByKey.get(key);
+    if (!candidates || candidates.length === 0) {
+      removed.push({
+        event: baselineEvent,
+        message: `${baselineEvent.type} on "${baselineEvent.target.selector}" was removed`
+      });
+      continue;
+    }
+    let matched = false;
+    for (let i = 0; i < candidates.length; i++) {
+      const candidateId = `${key}::${i}`;
+      if (matchedCurrentIndices.has(candidateId)) continue;
+      const currentEvent = candidates[i];
+      matchedCurrentIndices.add(candidateId);
+      if (!payloadsEqual(baselineEvent, currentEvent)) {
+        modified.push({
+          event: currentEvent,
+          previousEvent: baselineEvent,
+          message: buildModifiedMessage(baselineEvent, currentEvent)
+        });
+      }
+      matched = true;
+      break;
+    }
+    if (!matched) {
+      removed.push({
+        event: baselineEvent,
+        message: `${baselineEvent.type} on "${baselineEvent.target.selector}" was removed`
+      });
+    }
+  }
+  for (const [key, candidates] of currentByKey.entries()) {
+    for (let i = 0; i < candidates.length; i++) {
+      const candidateId = `${key}::${i}`;
+      if (!matchedCurrentIndices.has(candidateId)) {
+        const event = candidates[i];
+        added.push({
+          event,
+          message: `${event.type} on "${event.target.selector}" was added`
+        });
+      }
+    }
+  }
+  return {
+    baseline: { totalEvents: baseline.events.length },
+    current: { totalEvents: current.events.length },
+    added,
+    removed,
+    modified,
+    summary: {
+      totalBaseline: baseline.events.length,
+      totalCurrent: current.events.length,
+      added: added.length,
+      removed: removed.length,
+      modified: modified.length
+    }
+  };
+}
+
+// src/runtime/severity.ts
+function classifyDiff(report) {
+  const entries = [];
+  for (const entry of report.removed) {
+    const severity = classifyRemoved(entry);
+    entries.push({ ...entry, severity });
+  }
+  for (const entry of report.added) {
+    const severity = classifyAdded(entry);
+    entries.push({ ...entry, severity });
+  }
+  for (const entry of report.modified) {
+    const severity = classifyModified(entry);
+    entries.push({ ...entry, severity });
+  }
+  const criticalCount = entries.filter((e) => e.severity === "critical").length;
+  const highCount = entries.filter((e) => e.severity === "high").length;
+  const mediumCount = entries.filter((e) => e.severity === "medium").length;
+  const lowCount = entries.filter((e) => e.severity === "low").length;
+  let highestSeverity = null;
+  if (criticalCount > 0) highestSeverity = "critical";
+  else if (highCount > 0) highestSeverity = "high";
+  else if (mediumCount > 0) highestSeverity = "medium";
+  else if (lowCount > 0) highestSeverity = "low";
+  return { entries, highestSeverity, criticalCount, highCount, mediumCount, lowCount };
+}
+function classifyRemoved(entry) {
+  switch (entry.event.type) {
+    case "FOCUS_CHANGED":
+      return "critical";
+    case "ANNOUNCEMENT":
+      return "critical";
+    case "DIALOG_OPENED":
+      return "high";
+    case "DIALOG_CLOSED":
+      return "high";
+    case "STATE_CHANGED":
+      return "high";
+    case "KEYBOARD_ACTION":
+      return "medium";
+    default:
+      return "medium";
+  }
+}
+function classifyAdded(entry) {
+  switch (entry.event.type) {
+    case "WARNING":
+      return "high";
+    case "REGRESSION":
+      return "critical";
+    case "ANNOUNCEMENT":
+      return "medium";
+    case "FOCUS_CHANGED":
+      return "medium";
+    default:
+      return "low";
+  }
+}
+function classifyModified(entry) {
+  switch (entry.event.type) {
+    case "FOCUS_CHANGED":
+      return "high";
+    case "STATE_CHANGED":
+      return "high";
+    case "ACCESSIBLE_NAME_CHANGED":
+      return "medium";
+    case "ANNOUNCEMENT":
+      return "medium";
+    default:
+      return "medium";
+  }
+}
+
+// src/runtime/baseline-storage.ts
+import { readFile, writeFile, mkdir, access } from "fs/promises";
+import { join, dirname } from "path";
+var SPEAKABLE_VERSION2 = "1.3.0";
+function createBaselineStorage(baseDir) {
+  function sanitize(name) {
+    return name.toLowerCase().replace(/[/\\]/g, "-").replace(/[^a-z0-9._-]/g, "-");
+  }
+  function getPath(componentName, storyName) {
+    return join(baseDir, sanitize(componentName), `${sanitize(storyName)}.timeline.json`);
+  }
+  return {
+    async save(componentName, storyName, timeline, meta) {
+      const filePath = getPath(componentName, storyName);
+      const dir = dirname(filePath);
+      try {
+        await mkdir(dir, { recursive: true });
+      } catch (err) {
+        throw new Error(`Cannot create baseline directory "${dir}": ${err.message}`);
+      }
+      const baselineFile = {
+        baseline: {
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          speakableVersion: SPEAKABLE_VERSION2,
+          storybookUrl: meta?.storybookUrl,
+          interactionSequence: timeline.interactionSequence
+        },
+        timeline
+      };
+      const json = JSON.stringify(baselineFile, null, 2);
+      try {
+        await writeFile(filePath, json, "utf-8");
+      } catch (err) {
+        throw new Error(`Cannot write baseline file "${filePath}": ${err.message}`);
+      }
+    },
+    async load(componentName, storyName) {
+      const filePath = getPath(componentName, storyName);
+      try {
+        const content = await readFile(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        return parsed;
+      } catch {
+        return null;
+      }
+    },
+    async exists(componentName, storyName) {
+      const filePath = getPath(componentName, storyName);
+      try {
+        await access(filePath);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    getBaselinePath(componentName, storyName) {
+      return getPath(componentName, storyName);
+    }
+  };
+}
 export {
   CURRENT_MODEL_VERSION,
+  ParsingError,
   SUPPORTED_ROLES,
+  SelectorError,
   ValidationError,
+  buildAccessibilityTree,
+  buildAccessibilityTreeWithSelector,
   cloneModel,
+  computeAccessibleDescription,
+  computeAccessibleName,
+  computeRole,
   createModel,
   describeChange,
   deserializeModel,
   diffAccessibilityTrees,
+  extractFocusInfo,
+  extractState,
+  extractValue,
   formatDiffAsJSON,
   formatDiffAsText,
   formatDiffForCI,
+  generateAuditReport,
   hasAccessibilityRegression,
+  isAccessible,
   modelsEqual,
+  parseHTML,
+  parseHTMLStrict,
+  renderAuditReport,
+  renderJAWS,
+  renderNVDA,
+  renderNarrator,
+  renderVoiceOver,
+  runtime_exports as runtime,
   serializeModel,
+  validateHTMLNotEmpty,
   validateModel,
   validateRole,
   validateState,