blastproof 0.16.0 → 0.18.0

package/README.md

@@ -77,6 +77,8 @@ Three questions. The first one decides most cases.
 
 **A hard requirement, not a preference.** blastproof finds elements the way a screen reader does — by role, by label, by visible text. That is what removes selectors and survives redesigns. The cost is that there is deliberately no CSS or XPath fallback, so anything the accessibility tree cannot describe cannot be driven at all.
 
+The name is matched **exactly first**, then by substring if nothing matches exactly — so a control named `Add` is found even when `Add New` sits above it. When several controls answer to the same name, the first one on the page wins. Give each control an accessible name no other control on the page shares; a page that cannot offer one cannot be driven unambiguously, and no matching rule fixes that.
+
 | works | cannot be driven |
 | --- | --- |
 | `<button>Add to cart</button>` | a `<div>` with a click handler |

package/dist/cli.js

@@ -424,13 +424,18 @@ function describeTarget(target) {
 async function resolveTarget(page, target, resolveTimeoutMs = 2e3) {
   const candidates = [];
   if (target.role) {
+    if (target.name) {
+      candidates.push(page.getByRole(target.role, { name: target.name, exact: true }));
+    }
     candidates.push(page.getByRole(target.role, target.name ? { name: target.name } : {}));
   }
   if (target.name) {
+    candidates.push(page.getByLabel(target.name, { exact: true }));
     candidates.push(page.getByLabel(target.name));
   }
   const text = target.text ?? target.name;
   if (text) {
+    candidates.push(page.getByText(text, { exact: true }));
     candidates.push(page.getByText(text));
   }
   for (const candidate of candidates) {
@@ -593,6 +598,23 @@ var StepRecovery = class {
   observe(maskedSnapshot) {
     this.readable.push(normalise(maskedSnapshot));
   }
+  /**
+   * Whether anything succeeded during this step (design close-a-step D1).
+   *
+   * Reads the history `record` already keeps rather than a flag threaded
+   * through the loop: `record` is reached at one place, after `performAction`
+   * returns without throwing, so this is "what worked" and not "what was
+   * attempted" — a click that raised is correctly absent. A separate counter
+   * would be one more thing a future branch can forget to increment, which is
+   * the shape that let `timeoutMs` and the budget go unset at a single call
+   * site while every other one set them.
+   *
+   * `observe` deliberately does not move it. Being shown a page is not doing
+   * something to it.
+   */
+  get acted() {
+    return this.history.length > 0;
+  }
   /** Records an action that was actually performed and succeeded. */
   record(action, description, result) {
     this.performed.add(identity(action));
@@ -686,6 +708,7 @@ function slugify(text) {
   const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
   return slug || "test";
 }
+var NOTHING_DONE_REFUSAL = "refused: nothing succeeded during this step, so it was NOT closed. A step closes on what was done in it, not on being declared finished. If the outcome already holds \u2014 there was nothing left to do \u2014 assert that it holds and let the judgment close the step; an assertion is evidence, a declaration is not. If the step cannot be carried out at all, fail it and say why.";
 var StepFailure = class extends Error {
 };
 async function executeTest(page, test, options) {
@@ -770,6 +793,15 @@ async function executeTest(page, test, options) {
         }
         iterations++;
         if (action.action === "done") {
+          if (!recovery.acted) {
+            failedAttempts++;
+            lastResult = NOTHING_DONE_REFUSAL;
+            emitAction(index, action, lastResult);
+            if (failedAttempts >= maxRetries) {
+              throw new StepFailure(lastResult);
+            }
+            continue;
+          }
           emitAction(index, action, action.reasoning);
           break;
         }
@@ -2952,13 +2984,11 @@ async function planCommand(options) {
           written.push(path10.relative(options.cwd, file));
           console.log(`  wrote ${path10.relative(options.cwd, file)}`);
         } catch (error) {
-          if (error instanceof PlannerError) {
-            generated.pop();
-            failed.push({ route, reason: error.message });
-            console.log(`  X failed: ${error.message}`);
-            continue;
-          }
-          throw error;
+          generated.pop();
+          const reason = error instanceof Error ? error.message : String(error);
+          failed.push({ route, reason });
+          console.log(`  X failed: ${reason}`);
+          continue;
         }
       } else {
         console.log(`
@@ -3079,7 +3109,7 @@ function parsePositiveNumber(flag) {
   };
 }
 var program = new Command();
-program.name("blastproof").description("Open-source AI testing agent: plain-English YAML tests executed agentically on a real browser.").version("0.16.0");
+program.name("blastproof").description("Open-source AI testing agent: plain-English YAML tests executed agentically on a real browser.").version("0.18.0");
 program.command("init").description("Scaffold .blastproof/ (config, tests, sample tests) in the current directory").action(async () => {
   try {
     const result = await initProject(process.cwd());