@skyramp/mcp 0.1.8 → 0.2.0-rc.1

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

@@ -0,0 +1,250 @@
+"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 blueprintDiff_exports = {};
+__export(blueprintDiff_exports, {
+  diffBlueprints: () => diffBlueprints
+});
+module.exports = __toCommonJS(blueprintDiff_exports);
+var import_fingerprint = require("./fingerprint");
+const TRANSIENT_ROLES = /* @__PURE__ */ new Set(["status", "alert", "log", "marquee"]);
+function truncate(s, max) {
+  return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
+}
+function isTransient(el) {
+  return TRANSIENT_ROLES.has(el.role);
+}
+function indexBlueprint(bp) {
+  const sections = /* @__PURE__ */ new Map();
+  const elementsByLogical = /* @__PURE__ */ new Map();
+  const elementsByStableId = /* @__PURE__ */ new Map();
+  const elementsByTestId = /* @__PURE__ */ new Map();
+  const repeatingByLogical = /* @__PURE__ */ new Map();
+  const repeatingByStableId = /* @__PURE__ */ new Map();
+  const repeatingByTestId = /* @__PURE__ */ new Map();
+  const ambiguousElementStableIds = /* @__PURE__ */ new Set();
+  const ambiguousElementTestIds = /* @__PURE__ */ new Set();
+  const ambiguousRepeatingStableIds = /* @__PURE__ */ new Set();
+  const ambiguousRepeatingTestIds = /* @__PURE__ */ new Set();
+  function setOnce(map, key, value, ambiguous) {
+    if (map.has(key))
+      ambiguous.add(key);
+    else
+      map.set(key, value);
+  }
+  for (const section of bp.sections) {
+    sections.set(section.name, section);
+    for (const el of section.elements) {
+      const entry = { section, element: el };
+      elementsByLogical.set(`${section.name}::${el.logicalName}`, entry);
+      if (el.stableId !== null)
+        setOnce(elementsByStableId, `${section.name}::${el.stableId}`, entry, ambiguousElementStableIds);
+      if (el.testId !== null)
+        setOnce(elementsByTestId, `${section.name}::${el.testId}`, entry, ambiguousElementTestIds);
+    }
+    for (const rep of section.repeatingElements) {
+      const entry = { section, element: rep };
+      repeatingByLogical.set(`${section.name}::${rep.logicalName}`, entry);
+      if (rep.stableId !== null)
+        setOnce(repeatingByStableId, `${section.name}::${rep.stableId}`, entry, ambiguousRepeatingStableIds);
+      if (rep.testId !== null)
+        setOnce(repeatingByTestId, `${section.name}::${rep.testId}`, entry, ambiguousRepeatingTestIds);
+    }
+  }
+  return {
+    sections,
+    elementsByLogical,
+    elementsByStableId,
+    elementsByTestId,
+    repeatingByLogical,
+    repeatingByStableId,
+    repeatingByTestId,
+    ambiguousElementStableIds,
+    ambiguousElementTestIds,
+    ambiguousRepeatingStableIds,
+    ambiguousRepeatingTestIds
+  };
+}
+function findCounterpart(el, section, index) {
+  const byLogical = index.elementsByLogical.get(`${section.name}::${el.logicalName}`);
+  if (byLogical) return byLogical;
+  if (el.stableId !== null) {
+    const key = `${section.name}::${el.stableId}`;
+    if (!index.ambiguousElementStableIds.has(key)) {
+      const bySid = index.elementsByStableId.get(key);
+      if (bySid) return bySid;
+    }
+  }
+  if (el.testId !== null) {
+    const key = `${section.name}::${el.testId}`;
+    if (!index.ambiguousElementTestIds.has(key)) {
+      const byTid = index.elementsByTestId.get(key);
+      if (byTid) return byTid;
+    }
+  }
+  return null;
+}
+function findRepeatingCounterpart(rep, section, index) {
+  const byLogical = index.repeatingByLogical.get(`${section.name}::${rep.logicalName}`);
+  if (byLogical) return byLogical;
+  if (rep.stableId !== null) {
+    const key = `${section.name}::${rep.stableId}`;
+    if (!index.ambiguousRepeatingStableIds.has(key)) {
+      const bySid = index.repeatingByStableId.get(key);
+      if (bySid) return bySid;
+    }
+  }
+  if (rep.testId !== null) {
+    const key = `${section.name}::${rep.testId}`;
+    if (!index.ambiguousRepeatingTestIds.has(key)) {
+      const byTid = index.repeatingByTestId.get(key);
+      if (byTid) return byTid;
+    }
+  }
+  return null;
+}
+function elementRef(section, el) {
+  return {
+    logicalName: el.logicalName,
+    sectionLogicalName: section.name,
+    role: el.role,
+    accessibleName: el.accessibleName
+  };
+}
+function diffBlueprints(before, after) {
+  const A = indexBlueprint(before);
+  const B = indexBlueprint(after);
+  const delta = {
+    hasStructuralChange: false,
+    sectionsAdded: [],
+    sectionsRemoved: [],
+    elementsAdded: [],
+    elementsRemoved: [],
+    repeatingCountChanges: [],
+    repeatingItemsChanged: [],
+    textChanges: [],
+    enrichmentChanges: []
+  };
+  if (before.url !== after.url)
+    delta.urlChange = { before: before.url, after: after.url };
+  if (before.pageHash !== after.pageHash)
+    delta.pageHashChange = { before: before.pageHash, after: after.pageHash };
+  for (const name of B.sections.keys())
+    if (!A.sections.has(name)) delta.sectionsAdded.push({ sectionLogicalName: name });
+  for (const name of A.sections.keys())
+    if (!B.sections.has(name)) delta.sectionsRemoved.push({ sectionLogicalName: name });
+  for (const { section, element } of B.elementsByLogical.values()) {
+    if (findCounterpart(element, section, A)) continue;
+    delta.elementsAdded.push({
+      ...elementRef(section, element),
+      kind: isTransient(element) ? "transient" : "persistent"
+    });
+  }
+  for (const { section, element } of A.elementsByLogical.values()) {
+    if (findCounterpart(element, section, B)) continue;
+    delta.elementsRemoved.push(elementRef(section, element));
+  }
+  for (const { section: sBefore, element: elBefore } of A.elementsByLogical.values()) {
+    const matched = findCounterpart(elBefore, sBefore, B);
+    if (!matched) continue;
+    const elAfter = matched.element;
+    const tA = elBefore.accessibleName.trim();
+    const tB = elAfter.accessibleName.trim();
+    if (tA !== tB) {
+      delta.textChanges.push({
+        logicalName: elBefore.logicalName,
+        sectionLogicalName: sBefore.name,
+        before: truncate(tA, 200),
+        after: truncate(tB, 200)
+      });
+    }
+    if (elBefore.mutability !== elAfter.mutability) {
+      delta.enrichmentChanges.push({
+        logicalName: elBefore.logicalName,
+        sectionLogicalName: sBefore.name,
+        field: "mutability",
+        before: elBefore.mutability,
+        after: elAfter.mutability
+      });
+    }
+    if (elBefore.widgetType !== elAfter.widgetType) {
+      delta.enrichmentChanges.push({
+        logicalName: elBefore.logicalName,
+        sectionLogicalName: sBefore.name,
+        field: "widgetType",
+        before: elBefore.widgetType,
+        after: elAfter.widgetType
+      });
+    }
+  }
+  for (const { section, element: repB } of B.repeatingByLogical.values()) {
+    const matched = findRepeatingCounterpart(repB, section, A);
+    if (!matched) {
+      delta.elementsAdded.push({
+        logicalName: repB.logicalName,
+        sectionLogicalName: section.name,
+        role: repB.role,
+        accessibleName: repB.accessibleNameTemplate,
+        kind: "persistent"
+      });
+      continue;
+    }
+    const repA = matched.element;
+    if (repA.items.length !== repB.items.length) {
+      delta.repeatingCountChanges.push({
+        logicalName: repB.logicalName,
+        sectionLogicalName: section.name,
+        before: repA.items.length,
+        after: repB.items.length,
+        delta: repB.items.length - repA.items.length
+      });
+    } else {
+      const aKeys = new Set(repA.items.map((i) => (0, import_fingerprint.canonicalJson)(i.parameters)));
+      const bKeys = new Set(repB.items.map((i) => (0, import_fingerprint.canonicalJson)(i.parameters)));
+      let changed = aKeys.size !== bKeys.size;
+      if (!changed) {
+        for (const k of aKeys) if (!bKeys.has(k)) {
+          changed = true;
+          break;
+        }
+      }
+      if (changed) {
+        delta.repeatingItemsChanged.push({
+          logicalName: repB.logicalName,
+          sectionLogicalName: section.name,
+          changed: true
+        });
+      }
+    }
+  }
+  for (const { section, element: repA } of A.repeatingByLogical.values()) {
+    if (findRepeatingCounterpart(repA, section, B)) continue;
+    delta.elementsRemoved.push({
+      logicalName: repA.logicalName,
+      sectionLogicalName: section.name,
+      role: repA.role,
+      accessibleName: repA.accessibleNameTemplate
+    });
+  }
+  delta.hasStructuralChange = delta.sectionsAdded.length > 0 || delta.sectionsRemoved.length > 0 || delta.elementsAdded.length > 0 || delta.elementsRemoved.length > 0 || delta.repeatingCountChanges.length > 0 || delta.repeatingItemsChanged.length > 0;
+  return delta;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffBlueprints
+});

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

@@ -0,0 +1,298 @@
+"use strict";
+var import_blueprintDiff = require("./blueprintDiff");
+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}`);
+}
+function makeElement(overrides = {}) {
+  return {
+    logicalName: "el",
+    role: "button",
+    accessibleName: "Click me",
+    xpath: "//button",
+    mutability: "immutable",
+    widgetType: "native",
+    framePath: [],
+    shadowRoot: false,
+    stableId: null,
+    testId: null,
+    fingerprint: null,
+    ...overrides
+  };
+}
+function makeRepeating(overrides = {}) {
+  return {
+    logicalName: "view_details_for_order_btn",
+    role: "button",
+    accessibleNameTemplate: "View details for order {orderId}",
+    parameters: ["orderId"],
+    xpathPattern: ".//button[{row}]",
+    indexParameter: "orderId",
+    items: [],
+    mutability: "immutable",
+    widgetType: "native",
+    framePath: [],
+    shadowRoot: false,
+    stableId: null,
+    testId: null,
+    fingerprint: null,
+    ...overrides
+  };
+}
+function makeSection(name, elements = [], reps = []) {
+  return { name, landmark: "main", elements, repeatingElements: reps };
+}
+function makeBlueprint(url, sections, pageHash = "h1") {
+  return {
+    schemaVersion: 1,
+    url,
+    capturedAt: "2026-04-30T00:00:00.000Z",
+    pageHash,
+    sections
+  };
+}
+test("diffBlueprints: identical blueprints have no changes", () => {
+  const bp = makeBlueprint("http://x/a", [makeSection("header", [makeElement()])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(bp, bp);
+  assertEqual(d.hasStructuralChange, false);
+  assertEqual(d.sectionsAdded, []);
+  assertEqual(d.sectionsRemoved, []);
+  assertEqual(d.elementsAdded, []);
+  assertEqual(d.elementsRemoved, []);
+  assertEqual(d.textChanges, []);
+});
+test("diffBlueprints: urlChange emitted when URL differs", () => {
+  const a = makeBlueprint("http://x/a", [makeSection("main")]);
+  const b = makeBlueprint("http://x/b", [makeSection("main")]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.urlChange, { before: "http://x/a", after: "http://x/b" });
+});
+test("diffBlueprints: pageHashChange emitted when hash differs", () => {
+  const a = makeBlueprint("http://x/a", [makeSection("main")], "h1");
+  const b = makeBlueprint("http://x/a", [makeSection("main")], "h2");
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.pageHashChange, { before: "h1", after: "h2" });
+});
+test("diffBlueprints: hasStructuralChange false when only URL and pageHash changed", () => {
+  const a = makeBlueprint("http://x/a", [makeSection("main")], "h1");
+  const b = makeBlueprint("http://x/b", [makeSection("main")], "h2");
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.urlChange, { before: "http://x/a", after: "http://x/b" });
+  assertEqual(d.pageHashChange, { before: "h1", after: "h2" });
+  assertEqual(d.hasStructuralChange, false);
+});
+test("diffBlueprints: sectionsAdded / sectionsRemoved", () => {
+  const a = makeBlueprint("http://x", [makeSection("a")]);
+  const b = makeBlueprint("http://x", [makeSection("a"), makeSection("b")]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.sectionsAdded, [{ sectionLogicalName: "b" }]);
+  assertEqual(d.sectionsRemoved, []);
+  assertEqual(d.hasStructuralChange, true);
+});
+test("diffBlueprints: elementsAdded in existing section", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "a" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "a" }),
+    makeElement({ logicalName: "b", accessibleName: "Second" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded.length, 1);
+  assertEqual(d.elementsAdded[0].logicalName, "b");
+  assertEqual(d.elementsAdded[0].kind, "persistent");
+});
+test("diffBlueprints: elementsAdded with role=status tagged transient", () => {
+  const a = makeBlueprint("http://x", [makeSection("main")]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "toast", role: "status", accessibleName: "Saved" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded[0].kind, "transient");
+});
+test("diffBlueprints: role=alert is transient", () => {
+  const a = makeBlueprint("http://x", [makeSection("main")]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "err", role: "alert", accessibleName: "Error" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded[0].kind, "transient");
+});
+test("diffBlueprints: elementsRemoved", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "a" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main")]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsRemoved.length, 1);
+  assertEqual(d.elementsRemoved[0].logicalName, "a");
+});
+test("diffBlueprints: same logicalName in different sections is not accidentally matched", () => {
+  const a = makeBlueprint("http://x", [
+    makeSection("header", [makeElement({ logicalName: "login_btn", accessibleName: "Log in" })]),
+    makeSection("footer", [makeElement({ logicalName: "login_btn", accessibleName: "Sign in" })])
+  ]);
+  const b = makeBlueprint("http://x", [
+    makeSection("header", [makeElement({ logicalName: "login_btn", accessibleName: "Log in" })])
+    // footer's login_btn removed
+  ]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsRemoved.length, 1);
+  assertEqual(d.elementsRemoved[0].logicalName, "login_btn");
+  assertEqual(d.elementsRemoved[0].sectionLogicalName, "footer");
+  assertEqual(d.textChanges, []);
+  assertEqual(d.elementsAdded, []);
+});
+test("diffBlueprints: repeatingCountChanges 12 -> 13", () => {
+  const items12 = Array.from({ length: 12 }, (_, i) => ({ parameters: { orderId: String(i + 1) } }));
+  const items13 = [...items12, { parameters: { orderId: "13" } }];
+  const a = makeBlueprint("http://x", [makeSection("list", [], [makeRepeating({ items: items12 })])]);
+  const b = makeBlueprint("http://x", [makeSection("list", [], [makeRepeating({ items: items13 })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.repeatingCountChanges.length, 1);
+  assertEqual(d.repeatingCountChanges[0].before, 12);
+  assertEqual(d.repeatingCountChanges[0].after, 13);
+  assertEqual(d.repeatingCountChanges[0].delta, 1);
+});
+test("diffBlueprints: repeatingItemsChanged detects same-count composition shift", () => {
+  const items1 = [{ parameters: { orderId: "1" } }, { parameters: { orderId: "2" } }];
+  const items2 = [{ parameters: { orderId: "1" } }, { parameters: { orderId: "3" } }];
+  const a = makeBlueprint("http://x", [makeSection("list", [], [makeRepeating({ items: items1 })])]);
+  const b = makeBlueprint("http://x", [makeSection("list", [], [makeRepeating({ items: items2 })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.repeatingCountChanges, []);
+  assertEqual(d.repeatingItemsChanged.length, 1);
+  assertEqual(d.repeatingItemsChanged[0].changed, true);
+});
+test("diffBlueprints: textChanges on matched element", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "status", accessibleName: "Pending" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "status", accessibleName: "Cancelled" })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.textChanges.length, 1);
+  assertEqual(d.textChanges[0].before, "Pending");
+  assertEqual(d.textChanges[0].after, "Cancelled");
+});
+test("diffBlueprints: whitespace-only text changes ignored", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "s", accessibleName: "Saved" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "s", accessibleName: "Saved " })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.textChanges, []);
+});
+test("diffBlueprints: text truncated to 200 chars", () => {
+  const long = "x".repeat(300);
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "s", accessibleName: "a" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "s", accessibleName: long })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  if (d.textChanges[0].after.length > 200)
+    throw new Error(`text not truncated: ${d.textChanges[0].after.length}`);
+});
+test("diffBlueprints: enrichmentChanges for mutability flip", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "x", mutability: "immutable" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "x", mutability: "mutable" })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.enrichmentChanges.length, 1);
+  assertEqual(d.enrichmentChanges[0].field, "mutability");
+});
+test("diffBlueprints: enrichmentChanges for widgetType flip", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "x", widgetType: "native" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "x", widgetType: "custom", fingerprint: "abcdef0123456789" })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.enrichmentChanges.length, 1);
+  assertEqual(d.enrichmentChanges[0].field, "widgetType");
+  assertEqual(d.enrichmentChanges[0].before, "native");
+  assertEqual(d.enrichmentChanges[0].after, "custom");
+});
+test("diffBlueprints: hasStructuralChange false when only text changed", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "s", accessibleName: "A" })])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [makeElement({ logicalName: "s", accessibleName: "B" })])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.hasStructuralChange, false);
+});
+test("diffBlueprints: element matched via stableId when logicalName drifts", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "status_region", stableId: "toast-region", accessibleName: "" })
+  ])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "order_placed_status", stableId: "toast-region", accessibleName: "Order placed" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded, []);
+  assertEqual(d.elementsRemoved, []);
+  assertEqual(d.textChanges.length, 1);
+  assertEqual(d.textChanges[0].before, "");
+  assertEqual(d.textChanges[0].after, "Order placed");
+  assertEqual(d.hasStructuralChange, false);
+});
+test("diffBlueprints: element matched via testId when logicalName drifts", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "save_btn", testId: "save-action", accessibleName: "Save" })
+  ])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "saving_btn", testId: "save-action", accessibleName: "Saving\u2026" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded, []);
+  assertEqual(d.elementsRemoved, []);
+  assertEqual(d.textChanges.length, 1);
+});
+test("diffBlueprints: elements with no stable identity fall through to add+remove when logicalName drifts", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "alpha", stableId: null, testId: null, accessibleName: "Alpha" })
+  ])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "beta", stableId: null, testId: null, accessibleName: "Beta" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded.length, 1);
+  assertEqual(d.elementsRemoved.length, 1);
+});
+test("diffBlueprints: duplicate testId in same section disables testId fallback", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "alpha_btn", testId: "shared-tid", accessibleName: "Alpha" }),
+    makeElement({ logicalName: "beta_btn", testId: "shared-tid", accessibleName: "Beta" })
+  ])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "alpha_renamed", testId: "shared-tid", accessibleName: "Alpha Renamed" }),
+    makeElement({ logicalName: "beta_renamed", testId: "shared-tid", accessibleName: "Beta Renamed" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded.length, 2);
+  assertEqual(d.elementsRemoved.length, 2);
+  assertEqual(d.textChanges.length, 0);
+});
+test("diffBlueprints: unique testId still falls back to match correctly", () => {
+  const a = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "unique_btn", testId: "unique-tid", accessibleName: "Unique" }),
+    makeElement({ logicalName: "dup_a", testId: "dup-tid", accessibleName: "Dup A" }),
+    makeElement({ logicalName: "dup_b", testId: "dup-tid", accessibleName: "Dup B" })
+  ])]);
+  const b = makeBlueprint("http://x", [makeSection("main", [
+    makeElement({ logicalName: "unique_renamed", testId: "unique-tid", accessibleName: "Unique Renamed" }),
+    makeElement({ logicalName: "dup_a", testId: "dup-tid", accessibleName: "Dup A" }),
+    makeElement({ logicalName: "dup_b", testId: "dup-tid", accessibleName: "Dup B" })
+  ])]);
+  const d = (0, import_blueprintDiff.diffBlueprints)(a, b);
+  assertEqual(d.elementsAdded.length, 0);
+  assertEqual(d.elementsRemoved.length, 0);
+  assertEqual(d.textChanges.length, 1);
+});
+let failed = 0;
+for (const { name, run } of cases) {
+  try {
+    run();
+    console.log("  \u2713", name);
+  } catch (e) {
+    failed++;
+    console.log("  \u2717", name);
+    console.log("     ", e.message);
+  }
+}
+if (failed > 0) {
+  console.log(`
+${failed}/${cases.length} failed`);
+  process.exit(1);
+}
+console.log(`
+${cases.length} passed`);