harnery 0.17.0 → 0.19.0

package/src/core/workflow/validate.ts

@@ -2,8 +2,9 @@
  * Minimal validator for the StageSchema JSON-schema subset. Deliberately tiny:
  * a full JSON Schema implementation would pull a dependency (ajv) for
  * validation depth workflow gates don't need. Supported: type, properties,
- * required, items, enum. Returns a list of human-readable problems (empty =
- * valid) so the engine can feed failures back into the retry prompt verbatim.
+ * required, items, minItems/maxItems, minLength/maxLength, pattern, and enum.
+ * Returns a list of human-readable problems (empty = valid) so the engine can
+ * feed failures back into the retry prompt verbatim.
  */
 
 import type { StageSchema } from "./types.ts";
@@ -34,6 +35,12 @@ export function validateAgainstSchema(value: unknown, schema: StageSchema, path
     }
     case "array": {
       if (!Array.isArray(value)) return [`${path}: expected array, got ${short(value)}`];
+      if (schema.minItems !== undefined && value.length < schema.minItems) {
+        problems.push(`${path}: expected at least ${schema.minItems} item(s), got ${value.length}`);
+      }
+      if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        problems.push(`${path}: expected at most ${schema.maxItems} item(s), got ${value.length}`);
+      }
       if (schema.items) {
         for (const [i, item] of value.entries()) {
           problems.push(
@@ -43,7 +50,31 @@ export function validateAgainstSchema(value: unknown, schema: StageSchema, path
       }
       return problems;
     }
-    case "string":
+    case "string": {
+      if (typeof value !== "string") {
+        return [`${path}: expected string, got ${short(value)}`];
+      }
+      if (schema.minLength !== undefined && value.length < schema.minLength) {
+        problems.push(
+          `${path}: expected at least ${schema.minLength} character(s), got ${value.length}`,
+        );
+      }
+      if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        problems.push(
+          `${path}: expected at most ${schema.maxLength} character(s), got ${value.length}`,
+        );
+      }
+      if (schema.pattern !== undefined) {
+        try {
+          if (!new RegExp(schema.pattern).test(value)) {
+            problems.push(`${path}: expected string matching ${JSON.stringify(schema.pattern)}`);
+          }
+        } catch {
+          problems.push(`${path}: schema pattern is invalid`);
+        }
+      }
+      return problems;
+    }
     case "number":
     case "boolean": {
       if (typeof value !== schema.type) {

package/src/lib/browser/client.ts

@@ -1,6 +1,7 @@
 import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import axe from "axe-core";
 import {
   type BrowserContext,
   type ConsoleMessage,
@@ -10,6 +11,13 @@ import {
   type Request,
 } from "playwright";
 import type { CookieJar, Cookie as JarCookie } from "../cookies/index.ts";
+import {
+  buildClearLayoutLintAnnotationsScript,
+  buildLayoutLintAnnotateScript,
+  buildLayoutLintCheck,
+  type LayoutLintRequest,
+  type LayoutLintResult,
+} from "./geometry.js";
 import {
   buildClearLayoutAnnotationsScript,
   buildLayoutAnnotateScript,
@@ -24,6 +32,13 @@ import {
   buildRuntsCheck,
   type RuntsResult,
 } from "./runts.js";
+import {
+  buildClearTargetSizeAnnotationsScript,
+  buildTargetSizeAnnotateScript,
+  buildTargetSizeCheck,
+  type TargetSizeProfile,
+  type TargetSizeResult,
+} from "./target-size.js";
 import {
   buildAnnotateScript,
   buildClearAnnotationsScript,
@@ -441,6 +456,53 @@ export class Browser {
     await this.currentPage.evaluate(buildClearLayoutAnnotationsScript());
   }
 
+  /** Run the selector-scoped rendered-geometry rule family in one page evaluation. */
+  async checkLayoutLint(request: LayoutLintRequest): Promise<LayoutLintResult> {
+    return await this.currentPage.evaluate(buildLayoutLintCheck(), request);
+  }
+
+  /** Draw one document-space annotation layer for rendered-geometry results. */
+  async annotateLayoutLint(result: LayoutLintResult): Promise<void> {
+    await this.currentPage.evaluate(buildLayoutLintAnnotateScript(), result);
+  }
+
+  /** Remove rendered-geometry annotations. */
+  async clearLayoutLintAnnotations(): Promise<void> {
+    await this.currentPage.evaluate(buildClearLayoutLintAnnotationsScript());
+  }
+
+  /**
+   * Run the target-size rule against the page or explicit scopes. The
+   * dependency's browser bundle is evaluated directly in the page context so
+   * a document CSP cannot silently block a script element.
+   */
+  async checkTargetSize(
+    selectors: Array<string | null>,
+    profile: TargetSizeProfile,
+  ): Promise<TargetSizeResult[]> {
+    await this.currentPage.evaluate(axe.source);
+    const results: TargetSizeResult[] = [];
+    for (const selector of selectors) {
+      results.push(
+        await this.currentPage.evaluate(buildTargetSizeCheck(), {
+          selector,
+          profile,
+        }),
+      );
+    }
+    return results;
+  }
+
+  /** Draw target-size failures and unknowns on the screenshot. */
+  async annotateTargetSize(results: TargetSizeResult[]): Promise<void> {
+    await this.currentPage.evaluate(buildTargetSizeAnnotateScript(), results);
+  }
+
+  /** Remove target-size annotations. */
+  async clearTargetSizeAnnotations(): Promise<void> {
+    await this.currentPage.evaluate(buildClearTargetSizeAnnotationsScript());
+  }
+
   /**
    * Inject a script that runs in every page context before page scripts
    * execute. Useful for seeding localStorage before an SSR/CSR comparison;