@cementic/cementic-test 0.2.14 → 0.2.15

package/README.md

@@ -216,9 +216,9 @@ node --test --test-name-pattern="counting intent" test/prompt.spec.mjs
 
 Note: on current Node test runner versions, use `--test-reporter=spec`, not `--reporter=spec`.
 
-### v0.2.14 acceptance criteria
+### v0.2.15 acceptance criteria
 
-All of the following must be true before publishing `v0.2.14`:
+All of the following must be true before publishing `v0.2.15`:
 
 - `npm test` passes from a clean checkout and includes both the integration suite and `test/prompt.spec.mjs`
 - `prepublishOnly` runs the same full release gate, not just `build`
@@ -226,6 +226,8 @@ All of the following must be true before publishing `v0.2.14`:
   - counting intents generate `toHaveCount()` or `.count()`
   - intent text is never reused as `getByText(...)`
   - presence-only intents generate visibility assertions without click steps
+  - CTA-like presence intents can fall back from `button` to `link` selectors with `Locator.or(...)`
+  - counting button intents exclude CTA links that are really anchors
   - generated specs always use `await expect(...)`
   - auth/navigation intents generate `toHaveURL(...)`
   - negative intents generate `.not.` or `toBeHidden()`
@@ -236,6 +238,7 @@ All of the following must be true before publishing `v0.2.14`:
 - `ct tc url --ai` works in both modes:
   - with an LLM key, capture analysis remains intent-first and selector-safe
   - without an LLM key, deterministic capture-backed scenario generation still produces runnable, intent-aligned output
+  - capture semantics never classify `<a href="...">` as a button unless `role="button"` is explicit
 - `ct normalize` preserves:
   - `ct:url` metadata
   - selector hints
@@ -448,6 +451,13 @@ And start automating.
 
 ## Changelog
 
+### v0.2.15
+
+- fixed capture semantics so `<a href="...">` elements are classified as links unless they explicitly expose `role="button"`
+- made CTA-like presence selectors resilient by generating `Locator.or(...)` fallbacks across button and link roles when the intent is ambiguous
+- tightened intent label cleanup so trailing filler phrases like `on the page` do not leak into generated locator text
+- updated capture artifact metadata and capture user agent version strings to `0.2.15`
+
 ### v0.2.14
 
 - hardened the release gate so `npm test` now includes the prompt regression suite and `prepublishOnly` runs the full test gate

package/dist/capture.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import {
+  CaptureRuntimeError,
+  captureElements,
+  extractDomDataFromEnvironment,
+  formatCaptureFailure,
+  inferInteractiveRole,
+  toPageSummary
+} from "./chunk-XUWFEWJZ.js";
+export {
+  CaptureRuntimeError,
+  captureElements,
+  extractDomDataFromEnvironment,
+  formatCaptureFailure,
+  inferInteractiveRole,
+  toPageSummary
+};
+//# sourceMappingURL=capture.js.map

package/dist/capture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-XUWFEWJZ.js

@@ -0,0 +1,622 @@
+#!/usr/bin/env node
+
+// src/core/playwright.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { createRequire } from "module";
+import { fileURLToPath, pathToFileURL } from "url";
+var require2 = createRequire(import.meta.url);
+var moduleDir = dirname(fileURLToPath(import.meta.url));
+async function resolvePlaywrightChromium(cwd = process.cwd()) {
+  const searchRoots = buildSearchRoots(cwd);
+  for (const packageName of ["@playwright/test", "playwright-core"]) {
+    for (const searchRoot of searchRoots) {
+      const resolvedPath = resolveFromRoot(packageName, searchRoot);
+      if (!resolvedPath) continue;
+      const imported = await import(pathToFileURL(resolvedPath).href);
+      const chromium = imported.chromium ?? imported.default?.chromium;
+      if (chromium) {
+        return {
+          packageName,
+          resolvedPath,
+          searchRoot,
+          chromium
+        };
+      }
+    }
+  }
+  throw new Error(
+    "Playwright runtime not found in this project.\nTry:\n  npm install\n  npx playwright install chromium"
+  );
+}
+function buildSearchRoots(cwd) {
+  const roots = [resolve(cwd)];
+  const projectRoot = findNearestProjectRoot(cwd);
+  if (projectRoot && projectRoot !== roots[0]) {
+    roots.push(projectRoot);
+  }
+  roots.push(moduleDir);
+  return Array.from(new Set(roots));
+}
+function findNearestProjectRoot(startDir) {
+  let currentDir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) return void 0;
+    currentDir = parentDir;
+  }
+}
+function resolveFromRoot(packageName, searchRoot) {
+  try {
+    return require2.resolve(packageName, { paths: [searchRoot] });
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/capture.ts
+var SETTLE_MS = 1200;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_PER_CATEGORY = 50;
+var CaptureRuntimeError = class extends Error {
+  constructor(code, message, options) {
+    super(message);
+    this.name = "CaptureRuntimeError";
+    this.code = code;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+function inferInteractiveRole(tagName, attrs = {}) {
+  const tag = String(tagName ?? "").trim().toLowerCase();
+  const explicitRole = String(attrs.role ?? "").trim().toLowerCase();
+  const type = String(attrs.type ?? "").trim().toLowerCase();
+  const href = String(attrs.href ?? "").trim();
+  if (explicitRole === "button") return "button";
+  if (explicitRole === "link") return "link";
+  if (explicitRole === "textbox") return "textbox";
+  if (explicitRole === "checkbox") return "checkbox";
+  if (tag === "a" && href) return "link";
+  if (tag === "button") return "button";
+  if (tag === "textarea") return "textbox";
+  if (tag === "select") return "textbox";
+  if (tag === "input") {
+    if (type === "submit" || type === "button" || type === "reset" || type === "image") return "button";
+    if (type === "checkbox") return "checkbox";
+    return "textbox";
+  }
+  return void 0;
+}
+async function captureElements(url, options = {}) {
+  const {
+    headless = true,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    verbose = false,
+    userAgent = "Mozilla/5.0 (compatible; CementicTest/0.2.15 capture)"
+  } = options;
+  const chromium = await loadChromium();
+  const mode = headless ? "headless" : "headed";
+  log(verbose, `
+[capture] Starting ${mode} capture: ${url}`);
+  let browser;
+  try {
+    browser = await chromium.launch({
+      headless,
+      slowMo: headless ? 0 : 150
+    });
+  } catch (error) {
+    throw classifyCaptureError(error);
+  }
+  const context = await browser.newContext({
+    userAgent,
+    viewport: { width: 1280, height: 800 },
+    ignoreHTTPSErrors: true
+  });
+  const page = await context.newPage();
+  try {
+    log(verbose, `  -> Navigating (timeout: ${timeoutMs}ms)`);
+    try {
+      await page.goto(url, {
+        waitUntil: "domcontentloaded",
+        timeout: timeoutMs
+      });
+    } catch (error) {
+      throw new CaptureRuntimeError(
+        "PAGE_LOAD_FAILED",
+        `Page load failed for ${url}. ${error?.message ?? error}`,
+        { cause: error }
+      );
+    }
+    log(verbose, `  -> Waiting ${SETTLE_MS}ms for page settle`);
+    await page.waitForTimeout(SETTLE_MS);
+    log(verbose, "  -> Extracting accessibility snapshot");
+    const a11ySnapshot = await getAccessibilitySnapshot(page, verbose);
+    log(verbose, "  -> Extracting DOM data");
+    const domData = await page.evaluate(extractDomData);
+    const title = await page.title();
+    const finalUrl = page.url();
+    const elements = buildElementMap(domData);
+    const warnings = buildWarnings(elements, domData, a11ySnapshot);
+    const byCategory = {};
+    for (const element of elements) {
+      byCategory[element.category] = (byCategory[element.category] ?? 0) + 1;
+    }
+    const result = {
+      url: finalUrl,
+      title,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      mode,
+      summary: {
+        totalElements: elements.length,
+        byCategory
+      },
+      elements,
+      warnings
+    };
+    log(verbose, `  -> Captured ${elements.length} testable elements from "${title}"`);
+    return result;
+  } catch (error) {
+    throw classifyCaptureError(error);
+  } finally {
+    await browser?.close();
+  }
+}
+function toPageSummary(elementMap) {
+  const inputs = elementMap.elements.filter((element) => element.category === "input").slice(0, 30).map((element) => ({
+    label: asString(element.attributes.label),
+    placeholder: asString(element.attributes.placeholder),
+    name: asString(element.attributes.name),
+    type: asString(element.attributes.type),
+    testId: asString(element.attributes.testId)
+  }));
+  return {
+    url: elementMap.url,
+    title: elementMap.title,
+    headings: elementMap.elements.filter((element) => element.category === "heading").map((element) => element.name ?? "").filter(Boolean).slice(0, 20),
+    buttons: elementMap.elements.filter((element) => element.category === "button").map((element) => element.name ?? "").filter(Boolean).slice(0, 30),
+    links: elementMap.elements.filter((element) => element.category === "link").map((element) => element.name ?? "").filter(Boolean).slice(0, 50),
+    inputs,
+    landmarks: [],
+    rawLength: elementMap.elements.length
+  };
+}
+async function loadChromium() {
+  try {
+    const resolution = await resolvePlaywrightChromium(process.cwd());
+    return resolution.chromium;
+  } catch (error) {
+    throw new CaptureRuntimeError(
+      "PLAYWRIGHT_NOT_FOUND",
+      error?.message ?? "Playwright runtime not found in this project.\nTry:\n  npm install\n  npx playwright install chromium",
+      { cause: error }
+    );
+  }
+}
+function extractDomDataFromEnvironment(doc, win) {
+  const localMaxPerCategory = 50;
+  const attr = (el, name) => el.getAttribute(name)?.trim() || void 0;
+  const text = (el) => el?.textContent?.replace(/\s+/g, " ").trim() || void 0;
+  const jsString = (value) => JSON.stringify(value);
+  const semanticRole = (el) => inferInteractiveRole(el.tagName, {
+    role: attr(el, "role"),
+    href: attr(el, "href"),
+    type: attr(el, "type")
+  });
+  const findLabel = (el) => {
+    const id = attr(el, "id");
+    if (id) {
+      const labelEl = doc.querySelector(`label[for="${id}"]`);
+      if (labelEl) return text(labelEl);
+    }
+    const ariaLabel = attr(el, "aria-label");
+    if (ariaLabel) return ariaLabel;
+    const labelledBy = attr(el, "aria-labelledby");
+    if (labelledBy) {
+      const labelEl = doc.getElementById(labelledBy);
+      if (labelEl) return text(labelEl);
+    }
+    const closestLabel = el.closest("label");
+    if (closestLabel) {
+      const raw = text(closestLabel) || "";
+      const placeholder = attr(el, "placeholder") || "";
+      return raw.replace(placeholder, "").trim() || void 0;
+    }
+    const previous = el.previousElementSibling;
+    if (previous?.tagName === "LABEL") return text(previous);
+    return void 0;
+  };
+  const buildSelector = (el, labelText, buttonText) => {
+    const testId = attr(el, "data-testid");
+    if (testId) return `getByTestId(${jsString(testId)})`;
+    const id = attr(el, "id");
+    if (id && !id.match(/^(ember|react|vue|ng|auto|rand)/i)) {
+      return `locator(${jsString(`#${id}`)})`;
+    }
+    const ariaLabel = attr(el, "aria-label");
+    if (ariaLabel) {
+      const role = semanticRole(el);
+      if (role === "textbox") return `getByLabel(${jsString(ariaLabel)})`;
+      if (role) {
+        return `getByRole(${jsString(role)}, { name: ${jsString(ariaLabel)} })`;
+      }
+    }
+    if (labelText) {
+      const tag = el.tagName.toLowerCase();
+      if (tag === "input" || tag === "textarea" || tag === "select") {
+        return `getByLabel(${jsString(labelText)})`;
+      }
+    }
+    if (buttonText) {
+      const role = semanticRole(el);
+      if (role === "button" || role === "link") {
+        return `getByRole(${jsString(role)}, { name: ${jsString(buttonText)} })`;
+      }
+    }
+    const name = attr(el, "name");
+    if (name) return `locator(${jsString(`[name="${name}"]`)})`;
+    return null;
+  };
+  const buttons = [];
+  Array.from(doc.querySelectorAll('button, [role="button"], input[type="submit"], input[type="button"]')).forEach((el) => {
+    const role = semanticRole(el);
+    if (role !== "button") return;
+    const buttonText = attr(el, "aria-label") || text(el) || attr(el, "value");
+    const testId = attr(el, "data-testid");
+    const id = attr(el, "id");
+    const type = attr(el, "type");
+    const disabled = el.hasAttribute("disabled") || el.getAttribute("aria-disabled") === "true";
+    const selector = buildSelector(el, void 0, buttonText);
+    if (buttonText || testId) {
+      buttons.push({
+        tag: el.tagName.toLowerCase(),
+        role,
+        text: buttonText,
+        testId,
+        id,
+        type,
+        disabled,
+        selector,
+        cssPath: testId ? `[data-testid="${testId}"]` : id ? `#${id}` : null
+      });
+    }
+  });
+  const inputs = [];
+  Array.from(doc.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]), textarea, select')).forEach((el) => {
+    const label = findLabel(el);
+    const placeholder = attr(el, "placeholder");
+    const name = attr(el, "name");
+    const id = attr(el, "id");
+    const type = attr(el, "type") || el.tagName.toLowerCase();
+    const testId = attr(el, "data-testid");
+    const required = el.hasAttribute("required");
+    const selector = buildSelector(el, label);
+    if (label || placeholder || name || testId || id) {
+      inputs.push({
+        tag: el.tagName.toLowerCase(),
+        type,
+        label,
+        placeholder,
+        name,
+        id,
+        testId,
+        required,
+        selector,
+        cssPath: testId ? `[data-testid="${testId}"]` : id ? `#${id}` : name ? `[name="${name}"]` : null
+      });
+    }
+  });
+  const links = [];
+  Array.from(doc.querySelectorAll("a[href]")).forEach((el) => {
+    const role = semanticRole(el);
+    if (role !== "link") return;
+    const linkText = attr(el, "aria-label") || text(el);
+    const href = attr(el, "href");
+    const testId = attr(el, "data-testid");
+    if (!linkText || href === "#") return;
+    links.push({
+      tag: el.tagName.toLowerCase(),
+      role,
+      text: linkText,
+      href,
+      testId,
+      external: Boolean(href?.startsWith("http") && !href.includes(win.location.hostname)),
+      selector: testId ? `getByTestId(${jsString(testId)})` : `getByRole('link', { name: ${jsString(linkText)} })`
+    });
+  });
+  const headings = [];
+  Array.from(doc.querySelectorAll("h1, h2, h3")).forEach((el) => {
+    const headingText = text(el);
+    if (headingText) {
+      headings.push({
+        level: el.tagName.toLowerCase(),
+        text: headingText,
+        selector: `getByRole('heading', { name: ${jsString(headingText)} })`
+      });
+    }
+  });
+  const landmarks = [];
+  Array.from(doc.querySelectorAll("[role], main, nav, header, footer, aside, section[aria-label]")).forEach((el) => {
+    const role = attr(el, "role") || el.tagName.toLowerCase();
+    const label = attr(el, "aria-label") || text(el)?.slice(0, 40);
+    if (role && label) landmarks.push({ role, label });
+  });
+  const statusRegions = [];
+  Array.from(doc.querySelectorAll('[role="alert"], [role="status"], [aria-live]')).forEach((el) => {
+    const role = attr(el, "role") || "live";
+    statusRegions.push({
+      role,
+      ariaLive: attr(el, "aria-live"),
+      text: text(el),
+      selector: el.getAttribute("role") ? `getByRole(${jsString(role)})` : `locator('[aria-live]')`
+    });
+  });
+  const forms = [];
+  Array.from(doc.querySelectorAll("form")).forEach((form, index) => {
+    forms.push({
+      id: attr(form, "id"),
+      label: attr(form, "aria-label") || attr(form, "aria-labelledby"),
+      action: attr(form, "action"),
+      method: attr(form, "method") || "get",
+      fieldCount: Array.from(form.querySelectorAll?.("input, textarea, select") ?? []).length,
+      index
+    });
+  });
+  return {
+    buttons: buttons.slice(0, localMaxPerCategory),
+    inputs: inputs.slice(0, localMaxPerCategory),
+    links: links.slice(0, localMaxPerCategory),
+    headings: headings.slice(0, 20),
+    landmarks,
+    statusRegions,
+    forms,
+    pageUrl: win.location.href,
+    pageTitle: doc.title ?? ""
+  };
+}
+function extractDomData() {
+  return extractDomDataFromEnvironment(
+    document,
+    window
+  );
+}
+function buildElementMap(domData) {
+  const elements = [];
+  for (const input of domData.inputs) {
+    const displayName = input.label || input.placeholder || input.name || input.testId;
+    if (!displayName) continue;
+    const selector = input.selector || (input.testId ? `getByTestId(${JSON.stringify(input.testId)})` : null) || (input.label ? `getByLabel(${JSON.stringify(input.label)})` : null) || (input.id ? `locator(${JSON.stringify(`#${input.id}`)})` : null) || (input.name ? `locator(${JSON.stringify(`[name="${input.name}"]`)})` : null) || `locator(${JSON.stringify(`${input.tag}[placeholder="${input.placeholder ?? ""}"]`)})`;
+    const selectorAlt = [];
+    if (input.id && !selector.includes(`#${input.id}`)) selectorAlt.push(`locator(${JSON.stringify(`#${input.id}`)})`);
+    if (input.name && !selector.includes(input.name)) selectorAlt.push(`locator(${JSON.stringify(`[name="${input.name}"]`)})`);
+    if (input.testId && !selector.includes(input.testId)) selectorAlt.push(`getByTestId(${JSON.stringify(input.testId)})`);
+    if (input.placeholder && !selector.includes(input.placeholder)) selectorAlt.push(`getByPlaceholder(${JSON.stringify(input.placeholder)})`);
+    if (input.label && !selector.includes(input.label)) selectorAlt.push(`getByLabel(${JSON.stringify(input.label)})`);
+    elements.push({
+      category: "input",
+      role: input.type === "checkbox" ? "checkbox" : "textbox",
+      name: displayName,
+      selector,
+      selectorAlt,
+      purpose: input.required ? `Required ${input.type} field - "${displayName}"` : `${input.type} field - "${displayName}"`,
+      confidence: input.testId || input.label || input.id ? "high" : input.placeholder ? "medium" : "low",
+      attributes: {
+        type: input.type,
+        label: input.label,
+        placeholder: input.placeholder,
+        name: input.name,
+        id: input.id,
+        testId: input.testId,
+        required: input.required,
+        tag: input.tag
+      }
+    });
+  }
+  for (const button of domData.buttons) {
+    const buttonRole = button.role || "button";
+    const displayName = button.text || button.testId;
+    if (!displayName) continue;
+    const selector = button.selector || (button.testId ? `getByTestId(${JSON.stringify(button.testId)})` : null) || (button.text ? `getByRole(${JSON.stringify(buttonRole)}, { name: ${JSON.stringify(button.text)} })` : null) || (button.id ? `locator(${JSON.stringify(`#${button.id}`)})` : null) || (button.tag === "button" ? `locator('button')` : `locator('[role="button"]')`);
+    const selectorAlt = [];
+    if (button.id && !selector.includes(button.id)) selectorAlt.push(`locator(${JSON.stringify(`#${button.id}`)})`);
+    if (button.testId && !selector.includes(button.testId)) selectorAlt.push(`getByTestId(${JSON.stringify(button.testId)})`);
+    if (button.text && !selector.includes(button.text)) selectorAlt.push(`getByText(${JSON.stringify(button.text)})`);
+    if (button.cssPath) selectorAlt.push(`locator(${JSON.stringify(button.cssPath)})`);
+    elements.push({
+      category: "button",
+      role: buttonRole,
+      name: displayName,
+      selector,
+      selectorAlt,
+      purpose: button.disabled ? `Disabled button - "${displayName}"` : button.type === "submit" ? `Form submit button - "${displayName}"` : `Button - "${displayName}"`,
+      confidence: button.testId || button.text ? "high" : button.id ? "medium" : "low",
+      attributes: {
+        text: button.text,
+        testId: button.testId,
+        id: button.id,
+        type: button.type,
+        disabled: button.disabled,
+        tag: button.tag,
+        role: buttonRole
+      }
+    });
+  }
+  for (const link of domData.links) {
+    const linkRole = link.role || "link";
+    elements.push({
+      category: "link",
+      role: linkRole,
+      name: link.text,
+      selector: link.selector,
+      selectorAlt: [
+        ...link.testId ? [`getByTestId(${JSON.stringify(link.testId)})`] : [],
+        `getByText(${JSON.stringify(link.text)})`
+      ],
+      purpose: link.external ? `External link to "${link.href}" - "${link.text}"` : `Internal navigation link - "${link.text}" -> ${link.href}`,
+      confidence: link.testId ? "high" : "medium",
+      attributes: {
+        text: link.text,
+        href: link.href,
+        testId: link.testId,
+        external: link.external,
+        tag: link.tag,
+        role: linkRole
+      }
+    });
+  }
+  for (const heading of domData.headings) {
+    elements.push({
+      category: "heading",
+      role: "heading",
+      name: heading.text,
+      selector: heading.selector,
+      selectorAlt: [`getByText(${JSON.stringify(heading.text)})`],
+      purpose: `Page ${heading.level} heading - use to assert the correct page or section loaded`,
+      confidence: "medium",
+      attributes: {
+        level: heading.level,
+        text: heading.text
+      }
+    });
+  }
+  for (const status of domData.statusRegions) {
+    elements.push({
+      category: "status",
+      role: status.role,
+      name: status.text || status.role,
+      selector: status.selector,
+      selectorAlt: [],
+      purpose: "Live region - use to assert error messages, success toasts, and validation feedback",
+      confidence: "medium",
+      attributes: {
+        role: status.role,
+        ariaLive: status.ariaLive,
+        currentText: status.text
+      }
+    });
+  }
+  return elements;
+}
+function buildWarnings(elements, domData, a11ySnapshot) {
+  const warnings = [];
+  if (!a11ySnapshot) {
+    warnings.push("Playwright accessibility snapshot was unavailable. Capture continued using DOM extraction only.");
+  }
+  const lowConfidenceInputs = elements.filter((element) => element.category === "input" && element.confidence === "low");
+  if (lowConfidenceInputs.length > 0) {
+    warnings.push(
+      `${lowConfidenceInputs.length} input(s) have low-confidence selectors. Consider adding data-testid attributes to: ${lowConfidenceInputs.map((element) => element.name).filter(Boolean).join(", ")}`
+    );
+  }
+  if (domData.statusRegions.length === 0) {
+    warnings.push("No ARIA alert or status regions detected. Error message assertions may need manual selector adjustments after generation.");
+  }
+  for (const form of domData.forms) {
+    const hasSubmit = domData.buttons.some((button) => button.type === "submit");
+    if (form.fieldCount > 0 && !hasSubmit) {
+      warnings.push(
+        `Form ${form.id || `#${form.index}`} has ${form.fieldCount} field(s) but no detected submit button. It may use keyboard submit or a custom handler.`
+      );
+    }
+  }
+  if (domData.links.length >= MAX_PER_CATEGORY) {
+    warnings.push(`Link count hit the ${MAX_PER_CATEGORY} capture limit. Generation will focus on forms and buttons.`);
+  }
+  const interactive = elements.filter((element) => element.category === "button" || element.category === "input" || element.category === "link");
+  if (interactive.length === 0) {
+    warnings.push("No interactive elements detected. The page may require authentication, render later than the current settle window, or be mostly static content.");
+  }
+  return warnings;
+}
+function log(verbose, message) {
+  if (verbose) console.log(message);
+}
+async function getAccessibilitySnapshot(page, verbose) {
+  if (!page.accessibility || typeof page.accessibility.snapshot !== "function") {
+    log(verbose, "  -> Accessibility snapshot API unavailable; continuing with DOM-only capture");
+    return null;
+  }
+  try {
+    return await page.accessibility.snapshot({ interestingOnly: false });
+  } catch (error) {
+    log(verbose, `  -> Accessibility snapshot failed (${error?.message ?? error}); continuing with DOM-only capture`);
+    return null;
+  }
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function formatCaptureFailure(error) {
+  const resolved = classifyCaptureError(error);
+  if (resolved.code === "PLAYWRIGHT_NOT_FOUND") {
+    return [
+      "Playwright not resolvable.",
+      "Playwright runtime not found in this project.",
+      "Try:",
+      "  npm install",
+      "  npx playwright install chromium"
+    ];
+  }
+  if (resolved.code === "BROWSER_NOT_INSTALLED") {
+    return [
+      "Browser not installed.",
+      "Playwright resolved, but Chromium is not installed for this project.",
+      "Try:",
+      "  npx playwright install chromium"
+    ];
+  }
+  if (resolved.code === "PAGE_LOAD_FAILED") {
+    return [
+      "Page load failed.",
+      resolved.message
+    ];
+  }
+  return [
+    "Capture failed.",
+    resolved.message
+  ];
+}
+function classifyCaptureError(error) {
+  if (error instanceof CaptureRuntimeError) {
+    return error;
+  }
+  const message = errorMessage(error);
+  if (isBrowserInstallError(message)) {
+    return new CaptureRuntimeError(
+      "BROWSER_NOT_INSTALLED",
+      "Playwright resolved, but Chromium is not installed for this project.",
+      { cause: error }
+    );
+  }
+  if (isPlaywrightNotFoundError(message)) {
+    return new CaptureRuntimeError(
+      "PLAYWRIGHT_NOT_FOUND",
+      "Playwright runtime not found in this project.",
+      { cause: error }
+    );
+  }
+  return new CaptureRuntimeError("CAPTURE_FAILED", message || "Unknown capture failure.", { cause: error });
+}
+function isBrowserInstallError(message) {
+  return /Executable doesn't exist|browserType\.launch: Executable doesn't exist|Please run the following command|playwright install/i.test(message);
+}
+function isPlaywrightNotFoundError(message) {
+  return /Playwright runtime not found|Cannot find package ['"](?:@playwright\/test|playwright-core)['"]/i.test(message);
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error ?? "");
+}
+
+export {
+  CaptureRuntimeError,
+  inferInteractiveRole,
+  captureElements,
+  toPageSummary,
+  extractDomDataFromEnvironment,
+  formatCaptureFailure
+};
+//# sourceMappingURL=chunk-XUWFEWJZ.js.map