@reticular/speakable 1.0.0

package/dist/cli.js

@@ -0,0 +1,2862 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/cli.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+// src/cli/options.ts
+function validateOptions(rawOptions) {
+  const format = rawOptions.format;
+  const screenReader = rawOptions.screenReader;
+  const validFormats = ["json", "text", "audit", "both"];
+  if (!validFormats.includes(format)) {
+    throw new Error(
+      `Invalid format: ${format}. Must be one of: ${validFormats.join(", ")}`
+    );
+  }
+  const validReaders = ["nvda", "jaws", "voiceover", "all"];
+  if (!validReaders.includes(screenReader)) {
+    throw new Error(
+      `Invalid screen reader: ${screenReader}. Must be one of: ${validReaders.join(", ")}`
+    );
+  }
+  return {
+    output: rawOptions.output,
+    format,
+    screenReader,
+    selector: rawOptions.selector,
+    validate: rawOptions.validate || false,
+    diff: rawOptions.diff,
+    batch: rawOptions.batch || false
+  };
+}
+function parseInput(input) {
+  if (Array.isArray(input)) {
+    if (input.length === 0) {
+      return {
+        input: void 0,
+        isStdin: false,
+        inputs: []
+      };
+    }
+    if (input.includes("-")) {
+      if (input.length === 1) {
+        return { input: void 0, isStdin: true };
+      }
+      throw new Error("Batch mode cannot be used with stdin input");
+    }
+    if (input.length === 1) {
+      return {
+        input: input[0],
+        isStdin: false
+      };
+    }
+    return {
+      input: void 0,
+      isStdin: false,
+      inputs: input
+    };
+  }
+  if (!input) {
+    return {
+      input: void 0,
+      isStdin: false
+    };
+  }
+  if (input === "-") {
+    return {
+      input: void 0,
+      isStdin: true
+    };
+  }
+  return {
+    input,
+    isStdin: false
+  };
+}
+function validateInput(parsedInput) {
+  const hasInputs = parsedInput.inputs && parsedInput.inputs.length > 0;
+  if (!parsedInput.input && !parsedInput.isStdin && !hasInputs) {
+    throw new Error(
+      'No input provided. Specify an HTML file path or use "-" for stdin.'
+    );
+  }
+}
+function validateDiffMode(options, parsedInput) {
+  if (options.diff) {
+    if (parsedInput.isStdin) {
+      throw new Error("Diff mode cannot be used with stdin input");
+    }
+    if (!parsedInput.input) {
+      throw new Error("Diff mode requires an input file");
+    }
+    if (parsedInput.inputs && parsedInput.inputs.length > 0) {
+      throw new Error("Diff mode cannot be used with batch mode");
+    }
+  }
+}
+function validateBatchMode(options, parsedInput) {
+  if (options.batch) {
+    if (parsedInput.isStdin) {
+      throw new Error("Batch mode cannot be used with stdin input");
+    }
+    if (options.diff) {
+      throw new Error("Batch mode cannot be used with diff mode");
+    }
+    if (!parsedInput.inputs || parsedInput.inputs.length === 0) {
+      throw new Error("Batch mode requires multiple input files");
+    }
+  }
+}
+
+// src/cli/io.ts
+import { readFileSync, writeFileSync } from "fs";
+import { stdin } from "process";
+var FileIOError = class extends Error {
+  constructor(message, code, path) {
+    super(message);
+    this.code = code;
+    this.path = path;
+    this.name = "FileIOError";
+  }
+};
+function readHTMLFromFile(filePath) {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new FileIOError(
+        `File not found: ${filePath}`,
+        "ENOENT",
+        filePath
+      );
+    }
+    if (error.code === "EACCES") {
+      throw new FileIOError(
+        `Permission denied: ${filePath}`,
+        "EACCES",
+        filePath
+      );
+    }
+    if (error.code === "EISDIR") {
+      throw new FileIOError(
+        `Path is a directory, not a file: ${filePath}`,
+        "EISDIR",
+        filePath
+      );
+    }
+    throw new FileIOError(
+      `Failed to read file: ${filePath}. ${error.message}`,
+      error.code,
+      filePath
+    );
+  }
+}
+async function readHTMLFromStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stdin.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    stdin.on("end", () => {
+      const content = Buffer.concat(chunks).toString("utf-8");
+      resolve(content);
+    });
+    stdin.on("error", (error) => {
+      reject(new FileIOError(
+        `Failed to read from stdin: ${error.message}`,
+        "STDIN_ERROR"
+      ));
+    });
+    stdin.resume();
+  });
+}
+function writeOutputToFile(filePath, content) {
+  try {
+    writeFileSync(filePath, content, "utf-8");
+  } catch (error) {
+    if (error.code === "EACCES") {
+      throw new FileIOError(
+        `Permission denied: ${filePath}`,
+        "EACCES",
+        filePath
+      );
+    }
+    if (error.code === "ENOSPC") {
+      throw new FileIOError(
+        `No space left on device: ${filePath}`,
+        "ENOSPC",
+        filePath
+      );
+    }
+    if (error.code === "EISDIR") {
+      throw new FileIOError(
+        `Path is a directory, not a file: ${filePath}`,
+        "EISDIR",
+        filePath
+      );
+    }
+    throw new FileIOError(
+      `Failed to write file: ${filePath}. ${error.message}`,
+      error.code,
+      filePath
+    );
+  }
+}
+function writeOutputToStdout(content) {
+  console.log(content);
+}
+function readHTML(filePath, isStdin) {
+  if (isStdin) {
+    return readHTMLFromStdin();
+  }
+  if (!filePath) {
+    throw new FileIOError("No input source specified");
+  }
+  return readHTMLFromFile(filePath);
+}
+function writeOutput(content, outputPath) {
+  if (outputPath) {
+    writeOutputToFile(outputPath, content);
+  } else {
+    writeOutputToStdout(content);
+  }
+}
+
+// src/parser/html-parser.ts
+import { JSDOM } from "jsdom";
+var ParsingError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ParsingError";
+  }
+};
+function parseHTML(html) {
+  const warnings = [];
+  try {
+    const dom = new JSDOM(html, {
+      contentType: "text/html",
+      // Include useful defaults for accessibility tree extraction
+      includeNodeLocations: false,
+      storageQuota: 0
+    });
+    const document = dom.window.document;
+    if (!document.documentElement) {
+      warnings.push({
+        message: "Document has no root element. HTML may be severely malformed."
+      });
+    }
+    if (!document.body) {
+      warnings.push({
+        message: "Document has no body element. HTML may be malformed."
+      });
+    }
+    return {
+      document,
+      warnings
+    };
+  } catch (error) {
+    throw new ParsingError(
+      `Failed to parse HTML: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+
+// src/extractor/aria-name.ts
+function computeAccessibleName(element, visited = /* @__PURE__ */ new Set()) {
+  const warnings = [];
+  if (visited.has(element)) {
+    warnings.push({
+      message: "Circular reference detected in aria-labelledby chain",
+      element
+    });
+    return { name: "", warnings };
+  }
+  visited.add(element);
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const name = computeNameFromLabelledBy(element, labelledBy, visited, warnings);
+    return { name, warnings };
+  }
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.trim()) {
+    return { name: ariaLabel.trim(), warnings };
+  }
+  if (isFormControl(element)) {
+    const labelName = computeNameFromLabel(element);
+    if (labelName) {
+      return { name: labelName, warnings };
+    }
+  }
+  if (element.tagName.toLowerCase() === "img") {
+    const alt = element.getAttribute("alt");
+    if (alt !== null) {
+      return { name: alt.trim(), warnings };
+    }
+  }
+  if (supportsNameFromContent(element)) {
+    const textName = computeNameFromContent(element, visited);
+    if (textName) {
+      return { name: textName, warnings };
+    }
+  }
+  const title = element.getAttribute("title");
+  if (title && title.trim()) {
+    return { name: title.trim(), warnings };
+  }
+  return { name: "", warnings };
+}
+function computeNameFromLabelledBy(element, labelledBy, visited, warnings) {
+  const document = element.ownerDocument;
+  if (!document) {
+    return "";
+  }
+  const ids = labelledBy.trim().split(/\s+/);
+  const names = [];
+  for (const id of ids) {
+    if (!id) continue;
+    const referencedElement = document.getElementById(id);
+    if (!referencedElement) {
+      warnings.push({
+        message: `aria-labelledby references non-existent ID: ${id}`,
+        element
+      });
+      continue;
+    }
+    const result = computeAccessibleName(referencedElement, new Set(visited));
+    warnings.push(...result.warnings);
+    const name = result.name || getTextContent(referencedElement);
+    if (name) {
+      names.push(name);
+    }
+  }
+  return names.join(" ").trim();
+}
+function computeNameFromLabel(element) {
+  const document = element.ownerDocument;
+  if (!document) {
+    return "";
+  }
+  const id = element.getAttribute("id");
+  if (id) {
+    const label = document.querySelector(`label[for="${id}"]`);
+    if (label) {
+      return getTextContent(label);
+    }
+  }
+  const parentLabel = element.closest("label");
+  if (parentLabel) {
+    return getTextContent(parentLabel);
+  }
+  return "";
+}
+function computeNameFromContent(element, _visited) {
+  return getTextContent(element);
+}
+function getTextContent(element) {
+  if (element.getAttribute("aria-hidden") === "true") {
+    return "";
+  }
+  let text = "";
+  for (const node of Array.from(element.childNodes)) {
+    if (node.nodeType === 3) {
+      text += node.textContent || "";
+    } else if (node.nodeType === 1) {
+      const childElement = node;
+      if (childElement.getAttribute("aria-hidden") === "true") {
+        continue;
+      }
+      text += getTextContent(childElement);
+    }
+  }
+  return text.trim();
+}
+function isFormControl(element) {
+  const tagName = element.tagName.toLowerCase();
+  return tagName === "input" || tagName === "textarea" || tagName === "select" || tagName === "button";
+}
+function supportsNameFromContent(element) {
+  const tagName = element.tagName.toLowerCase();
+  const role = element.getAttribute("role");
+  const contentElements = [
+    "button",
+    "a",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "summary",
+    "figcaption",
+    "legend",
+    "caption",
+    "th",
+    "td",
+    "li",
+    "dt",
+    "dd"
+  ];
+  if (contentElements.includes(tagName)) {
+    return true;
+  }
+  const contentRoles = [
+    "button",
+    "link",
+    "heading",
+    "tab",
+    "treeitem",
+    "option",
+    "row",
+    "cell",
+    "columnheader",
+    "rowheader",
+    "tooltip",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio"
+  ];
+  if (role && contentRoles.includes(role)) {
+    return true;
+  }
+  return false;
+}
+function computeAccessibleDescription(element) {
+  const warnings = [];
+  const describedBy = element.getAttribute("aria-describedby");
+  if (describedBy) {
+    const description = computeDescriptionFromDescribedBy(
+      element,
+      describedBy,
+      warnings
+    );
+    if (description) {
+      return { description, warnings };
+    }
+  }
+  const title = element.getAttribute("title");
+  if (title && title.trim()) {
+    return { description: title.trim(), warnings };
+  }
+  return { description: "", warnings };
+}
+function computeDescriptionFromDescribedBy(element, describedBy, warnings) {
+  const document = element.ownerDocument;
+  if (!document) {
+    return "";
+  }
+  const ids = describedBy.trim().split(/\s+/);
+  const descriptions = [];
+  for (const id of ids) {
+    if (!id) continue;
+    const referencedElement = document.getElementById(id);
+    if (!referencedElement) {
+      warnings.push({
+        message: `aria-describedby references non-existent ID: ${id}`,
+        element
+      });
+      continue;
+    }
+    const text = getTextContent(referencedElement);
+    if (text) {
+      descriptions.push(text);
+    }
+  }
+  return descriptions.join(" ").trim();
+}
+
+// src/model/types.ts
+var SUPPORTED_ROLES = [
+  // Original roles (22)
+  "button",
+  "link",
+  "heading",
+  "textbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "option",
+  "list",
+  "listitem",
+  "navigation",
+  "main",
+  "banner",
+  "contentinfo",
+  "region",
+  "img",
+  "article",
+  "complementary",
+  "form",
+  "search",
+  "generic",
+  // New roles (21)
+  "paragraph",
+  "blockquote",
+  "code",
+  "staticText",
+  "table",
+  "row",
+  "cell",
+  "columnheader",
+  "rowheader",
+  "term",
+  "definition",
+  "figure",
+  "caption",
+  "group",
+  "dialog",
+  "meter",
+  "progressbar",
+  "status",
+  "document",
+  "application",
+  "separator"
+];
+var CURRENT_MODEL_VERSION = {
+  major: 1,
+  minor: 0
+};
+
+// src/extractor/role-mapper.ts
+var IMPLICIT_ROLE_MAP = {
+  // Interactive elements
+  "button": "button",
+  "a": "link",
+  // Only if href attribute present
+  // Form controls
+  "input": "textbox",
+  // Default, varies by type
+  "textarea": "textbox",
+  "select": "listbox",
+  // Headings
+  "h1": "heading",
+  "h2": "heading",
+  "h3": "heading",
+  "h4": "heading",
+  "h5": "heading",
+  "h6": "heading",
+  // Landmarks
+  "nav": "navigation",
+  "main": "main",
+  "header": "banner",
+  // Only if not nested in article/section
+  "footer": "contentinfo",
+  // Only if not nested in article/section
+  "aside": "complementary",
+  "form": "form",
+  "section": "region",
+  // Only if has accessible name
+  // Lists
+  "ul": "list",
+  "ol": "list",
+  "li": "listitem",
+  // Images
+  "img": "img",
+  // Articles
+  "article": "article",
+  // Static content (new)
+  "p": "paragraph",
+  "blockquote": "blockquote",
+  "code": "code",
+  "pre": "code",
+  // Tables (new)
+  "table": "table",
+  "tr": "row",
+  "td": "cell",
+  "th": "columnheader",
+  // Default; scope="row" handled in computeImplicitRole
+  // Definition lists (new)
+  "dl": "list",
+  "dt": "term",
+  "dd": "definition",
+  // Figures (new)
+  "figure": "figure",
+  "figcaption": "caption",
+  // Disclosure (new)
+  "details": "group",
+  "summary": "button",
+  // Dialogs and widgets (new)
+  "dialog": "dialog",
+  "meter": "meter",
+  "progress": "progressbar",
+  "output": "status",
+  // Forms (new)
+  "fieldset": "group",
+  "legend": "caption",
+  // Embedded content (new)
+  "iframe": "document",
+  "video": "application",
+  "audio": "application",
+  // Separators (new)
+  "hr": "separator",
+  // Table caption (new)
+  "caption": "caption"
+};
+var INPUT_TYPE_ROLE_MAP = {
+  "button": "button",
+  "submit": "button",
+  "reset": "button",
+  "checkbox": "checkbox",
+  "radio": "radio",
+  "text": "textbox",
+  "email": "textbox",
+  "password": "textbox",
+  "search": "textbox",
+  "tel": "textbox",
+  "url": "textbox",
+  "number": "textbox"
+};
+function computeRole(element) {
+  const warnings = [];
+  const explicitRole = element.getAttribute("role");
+  if (explicitRole) {
+    const role = validateAndNormalizeRole(explicitRole, element, warnings);
+    if (role) {
+      return { role, warnings };
+    }
+  }
+  const implicitRole = computeImplicitRole(element, warnings);
+  return { role: implicitRole, warnings };
+}
+function validateAndNormalizeRole(roleAttr, element, warnings) {
+  const role = roleAttr.trim().toLowerCase();
+  if (role === "presentation" || role === "none") {
+    return null;
+  }
+  if (SUPPORTED_ROLES.includes(role)) {
+    return role;
+  }
+  warnings.push({
+    message: `Invalid or unsupported role: "${roleAttr}". Falling back to implicit role.`,
+    element
+  });
+  return null;
+}
+function computeImplicitRole(element, _warnings) {
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input") {
+    return computeInputRole(element);
+  }
+  if (tagName === "a") {
+    return element.hasAttribute("href") ? "link" : null;
+  }
+  if (tagName === "header") {
+    return isTopLevelLandmark(element) ? "banner" : null;
+  }
+  if (tagName === "footer") {
+    return isTopLevelLandmark(element) ? "contentinfo" : null;
+  }
+  if (tagName === "th") {
+    const scope = element.getAttribute("scope");
+    return scope === "row" ? "rowheader" : "columnheader";
+  }
+  if (tagName === "section") {
+    return element.hasAttribute("aria-label") || element.hasAttribute("aria-labelledby") ? "region" : null;
+  }
+  const implicitRole = IMPLICIT_ROLE_MAP[tagName];
+  return implicitRole || null;
+}
+function computeInputRole(input) {
+  const type = (input.getAttribute("type") || "text").toLowerCase();
+  return INPUT_TYPE_ROLE_MAP[type] || "textbox";
+}
+function isTopLevelLandmark(element) {
+  let parent = element.parentElement;
+  while (parent) {
+    const tagName = parent.tagName.toLowerCase();
+    if (tagName === "article" || tagName === "section") {
+      return false;
+    }
+    parent = parent.parentElement;
+  }
+  return true;
+}
+function isAccessible(element) {
+  if (element.getAttribute("aria-hidden") === "true") {
+    return false;
+  }
+  const role = element.getAttribute("role");
+  if (role === "presentation" || role === "none") {
+    return false;
+  }
+  const roleResult = computeRole(element);
+  return roleResult.role !== null;
+}
+
+// src/extractor/state-extractor.ts
+function extractState(element) {
+  const warnings = [];
+  const state = {};
+  const expanded = extractBooleanAttribute(element, "aria-expanded", warnings);
+  if (expanded !== void 0) {
+    state.expanded = expanded;
+  }
+  const checked = extractTriStateAttribute(element, "aria-checked", warnings);
+  if (checked !== void 0) {
+    state.checked = checked;
+  }
+  const pressed = extractTriStateAttribute(element, "aria-pressed", warnings);
+  if (pressed !== void 0) {
+    state.pressed = pressed;
+  }
+  const selected = extractBooleanAttribute(element, "aria-selected", warnings);
+  if (selected !== void 0) {
+    state.selected = selected;
+  }
+  const disabled = extractBooleanAttribute(element, "aria-disabled", warnings);
+  if (disabled !== void 0) {
+    state.disabled = disabled;
+  }
+  const invalid = extractBooleanAttribute(element, "aria-invalid", warnings);
+  if (invalid !== void 0) {
+    state.invalid = invalid;
+  }
+  const required = extractBooleanAttribute(element, "aria-required", warnings);
+  if (required !== void 0) {
+    state.required = required;
+  }
+  const readonly = extractBooleanAttribute(element, "aria-readonly", warnings);
+  if (readonly !== void 0) {
+    state.readonly = readonly;
+  }
+  const busy = extractBooleanAttribute(element, "aria-busy", warnings);
+  if (busy !== void 0) {
+    state.busy = busy;
+  }
+  const current = extractCurrentAttribute(element, warnings);
+  if (current !== void 0) {
+    state.current = current;
+  }
+  const grabbed = extractBooleanAttribute(element, "aria-grabbed", warnings);
+  if (grabbed !== void 0) {
+    state.grabbed = grabbed;
+  }
+  const hidden = extractBooleanAttribute(element, "aria-hidden", warnings);
+  if (hidden !== void 0) {
+    state.hidden = hidden;
+  }
+  const level = extractLevelAttribute(element, warnings);
+  if (level !== void 0) {
+    state.level = level;
+  }
+  const posinset = extractNumberAttribute(element, "aria-posinset", warnings);
+  if (posinset !== void 0) {
+    state.posinset = posinset;
+  }
+  const setsize = extractNumberAttribute(element, "aria-setsize", warnings);
+  if (setsize !== void 0) {
+    state.setsize = setsize;
+  }
+  extractNativeStates(element, state, warnings);
+  return { state, warnings };
+}
+function extractValue(element) {
+  const warnings = [];
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input") {
+    return extractInputValue(element, warnings);
+  }
+  if (tagName === "textarea") {
+    return extractTextareaValue(element, warnings);
+  }
+  if (tagName === "select") {
+    return extractSelectValue(element, warnings);
+  }
+  const valueNow = element.getAttribute("aria-valuenow");
+  if (valueNow !== null) {
+    const current = parseFloat(valueNow);
+    if (!isNaN(current)) {
+      const valueMin = element.getAttribute("aria-valuemin");
+      const valueMax = element.getAttribute("aria-valuemax");
+      const valueText = element.getAttribute("aria-valuetext");
+      return {
+        value: {
+          current,
+          min: valueMin !== null ? parseFloat(valueMin) : void 0,
+          max: valueMax !== null ? parseFloat(valueMax) : void 0,
+          text: valueText || void 0
+        },
+        warnings
+      };
+    }
+  }
+  return { value: void 0, warnings };
+}
+function extractBooleanAttribute(element, attrName, warnings) {
+  const value = element.getAttribute(attrName);
+  if (value === null) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  warnings.push({
+    message: `Invalid ${attrName} value: "${value}". Expected "true" or "false".`,
+    element
+  });
+  return void 0;
+}
+function extractTriStateAttribute(element, attrName, warnings) {
+  const value = element.getAttribute(attrName);
+  if (value === null) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  if (normalized === "mixed") {
+    return "mixed";
+  }
+  warnings.push({
+    message: `Invalid ${attrName} value: "${value}". Expected "true", "false", or "mixed".`,
+    element
+  });
+  return void 0;
+}
+function extractCurrentAttribute(element, warnings) {
+  const value = element.getAttribute("aria-current");
+  if (value === null) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase().trim();
+  const validValues = ["page", "step", "location", "date", "time", "true", "false"];
+  if (validValues.includes(normalized)) {
+    return normalized === "false" ? false : normalized;
+  }
+  warnings.push({
+    message: `Invalid aria-current value: "${value}". Expected one of: ${validValues.join(", ")}.`,
+    element
+  });
+  return void 0;
+}
+function extractLevelAttribute(element, warnings) {
+  const ariaLevel = element.getAttribute("aria-level");
+  if (ariaLevel !== null) {
+    const level = parseInt(ariaLevel, 10);
+    if (!isNaN(level) && level >= 1 && level <= 6) {
+      return level;
+    }
+    warnings.push({
+      message: `Invalid aria-level value: "${ariaLevel}". Expected integer 1-6.`,
+      element
+    });
+    return void 0;
+  }
+  const tagName = element.tagName.toLowerCase();
+  const match = tagName.match(/^h([1-6])$/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return void 0;
+}
+function extractNumberAttribute(element, attrName, warnings) {
+  const value = element.getAttribute(attrName);
+  if (value === null) {
+    return void 0;
+  }
+  const num = parseInt(value, 10);
+  if (isNaN(num) || num < 1) {
+    warnings.push({
+      message: `Invalid ${attrName} value: "${value}". Expected positive integer.`,
+      element
+    });
+    return void 0;
+  }
+  return num;
+}
+function extractNativeStates(element, state, _warnings) {
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input") {
+    const input = element;
+    const type = input.type.toLowerCase();
+    if (type === "checkbox" || type === "radio") {
+      if (state.checked === void 0) {
+        state.checked = input.checked;
+      }
+    }
+  }
+  if ("disabled" in element) {
+    const htmlElement = element;
+    if (state.disabled === void 0 && htmlElement.disabled) {
+      state.disabled = true;
+    }
+  }
+  if ("required" in element) {
+    const htmlElement = element;
+    if (state.required === void 0 && htmlElement.required) {
+      state.required = true;
+    }
+  }
+  if ("readOnly" in element) {
+    const htmlElement = element;
+    if (state.readonly === void 0 && htmlElement.readOnly) {
+      state.readonly = true;
+    }
+  }
+}
+function extractInputValue(input, warnings) {
+  const type = input.type.toLowerCase();
+  if (type === "checkbox" || type === "radio") {
+    return { value: void 0, warnings };
+  }
+  if (type === "button" || type === "submit" || type === "reset") {
+    return { value: void 0, warnings };
+  }
+  const value = input.value;
+  if (value) {
+    return {
+      value: {
+        current: value,
+        text: value
+      },
+      warnings
+    };
+  }
+  return { value: void 0, warnings };
+}
+function extractTextareaValue(textarea, warnings) {
+  const value = textarea.value;
+  if (value) {
+    return {
+      value: {
+        current: value,
+        text: value
+      },
+      warnings
+    };
+  }
+  return { value: void 0, warnings };
+}
+function extractSelectValue(select, warnings) {
+  const value = select.value;
+  const selectedOption = select.options[select.selectedIndex];
+  const text = selectedOption?.textContent || value;
+  if (value) {
+    return {
+      value: {
+        current: value,
+        text
+      },
+      warnings
+    };
+  }
+  return { value: void 0, warnings };
+}
+
+// src/extractor/focus-extractor.ts
+var NATIVELY_FOCUSABLE_ELEMENTS = [
+  "a",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "area",
+  "iframe",
+  "object",
+  "embed",
+  "audio",
+  "video"
+];
+function extractFocusInfo(element) {
+  const tabindexAttr = element.getAttribute("tabindex");
+  const tabindex = tabindexAttr !== null ? parseInt(tabindexAttr, 10) : void 0;
+  const focusable = isFocusable(element, tabindex);
+  return {
+    focusable,
+    ...tabindexAttr !== null && !isNaN(tabindex) && { tabindex }
+  };
+}
+function isFocusable(element, tabindex) {
+  const tagName = element.tagName.toLowerCase();
+  if (isDisabled(element)) {
+    return false;
+  }
+  if (tabindex !== void 0 && !isNaN(tabindex)) {
+    return true;
+  }
+  if (isNativelyFocusable(element, tagName)) {
+    return true;
+  }
+  return false;
+}
+function isNativelyFocusable(element, tagName) {
+  if (tagName === "a" || tagName === "area") {
+    return element.hasAttribute("href");
+  }
+  if (NATIVELY_FOCUSABLE_ELEMENTS.includes(tagName)) {
+    return true;
+  }
+  return false;
+}
+function isDisabled(element) {
+  if ("disabled" in element) {
+    const htmlElement = element;
+    if (htmlElement.disabled) {
+      return true;
+    }
+  }
+  const ariaDisabled = element.getAttribute("aria-disabled");
+  if (ariaDisabled === "true") {
+    return true;
+  }
+  return false;
+}
+
+// src/extractor/tree-builder.ts
+var SelectorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SelectorError";
+  }
+};
+function isHidden(element) {
+  if (element.getAttribute("aria-hidden") === "true") return true;
+  if (typeof getComputedStyle === "function") {
+    try {
+      const style = getComputedStyle(element);
+      if (style.display === "none") return true;
+      if (style.visibility === "hidden") return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function processChildNode(node, children, warnings) {
+  if (node.nodeType === 3) {
+    const text = (node.textContent || "").trim();
+    if (text.length > 0) {
+      children.push({
+        role: "staticText",
+        name: text,
+        state: {},
+        focus: { focusable: false },
+        children: []
+      });
+    }
+    return;
+  }
+  if (node.nodeType === 1) {
+    const element = node;
+    if (isHidden(element)) return;
+    if (!isAccessible(element)) {
+      const grandchildren = collectChildrenFromRolelessElement(element, warnings);
+      children.push(...grandchildren);
+      return;
+    }
+    const childNode = buildNodeRecursive(element, warnings);
+    if (childNode) children.push(childNode);
+  }
+}
+function collectChildrenFromRolelessElement(element, warnings) {
+  const children = [];
+  if (element.shadowRoot) {
+    for (const child of Array.from(element.shadowRoot.childNodes)) {
+      processChildNode(child, children, warnings);
+    }
+  }
+  for (const child of Array.from(element.childNodes)) {
+    processChildNode(child, children, warnings);
+  }
+  return children;
+}
+function buildAccessibilityTree(rootElement, sourceHash) {
+  const warnings = [];
+  if (isHidden(rootElement)) {
+    const model2 = {
+      version: CURRENT_MODEL_VERSION,
+      root: {
+        role: "generic",
+        name: "",
+        state: {},
+        focus: { focusable: false },
+        children: []
+      },
+      metadata: {
+        extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...sourceHash && { sourceHash }
+      }
+    };
+    return { model: model2, warnings };
+  }
+  const rootNode = buildNodeRecursive(rootElement, warnings);
+  const accessibleRoot = rootNode || createGenericContainer(rootElement, warnings);
+  const model = {
+    version: CURRENT_MODEL_VERSION,
+    root: accessibleRoot,
+    metadata: {
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...sourceHash && { sourceHash }
+    }
+  };
+  return { model, warnings };
+}
+function buildAccessibilityTreeWithSelector(rootElement, selector, sourceHash) {
+  const document = rootElement.ownerDocument;
+  if (!document) {
+    throw new SelectorError("Element has no owner document");
+  }
+  let matchingElements;
+  try {
+    if (rootElement.matches(selector)) {
+      matchingElements = [rootElement];
+    } else {
+      matchingElements = Array.from(rootElement.querySelectorAll(selector));
+    }
+  } catch (error) {
+    throw new SelectorError(`Invalid CSS selector: "${selector}". ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (matchingElements.length === 0) {
+    throw new SelectorError(`No elements match selector: "${selector}"`);
+  }
+  const results = [];
+  for (const element of matchingElements) {
+    const result = buildAccessibilityTree(element, sourceHash);
+    results.push(result);
+  }
+  return results;
+}
+function buildNodeRecursive(element, warnings) {
+  if (isHidden(element)) {
+    return null;
+  }
+  if (!isAccessible(element)) {
+    return null;
+  }
+  const roleResult = computeRole(element);
+  warnings.push(...roleResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  if (!roleResult.role) {
+    return null;
+  }
+  const nameResult = computeAccessibleName(element);
+  warnings.push(...nameResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const descResult = computeAccessibleDescription(element);
+  warnings.push(...descResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const stateResult = extractState(element);
+  warnings.push(...stateResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const valueResult = extractValue(element);
+  warnings.push(...valueResult.warnings.map((w) => ({
+    message: w.message,
+    element: w.element
+  })));
+  const focusInfo = extractFocusInfo(element);
+  const children = [];
+  if (element.shadowRoot) {
+    for (const child of Array.from(element.shadowRoot.childNodes)) {
+      processChildNode(child, children, warnings);
+    }
+  }
+  for (const child of Array.from(element.childNodes)) {
+    processChildNode(child, children, warnings);
+  }
+  const node = {
+    role: roleResult.role,
+    name: nameResult.name,
+    ...descResult.description && { description: descResult.description },
+    ...valueResult.value && { value: valueResult.value },
+    state: stateResult.state,
+    focus: focusInfo,
+    children
+  };
+  return node;
+}
+function createGenericContainer(rootElement, warnings) {
+  const children = [];
+  if (rootElement.shadowRoot) {
+    for (const child of Array.from(rootElement.shadowRoot.childNodes)) {
+      processChildNode(child, children, warnings);
+    }
+  }
+  for (const child of Array.from(rootElement.childNodes)) {
+    processChildNode(child, children, warnings);
+  }
+  return {
+    role: "generic",
+    name: "",
+    state: {},
+    focus: {
+      focusable: false
+    },
+    children
+  };
+}
+
+// src/model/validation.ts
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function validateRole(role) {
+  if (!SUPPORTED_ROLES.includes(role)) {
+    throw new ValidationError(
+      `Invalid role: "${role}". Supported roles: ${SUPPORTED_ROLES.join(", ")}`
+    );
+  }
+  return true;
+}
+function validateState(state) {
+  if (state.level !== void 0) {
+    if (!Number.isInteger(state.level) || state.level < 1 || state.level > 6) {
+      throw new ValidationError(
+        `Invalid heading level: ${state.level}. Must be an integer between 1 and 6.`
+      );
+    }
+  }
+  if (state.posinset !== void 0) {
+    if (!Number.isInteger(state.posinset) || state.posinset < 1) {
+      throw new ValidationError(
+        `Invalid posinset: ${state.posinset}. Must be a positive integer.`
+      );
+    }
+  }
+  if (state.setsize !== void 0) {
+    if (!Number.isInteger(state.setsize) || state.setsize < 1) {
+      throw new ValidationError(
+        `Invalid setsize: ${state.setsize}. Must be a positive integer.`
+      );
+    }
+  }
+  if (state.posinset !== void 0 && state.setsize !== void 0 && state.posinset > state.setsize) {
+    throw new ValidationError(
+      `Invalid set position: posinset (${state.posinset}) cannot exceed setsize (${state.setsize}).`
+    );
+  }
+  if (state.checked !== void 0) {
+    if (typeof state.checked !== "boolean" && state.checked !== "mixed") {
+      throw new ValidationError(
+        `Invalid checked value: ${state.checked}. Must be boolean or 'mixed'.`
+      );
+    }
+  }
+  if (state.pressed !== void 0) {
+    if (typeof state.pressed !== "boolean" && state.pressed !== "mixed") {
+      throw new ValidationError(
+        `Invalid pressed value: ${state.pressed}. Must be boolean or 'mixed'.`
+      );
+    }
+  }
+  if (state.current !== void 0) {
+    const validCurrentValues = ["page", "step", "location", "date", "time", "true", false];
+    if (!validCurrentValues.includes(state.current)) {
+      throw new ValidationError(
+        `Invalid current value: ${state.current}. Must be one of: ${validCurrentValues.join(", ")}`
+      );
+    }
+  }
+}
+function validateTreeStructure(node, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(node)) {
+    throw new ValidationError(
+      "Circular reference detected in accessibility tree. Tree must be acyclic."
+    );
+  }
+  visited.add(node);
+  validateRole(node.role);
+  validateState(node.state);
+  for (const child of node.children) {
+    validateTreeStructure(child, new Set(visited));
+  }
+}
+function validateModel(model) {
+  if (!model.version || typeof model.version.major !== "number" || typeof model.version.minor !== "number") {
+    throw new ValidationError("Invalid model version. Must have major and minor number fields.");
+  }
+  if (!model.metadata || !model.metadata.extractedAt) {
+    throw new ValidationError("Invalid metadata. Must have extractedAt timestamp.");
+  }
+  const timestamp = new Date(model.metadata.extractedAt);
+  if (isNaN(timestamp.getTime())) {
+    throw new ValidationError(
+      `Invalid extractedAt timestamp: ${model.metadata.extractedAt}. Must be ISO 8601 format.`
+    );
+  }
+  if (!model.root) {
+    throw new ValidationError("Model must have a root node.");
+  }
+  validateTreeStructure(model.root);
+}
+
+// src/model/serialization.ts
+function sortObjectKeys(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(sortObjectKeys);
+  }
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    const value = obj[key];
+    sorted[key] = typeof value === "object" && value !== null ? sortObjectKeys(value) : value;
+  }
+  return sorted;
+}
+function serializeModel(model, options = {}) {
+  const { pretty = false, validate = true } = options;
+  if (validate) {
+    validateModel(model);
+  }
+  const sorted = sortObjectKeys(model);
+  return pretty ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
+}
+function deserializeModel(json, options = {}) {
+  const { validate = true } = options;
+  const model = JSON.parse(json);
+  if (validate) {
+    validateModel(model);
+  }
+  return model;
+}
+function modelsEqual(a, b) {
+  const jsonA = serializeModel(a, { validate: false });
+  const jsonB = serializeModel(b, { validate: false });
+  return jsonA === jsonB;
+}
+
+// src/cli/colors.ts
+import pc from "picocolors";
+var identity = (s) => s;
+function isColorEnabled(stream) {
+  return stream.isTTY === true;
+}
+function createColors(enabled) {
+  if (!enabled) {
+    return {
+      error: identity,
+      warning: identity,
+      info: identity,
+      success: identity,
+      heading: identity,
+      title: identity,
+      dim: identity,
+      roleName: identity,
+      stateName: identity,
+      elementName: identity,
+      sectionHeader: identity,
+      description: identity,
+      bold: identity,
+      enabled: false
+    };
+  }
+  return {
+    error: pc.red,
+    warning: pc.yellow,
+    info: pc.blue,
+    success: pc.green,
+    heading: (s) => pc.bold(pc.cyan(s)),
+    title: (s) => pc.bold(pc.cyan(s)),
+    dim: pc.dim,
+    roleName: pc.cyan,
+    stateName: pc.yellow,
+    elementName: (s) => pc.bold(pc.white(s)),
+    sectionHeader: (s) => pc.bold(pc.white(s)),
+    description: pc.dim,
+    bold: pc.bold,
+    enabled: true
+  };
+}
+
+// src/renderer/nvda-renderer.ts
+function renderNVDA(model, colorize) {
+  const c = createColors(colorize ?? false);
+  const announcements = [];
+  renderNodeNVDA(model.root, announcements, c);
+  return announcements.join("\n");
+}
+function renderNodeNVDA(node, announcements, c) {
+  const announcement = formatNodeNVDA(node, c);
+  if (announcement) {
+    announcements.push(announcement);
+  }
+  for (const child of node.children) {
+    renderNodeNVDA(child, announcements, c);
+  }
+}
+function formatNodeNVDA(node, c) {
+  const parts = [];
+  if (node.name) {
+    parts.push(c.elementName(node.name));
+  }
+  const roleText = formatRoleNVDA(node);
+  if (roleText) {
+    parts.push(c.roleName(roleText));
+  }
+  const stateText = formatStatesNVDA(node);
+  if (stateText) {
+    parts.push(c.stateName(stateText));
+  }
+  if (node.value) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) {
+      parts.push(valueText);
+    }
+  }
+  if (node.description) {
+    parts.push(c.description(node.description));
+  }
+  return parts.join(", ");
+}
+function formatRoleNVDA(node) {
+  const role = node.role;
+  switch (role) {
+    case "button":
+      return "button";
+    case "link":
+      return "link";
+    case "heading":
+      if (node.state.level) {
+        return `heading level ${node.state.level}`;
+      }
+      return "heading";
+    case "textbox":
+      return "edit";
+    case "checkbox":
+      return "checkbox";
+    case "radio":
+      return "radio button";
+    case "combobox":
+      return "combo box";
+    case "listbox":
+      return "list box";
+    case "option":
+      return "option";
+    case "list":
+      return "list";
+    case "listitem":
+      return "list item";
+    case "navigation":
+      return "navigation landmark";
+    case "main":
+      return "main landmark";
+    case "banner":
+      return "banner landmark";
+    case "contentinfo":
+      return "content information landmark";
+    case "region":
+      return "region landmark";
+    case "complementary":
+      return "complementary landmark";
+    case "form":
+      return "form landmark";
+    case "search":
+      return "search landmark";
+    case "img":
+      return "graphic";
+    case "article":
+      return "article";
+    case "generic":
+      return "";
+    case "staticText":
+    case "paragraph":
+    case "cell":
+    case "term":
+    case "definition":
+    case "caption":
+      return "";
+    case "blockquote":
+      return "block quote";
+    case "code":
+      return "code";
+    case "table":
+      return "table";
+    case "row":
+      return "row";
+    case "columnheader":
+      return "column header";
+    case "rowheader":
+      return "row header";
+    case "figure":
+      return "figure";
+    case "dialog":
+      return "dialog";
+    case "meter":
+      return "meter";
+    case "progressbar":
+      return "progress bar";
+    case "status":
+      return "status";
+    case "group":
+      return node.name ? "grouping" : "";
+    case "document":
+      return "document";
+    case "application":
+      return "embedded object";
+    case "separator":
+      return "separator";
+    default:
+      return role;
+  }
+}
+function formatStatesNVDA(node) {
+  const states = [];
+  if (node.state.expanded !== void 0) {
+    states.push(node.state.expanded ? "expanded" : "collapsed");
+  }
+  if (node.state.checked !== void 0) {
+    if (node.state.checked === "mixed") {
+      states.push("half checked");
+    } else {
+      states.push(node.state.checked ? "checked" : "not checked");
+    }
+  }
+  if (node.state.pressed !== void 0) {
+    if (node.state.pressed === "mixed") {
+      states.push("half pressed");
+    } else {
+      states.push(node.state.pressed ? "pressed" : "not pressed");
+    }
+  }
+  if (node.state.selected !== void 0) {
+    states.push(node.state.selected ? "selected" : "not selected");
+  }
+  if (node.state.disabled) {
+    states.push("unavailable");
+  }
+  if (node.state.invalid) {
+    states.push("invalid entry");
+  }
+  if (node.state.required) {
+    states.push("required");
+  }
+  if (node.state.readonly) {
+    states.push("read only");
+  }
+  if (node.state.busy) {
+    states.push("busy");
+  }
+  if (node.state.current) {
+    if (node.state.current === "page") {
+      states.push("current page");
+    } else if (node.state.current === "step") {
+      states.push("current step");
+    } else if (node.state.current === "location") {
+      states.push("current location");
+    } else if (node.state.current === "date") {
+      states.push("current date");
+    } else if (node.state.current === "time") {
+      states.push("current time");
+    } else if (node.state.current === "true") {
+      states.push("current");
+    }
+  }
+  if (node.state.grabbed !== void 0) {
+    states.push(node.state.grabbed ? "grabbed" : "not grabbed");
+  }
+  return states.join(", ");
+}
+
+// src/renderer/jaws-renderer.ts
+function renderJAWS(model, colorize) {
+  const c = createColors(colorize ?? false);
+  const announcements = [];
+  renderNodeJAWS(model.root, announcements, c);
+  return announcements.join("\n");
+}
+function renderNodeJAWS(node, announcements, c) {
+  const announcement = formatNodeJAWS(node, c);
+  if (announcement) {
+    announcements.push(announcement);
+  }
+  for (const child of node.children) {
+    renderNodeJAWS(child, announcements, c);
+  }
+}
+function formatNodeJAWS(node, c) {
+  const parts = [];
+  if (node.name) {
+    parts.push(c.elementName(node.name));
+  }
+  const roleText = formatRoleJAWS(node);
+  if (roleText) {
+    parts.push(c.roleName(roleText));
+  }
+  const stateText = formatStatesJAWS(node);
+  if (stateText) {
+    parts.push(c.stateName(stateText));
+  }
+  if (node.value) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) {
+      parts.push(valueText);
+    }
+  }
+  if (node.description) {
+    parts.push(c.description(node.description));
+  }
+  return parts.join(", ");
+}
+function formatRoleJAWS(node) {
+  const role = node.role;
+  switch (role) {
+    case "button":
+      return "button";
+    case "link":
+      return "clickable";
+    case "heading":
+      if (node.state.level) {
+        return `heading ${node.state.level}`;
+      }
+      return "heading";
+    case "textbox":
+      return "edit";
+    case "checkbox":
+      return "check box";
+    case "radio":
+      return "radio button";
+    case "combobox":
+      return "combo box";
+    case "listbox":
+      return "list box";
+    case "option":
+      return "option";
+    case "list":
+      return "list";
+    case "listitem":
+      return "list item";
+    case "navigation":
+      return "navigation region";
+    case "main":
+      return "main region";
+    case "banner":
+      return "banner region";
+    case "contentinfo":
+      return "content information region";
+    case "region":
+      return "region";
+    case "img":
+      return "graphic";
+    case "article":
+      return "article";
+    case "complementary":
+      return "complementary region";
+    case "form":
+      return "form";
+    case "search":
+      return "search region";
+    case "generic":
+      return "";
+    case "staticText":
+    case "paragraph":
+    case "term":
+    case "definition":
+    case "caption":
+      return "";
+    case "blockquote":
+      return "block quote";
+    case "code":
+      return "code";
+    case "table": {
+      const rows = node.children.filter((c) => c.role === "row");
+      const rowCount = rows.length;
+      const colCount = rows.length > 0 ? rows[0].children.length : 0;
+      return `table with ${rowCount} rows and ${colCount} columns`;
+    }
+    case "row": {
+      const pos = node.state.posinset ?? 0;
+      return `row ${pos}`;
+    }
+    case "cell": {
+      const pos = node.state.posinset ?? 0;
+      return `column ${pos}`;
+    }
+    case "columnheader":
+      return "column header";
+    case "rowheader":
+      return "row header";
+    case "figure":
+      return "figure";
+    case "dialog":
+      return "dialog";
+    case "meter":
+      return "meter";
+    case "progressbar":
+      return "progress bar";
+    case "status":
+      return "status";
+    case "group":
+      return node.name ? "group" : "";
+    case "document":
+      return "frame";
+    case "application":
+      return "embedded object";
+    case "separator":
+      return "separator";
+    default:
+      return role;
+  }
+}
+function formatStatesJAWS(node) {
+  const states = [];
+  if (node.state.expanded !== void 0) {
+    states.push(node.state.expanded ? "expanded" : "collapsed");
+  }
+  if (node.state.checked !== void 0) {
+    if (node.state.checked === "mixed") {
+      states.push("partially checked");
+    } else if (node.state.checked) {
+      states.push("checked");
+    } else {
+      states.push("not checked");
+    }
+  }
+  if (node.state.pressed !== void 0) {
+    if (node.state.pressed === "mixed") {
+      states.push("partially pressed");
+    } else if (node.state.pressed) {
+      states.push("pressed");
+    } else {
+      states.push("not pressed");
+    }
+  }
+  if (node.state.selected !== void 0) {
+    states.push(node.state.selected ? "selected" : "not selected");
+  }
+  if (node.state.disabled) {
+    states.push("unavailable");
+  }
+  if (node.state.invalid) {
+    states.push("invalid entry");
+  }
+  if (node.state.required) {
+    states.push("required");
+  }
+  if (node.state.readonly) {
+    states.push("read only");
+  }
+  if (node.state.busy) {
+    states.push("busy");
+  }
+  if (node.state.current) {
+    switch (node.state.current) {
+      case "page":
+        states.push("current page");
+        break;
+      case "step":
+        states.push("current step");
+        break;
+      case "location":
+        states.push("current location");
+        break;
+      case "date":
+        states.push("current date");
+        break;
+      case "time":
+        states.push("current time");
+        break;
+      case "true":
+        states.push("current");
+        break;
+    }
+  }
+  if (node.state.grabbed !== void 0) {
+    states.push(node.state.grabbed ? "grabbed" : "not grabbed");
+  }
+  return states.join(", ");
+}
+
+// src/renderer/voiceover-renderer.ts
+function renderVoiceOver(model, colorize) {
+  const c = createColors(colorize ?? false);
+  const announcements = [];
+  renderNodeVoiceOver(model.root, announcements, c);
+  return announcements.join("\n");
+}
+function renderNodeVoiceOver(node, announcements, c) {
+  const announcement = formatNodeVoiceOver(node, c);
+  if (announcement) {
+    announcements.push(announcement);
+  }
+  for (const child of node.children) {
+    renderNodeVoiceOver(child, announcements, c);
+  }
+}
+function formatNodeVoiceOver(node, c) {
+  const parts = [];
+  const roleFirst = shouldAnnounceRoleFirst(node.role);
+  if (roleFirst) {
+    const roleText = formatRoleVoiceOver(node);
+    if (roleText) {
+      parts.push(c.roleName(roleText));
+    }
+    if (node.name) {
+      parts.push(c.elementName(node.name));
+    }
+  } else {
+    if (node.name) {
+      parts.push(c.elementName(node.name));
+    }
+    const roleText = formatRoleVoiceOver(node);
+    if (roleText) {
+      parts.push(c.roleName(roleText));
+    }
+  }
+  const stateText = formatStatesVoiceOver(node);
+  if (stateText) {
+    parts.push(c.stateName(stateText));
+  }
+  if (node.value) {
+    const valueText = node.value.text || String(node.value.current);
+    if (valueText) {
+      parts.push(valueText);
+    }
+  }
+  if (node.description) {
+    parts.push(c.description(node.description));
+  }
+  return parts.join(", ");
+}
+function shouldAnnounceRoleFirst(role) {
+  return role === "heading" || role === "navigation" || role === "main" || role === "banner" || role === "contentinfo" || role === "complementary" || role === "region" || role === "form" || role === "search" || role === "blockquote" || role === "figure" || role === "dialog" || role === "group" || role === "document";
+}
+function formatRoleVoiceOver(node) {
+  const role = node.role;
+  switch (role) {
+    case "button":
+      return "button";
+    case "link":
+      return "link";
+    case "heading":
+      if (node.state.level) {
+        return `heading level ${node.state.level}`;
+      }
+      return "heading";
+    case "textbox":
+      return "edit text";
+    case "checkbox":
+      return "checkbox";
+    case "radio":
+      return "radio button";
+    case "combobox":
+      return "combo box";
+    case "listbox":
+      return "list box";
+    case "option":
+      return "option";
+    case "list":
+      return "list";
+    case "listitem":
+      return "item";
+    case "navigation":
+      return "navigation";
+    case "main":
+      return "main";
+    case "banner":
+      return "banner";
+    case "contentinfo":
+      return "content information";
+    case "region":
+      return "region";
+    case "complementary":
+      return "complementary";
+    case "form":
+      return "form";
+    case "search":
+      return "search";
+    case "img":
+      return "image";
+    case "article":
+      return "article";
+    case "generic":
+      return "";
+    case "staticText":
+    case "paragraph":
+    case "cell":
+    case "term":
+    case "definition":
+    case "caption":
+      return "";
+    case "blockquote":
+      return "blockquote";
+    case "code":
+      return "code";
+    case "table": {
+      const rows = node.children.filter((c) => c.role === "row");
+      const rowCount = rows.length;
+      const colCount = rows.length > 0 ? rows[0].children.length : 0;
+      return `table, ${rowCount} rows, ${colCount} columns`;
+    }
+    case "row":
+      return "row";
+    case "columnheader":
+      return "column header";
+    case "rowheader":
+      return "row header";
+    case "figure":
+      return "figure";
+    case "dialog":
+      return "web dialog";
+    case "meter":
+      return "level indicator";
+    case "progressbar":
+      return "progress indicator";
+    case "status":
+      return "status";
+    case "group":
+      return node.name ? "group" : "";
+    case "document":
+      return "frame";
+    case "application":
+      return "embedded object";
+    case "separator":
+      return "separator";
+    default:
+      return role;
+  }
+}
+function formatStatesVoiceOver(node) {
+  const states = [];
+  if (node.state.expanded !== void 0) {
+    states.push(node.state.expanded ? "expanded" : "collapsed");
+  }
+  if (node.state.checked !== void 0) {
+    if (node.state.checked === "mixed") {
+      states.push("mixed");
+    } else {
+      states.push(node.state.checked ? "checked" : "unchecked");
+    }
+  }
+  if (node.state.pressed !== void 0) {
+    if (node.state.pressed === "mixed") {
+      states.push("mixed");
+    } else {
+      states.push(node.state.pressed ? "pressed" : "not pressed");
+    }
+  }
+  if (node.state.selected !== void 0) {
+    states.push(node.state.selected ? "selected" : "unselected");
+  }
+  if (node.state.disabled) {
+    states.push("dimmed");
+  }
+  if (node.state.invalid) {
+    states.push("invalid data");
+  }
+  if (node.state.required) {
+    states.push("required");
+  }
+  if (node.state.readonly) {
+    states.push("read only");
+  }
+  if (node.state.busy) {
+    states.push("busy");
+  }
+  if (node.state.current) {
+    if (node.state.current === "page") {
+      states.push("current page");
+    } else if (node.state.current === "step") {
+      states.push("current step");
+    } else if (node.state.current === "location") {
+      states.push("current location");
+    } else if (node.state.current === "date") {
+      states.push("current date");
+    } else if (node.state.current === "time") {
+      states.push("current time");
+    } else if (node.state.current === "true") {
+      states.push("current");
+    }
+  }
+  if (node.state.grabbed !== void 0) {
+    states.push(node.state.grabbed ? "grabbed" : "not grabbed");
+  }
+  return states.join(", ");
+}
+
+// src/renderer/audit-renderer.ts
+function renderAuditReport(model, colorize) {
+  const report = generateAuditReport(model);
+  return formatAuditReport(report, model, colorize);
+}
+function generateAuditReport(model) {
+  const statistics = {
+    totalElements: 0,
+    roleDistribution: {},
+    landmarkCount: 0,
+    headingCount: 0,
+    interactiveCount: 0,
+    focusableCount: 0,
+    statesUsed: /* @__PURE__ */ new Set()
+  };
+  const landmarks = [];
+  const headings = [];
+  const interactiveElements = [];
+  const issues = [];
+  collectAuditData(model.root, statistics, landmarks, headings, interactiveElements);
+  detectLandmarkIssues(landmarks, issues);
+  detectHeadingIssues(headings, issues);
+  detectInteractiveIssues(interactiveElements, issues);
+  return {
+    statistics,
+    landmarks,
+    headings,
+    interactiveElements,
+    issues
+  };
+}
+function collectAuditData(node, statistics, landmarks, headings, interactiveElements) {
+  if (node.role !== "generic") {
+    statistics.totalElements++;
+    statistics.roleDistribution[node.role] = (statistics.roleDistribution[node.role] || 0) + 1;
+    if (isLandmark(node.role)) {
+      statistics.landmarkCount++;
+      landmarks.push(node);
+    }
+    if (node.role === "heading") {
+      statistics.headingCount++;
+      headings.push(node);
+    }
+    if (isInteractive(node.role)) {
+      statistics.interactiveCount++;
+      interactiveElements.push(node);
+    }
+    if (node.focus.focusable) {
+      statistics.focusableCount++;
+    }
+    Object.keys(node.state).forEach((state) => {
+      if (node.state[state] !== void 0) {
+        statistics.statesUsed.add(state);
+      }
+    });
+  }
+  for (const child of node.children) {
+    collectAuditData(child, statistics, landmarks, headings, interactiveElements);
+  }
+}
+function isLandmark(role) {
+  return [
+    "navigation",
+    "main",
+    "banner",
+    "contentinfo",
+    "region",
+    "complementary",
+    "form",
+    "search"
+  ].includes(role);
+}
+function isInteractive(role) {
+  return [
+    "button",
+    "link",
+    "textbox",
+    "checkbox",
+    "radio",
+    "combobox",
+    "listbox",
+    "option"
+  ].includes(role);
+}
+function detectLandmarkIssues(landmarks, issues) {
+  if (landmarks.length === 0) {
+    issues.push({
+      severity: "info",
+      message: "No landmarks found",
+      suggestion: "Consider adding semantic landmarks (main, nav, aside, etc.)"
+    });
+  }
+  landmarks.forEach((landmark) => {
+    if (!landmark.name && ["navigation", "region", "complementary", "form"].includes(landmark.role)) {
+      issues.push({
+        severity: "warning",
+        message: `${landmark.role} landmark has no accessible name`,
+        suggestion: `Add aria-label="${landmark.role === "navigation" ? "Main navigation" : "Descriptive name"}" to the ${landmark.role} element`,
+        element: {
+          role: landmark.role,
+          name: landmark.name
+        }
+      });
+    }
+  });
+  const landmarksByRole = /* @__PURE__ */ new Map();
+  landmarks.forEach((landmark) => {
+    if (!landmarksByRole.has(landmark.role)) {
+      landmarksByRole.set(landmark.role, []);
+    }
+    landmarksByRole.get(landmark.role).push(landmark);
+  });
+  landmarksByRole.forEach((nodes, role) => {
+    if (nodes.length > 1) {
+      const allUnnamed = nodes.every((n) => !n.name);
+      const allSameName = nodes.every((n) => n.name === nodes[0].name);
+      if (allUnnamed || allSameName) {
+        issues.push({
+          severity: "warning",
+          message: `Multiple ${role} landmarks without distinguishing names`,
+          suggestion: `Add unique aria-label attributes to distinguish between ${role} landmarks`
+        });
+      }
+    }
+  });
+}
+function detectHeadingIssues(headings, issues) {
+  if (headings.length === 0) {
+    return;
+  }
+  const firstHeading = headings[0];
+  if (firstHeading.state.level && firstHeading.state.level !== 1) {
+    issues.push({
+      severity: "error",
+      message: `First heading is h${firstHeading.state.level} (should be h1)`,
+      suggestion: `Change <h${firstHeading.state.level}> to <h1> or add h1 before it`,
+      element: {
+        role: firstHeading.role,
+        name: firstHeading.name
+      }
+    });
+  }
+  for (let i = 1; i < headings.length; i++) {
+    const prevLevel = headings[i - 1].state.level || 1;
+    const currLevel = headings[i].state.level || 1;
+    if (currLevel > prevLevel + 1) {
+      issues.push({
+        severity: "error",
+        message: `Heading hierarchy violation: h${prevLevel} followed by h${currLevel} (skipped h${prevLevel + 1})`,
+        suggestion: `Change h${currLevel} to h${prevLevel + 1} or add intermediate heading levels`,
+        element: {
+          role: headings[i].role,
+          name: headings[i].name
+        }
+      });
+    }
+  }
+}
+function detectInteractiveIssues(elements, issues) {
+  elements.forEach((element) => {
+    if (!element.name) {
+      issues.push({
+        severity: "error",
+        message: `${element.role} has no accessible name`,
+        suggestion: element.role === "button" ? "Add text content or aria-label to button" : element.role === "link" ? "Add text content or aria-label to link" : `Add aria-label to ${element.role}`,
+        element: {
+          role: element.role,
+          name: element.name
+        }
+      });
+    }
+    if (element.role === "textbox" && !element.name) {
+      issues.push({
+        severity: "error",
+        message: "Input has no associated label",
+        suggestion: "Add <label> element or aria-label attribute",
+        element: {
+          role: element.role,
+          name: element.name
+        }
+      });
+    }
+  });
+}
+function formatAuditReport(report, model, colorize) {
+  const c = createColors(colorize ?? false);
+  const lines = [];
+  lines.push(c.title("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  lines.push(c.title("\u2551                      ACCESSIBILITY AUDIT REPORT                              \u2551"));
+  lines.push(c.title("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  lines.push("");
+  lines.push(c.dim(`Analyzed: ${model.metadata.extractedAt}`));
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F4CD} LANDMARK STRUCTURE"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  if (report.landmarks.length === 0) {
+    lines.push(c.error("\u2717 No landmarks found"));
+  } else {
+    lines.push(c.success(`\u2713 ${report.landmarks.length} landmark(s) found`));
+    lines.push("");
+    report.landmarks.forEach((landmark) => {
+      const name = landmark.name ? `"${landmark.name}"` : "(unnamed)";
+      lines.push(`${landmark.role} ${name}`);
+    });
+  }
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F4D1} HEADING HIERARCHY"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  if (report.headings.length === 0) {
+    lines.push(c.info("\u2139 No headings found"));
+  } else {
+    const hasHierarchyIssues = report.issues.some(
+      (i) => i.message.includes("heading") || i.message.includes("h1") || i.message.includes("h2")
+    );
+    lines.push(`${hasHierarchyIssues ? c.error("\u2717") : c.success("\u2713")} ${report.headings.length} heading(s) found ${hasHierarchyIssues ? "(HIERARCHY VIOLATION)" : "(proper hierarchy)"}`);
+    lines.push("");
+    report.headings.forEach((heading) => {
+      const level = heading.state.level || 1;
+      const indent = "  ".repeat(level - 1);
+      lines.push(`${indent}h${level} "${heading.name}"`);
+    });
+  }
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F3AF} INTERACTIVE ELEMENTS"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  if (report.interactiveElements.length === 0) {
+    lines.push(c.info("\u2139 No interactive elements found"));
+  } else {
+    lines.push(c.success(`\u2713 ${report.interactiveElements.length} interactive element(s) found`));
+    lines.push("");
+    const byRole = /* @__PURE__ */ new Map();
+    report.interactiveElements.forEach((el) => {
+      if (!byRole.has(el.role)) {
+        byRole.set(el.role, []);
+      }
+      byRole.get(el.role).push(el);
+    });
+    byRole.forEach((elements, role) => {
+      lines.push(`${role}s (${elements.length}):`);
+      elements.forEach((el) => {
+        const name = el.name ? `"${el.name}"` : "(unnamed)";
+        const states = Object.keys(el.state).filter((k) => el.state[k] !== void 0);
+        const stateStr = states.length > 0 ? ` [${states.join(", ")}]` : "";
+        lines.push(`  \u2022 ${name}${stateStr}`);
+      });
+    });
+  }
+  lines.push("");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.heading("\u{1F4CA} SUMMARY STATISTICS"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  lines.push(`Total accessible elements: ${report.statistics.totalElements}`);
+  lines.push("");
+  lines.push("Role distribution:");
+  Object.entries(report.statistics.roleDistribution).sort((a, b) => b[1] - a[1]).forEach(([role, count]) => {
+    lines.push(c.dim(`  \u2022 ${role}: ${count}`));
+  });
+  lines.push("");
+  lines.push(c.dim(`Focusable elements: ${report.statistics.focusableCount}`));
+  lines.push("");
+  if (report.issues.length > 0) {
+    lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    lines.push(c.heading("\u26A0\uFE0F  ACCESSIBILITY ISSUES"));
+    lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    lines.push("");
+    const errors = report.issues.filter((i) => i.severity === "error");
+    const warnings = report.issues.filter((i) => i.severity === "warning");
+    const infos = report.issues.filter((i) => i.severity === "info");
+    if (errors.length > 0) {
+      lines.push(c.error(`\u2717 Error (${errors.length}):`));
+      errors.forEach((issue) => {
+        lines.push(c.error(`  \u2022 ${issue.message}`));
+        if (issue.suggestion) {
+          lines.push(`    \u2192 ${issue.suggestion}`);
+        }
+      });
+      lines.push("");
+    }
+    if (warnings.length > 0) {
+      lines.push(c.warning(`\u26A0 Warning (${warnings.length}):`));
+      warnings.forEach((issue) => {
+        lines.push(c.warning(`  \u2022 ${issue.message}`));
+        if (issue.suggestion) {
+          lines.push(`    \u2192 ${issue.suggestion}`);
+        }
+      });
+      lines.push("");
+    }
+    if (infos.length > 0) {
+      lines.push(c.info(`\u2139 Info (${infos.length}):`));
+      infos.forEach((issue) => {
+        lines.push(c.info(`  \u2022 ${issue.message}`));
+        if (issue.suggestion) {
+          lines.push(`    \u2192 ${issue.suggestion}`);
+        }
+      });
+      lines.push("");
+    }
+  }
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(c.success("\u2705 OVERALL ASSESSMENT"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("");
+  const errorCount = report.issues.filter((i) => i.severity === "error").length;
+  const warningCount = report.issues.filter((i) => i.severity === "warning").length;
+  if (errorCount === 0 && warningCount === 0) {
+    lines.push(c.success("Excellent! No critical issues found."));
+  } else if (errorCount > 0) {
+    lines.push(`Critical accessibility issues found:`);
+    lines.push(c.error(`  \u2717 ${errorCount} error(s)`));
+    if (warningCount > 0) {
+      lines.push(c.warning(`  \u26A0 ${warningCount} warning(s)`));
+    }
+    lines.push("");
+    lines.push("Recommendation: Address errors before deployment");
+  } else {
+    lines.push(`Good structure with minor improvements needed:`);
+    lines.push(c.warning(`  \u26A0 ${warningCount} warning(s)`));
+  }
+  return lines.join("\n");
+}
+
+// src/diff/diff-algorithm.ts
+function diffAccessibilityTrees(oldTree, newTree) {
+  const changes = [];
+  const oldNodes = buildNodeMap(oldTree, "root");
+  const newNodes = buildNodeMap(newTree, "root");
+  for (const [path, node] of oldNodes) {
+    if (!newNodes.has(path)) {
+      changes.push({
+        type: "removed",
+        path,
+        node
+      });
+    }
+  }
+  for (const [path, node] of newNodes) {
+    if (!oldNodes.has(path)) {
+      changes.push({
+        type: "added",
+        path,
+        node
+      });
+    }
+  }
+  for (const [path, oldNode] of oldNodes) {
+    const newNode = newNodes.get(path);
+    if (newNode) {
+      const propertyChanges = compareNodes(oldNode, newNode);
+      if (propertyChanges.length > 0) {
+        changes.push({
+          type: "changed",
+          path,
+          changes: propertyChanges
+        });
+      }
+    }
+  }
+  changes.sort((a, b) => a.path.localeCompare(b.path));
+  const summary = {
+    added: changes.filter((c) => c.type === "added").length,
+    removed: changes.filter((c) => c.type === "removed").length,
+    changed: changes.filter((c) => c.type === "changed").length,
+    total: changes.length
+  };
+  return { changes, summary };
+}
+function buildNodeMap(node, path) {
+  const map = /* @__PURE__ */ new Map();
+  map.set(path, node);
+  node.children.forEach((child, index) => {
+    const childPath = `${path}.children[${index}]`;
+    const childMap = buildNodeMap(child, childPath);
+    for (const [childPath2, childNode] of childMap) {
+      map.set(childPath2, childNode);
+    }
+  });
+  return map;
+}
+function compareNodes(oldNode, newNode) {
+  const changes = [];
+  if (oldNode.role !== newNode.role) {
+    changes.push({
+      property: "role",
+      oldValue: oldNode.role,
+      newValue: newNode.role
+    });
+  }
+  if (oldNode.name !== newNode.name) {
+    changes.push({
+      property: "name",
+      oldValue: oldNode.name,
+      newValue: newNode.name
+    });
+  }
+  if (oldNode.description !== newNode.description) {
+    changes.push({
+      property: "description",
+      oldValue: oldNode.description,
+      newValue: newNode.description
+    });
+  }
+  if (!valuesEqual(oldNode.value, newNode.value)) {
+    changes.push({
+      property: "value",
+      oldValue: oldNode.value,
+      newValue: newNode.value
+    });
+  }
+  if (!statesEqual(oldNode.state, newNode.state)) {
+    changes.push({
+      property: "state",
+      oldValue: oldNode.state,
+      newValue: newNode.state
+    });
+  }
+  if (!focusEqual(oldNode.focus, newNode.focus)) {
+    changes.push({
+      property: "focus",
+      oldValue: oldNode.focus,
+      newValue: newNode.focus
+    });
+  }
+  return changes;
+}
+function valuesEqual(a, b) {
+  if (a === void 0 && b === void 0) return true;
+  if (a === void 0 || b === void 0) return false;
+  return a.current === b.current && a.min === b.min && a.max === b.max && a.text === b.text;
+}
+function statesEqual(a, b) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) {
+    const aValue = a[key];
+    const bValue = b[key];
+    if (aValue !== bValue) {
+      return false;
+    }
+  }
+  return true;
+}
+function focusEqual(a, b) {
+  return a.focusable === b.focusable && a.tabindex === b.tabindex;
+}
+
+// src/diff/formatter.ts
+function formatDiffAsJSON(diff) {
+  return JSON.stringify(diff, null, 2);
+}
+function formatDiffAsText(diff) {
+  const lines = [];
+  lines.push("=== Accessibility Tree Diff ===");
+  lines.push("");
+  lines.push(`Total changes: ${diff.summary.total}`);
+  lines.push(`  Added: ${diff.summary.added}`);
+  lines.push(`  Removed: ${diff.summary.removed}`);
+  lines.push(`  Changed: ${diff.summary.changed}`);
+  lines.push("");
+  if (diff.changes.length === 0) {
+    lines.push("No changes detected.");
+    return lines.join("\n");
+  }
+  const added = diff.changes.filter((c) => c.type === "added");
+  const removed = diff.changes.filter((c) => c.type === "removed");
+  const changed = diff.changes.filter((c) => c.type === "changed");
+  if (added.length > 0) {
+    lines.push("--- Added Nodes ---");
+    for (const change of added) {
+      lines.push(`+ ${change.path}`);
+      lines.push(`  Role: ${change.node?.role}`);
+      lines.push(`  Name: "${change.node?.name}"`);
+      if (change.node?.description) {
+        lines.push(`  Description: "${change.node.description}"`);
+      }
+      lines.push("");
+    }
+  }
+  if (removed.length > 0) {
+    lines.push("--- Removed Nodes ---");
+    for (const change of removed) {
+      lines.push(`- ${change.path}`);
+      lines.push(`  Role: ${change.node?.role}`);
+      lines.push(`  Name: "${change.node?.name}"`);
+      if (change.node?.description) {
+        lines.push(`  Description: "${change.node.description}"`);
+      }
+      lines.push("");
+    }
+  }
+  if (changed.length > 0) {
+    lines.push("--- Changed Nodes ---");
+    for (const change of changed) {
+      lines.push(`~ ${change.path}`);
+      if (change.changes) {
+        for (const propChange of change.changes) {
+          lines.push(`  ${formatPropertyChange(propChange)}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function formatPropertyChange(change) {
+  const oldVal = formatValue(change.oldValue);
+  const newVal = formatValue(change.newValue);
+  return `${change.property}: ${oldVal} \u2192 ${newVal}`;
+}
+function formatValue(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") return `"${value}"`;
+  if (typeof value === "object") {
+    const json = JSON.stringify(value);
+    if (json.length > 50) {
+      return json.substring(0, 47) + "...";
+    }
+    return json;
+  }
+  return String(value);
+}
+
+// src/cli/orchestrator.ts
+function processHTML(html, options, diffHTML) {
+  const warnings = [];
+  const colorize = isColorEnabled(process.stdout) && options.format !== "json" && !options.output;
+  try {
+    if (options.diff && diffHTML) {
+      return processDiff(html, diffHTML, options, warnings, colorize);
+    }
+    if (options.validate) {
+      return processValidation(html, options, warnings);
+    }
+    return processNormal(html, options, warnings, colorize);
+  } catch (error) {
+    if (error instanceof Error) {
+      return {
+        output: `Error: ${error.message}`,
+        exitCode: 2,
+        // Content error
+        warnings
+      };
+    }
+    throw error;
+  }
+}
+function processNormal(html, options, warnings, colorize) {
+  const doc = parseHTML(html);
+  if (doc.warnings.length > 0) {
+    warnings.push(...doc.warnings.map((w) => w.message));
+  }
+  let model;
+  if (options.selector) {
+    const results = buildAccessibilityTreeWithSelector(doc.document.body, options.selector);
+    if (results.length === 0) {
+      return {
+        output: `Error: No elements match selector: ${options.selector}`,
+        exitCode: 2,
+        warnings
+      };
+    }
+    model = results[0].model;
+    for (const result of results) {
+      if (result.warnings.length > 0) {
+        warnings.push(...result.warnings.map((w) => w.message));
+      }
+    }
+  } else {
+    const result = buildAccessibilityTree(doc.document.body);
+    model = result.model;
+    if (result.warnings.length > 0) {
+      warnings.push(...result.warnings.map((w) => w.message));
+    }
+  }
+  const output = formatOutput(model, options, colorize);
+  return {
+    output,
+    exitCode: 0,
+    warnings
+  };
+}
+function processDiff(html1, html2, options, warnings, _colorize) {
+  const doc1 = parseHTML(html1);
+  const doc2 = parseHTML(html2);
+  warnings.push(...doc1.warnings.map((w) => w.message), ...doc2.warnings.map((w) => w.message));
+  const result1 = buildAccessibilityTree(doc1.document.body);
+  const result2 = buildAccessibilityTree(doc2.document.body);
+  warnings.push(...result1.warnings.map((w) => w.message), ...result2.warnings.map((w) => w.message));
+  const diff = diffAccessibilityTrees(result1.model.root, result2.model.root);
+  let output;
+  if (options.format === "json") {
+    output = formatDiffAsJSON(diff);
+  } else {
+    output = formatDiffAsText(diff);
+  }
+  return {
+    output,
+    exitCode: 0,
+    warnings
+  };
+}
+function processValidation(html, _options, warnings) {
+  const doc = parseHTML(html);
+  warnings.push(...doc.warnings.map((w) => w.message));
+  const result = buildAccessibilityTree(doc.document.body);
+  warnings.push(...result.warnings.map((w) => w.message));
+  const model = result.model;
+  const serialized = serializeModel(model);
+  const deserialized = deserializeModel(serialized);
+  const isEqual = modelsEqual(model, deserialized);
+  if (isEqual) {
+    return {
+      output: "Validation passed: Model serialization is consistent",
+      exitCode: 0,
+      warnings
+    };
+  } else {
+    return {
+      output: "Validation failed: Model serialization is inconsistent",
+      exitCode: 2,
+      warnings
+    };
+  }
+}
+function formatOutput(model, options, colorize) {
+  const { format, screenReader } = options;
+  if (format === "audit") {
+    return renderAuditReport(model, colorize);
+  }
+  if (format === "json") {
+    return serializeModel(model);
+  }
+  if (format === "text") {
+    return formatScreenReaderOutput(model, screenReader, colorize);
+  }
+  if (format === "both") {
+    const json = serializeModel(model);
+    const text = formatScreenReaderOutput(model, screenReader, colorize);
+    const c = createColors(colorize);
+    return `${c.sectionHeader("=== JSON Output ===")}
+${json}
+
+${c.sectionHeader("=== Screen Reader Output ===")}
+${text}`;
+  }
+  throw new Error(`Unknown format: ${format}`);
+}
+function formatScreenReaderOutput(model, screenReader, colorize) {
+  if (screenReader === "all") {
+    const nvda = renderNVDA(model, colorize);
+    const jaws = renderJAWS(model, colorize);
+    const voiceover = renderVoiceOver(model, colorize);
+    const c = createColors(colorize);
+    return [
+      c.sectionHeader("=== NVDA ==="),
+      nvda,
+      "",
+      c.sectionHeader("=== JAWS ==="),
+      jaws,
+      "",
+      c.sectionHeader("=== VoiceOver ==="),
+      voiceover
+    ].join("\n");
+  }
+  switch (screenReader) {
+    case "nvda":
+      return renderNVDA(model, colorize);
+    case "jaws":
+      return renderJAWS(model, colorize);
+    case "voiceover":
+      return renderVoiceOver(model, colorize);
+    default:
+      throw new Error(`Unknown screen reader: ${screenReader}`);
+  }
+}
+function formatWarnings(warnings, colorize) {
+  if (warnings.length === 0) {
+    return "";
+  }
+  const c = createColors(colorize ?? false);
+  const header = colorize ? c.warning(c.bold("=== Warnings ===")) : "=== Warnings ===";
+  const lines = [
+    "",
+    header,
+    ...warnings.map((w) => colorize ? `${c.warning("\u26A0\uFE0F")}  ${w}` : `\u26A0\uFE0F  ${w}`),
+    ""
+  ];
+  return lines.join("\n");
+}
+function processBatch(filePaths, options) {
+  const results = [];
+  const allWarnings = [];
+  let anyFailed = false;
+  for (const filePath of filePaths) {
+    try {
+      const { readFileSync: readFileSync3 } = __require("fs");
+      const html = readFileSync3(filePath, "utf-8");
+      const result = processHTML(html, options);
+      results.push({
+        filePath,
+        success: result.exitCode === 0,
+        output: result.output,
+        warnings: result.warnings
+      });
+      allWarnings.push(...result.warnings);
+      if (result.exitCode !== 0) {
+        anyFailed = true;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      results.push({
+        filePath,
+        success: false,
+        error: errorMessage,
+        warnings: []
+      });
+      anyFailed = true;
+    }
+  }
+  const output = formatBatchOutput(results, options);
+  return {
+    results,
+    output,
+    exitCode: anyFailed ? 2 : 0,
+    warnings: allWarnings
+  };
+}
+function formatBatchOutput(results, _options) {
+  const lines = [];
+  lines.push("=== Batch Processing Results ===");
+  lines.push("");
+  for (const result of results) {
+    lines.push(`File: ${result.filePath}`);
+    if (result.success) {
+      lines.push("Status: \u2713 Success");
+      if (result.warnings.length > 0) {
+        lines.push(`Warnings: ${result.warnings.length}`);
+      }
+      lines.push("");
+      lines.push("--- Output ---");
+      lines.push(result.output || "");
+    } else {
+      lines.push("Status: \u2717 Failed");
+      lines.push(`Error: ${result.error}`);
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  lines.push("=== Summary ===");
+  lines.push(`Total files: ${results.length}`);
+  lines.push(`Successful: ${successCount}`);
+  lines.push(`Failed: ${failCount}`);
+  return lines.join("\n");
+}
+
+// src/cli.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var packageJson = JSON.parse(
+  readFileSync2(join(__dirname2, "../package.json"), "utf-8")
+);
+var program = new Command();
+program.name("speakable").description("Analyze HTML accessibility announcements and generate screen reader output").version(packageJson.version, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command");
+program.argument("[input...]", 'HTML file path(s) or "-" for stdin').option("-o, --output <path>", "Output file path (default: stdout)").option(
+  "-f, --format <format>",
+  "Output format: json, text, audit, or both (default: json)",
+  "json"
+).option(
+  "-s, --screen-reader <reader>",
+  "Screen reader: nvda, jaws, voiceover, or all (default: nvda)",
+  "nvda"
+).option(
+  "--selector <selector>",
+  "CSS selector to filter elements"
+).option(
+  "--validate",
+  "Validate round-trip serialization"
+).option(
+  "--diff <file>",
+  "Compare with another HTML file (semantic diff mode)"
+).option(
+  "--batch",
+  "Process multiple files in batch mode"
+).action(async (input, rawOptions) => {
+  try {
+    const options = validateOptions(rawOptions);
+    const parsedInput = parseInput(input);
+    validateInput(parsedInput);
+    validateDiffMode(options, parsedInput);
+    validateBatchMode(options, parsedInput);
+    if (options.batch && parsedInput.inputs && parsedInput.inputs.length > 0) {
+      const result2 = processBatch(parsedInput.inputs, options);
+      writeOutput(result2.output, options.output);
+      if (result2.warnings.length > 0) {
+        console.error(formatWarnings(result2.warnings, isColorEnabled(process.stderr)));
+      }
+      process.exit(result2.exitCode);
+      return;
+    }
+    const htmlResult = readHTML(parsedInput.input, parsedInput.isStdin);
+    const html = await Promise.resolve(htmlResult);
+    let diffHTML;
+    if (options.diff) {
+      diffHTML = readHTML(options.diff, false);
+    }
+    const result = processHTML(html, options, diffHTML);
+    writeOutput(result.output, options.output);
+    if (result.warnings.length > 0) {
+      console.error(formatWarnings(result.warnings, isColorEnabled(process.stderr)));
+    }
+    process.exit(result.exitCode);
+  } catch (error) {
+    if (error instanceof FileIOError) {
+      console.error(`Error: ${error.message}`);
+      process.exit(3);
+    }
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+    throw error;
+  }
+});
+program.addHelpText("after", `
+
+Examples:
+  $ speakable input.html
+  $ speakable input.html -f text -s nvda
+  $ speakable input.html -f both -s all
+  $ speakable input.html --selector "button"
+  $ speakable input.html --diff old.html
+  $ speakable --batch file1.html file2.html file3.html
+  $ cat input.html | speakable -
+  $ speakable input.html -o output.json
+  $ speakable input.html -f audit
+
+Screen Readers:
+  nvda       - NVDA (Windows)
+  jaws       - JAWS (Windows)
+  voiceover  - VoiceOver (macOS)
+  all        - All screen readers
+
+Output Formats:
+  json       - Semantic model as JSON
+  text       - Screen reader announcement text
+  audit      - Developer-friendly audit report
+  both       - Both JSON and text
+
+Notes:
+  - Screen reader output is heuristic and may differ from actual behavior
+  - Use --validate to check serialization round-trip integrity
+  - Use --diff to detect accessibility changes between versions
+  - Use --batch to process multiple files (continues on individual errors)
+`);
+program.parse();
+//# sourceMappingURL=cli.js.map