aria-ease 6.6.0 → 6.8.0

package/dist/{chunk-LKN5PRYD.js → chunk-2TOYEY5L.js}

@@ -24,10 +24,11 @@ var ContractReporter = class {
   componentName = "";
   staticPasses = 0;
   staticFailures = 0;
+  staticWarnings = 0;
   dynamicResults = [];
   totalTests = 0;
   skipped = 0;
-  optionalSuggestions = 0;
+  warnings = 0;
   isPlaywright = false;
   apgUrl = "https://www.w3.org/WAI/ARIA/apg/";
   hasPrintedStaticSection = false;
@@ -54,23 +55,27 @@ ${"\u2550".repeat(60)}`);
     this.log(`${"\u2550".repeat(60)}
 `);
   }
-  reportStatic(passes, failures) {
+  reportStatic(passes, failures, warnings = 0) {
     this.staticPasses = passes;
     this.staticFailures = failures;
+    this.staticWarnings = warnings;
   }
   /**
    * Report individual static test pass
    */
-  reportStaticTest(description, passed, failureMessage) {
+  reportStaticTest(description, status, failureMessage, level) {
     if (!this.hasPrintedStaticSection) {
       this.log(`${"\u2500".repeat(60)}`);
       this.log(`\u{1F9EA} Static Assertions`);
       this.log(`${"\u2500".repeat(60)}`);
       this.hasPrintedStaticSection = true;
     }
-    const icon = passed ? "\u2713" : "\u2717";
+    const icon = status === "pass" ? "\u2713" : status === "warn" ? "\u26A0" : status === "skip" ? "\u25CB" : "\u2717";
     this.log(`  ${icon} ${description}`);
-    if (!passed && failureMessage) {
+    if (level) {
+      this.log(`     \u21B3 level=${level}`);
+    }
+    if ((status === "fail" || status === "warn" || status === "skip") && failureMessage) {
       this.log(`     \u21B3 ${failureMessage}`);
     }
   }
@@ -89,23 +94,26 @@ ${"\u2550".repeat(60)}`);
       description: test.description,
       status,
       failureMessage,
-      isOptional: test.isOptional
+      level: test.level
     };
     if (status === "skip") {
       result.skipReason = "Requires real browser (addEventListener events)";
     }
     this.dynamicResults.push(result);
-    const icons = { pass: "\u2713", fail: "\u2717", skip: "\u25CB", "optional-fail": "\u25CB" };
-    const prefix = test.isOptional ? "[OPTIONAL] " : "";
-    this.log(`  ${icons[status]} ${prefix}${test.description}`);
+    const icons = { pass: "\u2713", fail: "\u2717", warn: "\u26A0", skip: "\u25CB" };
+    const levelPrefix = test.level ? `[${test.level.toUpperCase()}] ` : "";
+    this.log(`  ${icons[status]} ${levelPrefix}${test.description}`);
     if (status === "skip" && !this.isPlaywright) {
       this.log(`     \u21B3 Skipped in jsdom (runs in Playwright)`);
     }
-    if (status === "fail" && failureMessage && !test.isOptional) {
+    if (status === "fail" && failureMessage) {
       this.log(`     \u21B3 ${failureMessage}`);
     }
-    if (status === "optional-fail") {
-      this.log(`     \u21B3 Not implemented (recommended for enhanced UX)`);
+    if (status === "warn" && failureMessage) {
+      this.log(`     \u21B3 ${failureMessage}`);
+    }
+    if (status === "skip" && failureMessage) {
+      this.log(`     \u21B3 ${failureMessage}`);
     }
   }
   /**
@@ -129,29 +137,29 @@ ${"\u2500".repeat(60)}`);
       this.log("");
     });
   }
-  /**
-   * Report optional features that aren't implemented
-   */
-  reportOptionalSuggestions() {
-    const suggestions = this.dynamicResults.filter((r) => r.status === "optional-fail");
-    if (suggestions.length === 0) return;
+  reportWarnings() {
+    const warnings = this.dynamicResults.filter((r) => r.status === "warn");
+    if (warnings.length === 0 && this.staticWarnings === 0) return;
     this.log(`
 ${"\u2500".repeat(60)}`);
-    this.log(`\u{1F4A1} Optional Enhancements (${suggestions.length}):
+    this.log(`\u26A0\uFE0F Warnings (${this.staticWarnings + warnings.length}):
 `);
-    this.log(`These features are optional per APG guidelines but recommended`);
-    this.log(`for improved user experience and keyboard interaction:
+    this.log(`These checks are failing but treated as warnings under the active strictness mode.
 `);
-    suggestions.forEach((test, index) => {
+    warnings.forEach((test, index) => {
       this.log(`${index + 1}. ${test.description}`);
       if (test.failureMessage) {
         this.log(`   \u21B3 ${test.failureMessage}`);
       }
+      if (test.level) {
+        this.log(`   \u21B3 level=${test.level}`);
+      }
     });
-    this.log(`
-\u2728 Consider implementing these for better accessibility`);
-    this.log(`   Reference: ${this.apgUrl}
+    if (this.apgUrl) {
+      this.log(`
+Reference: ${this.apgUrl}
 `);
+    }
   }
   /**
    * Report skipped tests with helpful context
@@ -181,41 +189,42 @@ ${"\u2500".repeat(60)}`);
     const duration = Date.now() - this.startTime;
     const dynamicPasses = this.dynamicResults.filter((r) => r.status === "pass").length;
     const dynamicFailures = this.dynamicResults.filter((r) => r.status === "fail").length;
+    const dynamicWarnings = this.dynamicResults.filter((r) => r.status === "warn").length;
     this.skipped = this.dynamicResults.filter((r) => r.status === "skip").length;
-    this.optionalSuggestions = this.dynamicResults.filter((r) => r.status === "optional-fail").length;
+    this.warnings = this.staticWarnings + dynamicWarnings;
     const totalPasses = this.staticPasses + dynamicPasses;
     const totalFailures = this.staticFailures + dynamicFailures;
-    const totalRun = totalPasses + totalFailures;
+    const totalRun = totalPasses + totalFailures + this.warnings;
     if (failures.length > 0) {
       this.reportFailures(failures);
     }
-    this.reportOptionalSuggestions();
+    this.reportWarnings();
     this.reportSkipped();
     this.log(`
 ${"\u2550".repeat(60)}`);
     this.log(`\u{1F4CA} Summary
 `);
-    if (totalFailures === 0 && this.skipped === 0 && this.optionalSuggestions === 0) {
+    if (totalFailures === 0 && this.skipped === 0 && this.warnings === 0) {
       this.log(`\u2705 All ${totalRun} tests passed!`);
       this.log(`   ${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)} component meets WAI-ARIA expectations for Roles, States, Properties, and Keyboard Interactions \u2713`);
     } else if (totalFailures === 0) {
-      this.log(`\u2705 ${totalPasses}/${totalRun} required tests passed`);
+      this.log(`\u2705 ${totalPasses}/${totalRun} tests passed`);
       if (this.skipped > 0) {
         this.log(`\u25CB  ${this.skipped} tests skipped`);
       }
-      if (this.optionalSuggestions > 0) {
-        this.log(`\u{1F4A1} ${this.optionalSuggestions} optional enhancement${this.optionalSuggestions > 1 ? "s" : ""} suggested`);
+      if (this.warnings > 0) {
+        this.log(`\u26A0\uFE0F ${this.warnings} warning${this.warnings > 1 ? "s" : ""}`);
       }
       this.log(`   ${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)} component meets WAI-ARIA expectations for Roles, States, Properties, and Keyboard Interactions \u2713`);
     } else {
       this.log(`\u274C ${totalFailures} test${totalFailures > 1 ? "s" : ""} failed`);
       this.log(`\u2705 ${totalPasses} test${totalPasses > 1 ? "s" : ""} passed`);
+      if (this.warnings > 0) {
+        this.log(`\u26A0\uFE0F ${this.warnings} warning${this.warnings > 1 ? "s" : ""}`);
+      }
       if (this.skipped > 0) {
         this.log(`\u25CB  ${this.skipped} test${this.skipped > 1 ? "s" : ""} skipped`);
       }
-      if (this.optionalSuggestions > 0) {
-        this.log(`\u{1F4A1} ${this.optionalSuggestions} optional enhancement${this.optionalSuggestions > 1 ? "s" : ""} suggested`);
-      }
     }
     this.log(`\u23F1\uFE0F  Duration: ${duration}ms`);
     this.log(`${"\u2550".repeat(60)}
@@ -250,6 +259,46 @@ ${"\u2550".repeat(60)}`);
   }
 };
 
+// src/utils/test/src/strictness.ts
+var FALLBACK_LEVEL = "required";
+function normalizeLevel(level) {
+  if (level === "required" || level === "recommended" || level === "optional") {
+    return level;
+  }
+  return FALLBACK_LEVEL;
+}
+function normalizeStrictness(strictness) {
+  if (strictness === "minimal" || strictness === "balanced" || strictness === "strict" || strictness === "paranoid") {
+    return strictness;
+  }
+  return "balanced";
+}
+function resolveEnforcement(level, strictness) {
+  const matrix = {
+    minimal: {
+      required: "error",
+      recommended: "ignore",
+      optional: "ignore"
+    },
+    balanced: {
+      required: "error",
+      recommended: "warning",
+      optional: "ignore"
+    },
+    strict: {
+      required: "error",
+      recommended: "error",
+      optional: "warning"
+    },
+    paranoid: {
+      required: "error",
+      recommended: "error",
+      optional: "error"
+    }
+  };
+  return matrix[strictness][level];
+}
+
 // src/utils/test/src/playwrightTestHarness.ts
 import { chromium } from "playwright";
 var sharedBrowser = null;
@@ -297,6 +346,9 @@ async function closeSharedBrowser() {
 export {
   contract_default,
   ContractReporter,
+  normalizeLevel,
+  normalizeStrictness,
+  resolveEnforcement,
   createTestPage,
   closeSharedBrowser
 };

package/dist/configLoader-IT4PWCJB.js

@@ -0,0 +1,128 @@
+import "./chunk-I2KLQ2HA.js";
+
+// src/utils/cli/configLoader.ts
+import path from "path";
+import fs from "fs-extra";
+function validateConfig(config) {
+  const errors = [];
+  if (!config || typeof config !== "object") {
+    errors.push("Config must be an object");
+    return { valid: false, errors };
+  }
+  const cfg = config;
+  if (cfg.audit !== void 0) {
+    if (typeof cfg.audit !== "object" || cfg.audit === null) {
+      errors.push("audit must be an object");
+    } else {
+      if (cfg.audit.urls !== void 0) {
+        if (!Array.isArray(cfg.audit.urls)) {
+          errors.push("audit.urls must be an array");
+        } else if (cfg.audit.urls.some((url) => typeof url !== "string")) {
+          errors.push("audit.urls must contain only strings");
+        }
+      }
+      if (cfg.audit.output !== void 0) {
+        if (typeof cfg.audit.output !== "object") {
+          errors.push("audit.output must be an object");
+        } else {
+          const output = cfg.audit.output;
+          if (output.format !== void 0) {
+            if (!["json", "csv", "html", "all"].includes(output.format)) {
+              errors.push("audit.output.format must be one of: json, csv, html, all");
+            }
+          }
+          if (output.out !== void 0 && typeof output.out !== "string") {
+            errors.push("audit.output.out must be a string");
+          }
+        }
+      }
+    }
+  }
+  if (cfg.test !== void 0) {
+    if (typeof cfg.test !== "object" || cfg.test === null) {
+      errors.push("test must be an object");
+    } else {
+      if (cfg.test.components !== void 0) {
+        if (!Array.isArray(cfg.test.components)) {
+          errors.push("test.components must be an array");
+        } else {
+          cfg.test.components.forEach((comp, idx) => {
+            if (typeof comp !== "object" || comp === null) {
+              errors.push(`test.components[${idx}] must be an object`);
+            } else {
+              if (typeof comp.name !== "string") {
+                errors.push(`test.components[${idx}].name must be a string`);
+              }
+              if (comp.path !== void 0 && typeof comp.path !== "string") {
+                errors.push(`test.components[${idx}].path must be a string when provided`);
+              }
+              if (comp.strictness !== void 0 && !["minimal", "balanced", "strict", "paranoid"].includes(comp.strictness)) {
+                errors.push(`test.components[${idx}].strictness must be one of: minimal, balanced, strict, paranoid`);
+              }
+            }
+          });
+        }
+      }
+      if (cfg.test.strictness !== void 0) {
+        if (!["minimal", "balanced", "strict", "paranoid"].includes(cfg.test.strictness)) {
+          errors.push("test.strictness must be one of: minimal, balanced, strict, paranoid");
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+async function loadConfigFile(filePath) {
+  try {
+    const ext = path.extname(filePath);
+    if (ext === ".json") {
+      const content = await fs.readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } else if ([".js", ".mjs", ".cjs", ".ts"].includes(ext)) {
+      const imported = await import(filePath);
+      return imported.default || imported;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function loadConfig(cwd = process.cwd()) {
+  const configNames = [
+    "ariaease.config.js",
+    "ariaease.config.mjs",
+    "ariaease.config.cjs",
+    "ariaease.config.json",
+    "ariaease.config.ts"
+  ];
+  let loadedConfig = null;
+  let foundPath = null;
+  const errors = [];
+  for (const name of configNames) {
+    const configPath = path.resolve(cwd, name);
+    if (await fs.pathExists(configPath)) {
+      foundPath = configPath;
+      loadedConfig = await loadConfigFile(configPath);
+      if (loadedConfig === null) {
+        errors.push(`Found config at ${name} but failed to load it. Check for syntax errors.`);
+        continue;
+      }
+      const validation = validateConfig(loadedConfig);
+      if (!validation.valid) {
+        errors.push(`Config validation failed in ${name}:`);
+        errors.push(...validation.errors.map((err) => `  - ${err}`));
+        loadedConfig = null;
+        continue;
+      }
+      break;
+    }
+  }
+  return {
+    config: loadedConfig || {},
+    configPath: loadedConfig ? foundPath : null,
+    errors
+  };
+}
+export {
+  loadConfig
+};

package/{bin/contractTestRunnerPlaywright-PC6JOYYV.js → dist/contractTestRunnerPlaywright-UAOFNS7Z.js}

@@ -1,8 +1,11 @@
 import {
   ContractReporter,
   contract_default,
-  createTestPage
-} from "./chunk-LKN5PRYD.js";
+  createTestPage,
+  normalizeLevel,
+  normalizeStrictness,
+  resolveEnforcement
+} from "./chunk-2TOYEY5L.js";
 import {
   __export,
   __reExport
@@ -291,9 +294,6 @@ var ActionExecutor = class {
     this.selectors = selectors;
     this.timeoutMs = timeoutMs;
   }
-  isOptionalMenuTarget(target) {
-    return ["submenu", "submenuTrigger", "submenuItems"].includes(target);
-  }
   /**
    * Check if error is due to browser/page being closed
    */
@@ -425,10 +425,9 @@ var ActionExecutor = class {
       const locator = this.page.locator(selector).first();
       const elementCount = await locator.count();
       if (elementCount === 0) {
-        const optionalMenuTarget = this.isOptionalMenuTarget(target);
         return {
           success: false,
-          error: optionalMenuTarget ? `${target} element not found (optional submenu test)` : `${target} element not found.`,
+          error: `${target} element not found.`,
           shouldBreak: true
           // Signal to skip this test
         };
@@ -728,10 +727,11 @@ var AssertionRunner = class {
 };
 
 // src/utils/test/src/contractTestRunnerPlaywright.ts
-async function runContractTestsPlaywright(componentName, url) {
+async function runContractTestsPlaywright(componentName, url, strictness) {
   const reporter = new ContractReporter(true);
   const actionTimeoutMs = 400;
   const assertionTimeoutMs = 400;
+  const strictnessMode = normalizeStrictness(strictness);
   const contractTyped = contract_default;
   const contractPath = contractTyped[componentName]?.path;
   const resolvedPath = new URL(contractPath, import.meta.url).pathname;
@@ -740,9 +740,25 @@ async function runContractTestsPlaywright(componentName, url) {
   const totalTests = componentContract.static[0].assertions.length + componentContract.dynamic.length;
   const apgUrl = componentContract.meta?.source?.apg;
   const failures = [];
+  const warnings = [];
   const passes = [];
   const skipped = [];
   let page = null;
+  const classifyFailure = (message, levelRaw) => {
+    const level = normalizeLevel(levelRaw);
+    const enforcement = resolveEnforcement(level, strictnessMode);
+    if (enforcement === "error") {
+      failures.push(message);
+      return { status: "fail", level, detail: message };
+    }
+    if (enforcement === "warning") {
+      warnings.push(message);
+      return { status: "warn", level, detail: message };
+    }
+    const ignoredMessage = `${message} (ignored by strictness=${strictnessMode}, level=${level})`;
+    skipped.push(ignoredMessage);
+    return { status: "skip", level, detail: ignoredMessage };
+  };
   try {
     page = await createTestPage();
     if (url) {
@@ -788,35 +804,37 @@ This usually means:
       });
     }
     const hasSubmenuCapability = componentName === "menu" && !!componentContract.selectors.submenuTrigger ? await page.locator(componentContract.selectors.submenuTrigger).count() > 0 : false;
+    let staticPassed = 0;
     let staticFailed = 0;
+    let staticWarnings = 0;
     const staticAssertionRunner = new AssertionRunner(page, componentContract.selectors, assertionTimeoutMs);
     for (const test of componentContract.static[0]?.assertions || []) {
       if (test.target === "relative") continue;
       const staticDescription = `${test.target}${test.attribute ? ` (${test.attribute})` : ""}`;
+      const staticLevel = normalizeLevel(test.level);
       if (componentName === "menu" && test.target === "submenuTrigger" && !hasSubmenuCapability) {
-        passes.push(`Skipping submenu static assertion for ${test.target}: no submenu capability detected in rendered component.`);
-        reporter.reportStaticTest(staticDescription, true);
+        const skipMessage = `Skipping submenu static assertion for ${test.target}: no submenu capability detected in rendered component.`;
+        skipped.push(skipMessage);
+        reporter.reportStaticTest(staticDescription, "skip", skipMessage, staticLevel);
         continue;
       }
       const targetSelector = componentContract.selectors[test.target];
       if (!targetSelector) {
         const failure = `Selector for target ${test.target} not found.`;
-        failures.push(failure);
-        staticFailed += 1;
-        reporter.reportStaticTest(staticDescription, false, failure);
+        const outcome = classifyFailure(failure, test.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
         continue;
       }
       const target = page.locator(targetSelector).first();
       const exists = await target.count() > 0;
       if (!exists) {
-        if (test.isOptional === true) {
-          reporter.reportStaticTest(staticDescription, true);
-          continue;
-        }
         const failure = `Target ${test.target} not found.`;
-        failures.push(failure);
-        staticFailed += 1;
-        reporter.reportStaticTest(staticDescription, false, failure);
+        const outcome = classifyFailure(failure, test.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
         continue;
       }
       const isRedundantCheck = (selector, attrName, expectedVal) => {
@@ -851,19 +869,23 @@ This usually means:
         }
         if (!hasAny && !allRedundant) {
           const failure = test.failureMessage + ` None of the attributes "${test.attribute}" are present.`;
-          failures.push(failure);
-          staticFailed += 1;
-          reporter.reportStaticTest(staticDescription, false, failure);
+          const outcome = classifyFailure(failure, test.level);
+          if (outcome.status === "fail") staticFailed += 1;
+          if (outcome.status === "warn") staticWarnings += 1;
+          reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
         } else if (!allRedundant && hasAny) {
           passes.push(`At least one of the attributes "${test.attribute}" exists on the element.`);
-          reporter.reportStaticTest(staticDescription, true);
+          staticPassed += 1;
+          reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
         } else {
-          reporter.reportStaticTest(staticDescription, true);
+          staticPassed += 1;
+          reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
         }
       } else {
         if (isRedundantCheck(targetSelector, test.attribute, test.expectedValue)) {
           passes.push(`${test.attribute}="${test.expectedValue}" on ${test.target} verified by selector (already present in: ${targetSelector}).`);
-          reporter.reportStaticTest(staticDescription, true);
+          staticPassed += 1;
+          reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
         } else {
           const result = await staticAssertionRunner.validateAttribute(
             target,
@@ -875,11 +897,13 @@ This usually means:
           );
           if (result.success && result.passMessage) {
             passes.push(result.passMessage);
-            reporter.reportStaticTest(staticDescription, true);
+            staticPassed += 1;
+            reporter.reportStaticTest(staticDescription, "pass", void 0, staticLevel);
           } else if (!result.success && result.failMessage) {
-            failures.push(result.failMessage);
-            staticFailed += 1;
-            reporter.reportStaticTest(staticDescription, false, result.failMessage);
+            const outcome = classifyFailure(result.failMessage, test.level);
+            if (outcome.status === "fail") staticFailed += 1;
+            if (outcome.status === "warn") staticWarnings += 1;
+            reporter.reportStaticTest(staticDescription, outcome.status, outcome.detail, outcome.level);
           }
         }
       }
@@ -894,6 +918,9 @@ This usually means:
       }
       const { action, assertions } = dynamicTest;
       const failuresBeforeTest = failures.length;
+      const warningsBeforeTest = warnings.length;
+      const skippedBeforeTest = skipped.length;
+      const dynamicLevel = normalizeLevel(dynamicTest.level);
       try {
         await strategy.resetState(page);
       } catch (error) {
@@ -903,13 +930,15 @@ This usually means:
       }
       const shouldSkipTest = await strategy.shouldSkipTest(dynamicTest, page);
       if (shouldSkipTest) {
-        reporter.reportTest(dynamicTest, "skip", `Skipping test - component-specific conditions not met`);
+        const skipMessage = `Skipping test - component-specific conditions not met`;
+        skipped.push(skipMessage);
+        reporter.reportTest({ description: dynamicTest.description, level: dynamicLevel }, "skip", skipMessage);
         continue;
       }
       const actionExecutor = new ActionExecutor(page, componentContract.selectors, actionTimeoutMs);
       const assertionRunner = new AssertionRunner(page, componentContract.selectors, assertionTimeoutMs);
-      let shouldSkipCurrentTest = false;
       let shouldAbortCurrentTest = false;
+      let actionOutcome = null;
       for (const act of action) {
         if (!page || page.isClosed()) {
           failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
@@ -931,27 +960,20 @@ This usually means:
           continue;
         }
         if (!result.success) {
-          if (result.shouldBreak) {
-            if (result.error?.includes("optional submenu test")) {
-              reporter.reportTest(dynamicTest, "skip", result.error);
-              shouldSkipCurrentTest = true;
-            } else if (result.error) {
-              failures.push(result.error);
-              shouldAbortCurrentTest = true;
-            }
-            break;
-          }
           if (result.error) {
-            failures.push(result.error);
+            const outcome = classifyFailure(result.error, dynamicTest.level);
+            actionOutcome = { status: outcome.status, detail: outcome.detail };
           }
-          continue;
+          shouldAbortCurrentTest = true;
+          break;
         }
       }
-      if (shouldSkipCurrentTest) {
-        continue;
-      }
       if (shouldAbortCurrentTest) {
-        reporter.reportTest(dynamicTest, "fail", failures[failures.length - 1]);
+        reporter.reportTest(
+          { description: dynamicTest.description, level: dynamicLevel },
+          actionOutcome?.status || "fail",
+          actionOutcome?.detail || failures[failures.length - 1]
+        );
         continue;
       }
       for (const assertion of assertions) {
@@ -959,22 +981,39 @@ This usually means:
         if (result.success && result.passMessage) {
           passes.push(result.passMessage);
         } else if (!result.success && result.failMessage) {
-          failures.push(result.failMessage);
+          const assertionLevel = normalizeLevel(assertion.level || dynamicTest.level);
+          const outcome = classifyFailure(result.failMessage, assertionLevel);
+          if (outcome.status === "skip") {
+            continue;
+          }
         }
       }
       const failuresAfterTest = failures.length;
-      const testPassed = failuresAfterTest === failuresBeforeTest;
-      const failureMessage = testPassed ? void 0 : failures[failures.length - 1];
-      if (dynamicTest.isOptional === true && !testPassed) {
-        failures.pop();
-        reporter.reportTest(dynamicTest, "optional-fail", failureMessage);
+      const warningsAfterTest = warnings.length;
+      const skippedAfterTest = skipped.length;
+      if (failuresAfterTest > failuresBeforeTest) {
+        reporter.reportTest(
+          { description: dynamicTest.description, level: dynamicLevel },
+          "fail",
+          failures[failures.length - 1]
+        );
+      } else if (warningsAfterTest > warningsBeforeTest) {
+        reporter.reportTest(
+          { description: dynamicTest.description, level: dynamicLevel },
+          "warn",
+          warnings[warnings.length - 1]
+        );
+      } else if (skippedAfterTest > skippedBeforeTest) {
+        reporter.reportTest(
+          { description: dynamicTest.description, level: dynamicLevel },
+          "skip",
+          skipped[skipped.length - 1]
+        );
       } else {
-        reporter.reportTest(dynamicTest, testPassed ? "pass" : "fail", failureMessage);
+        reporter.reportTest({ description: dynamicTest.description, level: dynamicLevel }, "pass");
       }
     }
-    const staticTotal = componentContract.static[0].assertions.length;
-    const staticPassed = Math.max(0, staticTotal - staticFailed);
-    reporter.reportStatic(staticPassed, staticFailed);
+    reporter.reportStatic(staticPassed, staticFailed, staticWarnings);
     reporter.summary(failures);
   } catch (error) {
     if (error instanceof Error) {
@@ -999,7 +1038,7 @@ Make sure your dev server is running at ${url}`);
   } finally {
     if (page) await page.close();
   }
-  return { passes, failures, skipped };
+  return { passes, failures, skipped, warnings };
 }
 export {
   runContractTestsPlaywright