@reticular/speakable 1.6.0 → 1.8.0

package/dist/storybook/dist/preview.js

@@ -1,8 +1,14 @@
 import {
   EVENT_RESULT,
+  EVENT_TIMELINE
+} from "./chunk-QVJRQZT5.js";
+import {
+  awaitCustomElementsReady
+} from "./chunk-3SVI6IQE.js";
+import {
   __commonJS,
   __toESM
-} from "./chunk-CL3DJBD7.js";
+} from "./chunk-JSBRDJBE.js";
 
 // ../node_modules/picocolors/picocolors.browser.js
 var require_picocolors_browser = __commonJS({
@@ -61,6 +67,12 @@ var SUPPORTED_ROLES = [
   "meter",
   "progressbar",
   "status",
+  "switch",
+  "slider",
+  "spinbutton",
+  "tab",
+  "tablist",
+  "tabpanel",
   "document",
   "application",
   "separator"
@@ -360,7 +372,10 @@ var INPUT_TYPE_ROLE_MAP = {
   "search": "textbox",
   "tel": "textbox",
   "url": "textbox",
-  "number": "textbox"
+  // Per ARIA, <input type="number"> has an implicit role of spinbutton
+  // (VoiceOver announces it as "stepper").
+  "number": "spinbutton",
+  "range": "slider"
 };
 function computeRole(element) {
   const warnings = [];
@@ -393,6 +408,11 @@ function computeImplicitRole(element, _warnings) {
   if (tagName === "input") {
     return computeInputRole(element);
   }
+  if (tagName === "select") {
+    const multiple = element.hasAttribute("multiple");
+    const size = parseInt(element.getAttribute("size") || "0", 10);
+    return multiple || size > 1 ? "listbox" : "combobox";
+  }
   if (tagName === "a") {
     return element.hasAttribute("href") ? "link" : null;
   }
@@ -796,6 +816,7 @@ function processChildNode(node, children, warnings) {
   if (node.nodeType === 1) {
     const element = node;
     if (isHidden(element)) return;
+    if (isConsumedLabel(element)) return;
     if (!isAccessible(element)) {
       const grandchildren = collectChildrenFromRolelessElement(element, warnings);
       children.push(...grandchildren);
@@ -805,18 +826,74 @@ function processChildNode(node, children, warnings) {
     if (childNode) children.push(childNode);
   }
 }
+function isConsumedLabel(element) {
+  if (element.tagName.toLowerCase() !== "label") return false;
+  const forId = element.getAttribute("for");
+  if (forId) {
+    const doc = element.ownerDocument;
+    const target = doc?.getElementById(forId);
+    if (target && isLabelableControl(target)) return true;
+  }
+  const wrapped = element.querySelector("input, select, textarea, button, meter, progress");
+  if (wrapped && isLabelableControl(wrapped)) return true;
+  return false;
+}
+function isLabelableControl(element) {
+  const tag = element.tagName.toLowerCase();
+  if (tag === "input") {
+    return (element.getAttribute("type") || "text").toLowerCase() !== "hidden";
+  }
+  return tag === "select" || tag === "textarea" || tag === "button" || tag === "meter" || tag === "progress";
+}
 function collectChildrenFromRolelessElement(element, warnings) {
+  return collectAccessibleChildren(element, warnings);
+}
+function collectAccessibleChildren(element, warnings) {
   const children = [];
   if (element.shadowRoot) {
     for (const child of Array.from(element.shadowRoot.childNodes)) {
-      processChildNode(child, children, warnings);
+      processShadowNode(child, children, warnings);
     }
+    return children;
+  }
+  if (element.localName && element.localName.includes("-") && element.childNodes.length === 0) {
+    warnings.push({
+      message: `Custom element <${element.localName}> has no accessible children and may have a closed shadow root; its content could not be analyzed.`,
+      element
+    });
   }
   for (const child of Array.from(element.childNodes)) {
     processChildNode(child, children, warnings);
   }
   return children;
 }
+function processShadowNode(node, children, warnings) {
+  if (node.nodeType === 1) {
+    const element = node;
+    if (element.localName === "slot") {
+      const slot = element;
+      let assigned = [];
+      if (typeof slot.assignedNodes === "function") {
+        try {
+          assigned = Array.from(slot.assignedNodes({ flatten: true }));
+        } catch {
+          assigned = [];
+        }
+      }
+      if (assigned.length > 0) {
+        for (const assignedNode of assigned) {
+          processChildNode(assignedNode, children, warnings);
+        }
+      } else {
+        for (const child of Array.from(slot.childNodes)) {
+          processShadowNode(child, children, warnings);
+        }
+      }
+      return;
+    }
+  }
+  processChildNode(node, children, warnings);
+}
 function buildAccessibilityTree(rootElement, sourceHash) {
   const warnings = [];
   if (isHidden(rootElement)) {
@@ -848,6 +925,30 @@ function buildAccessibilityTree(rootElement, sourceHash) {
   };
   return { model, warnings };
 }
+var SET_MEMBER_ROLES = /* @__PURE__ */ new Set([
+  "radio",
+  "option",
+  "listitem",
+  "tab"
+]);
+function assignImplicitSetPosition(children) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const child of children) {
+    if (SET_MEMBER_ROLES.has(child.role)) {
+      totals.set(child.role, (totals.get(child.role) ?? 0) + 1);
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const child of children) {
+    if (!SET_MEMBER_ROLES.has(child.role)) continue;
+    const total = totals.get(child.role);
+    if (total < 2) continue;
+    const pos = (seen.get(child.role) ?? 0) + 1;
+    seen.set(child.role, pos);
+    if (child.state.posinset === void 0) child.state.posinset = pos;
+    if (child.state.setsize === void 0) child.state.setsize = total;
+  }
+}
 function buildNodeRecursive(element, warnings) {
   if (isHidden(element)) {
     return null;
@@ -884,15 +985,15 @@ function buildNodeRecursive(element, warnings) {
     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);
+  let children = collectAccessibleChildren(element, warnings);
+  const isNativeSelect = element.tagName.toLowerCase() === "select";
+  if (isNativeSelect && roleResult.role === "combobox") {
+    children = [];
+    if (stateResult.state.expanded === void 0) {
+      stateResult.state.expanded = false;
     }
   }
-  for (const child of Array.from(element.childNodes)) {
-    processChildNode(child, children, warnings);
-  }
+  assignImplicitSetPosition(children);
   const node = {
     role: roleResult.role,
     name: nameResult.name,
@@ -905,15 +1006,7 @@ function buildNodeRecursive(element, warnings) {
   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);
-  }
+  const children = collectAccessibleChildren(rootElement, warnings);
   return {
     role: "generic",
     name: "",
@@ -1397,8 +1490,45 @@ function renderNodeVoiceOver(node, announcements, c) {
     renderNodeVoiceOver(child, announcements, c);
   }
 }
+function isValueFirstWidget(role) {
+  return role === "slider" || role === "spinbutton" || role === "combobox";
+}
+function isValueBeforeRoleWidget(role) {
+  return role === "progressbar" || role === "meter";
+}
+function isSilentContainerVoiceOver(node) {
+  if (node.role !== "list" && node.role !== "status") return false;
+  if (node.name) return false;
+  return node.children.length > 0;
+}
 function formatNodeVoiceOver(node, c) {
+  if (isSilentContainerVoiceOver(node)) {
+    return "";
+  }
   const parts = [];
+  const valueFirst = isValueFirstWidget(node.role) && node.value !== void 0;
+  if (valueFirst) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) parts.push(valueText);
+    if (node.name) parts.push(c.elementName(node.name));
+    const roleText = formatRoleVoiceOver(node);
+    if (roleText) parts.push(c.roleName(roleText));
+    const stateText2 = formatStatesVoiceOver(node);
+    if (stateText2) parts.push(c.stateName(stateText2));
+    if (node.description) parts.push(c.description(node.description));
+    return parts.join(", ");
+  }
+  if (isValueBeforeRoleWidget(node.role) && node.value !== void 0) {
+    if (node.name) parts.push(c.elementName(node.name));
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) parts.push(valueText);
+    const roleText = formatRoleVoiceOver(node);
+    if (roleText) parts.push(c.roleName(roleText));
+    const stateText2 = formatStatesVoiceOver(node);
+    if (stateText2) parts.push(c.stateName(stateText2));
+    if (node.description) parts.push(c.description(node.description));
+    return parts.join(", ");
+  }
   const roleFirst = shouldAnnounceRoleFirst(node.role);
   if (roleFirst) {
     const roleText = formatRoleVoiceOver(node);
@@ -1427,6 +1557,9 @@ function formatNodeVoiceOver(node, c) {
       parts.push(valueText);
     }
   }
+  if (node.state.posinset !== void 0 && node.state.setsize !== void 0) {
+    parts.push(`${node.state.posinset} of ${node.state.setsize}`);
+  }
   if (node.description) {
     parts.push(c.description(node.description));
   }
@@ -1462,7 +1595,7 @@ function formatRoleVoiceOver(node) {
     case "list":
       return "list";
     case "listitem":
-      return "item";
+      return "";
     case "navigation":
       return "navigation";
     case "main":
@@ -1518,6 +1651,18 @@ function formatRoleVoiceOver(node) {
       return "progress indicator";
     case "status":
       return "status";
+    case "switch":
+      return "switch";
+    case "slider":
+      return "slider";
+    case "spinbutton":
+      return "stepper";
+    case "tab":
+      return "tab";
+    case "tablist":
+      return node.name ? "tab group" : "tab group";
+    case "tabpanel":
+      return "tab panel";
     case "group":
       return node.name ? "group" : "";
     case "document":
@@ -1538,6 +1683,10 @@ function formatStatesVoiceOver(node) {
   if (node.state.checked !== void 0) {
     if (node.state.checked === "mixed") {
       states.push("mixed");
+    } else if (node.role === "switch") {
+      states.push(node.state.checked ? "on" : "off");
+    } else if (node.role === "radio") {
+      if (node.state.checked) states.push("selected");
     } else {
       states.push(node.state.checked ? "checked" : "unchecked");
     }
@@ -1546,10 +1695,10 @@ function formatStatesVoiceOver(node) {
     if (node.state.pressed === "mixed") {
       states.push("mixed");
     } else {
-      states.push(node.state.pressed ? "pressed" : "not pressed");
+      states.push(node.state.pressed ? "selected" : "unselected");
     }
   }
-  if (node.state.selected !== void 0) {
+  if (node.state.selected !== void 0 && node.role !== "tab") {
     states.push(node.state.selected ? "selected" : "unselected");
   }
   if (node.state.disabled) {
@@ -1999,7 +2148,7 @@ function detectInteractiveIssues(elements, issues) {
   });
 }
 
-// src/analyzer.ts
+// ../src/browser/analyze.ts
 var LANDMARK_ROLES = /* @__PURE__ */ new Set([
   "navigation",
   "main",
@@ -2042,37 +2191,2078 @@ function convertAuditFindings(model) {
     selector: issue.element ? `${issue.element.role}${issue.element.name ? ` "${issue.element.name}"` : ""}` : issue.suggestion || ""
   }));
 }
-function analyzeDOM(root) {
-  const { model } = buildAccessibilityTree(root);
-  const nvdaText = renderNVDA(model, false);
-  const jawsText = renderJAWS(model, false);
-  const voiceoverText = renderVoiceOver(model, false);
-  const narratorText = renderNarrator(model, false);
-  const nvda = nvdaText.split("\n").filter(Boolean);
-  const jaws = jawsText.split("\n").filter(Boolean);
-  const voiceover = voiceoverText.split("\n").filter(Boolean);
-  const narrator = narratorText.split("\n").filter(Boolean);
+function emptyResult(extraWarnings = []) {
+  return {
+    nvda: [],
+    jaws: [],
+    voiceover: [],
+    narrator: [],
+    audit: [],
+    stats: { totalElements: 0, interactiveElements: 0, landmarks: 0, headings: 0 },
+    warnings: [...extraWarnings]
+  };
+}
+function analyzeElement(root, extraWarnings = []) {
+  if (!root) {
+    return emptyResult(extraWarnings);
+  }
+  let built;
+  try {
+    built = buildAccessibilityTree(root);
+  } catch (err) {
+    return emptyResult([
+      ...extraWarnings,
+      `Analysis failed: ${err instanceof Error ? err.message : String(err)}`
+    ]);
+  }
+  const { model, warnings: treeWarnings } = built;
+  const nvda = renderNVDA(model, false).split("\n").filter(Boolean);
+  const jaws = renderJAWS(model, false).split("\n").filter(Boolean);
+  const voiceover = renderVoiceOver(model, false).split("\n").filter(Boolean);
+  const narrator = renderNarrator(model, false).split("\n").filter(Boolean);
   const audit = convertAuditFindings(model);
   const stats = countStats(model.root);
-  return { nvda, jaws, voiceover, narrator, audit, stats };
+  const warnings = [
+    ...extraWarnings,
+    ...treeWarnings.map((w) => w.message)
+  ];
+  return { nvda, jaws, voiceover, narrator, audit, stats, warnings };
 }
 
-// src/preview.ts
-var currentObserver = null;
-var debounceTimer = null;
-function getChannel() {
-  return window.__STORYBOOK_ADDONS_CHANNEL__;
+// src/analyzer.ts
+function analyzeDOM(root) {
+  return analyzeElement(root);
 }
-function findStoryRoot() {
-  return document.getElementById("storybook-root") || document.getElementById("root") || document.body;
+
+// ../src/runtime/selector.ts
+function generateSelector(element) {
+  if (element.id) {
+    return `#${escapeCSSIdentifier(element.id)}`;
+  }
+  const document2 = element.ownerDocument;
+  if (!document2) {
+    return getTagName(element);
+  }
+  const segments = [];
+  let current = element;
+  while (current && current !== document2.documentElement) {
+    const segment = buildSegment(current, document2);
+    segments.unshift(segment);
+    const partialSelector = segments.join(" > ");
+    try {
+      const matches = document2.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 runAnalysis() {
-  const root = findStoryRoot();
-  if (!root) return;
-  const analysis = analyzeDOM(root);
-  const channel = getChannel();
-  if (channel) {
-    channel.emit(EVENT_RESULT, analysis);
+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, document2) {
+  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 = document2.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, document2) {
+  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 = document2.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(document2, 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 = document2.querySelectorAll("[aria-live]");
+    ariaLiveElements.forEach((el) => {
+      if (getLiveRegionPoliteness(el) !== null) {
+        trackRegion(el);
+      }
+    });
+    IMPLICIT_LIVE_ROLES.forEach((role) => {
+      const roleElements = document2.querySelectorAll(`[role="${role}"]`);
+      roleElements.forEach((el) => {
+        if (!trackedRegions.has(el)) {
+          trackRegion(el);
+        }
+      });
+    });
+  }
+  function start() {
+    discoverExistingRegions();
+    contentObserver = new MutationObserver(handleContentMutations);
+    const body = document2.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, document2) {
+  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 = document2.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(document2) {
+  return Array.from(document2.querySelectorAll(FOCUSABLE_SELECTOR));
+}
+function computeAccessibleName4(element, document2) {
+  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 = document2.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, document2) {
+  return {
+    role: getElementRole3(element),
+    accessibleName: computeAccessibleName4(element, document2),
+    selector: generateSelector(element)
+  };
+}
+function dispatchKeyboardEvent(document2, options) {
+  const target = document2.activeElement || document2.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, document2, onEvent, getTimestamp) {
+  const element = document2.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(document2, onEvent, getTimestamp) {
+  const focusableElements = getFocusableElements(document2);
+  if (focusableElements.length === 0) return;
+  const activeElement = document2.activeElement;
+  let currentIndex = -1;
+  if (activeElement) {
+    currentIndex = focusableElements.indexOf(activeElement);
+  }
+  const nextIndex = (currentIndex + 1) % focusableElements.length;
+  const nextElement = focusableElements[nextIndex];
+  dispatchKeyboardEvent(document2, {
+    ...KEY_MAP["Tab"],
+    shiftKey: false
+  });
+  if (nextElement && typeof nextElement.focus === "function") {
+    nextElement.focus();
+  }
+  const target = document2.activeElement || document2.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document2),
+    payload: {
+      kind: "keyboard_action",
+      key: "Tab",
+      modifiers: []
+    }
+  };
+  onEvent(keyboardEvent);
+}
+function executeShiftTab(document2, onEvent, getTimestamp) {
+  const focusableElements = getFocusableElements(document2);
+  if (focusableElements.length === 0) return;
+  const activeElement = document2.activeElement;
+  let currentIndex = -1;
+  if (activeElement) {
+    currentIndex = focusableElements.indexOf(activeElement);
+  }
+  const prevIndex = currentIndex <= 0 ? focusableElements.length - 1 : currentIndex - 1;
+  const prevElement = focusableElements[prevIndex];
+  dispatchKeyboardEvent(document2, {
+    ...KEY_MAP["Tab"],
+    shiftKey: true
+  });
+  if (prevElement && typeof prevElement.focus === "function") {
+    prevElement.focus();
+  }
+  const target = document2.activeElement || document2.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document2),
+    payload: {
+      kind: "keyboard_action",
+      key: "Tab",
+      modifiers: ["Shift"]
+    }
+  };
+  onEvent(keyboardEvent);
+}
+function executeKeyAction(keyName, document2, onEvent, getTimestamp) {
+  const keyInfo = KEY_MAP[keyName];
+  if (!keyInfo) return;
+  dispatchKeyboardEvent(document2, {
+    ...keyInfo
+  });
+  const target = document2.activeElement || document2.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document2),
+    payload: {
+      kind: "keyboard_action",
+      key: keyName,
+      modifiers: []
+    }
+  };
+  onEvent(keyboardEvent);
+}
+function executeKeyCombo(combo, document2, onEvent, getTimestamp) {
+  const parsed = parseKeyCombo(combo);
+  const keyInfo = getKeyInfo(parsed.key);
+  dispatchKeyboardEvent(document2, {
+    ...keyInfo,
+    shiftKey: parsed.shiftKey,
+    ctrlKey: parsed.ctrlKey,
+    altKey: parsed.altKey,
+    metaKey: parsed.metaKey
+  });
+  const target = document2.activeElement || document2.body;
+  const keyboardEvent = {
+    type: "KEYBOARD_ACTION",
+    timestamp: getTimestamp(),
+    target: buildEventTarget(target, document2),
+    payload: {
+      kind: "keyboard_action",
+      key: parsed.key,
+      modifiers: parsed.modifiers
+    }
+  };
+  onEvent(keyboardEvent);
+}
+async function executeAction(action, document2, onEvent, getTimestamp) {
+  switch (action.type) {
+    case "click":
+      executeClick(action.selector, document2, onEvent, getTimestamp);
+      break;
+    case "tab":
+      executeTab(document2, onEvent, getTimestamp);
+      break;
+    case "shiftTab":
+      executeShiftTab(document2, onEvent, getTimestamp);
+      break;
+    case "escape":
+      executeKeyAction("Escape", document2, onEvent, getTimestamp);
+      break;
+    case "enter":
+      executeKeyAction("Enter", document2, onEvent, getTimestamp);
+      break;
+    case "space":
+      executeKeyAction(" ", document2, onEvent, getTimestamp);
+      break;
+    case "arrowUp":
+      executeKeyAction("ArrowUp", document2, onEvent, getTimestamp);
+      break;
+    case "arrowDown":
+      executeKeyAction("ArrowDown", document2, onEvent, getTimestamp);
+      break;
+    case "arrowLeft":
+      executeKeyAction("ArrowLeft", document2, onEvent, getTimestamp);
+      break;
+    case "arrowRight":
+      executeKeyAction("ArrowRight", document2, onEvent, getTimestamp);
+      break;
+    case "key":
+      executeKeyCombo(action.combo, document2, onEvent, getTimestamp);
+      break;
+    case "wait":
+      await new Promise((resolve) => setTimeout(resolve, action.ms));
+      break;
+  }
+}
+async function executeSequence(sequence, document2, onEvent, getTimestamp, settleTime = 100) {
+  for (let i = 0; i < sequence.actions.length; i++) {
+    const action = sequence.actions[i];
+    await executeAction(action, document2, 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/version.ts
+var SPEAKABLE_VERSION = typeof __SPEAKABLE_VERSION__ !== "undefined" && __SPEAKABLE_VERSION__ ? __SPEAKABLE_VERSION__ : "dev";
+
+// ../src/runtime/timeline-generator.ts
+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/browser/capture.ts
+async function captureTimeline(document2, options) {
+  const {
+    componentName,
+    storyName,
+    sequence,
+    settlePeriod,
+    awaitUpgrade = true,
+    upgradeTimeoutMs
+  } = options;
+  let upgradeWarnings = [];
+  if (awaitUpgrade) {
+    const warnings = await awaitCustomElementsReady(document2, upgradeTimeoutMs);
+    upgradeWarnings = warnings.map((w) => w.message);
+  }
+  const generator = createTimelineGenerator({
+    document: document2,
+    componentName,
+    storyName,
+    ...settlePeriod !== void 0 && { settlePeriod }
+  });
+  const timeline = await generator.capture(sequence);
+  if (upgradeWarnings.length > 0) {
+    const upgradeEvents = upgradeWarnings.map((message) => ({
+      type: "WARNING",
+      timestamp: 0,
+      target: { role: "generic", accessibleName: "", selector: ":root" },
+      payload: { kind: "warning", message }
+    }));
+    return {
+      ...timeline,
+      events: [...upgradeEvents, ...timeline.events],
+      warnings: [...upgradeEvents, ...timeline.warnings]
+    };
+  }
+  return timeline;
+}
+
+// ../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/sequence.ts
+var PLAY_PROBE_SEQUENCE = {
+  description: "Keyboard walk: tab through focusable elements",
+  actions: [{ type: "tab" }, { type: "tab" }, { type: "tab" }]
+};
+function resolveSequence(context) {
+  const params = context?.parameters?.speakable;
+  if (params && params.timeline === false) {
+    return null;
+  }
+  if (params?.sequence && Array.isArray(params.sequence.actions)) {
+    return params.sequence;
+  }
+  if (params?.pattern) {
+    try {
+      return getBuiltinPattern(params.pattern, params.selectors);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof context?.playFunction === "function" || typeof context?.play === "function") {
+    return PLAY_PROBE_SEQUENCE;
+  }
+  return null;
+}
+
+// src/preview.ts
+var currentObserver = null;
+var debounceTimer = null;
+var captureToken = 0;
+function getChannel() {
+  return window.__STORYBOOK_ADDONS_CHANNEL__;
+}
+function findStoryRoot() {
+  return document.getElementById("storybook-root") || document.getElementById("root") || document.body;
+}
+function runAnalysis() {
+  const root = findStoryRoot();
+  if (!root) return;
+  const analysis = analyzeDOM(root);
+  const channel = getChannel();
+  if (channel) {
+    channel.emit(EVENT_RESULT, analysis);
+  }
+}
+async function runTimelineCapture(context) {
+  const sequence = resolveSequence(context || {});
+  if (!sequence) return;
+  const token = ++captureToken;
+  const componentName = context?.title || context?.kind || context?.componentId || "Component";
+  const storyName = context?.name || context?.story || "Story";
+  let timeline;
+  try {
+    timeline = await captureTimeline(document, {
+      componentName,
+      storyName,
+      sequence
+    });
+  } catch {
+    return;
+  }
+  if (token !== captureToken) return;
+  const channel = getChannel();
+  if (channel) {
+    channel.emit(EVENT_TIMELINE, timeline);
   }
 }
 function debouncedAnalysis() {
@@ -2111,13 +4301,15 @@ function startObserving() {
     ]
   });
 }
-var withSpeakable = (storyFn, _context) => {
+var withSpeakable = (storyFn, context) => {
   const result = storyFn();
+  captureToken++;
   if (typeof window !== "undefined") {
     requestAnimationFrame(() => {
       setTimeout(() => {
         runAnalysis();
         startObserving();
+        void runTimelineCapture(context);
       }, 100);
     });
   }