@skyramp/mcp 0.2.0-rc.1 → 0.2.0-rc.2

package/node_modules/playwright/lib/dom-analyzer/possibleAssertions.js

@@ -0,0 +1,150 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var possibleAssertions_exports = {};
+__export(possibleAssertions_exports, {
+  buildFullCaptureAssertions: () => buildFullCaptureAssertions,
+  buildPossibleAssertions: () => buildPossibleAssertions
+});
+module.exports = __toCommonJS(possibleAssertions_exports);
+const INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "combobox",
+  "tab",
+  "menuitem",
+  "switch",
+  "checkbox",
+  "radio",
+  "option",
+  "searchbox",
+  "dialog",
+  "alertdialog"
+]);
+function escapeForSingleQuote(s) {
+  let cleaned = s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/[\r\n]+/g, " ");
+  if (cleaned.length > 80)
+    cleaned = cleaned.slice(0, 79) + "\u2026";
+  return cleaned;
+}
+function buildPossibleAssertions(delta) {
+  const results = [];
+  for (const el of delta.elementsAdded) {
+    if (!el.accessibleName.trim()) {
+      continue;
+    }
+    const escapedName = escapeForSingleQuote(el.accessibleName);
+    const code = `await expect(page.getByRole('${el.role}', { name: '${escapedName}' })).toBeVisible();`;
+    let rationale;
+    let tier;
+    if (INTERACTIVE_ROLES.has(el.role)) {
+      rationale = `Element added to DOM after action: ${el.role} "${el.accessibleName}"`;
+      tier = "MEDIUM";
+    } else if (el.role === "heading") {
+      rationale = `Heading appeared after action: "${el.accessibleName}"`;
+      tier = "MEDIUM";
+    } else {
+      rationale = `${el.role} live region appeared: "${el.accessibleName}"`;
+      tier = "LOW";
+    }
+    results.push({ code, rationale, tier });
+  }
+  for (const el of delta.elementsRemoved) {
+    if (!el.accessibleName.trim()) continue;
+    const escapedName = escapeForSingleQuote(el.accessibleName);
+    const code = `await expect(page.getByRole('${el.role}', { name: '${escapedName}' })).not.toBeVisible();`;
+    let tier;
+    if (INTERACTIVE_ROLES.has(el.role)) {
+      tier = "MEDIUM";
+    } else {
+      tier = "LOW";
+    }
+    results.push({
+      code,
+      rationale: `Element removed from DOM after action: ${el.role} "${el.accessibleName}"`,
+      tier
+    });
+  }
+  for (const tc of delta.textChanges) {
+    if (!tc.before.trim() && !tc.after.trim()) continue;
+    if (!tc.accessibleName.trim()) continue;
+    const escapedAccessibleName = escapeForSingleQuote(tc.accessibleName);
+    const escapedAfter = escapeForSingleQuote(tc.after);
+    const code = `await expect(page.getByRole('${tc.role}', { name: '${escapedAccessibleName}' })).toHaveText('${escapedAfter}');`;
+    results.push({
+      code,
+      rationale: `Text changed: "${tc.before}" \u2192 "${tc.after}"`,
+      tier: "HIGH"
+    });
+  }
+  for (const rc of delta.repeatingCountChanges) {
+    if (rc.before === rc.after) continue;
+    if (!rc.accessibleNameTemplate.trim()) continue;
+    const regexPattern = templateToRegex(rc.accessibleNameTemplate);
+    const code = `await expect(page.getByRole('${rc.role}', { name: ${regexPattern} })).toHaveCount(${rc.after});`;
+    results.push({
+      code,
+      rationale: `Repeating element count changed: ${rc.before} \u2192 ${rc.after}`,
+      tier: "HIGH"
+    });
+  }
+  const tierOrder = { HIGH: 0, MEDIUM: 1, LOW: 2 };
+  results.sort((a, b) => tierOrder[a.tier] - tierOrder[b.tier]);
+  return results;
+}
+function buildFullCaptureAssertions(blueprint) {
+  const out = [];
+  if (blueprint.url && blueprint.url.trim()) {
+    const escapedUrl = escapeForSingleQuote(blueprint.url);
+    out.push({
+      code: `await expect(page).toHaveURL('${escapedUrl}');`,
+      rationale: `Page URL after action: ${blueprint.url}`,
+      tier: "HIGH"
+    });
+  }
+  const heading = findFirstHeading(blueprint);
+  if (heading) {
+    const escapedName = escapeForSingleQuote(heading);
+    out.push({
+      code: `await expect(page.getByRole('heading', { name: '${escapedName}' })).toBeVisible();`,
+      rationale: `Heading visible on destination page: "${heading}"`,
+      tier: "LOW"
+    });
+  }
+  return out;
+}
+function findFirstHeading(blueprint) {
+  for (const section of blueprint.sections) {
+    for (const el of section.elements) {
+      if (el.role === "heading" && el.accessibleName.trim())
+        return el.accessibleName;
+    }
+  }
+  return null;
+}
+function templateToRegex(template) {
+  let pattern = template.replace(/[.+*?^$()|[\]\\]/g, "\\$&");
+  pattern = pattern.replace(/\{[a-zA-Z0-9_]+\}/g, ".+");
+  return `/^${pattern}$/i`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFullCaptureAssertions,
+  buildPossibleAssertions
+});

package/node_modules/playwright/lib/dom-analyzer/possibleAssertions.test.js

@@ -0,0 +1,470 @@
+"use strict";
+var import_possibleAssertions = require("./possibleAssertions");
+const cases = [];
+function test(name, run) {
+  cases.push({ name, run });
+}
+function assertEqual(actual, expected, msg) {
+  const a = JSON.stringify(actual);
+  const e = JSON.stringify(expected);
+  if (a !== e)
+    throw new Error(`${msg ?? "assertEqual"} \u2014 expected ${e}, got ${a}`);
+}
+test("Empty delta \u2192 empty array", () => {
+  const delta = {
+    hasStructuralChange: false,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0);
+});
+test("elementsAdded with a button \u2192 1 assertion, role-based locator, toBeVisible(), MEDIUM tier", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "save_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "Save Changes",
+        kind: "persistent"
+      }
+    ],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].code, "await expect(page.getByRole('button', { name: 'Save Changes' })).toBeVisible();");
+  assertEqual(assertions[0].tier, "MEDIUM");
+  if (!assertions[0].rationale.includes("button"))
+    throw new Error("rationale should mention button role");
+});
+test("elementsRemoved with a textbox \u2192 .not.toBeVisible(), MEDIUM", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [
+      {
+        logicalName: "email_input",
+        sectionLogicalName: "form",
+        role: "textbox",
+        accessibleName: "Email"
+      }
+    ],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].code, "await expect(page.getByRole('textbox', { name: 'Email' })).not.toBeVisible();");
+  assertEqual(assertions[0].tier, "MEDIUM");
+  if (!assertions[0].rationale.includes("removed"))
+    throw new Error("rationale should mention removed");
+});
+test("repeatingCountChanges 12 \u2192 13 \u2192 toHaveCount(13), HIGH", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [
+      {
+        logicalName: "order_row_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleNameTemplate: "View details for order {orderId}",
+        before: 12,
+        after: 13,
+        delta: 1
+      }
+    ],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  if (!assertions[0].code.includes("toHaveCount(13)"))
+    throw new Error("code should include toHaveCount(13)");
+  if (!assertions[0].code.includes("/^View details for order .+$/i"))
+    throw new Error("code should include regex pattern from template");
+  assertEqual(assertions[0].tier, "HIGH");
+  if (!assertions[0].rationale.includes("12") || !assertions[0].rationale.includes("13"))
+    throw new Error("rationale should mention before and after counts");
+});
+test('textChanges "Inbox (5)" \u2192 "Inbox (6)" \u2192 toHaveText(...), HIGH', () => {
+  const delta = {
+    hasStructuralChange: false,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [
+      {
+        logicalName: "inbox_link",
+        sectionLogicalName: "sidebar",
+        role: "link",
+        accessibleName: "Inbox (6)",
+        before: "Inbox (5)",
+        after: "Inbox (6)"
+      }
+    ],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  if (!assertions[0].code.includes("toHaveText('Inbox (6)')"))
+    throw new Error("code should include toHaveText with after value");
+  if (!assertions[0].code.includes("getByRole('link'"))
+    throw new Error("code should use role-based locator");
+  assertEqual(assertions[0].tier, "HIGH");
+  if (!assertions[0].rationale.includes("Inbox (5)") || !assertions[0].rationale.includes("Inbox (6)"))
+    throw new Error("rationale should mention before and after text");
+});
+test("elementsAdded with empty accessibleName + no testId + no stableId \u2192 skipped (zero output)", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "button_1",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "",
+        kind: "persistent"
+      }
+    ],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0, "should skip element with empty accessibleName");
+});
+test("Quote-escaping: accessibleName with quotes", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "greeting_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "He said 'hi'",
+        kind: "persistent"
+      }
+    ],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 1);
+  if (!assertions[0].code.includes("\\'"))
+    throw new Error("code should escape single quotes");
+});
+test("textChanges with empty accessibleName \u2192 skipped", () => {
+  const delta = {
+    hasStructuralChange: false,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [
+      {
+        logicalName: "icon_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "",
+        before: "",
+        after: "New Text"
+      }
+    ],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0, "should skip textChange with empty accessibleName");
+});
+test("repeatingCountChanges with empty accessibleNameTemplate \u2192 skipped", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [
+      {
+        logicalName: "item",
+        sectionLogicalName: "main",
+        role: "listitem",
+        accessibleNameTemplate: "",
+        before: 5,
+        after: 6,
+        delta: 1
+      }
+    ],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 0, "should skip repeatingCountChange with empty accessibleNameTemplate");
+});
+test("Mixed delta with all four kinds \u2192 all four translations appear, ordered HIGH first then MEDIUM then LOW", () => {
+  const delta = {
+    hasStructuralChange: true,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [
+      {
+        logicalName: "save_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "Save",
+        kind: "persistent"
+      },
+      {
+        logicalName: "notification_status",
+        sectionLogicalName: "main",
+        role: "status",
+        accessibleName: "Operation complete",
+        kind: "transient"
+      }
+    ],
+    elementsRemoved: [
+      {
+        logicalName: "cancel_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleName: "Cancel"
+      }
+    ],
+    repeatingCountChanges: [
+      {
+        logicalName: "order_row_btn",
+        sectionLogicalName: "main",
+        role: "button",
+        accessibleNameTemplate: "View details for order {orderId}",
+        before: 12,
+        after: 13,
+        delta: 1
+      }
+    ],
+    repeatingItemsChanged: [],
+    textChanges: [
+      {
+        logicalName: "inbox_link",
+        sectionLogicalName: "sidebar",
+        role: "link",
+        accessibleName: "Inbox (6)",
+        before: "Inbox (5)",
+        after: "Inbox (6)"
+      }
+    ],
+    enrichmentChanges: []
+  };
+  const assertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
+  assertEqual(assertions.length, 5);
+  assertEqual(assertions[0].tier, "HIGH");
+  assertEqual(assertions[1].tier, "HIGH");
+  assertEqual(assertions[2].tier, "MEDIUM");
+  assertEqual(assertions[3].tier, "MEDIUM");
+  assertEqual(assertions[4].tier, "LOW");
+});
+function makeBlueprint(url, sections = []) {
+  return {
+    schemaVersion: 1,
+    url,
+    capturedAt: "2026-01-01T00:00:00Z",
+    pageHash: "0:0",
+    sections
+  };
+}
+test("Full capture with URL + heading \u2192 2 assertions, HIGH then LOW", () => {
+  const blueprint = makeBlueprint("http://localhost:8055/settings/schema", [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "page_title",
+          role: "heading",
+          accessibleName: "Data Model",
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 2);
+  assertEqual(assertions[0].tier, "HIGH");
+  assertEqual(
+    assertions[0].code,
+    `await expect(page).toHaveURL('http://localhost:8055/settings/schema');`
+  );
+  assertEqual(assertions[1].tier, "LOW");
+  assertEqual(
+    assertions[1].code,
+    `await expect(page.getByRole('heading', { name: 'Data Model' })).toBeVisible();`
+  );
+});
+test("Full capture with URL only (no headings) \u2192 1 assertion", () => {
+  const blueprint = makeBlueprint("http://localhost:8055/applications", [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "create_btn",
+          role: "button",
+          accessibleName: "Create new",
+          xpath: "//button",
+          mutability: "mutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].tier, "HIGH");
+});
+test("Full capture with empty URL \u2192 no assertions", () => {
+  const blueprint = makeBlueprint("", []);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 0);
+});
+test("Full capture skips heading with empty accessibleName", () => {
+  const blueprint = makeBlueprint("http://example.com/", [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "unnamed_heading",
+          role: "heading",
+          accessibleName: "   ",
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 1);
+  assertEqual(assertions[0].tier, "HIGH");
+});
+test("Full capture finds first heading across multiple sections", () => {
+  const blueprint = makeBlueprint("http://example.com/page", [
+    {
+      name: "header",
+      landmark: "banner",
+      elements: [],
+      // no heading here
+      repeatingElements: []
+    },
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "main_heading",
+          role: "heading",
+          accessibleName: "Welcome",
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 2);
+  assertEqual(assertions[1].rationale, 'Heading visible on destination page: "Welcome"');
+});
+test("Full capture escapes single-quotes in URL and heading", () => {
+  const blueprint = makeBlueprint(`http://example.com/q?name='foo'`, [
+    {
+      name: "page",
+      landmark: "main",
+      elements: [
+        {
+          logicalName: "h1",
+          role: "heading",
+          accessibleName: `Bob's profile`,
+          xpath: "//h1",
+          mutability: "immutable",
+          widgetType: "native",
+          framePath: [],
+          shadowRoot: false
+        }
+      ],
+      repeatingElements: []
+    }
+  ]);
+  const assertions = (0, import_possibleAssertions.buildFullCaptureAssertions)(blueprint);
+  assertEqual(assertions.length, 2);
+  assertEqual(assertions[0].code.includes(`\\'`), true);
+  assertEqual(assertions[1].code.includes(`\\'`), true);
+});
+let passed = 0;
+let failed = 0;
+const failures = [];
+for (const c of cases) {
+  try {
+    c.run();
+    passed++;
+  } catch (e) {
+    failed++;
+    failures.push({ name: c.name, error: e.message });
+  }
+}
+console.log(`${passed}/${cases.length} passed${failed ? `, ${failed} failed` : ""}`);
+for (const f of failures)
+  console.error(`  \u2717 ${f.name}: ${f.error}`);
+if (failed > 0) {
+  process.exit(1);
+}

package/node_modules/playwright/lib/mcp/browser/tab.js

@@ -59,7 +59,7 @@ class Tab extends import_events.EventEmitter {
      * same URL instead of the full payload. Cleared on tab close (not on
      * navigation — same-URL revisits should reuse the prior blueprint).
      */
-    this.blueprintCache = new import_blueprintCache.BlueprintCache(5);
+    this.blueprintCache = new import_blueprintCache.BlueprintCache(10);
     this.context = context;
     this.page = page;
     this._onPageClose = onPageClose;

package/node_modules/playwright/lib/mcp/browser/tools/pageBlueprint.js

@@ -25,6 +25,7 @@ var import_mcpBundle = require("playwright-core/lib/mcpBundle");
 var import_tool = require("./tool");
 var import_blueprint = require("../../../dom-analyzer/blueprint");
 var import_blueprintDiff = require("../../../dom-analyzer/blueprintDiff");
+var import_possibleAssertions = require("../../../dom-analyzer/possibleAssertions");
 const blueprint = (0, import_tool.defineTabTool)({
   capability: "core",
   schema: {
@@ -36,13 +37,25 @@ const blueprint = (0, import_tool.defineTabTool)({
       "RETURN SHAPE \u2014 two cases:",
       "",
       "1. First call at a URL (or after the cache has evicted the entry):",
-      '   {"isFullCapture": true, "pageHash": "...", "blueprint": {...full PageBlueprint...}}',
+      '   {"isFullCapture": true, "pageHash": "...", "blueprint": {...full PageBlueprint...}, "possibleAssertions": [...]}',
+      "   The possibleAssertions[] for full captures is small (\u22642 entries):",
+      "   a HIGH-tier toHaveURL assertion plus a LOW-tier heading visibility",
+      "   check. Anchor candidates only \u2014 full deltas come from same-URL pairs.",
       "",
       "2. Subsequent call at the same URL:",
-      '   {"isFullCapture": false, "pageHash": "...", "previousPageHash": "...", "delta": {...BlueprintDelta...}}',
+      '   {"isFullCapture": false, "pageHash": "...", "previousPageHash": "...", "delta": {...BlueprintDelta...}, "possibleAssertions": [...]}',
       "   The delta is computed automatically against your most recent blueprint at this URL.",
       "   Empty arrays in delta (elementsAdded/Removed/textChanges) mean the action did not change observable DOM.",
       "",
+      "   The possibleAssertions[] here is built mechanically from the delta",
+      "   (interactive element add/remove, text changes, repeating-element",
+      "   counts) and tends to carry richer signal than the full-capture set.",
+      "",
+      "   In both cases possibleAssertions are options the data supports, not",
+      "   directives \u2014 read each, pick the ones that test something meaningful,",
+      "   edit the locator if needed, and emit them as browser_assert calls.",
+      "   Skip noise (e.g. timestamps).",
+      "",
       "CAPTURE-ACT-CAPTURE: capture once before your action, perform the action, capture again \u2014 the second",
       "response IS the diff. You only need browser_blueprint_diff when comparing across different URLs.",
       "",
@@ -59,20 +72,24 @@ const blueprint = (0, import_tool.defineTabTool)({
       const previous = tab.blueprintCache.get(url);
       if (!previous) {
         tab.blueprintCache.put(url, current);
+        const possibleAssertions2 = (0, import_possibleAssertions.buildFullCaptureAssertions)(current);
         response.addTextResult(JSON.stringify({
           isFullCapture: true,
           pageHash: current.pageHash,
-          blueprint: current
+          blueprint: current,
+          possibleAssertions: possibleAssertions2
         }, null, 2));
         return;
       }
       const delta = (0, import_blueprintDiff.diffBlueprints)(previous, current);
+      const possibleAssertions = (0, import_possibleAssertions.buildPossibleAssertions)(delta);
       tab.blueprintCache.put(url, current);
       response.addTextResult(JSON.stringify({
         isFullCapture: false,
         pageHash: current.pageHash,
         previousPageHash: previous.pageHash,
-        delta
+        delta,
+        possibleAssertions
       }, null, 2));
     } catch (err) {
       if (err instanceof import_blueprint.BlueprintInvariantError) {