sibujs 1.0.0-beta.1

package/dist/testing.cjs

@@ -0,0 +1,1919 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  assertA11y: () => assertA11y,
+  assertDOMEquals: () => assertDOMEquals,
+  captureFingerprint: () => captureFingerprint,
+  checkA11y: () => checkA11y,
+  checkAriaAttributes: () => checkAriaAttributes,
+  checkColorContrast: () => checkColorContrast,
+  checkFormLabels: () => checkFormLabels,
+  checkHeadingHierarchy: () => checkHeadingHierarchy,
+  checkImageAlt: () => checkImageAlt,
+  checkKeyboardAccess: () => checkKeyboardAccess,
+  checkLandmarks: () => checkLandmarks,
+  checkLinksAndButtons: () => checkLinksAndButtons,
+  checkListSemantics: () => checkListSemantics,
+  checkTabOrder: () => checkTabOrder,
+  compareFingerprints: () => compareFingerprints,
+  createCypressAdapter: () => createCypressAdapter,
+  createDOMSnapshot: () => createDOMSnapshot,
+  createHttpMock: () => createHttpMock,
+  createJestAdapter: () => createJestAdapter,
+  createPlaywrightAdapter: () => createPlaywrightAdapter,
+  createSnapshotMatcher: () => createSnapshotMatcher,
+  createSnapshotStore: () => createSnapshotStore,
+  createTimerMock: () => createTimerMock,
+  createUniversalAdapter: () => createUniversalAdapter,
+  createVisualSuite: () => createVisualSuite,
+  fireEvent: () => fireEvent,
+  matchSnapshot: () => matchSnapshot,
+  mockRouter: () => mockRouter,
+  mockStore: () => mockStore,
+  render: () => render,
+  snapshotComponent: () => snapshotComponent,
+  testComponent: () => testComponent,
+  waitFor: () => waitFor
+});
+module.exports = __toCommonJS(testing_exports);
+
+// src/testing/a11y.ts
+var VALID_ARIA_ROLES = /* @__PURE__ */ new Set([
+  "alert",
+  "alertdialog",
+  "application",
+  "article",
+  "banner",
+  "button",
+  "cell",
+  "checkbox",
+  "columnheader",
+  "combobox",
+  "complementary",
+  "contentinfo",
+  "definition",
+  "dialog",
+  "directory",
+  "document",
+  "feed",
+  "figure",
+  "form",
+  "grid",
+  "gridcell",
+  "group",
+  "heading",
+  "img",
+  "link",
+  "list",
+  "listbox",
+  "listitem",
+  "log",
+  "main",
+  "marquee",
+  "math",
+  "menu",
+  "menubar",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "meter",
+  "navigation",
+  "none",
+  "note",
+  "option",
+  "presentation",
+  "progressbar",
+  "radio",
+  "radiogroup",
+  "region",
+  "row",
+  "rowgroup",
+  "rowheader",
+  "scrollbar",
+  "search",
+  "searchbox",
+  "separator",
+  "slider",
+  "spinbutton",
+  "status",
+  "switch",
+  "tab",
+  "table",
+  "tablist",
+  "tabpanel",
+  "term",
+  "textbox",
+  "timer",
+  "toolbar",
+  "tooltip",
+  "tree",
+  "treegrid",
+  "treeitem"
+]);
+var LANDMARK_ROLES = /* @__PURE__ */ new Set([
+  "banner",
+  "complementary",
+  "contentinfo",
+  "form",
+  "main",
+  "navigation",
+  "region",
+  "search"
+]);
+var LANDMARK_ELEMENTS = {
+  header: "banner",
+  footer: "contentinfo",
+  main: "main",
+  nav: "navigation",
+  aside: "complementary",
+  form: "form",
+  section: "region"
+};
+var REQUIRED_ARIA_PROPS = {
+  checkbox: ["aria-checked"],
+  combobox: ["aria-expanded"],
+  heading: ["aria-level"],
+  meter: ["aria-valuenow"],
+  option: ["aria-selected"],
+  radio: ["aria-checked"],
+  scrollbar: ["aria-controls", "aria-valuenow"],
+  separator: [],
+  // only required when focusable
+  slider: ["aria-valuenow"],
+  spinbutton: ["aria-valuenow"],
+  switch: ["aria-checked"]
+};
+var VALID_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "aria-activedescendant",
+  "aria-atomic",
+  "aria-autocomplete",
+  "aria-busy",
+  "aria-checked",
+  "aria-colcount",
+  "aria-colindex",
+  "aria-colspan",
+  "aria-controls",
+  "aria-current",
+  "aria-describedby",
+  "aria-details",
+  "aria-disabled",
+  "aria-dropeffect",
+  "aria-errormessage",
+  "aria-expanded",
+  "aria-flowto",
+  "aria-grabbed",
+  "aria-haspopup",
+  "aria-hidden",
+  "aria-invalid",
+  "aria-keyshortcuts",
+  "aria-label",
+  "aria-labelledby",
+  "aria-level",
+  "aria-live",
+  "aria-modal",
+  "aria-multiline",
+  "aria-multiselectable",
+  "aria-orientation",
+  "aria-owns",
+  "aria-placeholder",
+  "aria-posinset",
+  "aria-pressed",
+  "aria-readonly",
+  "aria-relevant",
+  "aria-required",
+  "aria-roledescription",
+  "aria-rowcount",
+  "aria-rowindex",
+  "aria-rowspan",
+  "aria-selected",
+  "aria-setsize",
+  "aria-sort",
+  "aria-valuemax",
+  "aria-valuemin",
+  "aria-valuenow",
+  "aria-valuetext"
+]);
+function getSelector(el) {
+  if (el.id) return `#${el.id}`;
+  const tag = el.tagName.toLowerCase();
+  const classes = el.className && typeof el.className === "string" ? `.${el.className.trim().split(/\s+/).join(".")}` : "";
+  const role = el.getAttribute("role");
+  const roleStr = role ? `[role="${role}"]` : "";
+  return `${tag}${classes}${roleStr}`;
+}
+function hasAccessibleName(el) {
+  if (el.getAttribute("aria-label")?.trim()) return true;
+  const labelledBy = el.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const doc = el.ownerDocument;
+    const ids = labelledBy.split(/\s+/);
+    for (const id of ids) {
+      const ref = doc.getElementById(id);
+      if (ref?.textContent?.trim()) return true;
+    }
+  }
+  if (el.getAttribute("title")?.trim()) return true;
+  if (el.textContent?.trim()) return true;
+  return false;
+}
+function isNativeInteractive(el) {
+  const tag = el.tagName.toLowerCase();
+  if (["button", "select", "textarea"].includes(tag)) return true;
+  if (tag === "input" && el.getAttribute("type") !== "hidden") return true;
+  if (tag === "a" && el.hasAttribute("href")) return true;
+  if (tag === "area" && el.hasAttribute("href")) return true;
+  return false;
+}
+function checkImageAlt(root) {
+  const violations = [];
+  const images = root.querySelectorAll("img");
+  for (const img of Array.from(images)) {
+    if (!img.hasAttribute("alt")) {
+      violations.push({
+        rule: "image-alt",
+        level: "error",
+        message: 'Image element must have an alt attribute. Use alt="" for decorative images.',
+        element: img,
+        selector: getSelector(img)
+      });
+    } else if (img.getAttribute("alt") === "" && !img.getAttribute("role")) {
+      violations.push({
+        rule: "image-alt-empty",
+        level: "info",
+        message: "Image has empty alt text. Ensure this is a decorative image; otherwise provide meaningful alt text.",
+        element: img,
+        selector: getSelector(img)
+      });
+    }
+  }
+  const roleImgs = root.querySelectorAll('[role="img"]');
+  for (const el of Array.from(roleImgs)) {
+    if (!hasAccessibleName(el)) {
+      violations.push({
+        rule: "image-alt",
+        level: "error",
+        message: 'Element with role="img" must have an accessible name (aria-label or aria-labelledby).',
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+  }
+  return violations;
+}
+function checkFormLabels(root) {
+  const violations = [];
+  const inputs = root.querySelectorAll("input, select, textarea");
+  for (const input of Array.from(inputs)) {
+    if (input.getAttribute("type") === "hidden") continue;
+    const inputType = input.getAttribute("type");
+    if (inputType === "submit" || inputType === "reset" || inputType === "button") continue;
+    const hasLabel = checkInputHasLabel(input, root);
+    if (!hasLabel) {
+      violations.push({
+        rule: "form-label",
+        level: "error",
+        message: `Form ${input.tagName.toLowerCase()} element must have an associated label. Use <label for="id">, aria-label, aria-labelledby, or wrap in a <label>.`,
+        element: input,
+        selector: getSelector(input)
+      });
+    }
+  }
+  return violations;
+}
+function checkInputHasLabel(input, root) {
+  if (input.getAttribute("aria-label")?.trim()) return true;
+  const labelledBy = input.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const doc = input.ownerDocument;
+    const ids = labelledBy.split(/\s+/);
+    for (const id2 of ids) {
+      const ref = doc.getElementById(id2);
+      if (ref?.textContent?.trim()) return true;
+    }
+  }
+  if (input.getAttribute("title")?.trim()) return true;
+  const id = input.getAttribute("id");
+  if (id) {
+    const label = root.querySelector(`label[for="${id}"]`);
+    if (label?.textContent?.trim()) return true;
+  }
+  let parent = input.parentElement;
+  while (parent && parent !== root) {
+    if (parent.tagName.toLowerCase() === "label") return true;
+    parent = parent.parentElement;
+  }
+  return false;
+}
+function checkHeadingHierarchy(root) {
+  const violations = [];
+  const headings = root.querySelectorAll("h1, h2, h3, h4, h5, h6");
+  if (headings.length === 0) return violations;
+  let previousLevel = 0;
+  for (const heading of Array.from(headings)) {
+    const currentLevel = parseInt(heading.tagName[1], 10);
+    if (previousLevel === 0 && currentLevel !== 1) {
+      violations.push({
+        rule: "heading-order",
+        level: "warning",
+        message: `Heading hierarchy should start with h1. Found ${heading.tagName.toLowerCase()} as the first heading.`,
+        element: heading,
+        selector: getSelector(heading)
+      });
+    }
+    if (previousLevel > 0 && currentLevel > previousLevel + 1) {
+      violations.push({
+        rule: "heading-order",
+        level: "error",
+        message: `Heading level skipped: ${heading.tagName.toLowerCase()} follows h${previousLevel}. Headings should not skip levels.`,
+        element: heading,
+        selector: getSelector(heading)
+      });
+    }
+    if (!heading.textContent?.trim()) {
+      violations.push({
+        rule: "heading-empty",
+        level: "error",
+        message: `Heading ${heading.tagName.toLowerCase()} is empty. Headings must have discernible text.`,
+        element: heading,
+        selector: getSelector(heading)
+      });
+    }
+    previousLevel = currentLevel;
+  }
+  return violations;
+}
+function checkColorContrast(root) {
+  const violations = [];
+  const roledElements = root.querySelectorAll("[role]");
+  for (const el of Array.from(roledElements)) {
+    const role = el.getAttribute("role");
+    if (!role) continue;
+    if (role === "presentation" || role === "none") continue;
+    const nameRequiredRoles = /* @__PURE__ */ new Set([
+      "alert",
+      "alertdialog",
+      "button",
+      "checkbox",
+      "combobox",
+      "dialog",
+      "link",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "option",
+      "progressbar",
+      "radio",
+      "slider",
+      "spinbutton",
+      "switch",
+      "tab",
+      "textbox",
+      "treeitem"
+    ]);
+    if (nameRequiredRoles.has(role) && !hasAccessibleName(el)) {
+      violations.push({
+        rule: "accessible-name",
+        level: "error",
+        message: `Element with role="${role}" must have an accessible name (via aria-label, aria-labelledby, or text content).`,
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+  }
+  const inlineStyled = root.querySelectorAll("[style]");
+  for (const el of Array.from(inlineStyled)) {
+    const style = el.getAttribute("style") || "";
+    const hasColor = /(?:^|;)\s*color\s*:/i.test(style);
+    const hasBg = /(?:^|;)\s*background(?:-color)?\s*:/i.test(style);
+    if (hasColor && !hasBg && el.textContent?.trim()) {
+      violations.push({
+        rule: "color-contrast",
+        level: "warning",
+        message: "Element sets text color but not background color. Ensure sufficient contrast with the inherited background.",
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+    if (hasBg && !hasColor && el.textContent?.trim()) {
+      violations.push({
+        rule: "color-contrast",
+        level: "warning",
+        message: "Element sets background color but not text color. Ensure sufficient contrast with the inherited text color.",
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+  }
+  return violations;
+}
+function checkKeyboardAccess(root) {
+  const violations = [];
+  const clickElements = root.querySelectorAll("[onclick]");
+  for (const el of Array.from(clickElements)) {
+    if (isNativeInteractive(el)) continue;
+    const hasTabindex = el.hasAttribute("tabindex");
+    const hasRole = el.hasAttribute("role");
+    const hasKeyHandler = el.hasAttribute("onkeydown") || el.hasAttribute("onkeyup") || el.hasAttribute("onkeypress");
+    if (!hasTabindex) {
+      violations.push({
+        rule: "keyboard-access",
+        level: "error",
+        message: "Interactive element with onclick must have tabindex to be keyboard accessible.",
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+    if (!hasRole) {
+      violations.push({
+        rule: "keyboard-access",
+        level: "warning",
+        message: 'Interactive element with onclick should have an explicit role attribute (e.g., role="button").',
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+    if (!hasKeyHandler) {
+      violations.push({
+        rule: "keyboard-access",
+        level: "error",
+        message: "Interactive element with onclick must also have a keyboard event handler (onkeydown or onkeyup) for keyboard accessibility.",
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+  }
+  const interactiveRoles = root.querySelectorAll(
+    '[role="button"], [role="link"], [role="tab"], [role="menuitem"], [role="option"]'
+  );
+  for (const el of Array.from(interactiveRoles)) {
+    if (isNativeInteractive(el)) continue;
+    if (!el.hasAttribute("tabindex")) {
+      violations.push({
+        rule: "keyboard-access",
+        level: "error",
+        message: `Element with role="${el.getAttribute("role")}" must have tabindex to be keyboard accessible.`,
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+  }
+  return violations;
+}
+function checkAriaAttributes(root) {
+  const violations = [];
+  const roledElements = root.querySelectorAll("[role]");
+  for (const el of Array.from(roledElements)) {
+    const role = el.getAttribute("role");
+    if (!role) continue;
+    if (!VALID_ARIA_ROLES.has(role)) {
+      violations.push({
+        rule: "aria-valid-role",
+        level: "error",
+        message: `Invalid ARIA role "${role}". Must be a valid WAI-ARIA role.`,
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+    if (REQUIRED_ARIA_PROPS[role]) {
+      for (const requiredProp of REQUIRED_ARIA_PROPS[role]) {
+        if (!el.hasAttribute(requiredProp)) {
+          violations.push({
+            rule: "aria-required-attr",
+            level: "error",
+            message: `Element with role="${role}" requires the ${requiredProp} attribute.`,
+            element: el,
+            selector: getSelector(el)
+          });
+        }
+      }
+    }
+  }
+  const allElements = root.querySelectorAll("*");
+  for (const el of Array.from(allElements)) {
+    for (const attr of Array.from(el.attributes)) {
+      if (!attr.name.startsWith("aria-")) continue;
+      if (!VALID_ARIA_ATTRIBUTES.has(attr.name)) {
+        violations.push({
+          rule: "aria-valid-attr",
+          level: "error",
+          message: `Invalid ARIA attribute "${attr.name}". Must be a valid WAI-ARIA attribute.`,
+          element: el,
+          selector: getSelector(el)
+        });
+      }
+      if (attr.name === "aria-labelledby" || attr.name === "aria-describedby" || attr.name === "aria-controls" || attr.name === "aria-owns") {
+        const ids = attr.value.split(/\s+/).filter(Boolean);
+        const doc = el.ownerDocument;
+        for (const id of ids) {
+          if (!doc.getElementById(id)) {
+            violations.push({
+              rule: "aria-valid-attr-value",
+              level: "error",
+              message: `${attr.name} references id "${id}" which does not exist in the document.`,
+              element: el,
+              selector: getSelector(el)
+            });
+          }
+        }
+      }
+      const booleanAttrs = /* @__PURE__ */ new Set([
+        "aria-checked",
+        "aria-disabled",
+        "aria-expanded",
+        "aria-hidden",
+        "aria-pressed",
+        "aria-required",
+        "aria-selected",
+        "aria-busy",
+        "aria-modal",
+        "aria-multiline",
+        "aria-multiselectable",
+        "aria-readonly"
+      ]);
+      if (booleanAttrs.has(attr.name)) {
+        const validValues = ["true", "false"];
+        if (attr.name === "aria-checked" || attr.name === "aria-pressed") {
+          validValues.push("mixed");
+        }
+        if (!validValues.includes(attr.value) && attr.value !== "undefined") {
+          violations.push({
+            rule: "aria-valid-attr-value",
+            level: "error",
+            message: `${attr.name} has invalid value "${attr.value}". Expected one of: ${validValues.join(", ")}.`,
+            element: el,
+            selector: getSelector(el)
+          });
+        }
+      }
+    }
+  }
+  for (const attr of Array.from(root.attributes)) {
+    if (!attr.name.startsWith("aria-")) continue;
+    if (!VALID_ARIA_ATTRIBUTES.has(attr.name)) {
+      violations.push({
+        rule: "aria-valid-attr",
+        level: "error",
+        message: `Invalid ARIA attribute "${attr.name}" on root element. Must be a valid WAI-ARIA attribute.`,
+        element: root,
+        selector: getSelector(root)
+      });
+    }
+  }
+  return violations;
+}
+function checkLandmarks(root) {
+  const violations = [];
+  const foundLandmarks = /* @__PURE__ */ new Set();
+  for (const role of LANDMARK_ROLES) {
+    const elements = root.querySelectorAll(`[role="${role}"]`);
+    if (elements.length > 0) {
+      foundLandmarks.add(role);
+    }
+  }
+  for (const [tag, role] of Object.entries(LANDMARK_ELEMENTS)) {
+    const elements = root.querySelectorAll(tag);
+    if (elements.length > 0) {
+      foundLandmarks.add(role);
+    }
+  }
+  if (!foundLandmarks.has("main")) {
+    violations.push({
+      rule: "landmark-main",
+      level: "warning",
+      message: 'Page should have a main landmark (<main> element or role="main").',
+      selector: getSelector(root)
+    });
+  }
+  const mainElements = root.querySelectorAll('main, [role="main"]');
+  if (mainElements.length > 1) {
+    violations.push({
+      rule: "landmark-unique",
+      level: "error",
+      message: `Multiple main landmarks found (${mainElements.length}). A page should have at most one main landmark.`,
+      selector: getSelector(root)
+    });
+  }
+  const bannerElements = root.querySelectorAll('header, [role="banner"]');
+  if (bannerElements.length > 1) {
+    violations.push({
+      rule: "landmark-unique",
+      level: "warning",
+      message: `Multiple banner landmarks found (${bannerElements.length}). Consider using a single banner landmark.`,
+      selector: getSelector(root)
+    });
+  }
+  const contentinfoElements = root.querySelectorAll('footer, [role="contentinfo"]');
+  if (contentinfoElements.length > 1) {
+    violations.push({
+      rule: "landmark-unique",
+      level: "warning",
+      message: `Multiple contentinfo landmarks found (${contentinfoElements.length}). Consider using a single contentinfo landmark.`,
+      selector: getSelector(root)
+    });
+  }
+  const navElements = root.querySelectorAll('nav, [role="navigation"]');
+  if (navElements.length > 1) {
+    for (const nav of Array.from(navElements)) {
+      if (!nav.getAttribute("aria-label") && !nav.getAttribute("aria-labelledby")) {
+        violations.push({
+          rule: "landmark-label",
+          level: "warning",
+          message: "When multiple navigation landmarks exist, each should have a unique label (aria-label or aria-labelledby).",
+          element: nav,
+          selector: getSelector(nav)
+        });
+      }
+    }
+  }
+  return violations;
+}
+function checkLinksAndButtons(root) {
+  const violations = [];
+  const links = root.querySelectorAll("a[href]");
+  for (const link of Array.from(links)) {
+    if (!hasAccessibleName(link)) {
+      violations.push({
+        rule: "link-name",
+        level: "error",
+        message: "Link must have discernible text. Add text content, aria-label, or aria-labelledby.",
+        element: link,
+        selector: getSelector(link)
+      });
+    }
+    if (link.getAttribute("target") === "_blank") {
+      violations.push({
+        rule: "link-new-window",
+        level: "warning",
+        message: 'Link opens in a new window/tab (target="_blank"). Consider warning users or adding an icon to indicate this.',
+        element: link,
+        selector: getSelector(link)
+      });
+      const rel = link.getAttribute("rel") || "";
+      if (!rel.includes("noopener") && !rel.includes("noreferrer")) {
+        violations.push({
+          rule: "link-noopener",
+          level: "warning",
+          message: 'Link with target="_blank" should include rel="noopener" or rel="noreferrer" for security.',
+          element: link,
+          selector: getSelector(link)
+        });
+      }
+    }
+    const linkText = link.textContent?.trim().toLowerCase() || "";
+    const genericTexts = ["click here", "here", "read more", "more", "learn more", "link"];
+    if (genericTexts.includes(linkText)) {
+      violations.push({
+        rule: "link-purpose",
+        level: "warning",
+        message: `Link text "${link.textContent?.trim()}" is generic. Use descriptive text that explains the link's purpose.`,
+        element: link,
+        selector: getSelector(link)
+      });
+    }
+  }
+  const buttons = root.querySelectorAll('button, [role="button"]');
+  for (const button of Array.from(buttons)) {
+    if (!hasAccessibleName(button)) {
+      violations.push({
+        rule: "button-name",
+        level: "error",
+        message: "Button must have an accessible name. Add text content, aria-label, or aria-labelledby.",
+        element: button,
+        selector: getSelector(button)
+      });
+    }
+  }
+  const inputButtons = root.querySelectorAll('input[type="submit"], input[type="reset"], input[type="button"]');
+  for (const input of Array.from(inputButtons)) {
+    const value = input.getAttribute("value");
+    if (!value?.trim() && !input.getAttribute("aria-label") && !input.getAttribute("aria-labelledby")) {
+      violations.push({
+        rule: "button-name",
+        level: "error",
+        message: `Input button (type="${input.getAttribute("type")}") must have a value, aria-label, or aria-labelledby.`,
+        element: input,
+        selector: getSelector(input)
+      });
+    }
+  }
+  return violations;
+}
+function checkListSemantics(root) {
+  const violations = [];
+  const lists = root.querySelectorAll("ul, ol");
+  for (const list of Array.from(lists)) {
+    const children = Array.from(list.children);
+    for (const child of children) {
+      const tag = child.tagName.toLowerCase();
+      if (tag !== "li" && tag !== "script" && tag !== "template") {
+        violations.push({
+          rule: "list-semantics",
+          level: "error",
+          message: `Direct children of <${list.tagName.toLowerCase()}> must be <li> elements. Found <${tag}>.`,
+          element: child,
+          selector: getSelector(child)
+        });
+      }
+    }
+    if (children.length === 0) {
+      violations.push({
+        rule: "list-empty",
+        level: "info",
+        message: `Empty <${list.tagName.toLowerCase()}> element found. Consider removing or adding items.`,
+        element: list,
+        selector: getSelector(list)
+      });
+    }
+  }
+  const dlLists = root.querySelectorAll("dl");
+  for (const dl of Array.from(dlLists)) {
+    const children = Array.from(dl.children);
+    for (const child of children) {
+      const tag = child.tagName.toLowerCase();
+      if (tag !== "dt" && tag !== "dd" && tag !== "div" && tag !== "script" && tag !== "template") {
+        violations.push({
+          rule: "list-semantics",
+          level: "error",
+          message: `Direct children of <dl> must be <dt>, <dd>, or <div> elements. Found <${tag}>.`,
+          element: child,
+          selector: getSelector(child)
+        });
+      }
+    }
+  }
+  const roleLists = root.querySelectorAll('[role="list"]');
+  for (const list of Array.from(roleLists)) {
+    const children = Array.from(list.children);
+    const hasListItems = children.some(
+      (child) => child.getAttribute("role") === "listitem" || child.tagName.toLowerCase() === "li"
+    );
+    if (children.length > 0 && !hasListItems) {
+      violations.push({
+        rule: "list-semantics",
+        level: "warning",
+        message: 'Element with role="list" should contain children with role="listitem".',
+        element: list,
+        selector: getSelector(list)
+      });
+    }
+  }
+  return violations;
+}
+function checkTabOrder(root) {
+  const violations = [];
+  const tabbable = root.querySelectorAll("[tabindex]");
+  for (const el of Array.from(tabbable)) {
+    const tabindex = parseInt(el.getAttribute("tabindex") ?? "", 10);
+    if (!Number.isNaN(tabindex) && tabindex > 0) {
+      violations.push({
+        rule: "tabindex-positive",
+        level: "warning",
+        message: `Element has tabindex="${tabindex}". Positive tabindex values create a confusing tab order. Use tabindex="0" instead and rely on DOM order.`,
+        element: el,
+        selector: getSelector(el)
+      });
+    }
+  }
+  const focusTraps = root.querySelectorAll('[data-sibu-focus-trap], [aria-modal="true"]');
+  for (const trap of Array.from(focusTraps)) {
+    const role = trap.getAttribute("role");
+    if (role === "dialog" || role === "alertdialog" || trap.hasAttribute("aria-modal")) {
+      const hasCloseButton = trap.querySelector(
+        'button[aria-label*="close" i], button[aria-label*="dismiss" i], [data-dismiss], [data-close]'
+      );
+      if (!hasCloseButton) {
+        violations.push({
+          rule: "focus-trap-escape",
+          level: "warning",
+          message: "Modal/dialog with focus trap should have a visible close button. Users must be able to dismiss the dialog.",
+          element: trap,
+          selector: getSelector(trap)
+        });
+      }
+    }
+    const focusable = trap.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+    if (focusable.length === 0) {
+      violations.push({
+        rule: "focus-trap-empty",
+        level: "error",
+        message: "Focus trap contains no focusable elements. Users will be trapped with no way to interact.",
+        element: trap,
+        selector: getSelector(trap)
+      });
+    }
+  }
+  return violations;
+}
+var CHECK_FUNCTIONS = {
+  images: checkImageAlt,
+  forms: checkFormLabels,
+  headings: checkHeadingHierarchy,
+  contrast: checkColorContrast,
+  keyboard: checkKeyboardAccess,
+  aria: checkAriaAttributes,
+  landmarks: checkLandmarks,
+  links: checkLinksAndButtons,
+  lists: checkListSemantics,
+  tabOrder: checkTabOrder
+};
+var ALL_CHECKS = [
+  "images",
+  "forms",
+  "headings",
+  "contrast",
+  "keyboard",
+  "aria",
+  "landmarks",
+  "links",
+  "lists",
+  "tabOrder"
+];
+function checkA11y(root, options) {
+  const checksToRun = options?.checks || ALL_CHECKS;
+  const minLevel = options?.level || "info";
+  const levelPriority = {
+    error: 2,
+    warning: 1,
+    info: 0
+  };
+  const minPriority = levelPriority[minLevel];
+  const allViolations = [];
+  for (const check of checksToRun) {
+    const fn = CHECK_FUNCTIONS[check];
+    if (fn) {
+      const results = fn(root);
+      allViolations.push(...results);
+    }
+  }
+  const filtered = allViolations.filter((v) => levelPriority[v.level] >= minPriority);
+  const violations = filtered.filter((v) => v.level === "error");
+  const warnings = filtered.filter((v) => v.level === "warning");
+  const info = filtered.filter((v) => v.level === "info");
+  const parts = [];
+  if (violations.length > 0) parts.push(`${violations.length} error(s)`);
+  if (warnings.length > 0) parts.push(`${warnings.length} warning(s)`);
+  if (info.length > 0) parts.push(`${info.length} info`);
+  const passed = violations.length === 0;
+  const summary = passed ? parts.length > 0 ? `Passed with ${parts.join(", ")}.` : "Passed with no issues." : `Failed with ${parts.join(", ")}.`;
+  return { passed, violations, warnings, info, summary };
+}
+function assertA11y(root, options) {
+  const result = checkA11y(root, options);
+  if (!result.passed) {
+    const lines = [`Accessibility check failed: ${result.summary}`, ""];
+    if (result.violations.length > 0) {
+      lines.push("ERRORS:");
+      for (const v of result.violations) {
+        lines.push(`  [${v.rule}] ${v.message}${v.selector ? ` (${v.selector})` : ""}`);
+      }
+      lines.push("");
+    }
+    if (result.warnings.length > 0) {
+      lines.push("WARNINGS:");
+      for (const w of result.warnings) {
+        lines.push(`  [${w.rule}] ${w.message}${w.selector ? ` (${w.selector})` : ""}`);
+      }
+      lines.push("");
+    }
+    throw new Error(lines.join("\n"));
+  }
+}
+
+// src/testing/adapters.ts
+function createJestAdapter() {
+  let container = null;
+  return {
+    /** Call in beforeEach to set up DOM container */
+    setup() {
+      container = document.createElement("div");
+      container.setAttribute("data-testenv", "jest");
+      document.body.appendChild(container);
+      return container;
+    },
+    /** Call in afterEach to clean up */
+    teardown() {
+      if (container) {
+        container.innerHTML = "";
+        if (container.parentNode) {
+          container.parentNode.removeChild(container);
+        }
+        container = null;
+      }
+    },
+    /** Render a component into the test container */
+    render(component) {
+      if (!container) {
+        container = document.createElement("div");
+        container.setAttribute("data-testenv", "jest");
+        document.body.appendChild(container);
+      }
+      const element = typeof component === "function" ? component() : component;
+      container.appendChild(element);
+      return { element, container };
+    },
+    /** Custom Jest matchers */
+    matchers: {
+      /** Check if element has specific text content */
+      toHaveTextContent(element, expected) {
+        const actual = element.textContent || "";
+        const pass = actual.includes(expected);
+        return {
+          pass,
+          message: () => pass ? `Expected element not to have text content "${expected}", but found "${actual}"` : `Expected element to have text content "${expected}", but found "${actual}"`
+        };
+      },
+      /** Check if element has specific attribute */
+      toHaveAttribute(element, attr, value) {
+        const hasAttr = element.hasAttribute(attr);
+        const attrValue = element.getAttribute(attr);
+        const pass = value !== void 0 ? hasAttr && attrValue === value : hasAttr;
+        return {
+          pass,
+          message: () => {
+            if (value !== void 0) {
+              return pass ? `Expected element not to have attribute "${attr}" with value "${value}", but it does` : `Expected element to have attribute "${attr}" with value "${value}", but got "${attrValue}"`;
+            }
+            return pass ? `Expected element not to have attribute "${attr}", but it does` : `Expected element to have attribute "${attr}", but it does not`;
+          }
+        };
+      },
+      /** Check if element has specific class */
+      toHaveClass(element, className) {
+        const pass = element.classList.contains(className);
+        return {
+          pass,
+          message: () => pass ? `Expected element not to have class "${className}", but it does` : `Expected element to have class "${className}", but it has "${element.className}"`
+        };
+      },
+      /** Check if element is visible (no display:none, visibility:hidden, hidden attr) */
+      toBeVisible(element) {
+        const htmlEl = element;
+        const isHiddenAttr = element.hasAttribute("hidden");
+        const style = htmlEl.style;
+        const isDisplayNone = style?.display === "none";
+        const isVisibilityHidden = style?.visibility === "hidden";
+        const isOpacityZero = style?.opacity === "0";
+        const pass = !isHiddenAttr && !isDisplayNone && !isVisibilityHidden && !isOpacityZero;
+        return {
+          pass,
+          message: () => {
+            if (pass) {
+              return "Expected element to be hidden, but it is visible";
+            }
+            const reasons = [];
+            if (isHiddenAttr) reasons.push('has "hidden" attribute');
+            if (isDisplayNone) reasons.push("has display:none");
+            if (isVisibilityHidden) reasons.push("has visibility:hidden");
+            if (isOpacityZero) reasons.push("has opacity:0");
+            return `Expected element to be visible, but it ${reasons.join(" and ")}`;
+          }
+        };
+      },
+      /** Check if element is disabled */
+      toBeDisabled(element) {
+        const isDisabledProp = element.disabled === true;
+        const isDisabledAttr = element.hasAttribute("disabled");
+        const isAriaDisabled = element.getAttribute("aria-disabled") === "true";
+        const pass = isDisabledProp || isDisabledAttr || isAriaDisabled;
+        return {
+          pass,
+          message: () => pass ? "Expected element not to be disabled, but it is" : "Expected element to be disabled, but it is not"
+        };
+      },
+      /** Check if element has focus */
+      toHaveFocus(element) {
+        const pass = document.activeElement === element;
+        return {
+          pass,
+          message: () => pass ? "Expected element not to have focus, but it does" : `Expected element to have focus, but active element is <${document.activeElement?.tagName?.toLowerCase() || "none"}>`
+        };
+      },
+      /** Check if element has specific style */
+      toHaveStyle(element, style) {
+        const mismatches = [];
+        for (const [prop, expected] of Object.entries(style)) {
+          const kebabProp = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+          const actual = element.style.getPropertyValue(kebabProp);
+          if (actual !== expected) {
+            mismatches.push(`${prop}: expected "${expected}" but got "${actual}"`);
+          }
+        }
+        const pass = mismatches.length === 0;
+        return {
+          pass,
+          message: () => pass ? "Expected element not to have the specified styles, but it does" : `Style mismatches: ${mismatches.join("; ")}`
+        };
+      }
+    }
+  };
+}
+function createCypressAdapter() {
+  return {
+    /** Mount a component for Cypress component testing */
+    mount(component, options) {
+      const container = options?.container || document.createElement("div");
+      if (!options?.container) {
+        container.setAttribute("data-testenv", "cypress");
+        document.body.appendChild(container);
+      }
+      const element = typeof component === "function" ? component() : component;
+      container.appendChild(element);
+      return { element, container };
+    },
+    /** Generate Cypress custom commands for SibuJS */
+    commands: {
+      /** Find by data-testid */
+      getByTestId: (id) => `[data-testid="${id}"]`,
+      /** Find by text */
+      getByText: (text) => `:contains("${text}")`,
+      /** Find by role */
+      getByRole: (role) => `[role="${role}"]`
+    }
+  };
+}
+function createPlaywrightAdapter() {
+  return {
+    /** Selectors for common SibuJS patterns */
+    selectors: {
+      byTestId: (id) => `[data-testid="${id}"]`,
+      byRole: (role) => `[role="${role}"]`,
+      byAriaLabel: (label) => `[aria-label="${label}"]`,
+      byDataAttr: (attr, value) => value ? `[data-${attr}="${value}"]` : `[data-${attr}]`
+    },
+    /** Generate a page object for a SibuJS component */
+    createPageObject(name, selectors) {
+      const selectorMap = { ...selectors };
+      return {
+        name,
+        getSelector(key) {
+          const selector = selectorMap[key];
+          if (!selector) {
+            throw new Error(
+              `Page object "${name}" has no selector for key "${key}". Available keys: ${Object.keys(selectorMap).join(", ")}`
+            );
+          }
+          return selector;
+        },
+        allSelectors() {
+          return { ...selectorMap };
+        }
+      };
+    }
+  };
+}
+function createUniversalAdapter() {
+  let container = null;
+  return {
+    /** Setup test environment */
+    setup() {
+      container = document.createElement("div");
+      container.setAttribute("data-testenv", "universal");
+      document.body.appendChild(container);
+      return container;
+    },
+    /** Teardown test environment */
+    teardown() {
+      if (container) {
+        container.innerHTML = "";
+        if (container.parentNode) {
+          container.parentNode.removeChild(container);
+        }
+        container = null;
+      }
+    },
+    /** Render component */
+    render(component) {
+      if (!container) {
+        container = document.createElement("div");
+        container.setAttribute("data-testenv", "universal");
+        document.body.appendChild(container);
+      }
+      const element = typeof component === "function" ? component() : component;
+      container.appendChild(element);
+      return { element, container };
+    },
+    /** Query helpers */
+    queries: {
+      byTestId(container2, id) {
+        return container2.querySelector(`[data-testid="${id}"]`);
+      },
+      byRole(container2, role) {
+        return container2.querySelector(`[role="${role}"]`);
+      },
+      byText(container2, text) {
+        const walker = document.createTreeWalker(container2, NodeFilter.SHOW_TEXT);
+        while (walker.nextNode()) {
+          if (walker.currentNode.textContent?.includes(text)) {
+            return walker.currentNode.parentElement;
+          }
+        }
+        return null;
+      },
+      byLabelText(container2, label) {
+        const labels = container2.querySelectorAll("label");
+        for (const labelEl of Array.from(labels)) {
+          if (labelEl.textContent?.includes(label)) {
+            const forAttr = labelEl.getAttribute("for");
+            if (forAttr) {
+              return container2.querySelector(`#${forAttr}`);
+            }
+            const nested = labelEl.querySelector("input, select, textarea");
+            if (nested) return nested;
+          }
+        }
+        return container2.querySelector(`[aria-label="${label}"]`);
+      },
+      allByRole(container2, role) {
+        return Array.from(container2.querySelectorAll(`[role="${role}"]`));
+      }
+    },
+    /** Assertion helpers */
+    assert: {
+      textContent(el, expected) {
+        const actual = el.textContent || "";
+        if (!actual.includes(expected)) {
+          throw new Error(`Expected text content to include "${expected}", but got "${actual}"`);
+        }
+      },
+      attribute(el, attr, value) {
+        if (!el.hasAttribute(attr)) {
+          throw new Error(`Expected element to have attribute "${attr}", but it does not`);
+        }
+        if (value !== void 0) {
+          const actual = el.getAttribute(attr);
+          if (actual !== value) {
+            throw new Error(`Expected attribute "${attr}" to be "${value}", but got "${actual}"`);
+          }
+        }
+      },
+      visible(el) {
+        const htmlEl = el;
+        const reasons = [];
+        if (el.hasAttribute("hidden")) reasons.push('has "hidden" attribute');
+        if (htmlEl.style?.display === "none") reasons.push("has display:none");
+        if (htmlEl.style?.visibility === "hidden") reasons.push("has visibility:hidden");
+        if (reasons.length > 0) {
+          throw new Error(`Expected element to be visible, but it ${reasons.join(" and ")}`);
+        }
+      },
+      disabled(el) {
+        const isDisabled = el.disabled === true || el.hasAttribute("disabled") || el.getAttribute("aria-disabled") === "true";
+        if (!isDisabled) {
+          throw new Error("Expected element to be disabled, but it is not");
+        }
+      },
+      className(el, name) {
+        if (!el.classList.contains(name)) {
+          throw new Error(`Expected element to have class "${name}", but it has "${el.className}"`);
+        }
+      }
+    }
+  };
+}
+
+// src/testing/e2e.ts
+function createHttpMock(routes = []) {
+  const originalFetch = globalThis.fetch;
+  const requestLog = [];
+  const mockRoutes = [...routes];
+  function matchRoute(url, method) {
+    return mockRoutes.find((route) => {
+      const methodMatch = !route.method || route.method.toUpperCase() === method.toUpperCase();
+      if (!methodMatch) return false;
+      if (typeof route.url === "string") return url === route.url || url.endsWith(route.url);
+      return route.url.test(url);
+    });
+  }
+  const mockFetch = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method || "GET";
+    const body = init?.body ? JSON.parse(String(init.body)) : void 0;
+    requestLog.push({ url, method, body, timestamp: Date.now() });
+    const route = matchRoute(url, method);
+    if (!route) {
+      return new Response(JSON.stringify({ error: "Not mocked" }), { status: 404 });
+    }
+    let mockResponse;
+    if (typeof route.response === "function") {
+      mockResponse = await route.response({ url, method, body, headers: new Headers(init?.headers) });
+    } else {
+      mockResponse = route.response;
+    }
+    if (mockResponse.delay) {
+      await new Promise((r) => setTimeout(r, mockResponse.delay));
+    }
+    return new Response(typeof mockResponse.body === "string" ? mockResponse.body : JSON.stringify(mockResponse.body), {
+      status: mockResponse.status || 200,
+      statusText: mockResponse.statusText || "OK",
+      headers: mockResponse.headers
+    });
+  };
+  return {
+    /** Install the mock (replace global fetch) */
+    install() {
+      globalThis.fetch = mockFetch;
+    },
+    /** Restore original fetch */
+    restore() {
+      globalThis.fetch = originalFetch;
+    },
+    /** Add a mock route */
+    addRoute(route) {
+      mockRoutes.push(route);
+    },
+    /** Remove all mock routes */
+    clearRoutes() {
+      mockRoutes.length = 0;
+    },
+    /** Get the request log */
+    getRequests() {
+      return [...requestLog];
+    },
+    /** Clear the request log */
+    clearLog() {
+      requestLog.length = 0;
+    },
+    /** Assert that a URL was called */
+    assertCalled(url, method = "GET") {
+      const found = requestLog.some((r) => r.url.includes(url) && r.method.toUpperCase() === method.toUpperCase());
+      if (!found) throw new Error(`Expected ${method} ${url} to have been called`);
+    },
+    /** Assert that a URL was NOT called */
+    assertNotCalled(url, method = "GET") {
+      const found = requestLog.some((r) => r.url.includes(url) && r.method.toUpperCase() === method.toUpperCase());
+      if (found) throw new Error(`Expected ${method} ${url} to NOT have been called`);
+    },
+    /** Get number of times a URL was called */
+    callCount(url, method = "GET") {
+      return requestLog.filter((r) => r.url.includes(url) && r.method.toUpperCase() === method.toUpperCase()).length;
+    }
+  };
+}
+function createTimerMock() {
+  const originalSetTimeout = globalThis.setTimeout;
+  const originalSetInterval = globalThis.setInterval;
+  const originalClearTimeout = globalThis.clearTimeout;
+  const originalClearInterval = globalThis.clearInterval;
+  const originalRAF = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : void 0;
+  const originalCAF = typeof cancelAnimationFrame !== "undefined" ? cancelAnimationFrame : void 0;
+  let currentTime = 0;
+  let nextId = 1;
+  const timers = [];
+  return {
+    install() {
+      currentTime = 0;
+      globalThis.setTimeout = (cb, delay = 0) => {
+        const id = nextId++;
+        timers.push({ id, callback: cb, time: currentTime + delay });
+        return id;
+      };
+      globalThis.setInterval = (cb, interval) => {
+        const id = nextId++;
+        timers.push({ id, callback: cb, time: currentTime + interval, interval });
+        return id;
+      };
+      globalThis.clearTimeout = (id) => {
+        const idx = timers.findIndex((t) => t.id === id);
+        if (idx !== -1) timers.splice(idx, 1);
+      };
+      globalThis.clearInterval = (id) => {
+        const idx = timers.findIndex((t) => t.id === id);
+        if (idx !== -1) timers.splice(idx, 1);
+      };
+      globalThis.requestAnimationFrame = (cb) => {
+        const id = nextId++;
+        timers.push({ id, callback: () => cb(currentTime), time: currentTime + 16 });
+        return id;
+      };
+      globalThis.cancelAnimationFrame = (id) => {
+        const idx = timers.findIndex((t) => t.id === id);
+        if (idx !== -1) timers.splice(idx, 1);
+      };
+    },
+    restore() {
+      globalThis.setTimeout = originalSetTimeout;
+      globalThis.setInterval = originalSetInterval;
+      globalThis.clearTimeout = originalClearTimeout;
+      globalThis.clearInterval = originalClearInterval;
+      if (originalRAF) globalThis.requestAnimationFrame = originalRAF;
+      if (originalCAF) globalThis.cancelAnimationFrame = originalCAF;
+      timers.length = 0;
+    },
+    /** Advance time by a given number of ms, running any timers that fire */
+    advance(ms) {
+      const targetTime = currentTime + ms;
+      while (true) {
+        timers.sort((a, b) => a.time - b.time);
+        const next = timers.find((t) => t.time <= targetTime);
+        if (!next) break;
+        currentTime = next.time;
+        const idx = timers.indexOf(next);
+        if (next.interval) {
+          next.time += next.interval;
+        } else {
+          timers.splice(idx, 1);
+        }
+        next.callback();
+      }
+      currentTime = targetTime;
+    },
+    /** Run all pending timers immediately */
+    flush() {
+      const maxIterations = 1e3;
+      let i = 0;
+      while (timers.length > 0 && i++ < maxIterations) {
+        timers.sort((a, b) => a.time - b.time);
+        const next = timers[0];
+        currentTime = next.time;
+        if (next.interval) {
+          next.time += next.interval;
+        } else {
+          timers.shift();
+        }
+        next.callback();
+      }
+    },
+    /** Get current fake time */
+    now() {
+      return currentTime;
+    },
+    /** Get number of pending timers */
+    pendingCount() {
+      return timers.length;
+    }
+  };
+}
+function createDOMSnapshot(element) {
+  return serializeElement(element, 0);
+}
+function serializeElement(el, indent) {
+  const pad = "  ".repeat(indent);
+  const tag = el.tagName.toLowerCase();
+  const attrs = Array.from(el.attributes).sort((a, b) => a.name.localeCompare(b.name)).map((a) => `${a.name}="${a.value}"`).join(" ");
+  const open = attrs ? `${pad}<${tag} ${attrs}>` : `${pad}<${tag}>`;
+  const children = Array.from(el.childNodes);
+  if (children.length === 0) {
+    return `${open}</${tag}>`;
+  }
+  if (children.length === 1 && children[0].nodeType === 3) {
+    const text = children[0].textContent?.trim() || "";
+    return `${open}${text}</${tag}>`;
+  }
+  const childStr = children.map((child) => {
+    if (child.nodeType === 3) {
+      const text = child.textContent?.trim();
+      return text ? `${"  ".repeat(indent + 1)}${text}` : "";
+    }
+    if (child.nodeType === 1) {
+      return serializeElement(child, indent + 1);
+    }
+    return "";
+  }).filter(Boolean).join("\n");
+  return `${open}
+${childStr}
+${pad}</${tag}>`;
+}
+function assertDOMEquals(actual, expected) {
+  const actualSnapshot = createDOMSnapshot(actual);
+  const expectedSnapshot = createDOMSnapshot(expected);
+  if (actualSnapshot !== expectedSnapshot) {
+    throw new Error(`DOM mismatch:
+
+Actual:
+${actualSnapshot}
+
+Expected:
+${expectedSnapshot}`);
+  }
+}
+function testComponent(component, options = {}) {
+  const container = options.container || document.createElement("div");
+  if (!options.container) document.body.appendChild(container);
+  const element = typeof component === "function" ? component() : component;
+  container.appendChild(element);
+  return {
+    element,
+    container,
+    getByTestId(id) {
+      return container.querySelector(`[data-testid="${id}"]`);
+    },
+    getAllByTestId(id) {
+      return Array.from(container.querySelectorAll(`[data-testid="${id}"]`));
+    },
+    getByText(text) {
+      const walker = document.createTreeWalker(container, NodeFilter.SHOW_TEXT);
+      while (walker.nextNode()) {
+        if (walker.currentNode.textContent?.includes(text)) {
+          return walker.currentNode.parentElement;
+        }
+      }
+      return null;
+    },
+    click(el) {
+      el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+    },
+    type(el, value) {
+      el.value = value;
+      el.dispatchEvent(new Event("input", { bubbles: true }));
+      el.dispatchEvent(new Event("change", { bubbles: true }));
+    },
+    async waitForUpdate() {
+      await new Promise((r) => setTimeout(r, 0));
+    },
+    destroy() {
+      if (container.parentNode) container.parentNode.removeChild(container);
+    }
+  };
+}
+
+// src/testing/snapshot.ts
+function serializeElement2(el, indent) {
+  const pad = "  ".repeat(indent);
+  const tag = el.tagName.toLowerCase();
+  const attrs = Array.from(el.attributes).sort((a, b) => a.name.localeCompare(b.name)).map((a) => `${a.name}="${a.value}"`).join(" ");
+  const open = attrs ? `${pad}<${tag} ${attrs}>` : `${pad}<${tag}>`;
+  const children = Array.from(el.childNodes);
+  if (children.length === 0) {
+    return `${open}</${tag}>`;
+  }
+  if (children.length === 1 && children[0].nodeType === 3) {
+    const text = children[0].textContent?.trim() || "";
+    return `${open}${text}</${tag}>`;
+  }
+  const childStr = children.map((child) => {
+    if (child.nodeType === 3) {
+      const text = child.textContent?.trim();
+      return text ? `${"  ".repeat(indent + 1)}${text}` : "";
+    }
+    if (child.nodeType === 1) {
+      return serializeElement2(child, indent + 1);
+    }
+    if (child.nodeType === 8) {
+      return `${"  ".repeat(indent + 1)}<!-- ${child.textContent?.trim() || ""} -->`;
+    }
+    return "";
+  }).filter(Boolean).join("\n");
+  return `${open}
+${childStr}
+${pad}</${tag}>`;
+}
+function simpleDiff(a, b) {
+  const aLines = a.split("\n");
+  const bLines = b.split("\n");
+  const result = [];
+  const maxLen = Math.max(aLines.length, bLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    const aLine = i < aLines.length ? aLines[i] : void 0;
+    const bLine = i < bLines.length ? bLines[i] : void 0;
+    if (aLine === bLine) {
+      result.push(`  ${aLine}`);
+    } else {
+      if (aLine !== void 0) result.push(`- ${aLine}`);
+      if (bLine !== void 0) result.push(`+ ${bLine}`);
+    }
+  }
+  return result.join("\n");
+}
+function createSnapshotStore() {
+  const snapshots = /* @__PURE__ */ new Map();
+  return {
+    save(name, snapshot) {
+      if (snapshots.has(name)) {
+        throw new Error(`Snapshot "${name}" already exists. Use update() to overwrite.`);
+      }
+      snapshots.set(name, snapshot);
+    },
+    get(name) {
+      return snapshots.get(name);
+    },
+    has(name) {
+      return snapshots.has(name);
+    },
+    compare(name, current) {
+      const saved = snapshots.get(name);
+      if (saved === void 0) {
+        return { match: false, diff: "No saved snapshot found." };
+      }
+      if (saved === current) {
+        return { match: true };
+      }
+      return { match: false, diff: simpleDiff(saved, current) };
+    },
+    update(name, snapshot) {
+      snapshots.set(name, snapshot);
+    },
+    delete(name) {
+      snapshots.delete(name);
+    },
+    list() {
+      return Array.from(snapshots.keys());
+    },
+    clear() {
+      snapshots.clear();
+    }
+  };
+}
+function snapshotComponent(component) {
+  const container = document.createElement("div");
+  const element = component();
+  container.appendChild(element);
+  return serializeElement2(element, 0);
+}
+function matchSnapshot(store, name, component, options) {
+  const snapshot = snapshotComponent(component);
+  if (options?.update) {
+    store.update(name, snapshot);
+    return { passed: true, snapshot };
+  }
+  if (!store.has(name)) {
+    store.save(name, snapshot);
+    return { passed: true, snapshot };
+  }
+  const result = store.compare(name, snapshot);
+  return {
+    passed: result.match,
+    snapshot,
+    diff: result.diff
+  };
+}
+function createSnapshotMatcher(store) {
+  let counter = 0;
+  let updateMode = false;
+  return {
+    toMatchSnapshot(component, name) {
+      const snapshotName = name ?? `snapshot_${++counter}`;
+      const result = matchSnapshot(store, snapshotName, component, {
+        update: updateMode
+      });
+      if (!result.passed) {
+        throw new Error(`Snapshot "${snapshotName}" does not match.
+
+${result.diff ?? ""}`);
+      }
+    },
+    updateAll() {
+      updateMode = true;
+    }
+  };
+}
+
+// src/testing/visualRegression.ts
+function djb2Hash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function walkElements(root) {
+  const elements = [root];
+  for (const child of Array.from(root.children)) {
+    elements.push(...walkElements(child));
+  }
+  return elements;
+}
+function serializeStructure(el, indent) {
+  const pad = "  ".repeat(indent);
+  const tag = el.tagName.toLowerCase();
+  const attrs = Array.from(el.attributes).sort((a, b) => a.name.localeCompare(b.name)).map((a) => `${a.name}="${a.value}"`).join(" ");
+  const open = attrs ? `${pad}<${tag} ${attrs}>` : `${pad}<${tag}>`;
+  const children = Array.from(el.childNodes);
+  if (children.length === 0) {
+    return `${open}</${tag}>`;
+  }
+  if (children.length === 1 && children[0].nodeType === 3) {
+    const text = children[0].textContent?.trim() || "";
+    return `${open}${text}</${tag}>`;
+  }
+  const childStr = children.map((child) => {
+    if (child.nodeType === 3) {
+      const text = child.textContent?.trim();
+      return text ? `${"  ".repeat(indent + 1)}${text}` : "";
+    }
+    if (child.nodeType === 1) {
+      return serializeStructure(child, indent + 1);
+    }
+    return "";
+  }).filter(Boolean).join("\n");
+  return `${open}
+${childStr}
+${pad}</${tag}>`;
+}
+function captureFingerprint(element) {
+  const allElements = walkElements(element);
+  const structure = serializeStructure(element, 0);
+  const textContent = (element.textContent || "").replace(/\s+/g, " ").trim();
+  const elementCounts = {};
+  for (const el of allElements) {
+    const tag = el.tagName.toLowerCase();
+    elementCounts[tag] = (elementCounts[tag] || 0) + 1;
+  }
+  const classSet = /* @__PURE__ */ new Set();
+  for (const el of allElements) {
+    for (const cls of Array.from(el.classList)) {
+      classSet.add(cls);
+    }
+  }
+  const classNames = Array.from(classSet).sort();
+  const inlineStyles = [];
+  for (const el of allElements) {
+    const style = el.getAttribute("style");
+    if (style) {
+      inlineStyles.push(style.trim());
+    }
+  }
+  inlineStyles.sort();
+  const dataAttributes = {};
+  const tagCounters = {};
+  for (const el of allElements) {
+    const tag = el.tagName.toLowerCase();
+    tagCounters[tag] = (tagCounters[tag] || 0) + 1;
+    const idx = tagCounters[tag];
+    for (const attr of Array.from(el.attributes)) {
+      if (attr.name.startsWith("data-")) {
+        dataAttributes[`${tag}[${idx}].${attr.name}`] = attr.value;
+      }
+    }
+  }
+  const composite = [
+    structure,
+    textContent,
+    JSON.stringify(elementCounts),
+    classNames.join(","),
+    inlineStyles.join(";"),
+    JSON.stringify(dataAttributes)
+  ].join("|");
+  const hash = djb2Hash(composite);
+  return {
+    structure,
+    textContent,
+    elementCounts,
+    classNames,
+    inlineStyles,
+    dataAttributes,
+    hash
+  };
+}
+function compareFingerprints(baseline, current) {
+  const changes = [];
+  if (baseline.structure !== current.structure) {
+    changes.push({
+      type: "structure",
+      description: "DOM structure has changed."
+    });
+  }
+  if (baseline.textContent !== current.textContent) {
+    changes.push({
+      type: "text",
+      description: `Text content changed: "${truncate(baseline.textContent, 80)}" -> "${truncate(current.textContent, 80)}"`
+    });
+  }
+  const allTags = /* @__PURE__ */ new Set([...Object.keys(baseline.elementCounts), ...Object.keys(current.elementCounts)]);
+  for (const tag of allTags) {
+    const bCount = baseline.elementCounts[tag] || 0;
+    const cCount = current.elementCounts[tag] || 0;
+    if (bCount !== cCount) {
+      changes.push({
+        type: "elements",
+        description: `<${tag}> count changed: ${bCount} -> ${cCount}`
+      });
+    }
+  }
+  const addedClasses = current.classNames.filter((c) => !baseline.classNames.includes(c));
+  const removedClasses = baseline.classNames.filter((c) => !current.classNames.includes(c));
+  if (addedClasses.length > 0) {
+    changes.push({
+      type: "class",
+      description: `Added classes: ${addedClasses.join(", ")}`
+    });
+  }
+  if (removedClasses.length > 0) {
+    changes.push({
+      type: "class",
+      description: `Removed classes: ${removedClasses.join(", ")}`
+    });
+  }
+  const baselineStyleSet = new Set(baseline.inlineStyles);
+  const currentStyleSet = new Set(current.inlineStyles);
+  const addedStyles = current.inlineStyles.filter((s) => !baselineStyleSet.has(s));
+  const removedStyles = baseline.inlineStyles.filter((s) => !currentStyleSet.has(s));
+  if (addedStyles.length > 0 || removedStyles.length > 0) {
+    const parts = [];
+    if (addedStyles.length > 0) parts.push(`added: ${addedStyles.join("; ")}`);
+    if (removedStyles.length > 0) parts.push(`removed: ${removedStyles.join("; ")}`);
+    changes.push({
+      type: "style",
+      description: `Inline styles changed (${parts.join(", ")})`
+    });
+  }
+  const allDataKeys = /* @__PURE__ */ new Set([...Object.keys(baseline.dataAttributes), ...Object.keys(current.dataAttributes)]);
+  const dataChanges = [];
+  for (const key of allDataKeys) {
+    const bVal = baseline.dataAttributes[key];
+    const cVal = current.dataAttributes[key];
+    if (bVal === void 0) {
+      dataChanges.push(`added ${key}="${cVal}"`);
+    } else if (cVal === void 0) {
+      dataChanges.push(`removed ${key}="${bVal}"`);
+    } else if (bVal !== cVal) {
+      dataChanges.push(`changed ${key}: "${bVal}" -> "${cVal}"`);
+    }
+  }
+  if (dataChanges.length > 0) {
+    changes.push({
+      type: "data",
+      description: `Data attributes changed: ${dataChanges.join("; ")}`
+    });
+  }
+  return {
+    match: changes.length === 0,
+    changes
+  };
+}
+function createVisualSuite() {
+  const baselines = /* @__PURE__ */ new Map();
+  return {
+    baseline(name, element) {
+      if (baselines.has(name)) {
+        throw new Error(`Baseline "${name}" already exists. Use updateBaseline() to overwrite.`);
+      }
+      baselines.set(name, captureFingerprint(element));
+    },
+    check(name, element) {
+      const saved = baselines.get(name);
+      if (!saved) {
+        throw new Error(`No baseline found for "${name}". Call baseline() first to capture one.`);
+      }
+      const current = captureFingerprint(element);
+      return compareFingerprints(saved, current);
+    },
+    updateBaseline(name, element) {
+      baselines.set(name, captureFingerprint(element));
+    },
+    list() {
+      return Array.from(baselines.keys());
+    },
+    clear() {
+      baselines.clear();
+    }
+  };
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, maxLen - 3)}...`;
+}
+
+// src/testing/index.ts
+function render(component) {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const element = component();
+  container.appendChild(element);
+  function getByText(text) {
+    const walk = (node) => {
+      if (node.childNodes.length === 1 && node.childNodes[0].nodeType === 3) {
+        if (node.textContent?.includes(text)) return node;
+      }
+      for (const child of Array.from(node.children)) {
+        const found = walk(child);
+        if (found) return found;
+      }
+      return null;
+    };
+    return walk(container);
+  }
+  function getByTestId(testId) {
+    return container.querySelector(`[data-testid="${testId}"]`);
+  }
+  function getByRole(role) {
+    return container.querySelector(`[role="${role}"]`);
+  }
+  function queryAll(selector) {
+    return Array.from(container.querySelectorAll(selector));
+  }
+  function unmount() {
+    container.innerHTML = "";
+    if (container.parentNode) container.parentNode.removeChild(container);
+  }
+  return { container, element, getByText, getByTestId, getByRole, queryAll, unmount };
+}
+function fireEvent(element, eventName, eventInit) {
+  const event = new Event(eventName, { bubbles: true, cancelable: true, ...eventInit });
+  return element.dispatchEvent(event);
+}
+fireEvent.click = (element) => element.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+fireEvent.input = (element, value) => {
+  if (value !== void 0 && element instanceof HTMLInputElement) {
+    element.value = value;
+  }
+  return element.dispatchEvent(new Event("input", { bubbles: true }));
+};
+fireEvent.change = (element, value) => {
+  if (value !== void 0 && element instanceof HTMLInputElement) {
+    element.value = value;
+  }
+  return element.dispatchEvent(new Event("change", { bubbles: true }));
+};
+fireEvent.submit = (element) => element.dispatchEvent(new Event("submit", { bubbles: true, cancelable: true }));
+fireEvent.keyDown = (element, key, init) => element.dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true, ...init }));
+fireEvent.keyUp = (element, key, init) => element.dispatchEvent(new KeyboardEvent("keyup", { key, bubbles: true, ...init }));
+fireEvent.focus = (element) => element.focus();
+fireEvent.blur = (element) => element.blur();
+async function waitFor(callback, options = {}) {
+  const { timeout = 1e3, interval = 50 } = options;
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    const check = () => {
+      try {
+        callback();
+        resolve();
+      } catch (error) {
+        if (Date.now() - start >= timeout) {
+          reject(error);
+        } else {
+          setTimeout(check, interval);
+        }
+      }
+    };
+    check();
+  });
+}
+function mockRouter(initialPath = "/") {
+  const history = [initialPath];
+  let pathIndex = 0;
+  function currentPath() {
+    return history[pathIndex];
+  }
+  function navigate(path) {
+    history.push(path);
+    pathIndex = history.length - 1;
+  }
+  return { currentPath, navigate, history };
+}
+function mockStore(initialState) {
+  let state = { ...initialState };
+  return {
+    getState: () => ({ ...state }),
+    setState: (patch) => {
+      state = { ...state, ...patch };
+    },
+    reset: () => {
+      state = { ...initialState };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertA11y,
+  assertDOMEquals,
+  captureFingerprint,
+  checkA11y,
+  checkAriaAttributes,
+  checkColorContrast,
+  checkFormLabels,
+  checkHeadingHierarchy,
+  checkImageAlt,
+  checkKeyboardAccess,
+  checkLandmarks,
+  checkLinksAndButtons,
+  checkListSemantics,
+  checkTabOrder,
+  compareFingerprints,
+  createCypressAdapter,
+  createDOMSnapshot,
+  createHttpMock,
+  createJestAdapter,
+  createPlaywrightAdapter,
+  createSnapshotMatcher,
+  createSnapshotStore,
+  createTimerMock,
+  createUniversalAdapter,
+  createVisualSuite,
+  fireEvent,
+  matchSnapshot,
+  mockRouter,
+  mockStore,
+  render,
+  snapshotComponent,
+  testComponent,
+  waitFor
+});