@skyramp/mcp 0.1.8 → 0.2.0-rc.1

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

@@ -0,0 +1,182 @@
+"use strict";
+var import_logicalNameResolver = require("./logicalNameResolver");
+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 input(overrides = {}) {
+  return {
+    initialName: "save_btn",
+    sectionName: "main",
+    testId: null,
+    stableId: null,
+    nearestAncestorId: null,
+    ...overrides
+  };
+}
+test("resolveCollisions: single element no collision, pass through unchanged", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([input({ initialName: "save_btn" })]);
+  assertEqual(out, ["save_btn"]);
+});
+test("resolveCollisions: testId wins when element has one (slugged)", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-action" }),
+    input({ initialName: "save_btn", testId: "confirm-action" })
+  ]);
+  assertEqual(out, ["save_action_save_btn", "confirm_action_save_btn"]);
+});
+test("resolveCollisions: stableId used when testId absent (slugged)", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", stableId: "top-save" }),
+    input({ initialName: "save_btn", stableId: "bottom-save" })
+  ]);
+  assertEqual(out, ["top_save_save_btn", "bottom_save_save_btn"]);
+});
+test("resolveCollisions: nearestAncestorId used when self has no id (slugged)", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", nearestAncestorId: "form-a" }),
+    input({ initialName: "save_btn", nearestAncestorId: "form-b" })
+  ]);
+  assertEqual(out, ["form_a_save_btn", "form_b_save_btn"]);
+});
+test("resolveCollisions: position-hinted fallback when nothing disambiguates", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", sectionName: "main" }),
+    input({ initialName: "save_btn", sectionName: "main" }),
+    input({ initialName: "save_btn", sectionName: "main" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2", "main_save_btn_3"]);
+});
+test("resolveCollisions: duplicate testIds fall through to position-hinted fallback", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "save", sectionName: "main" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2"]);
+});
+test("resolveCollisions: ancestor id with spaces and caps is slugged", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({
+      initialName: "view_details_btn",
+      sectionName: "page",
+      nearestAncestorId: "order-detail-product-Bose QuietComfort 35 II"
+    }),
+    input({
+      initialName: "view_details_btn",
+      sectionName: "page",
+      nearestAncestorId: "order-detail-product-Apple iWatch"
+    })
+  ]);
+  assertEqual(out, [
+    "order_detail_product_bose_quietcomfort_35_ii_view_details_btn",
+    "order_detail_product_apple_iwatch_view_details_btn"
+  ]);
+});
+test("resolveCollisions: testId with capitals is slugged", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "MainSaveBtn" }),
+    input({ initialName: "save_btn", testId: "FooterSaveBtn" })
+  ]);
+  assertEqual(out, ["mainsavebtn_save_btn", "footersavebtn_save_btn"]);
+});
+test("resolveCollisions: prefix that slugs to empty falls through tier", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", sectionName: "main", nearestAncestorId: "!!!" }),
+    input({ initialName: "save_btn", sectionName: "main", nearestAncestorId: "---" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2"]);
+});
+test("resolveCollisions: ladder falls through when testId slugs to empty", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "!!!", stableId: "top-save" }),
+    input({ initialName: "save_btn", testId: "???", stableId: "bottom-save" })
+  ]);
+  assertEqual(out, ["top_save_save_btn", "bottom_save_save_btn"]);
+});
+test("resolveCollisions: CJK ancestor id preserved after slugging", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "edit_btn", nearestAncestorId: "\u8CC7\u7523\u7BA1\u7406_\u30D1\u30CD\u30EB" }),
+    input({ initialName: "edit_btn", nearestAncestorId: "\u5C65\u6B74\u60C5\u5831_\u30D1\u30CD\u30EB" })
+  ]);
+  assertEqual(out, ["\u8CC7\u7523\u7BA1\u7406_\u30D1\u30CD\u30EB_edit_btn", "\u5C65\u6B74\u60C5\u5831_\u30D1\u30CD\u30EB_edit_btn"]);
+});
+test("resolveCollisions: no cross-section collision \u2014 same initialName in different sections", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", sectionName: "header" }),
+    input({ initialName: "save_btn", sectionName: "footer" })
+  ]);
+  assertEqual(out, ["save_btn", "save_btn"]);
+});
+test("resolveCollisions: mixed group \u2014 one with testId, one without", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-top" }),
+    input({ initialName: "save_btn" })
+  ]);
+  assertEqual(out, ["main_save_btn_1", "main_save_btn_2"]);
+});
+test("resolveCollisions: preserves document order in position hints", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "item", sectionName: "list" }),
+    input({ initialName: "item", sectionName: "list" }),
+    input({ initialName: "item", sectionName: "list" })
+  ]);
+  assertEqual(out, ["list_item_1", "list_item_2", "list_item_3"]);
+});
+test("resolveCollisions: multi-signal precedence \u2014 testId beats stableId beats nearestAncestorId", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-all", stableId: "id-a", nearestAncestorId: "anc-a" }),
+    input({ initialName: "save_btn", testId: null, stableId: "id-b", nearestAncestorId: "anc-b" })
+  ]);
+  assertEqual(out, ["save_all_save_btn", "id_b_save_btn"]);
+});
+test("resolveCollisions: multiple simultaneous collision groups in one input", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "save_btn", testId: "save-a", sectionName: "main" }),
+    input({ initialName: "cancel_btn", testId: "cancel-a", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "save-b", sectionName: "main" }),
+    input({ initialName: "cancel_btn", testId: "cancel-b", sectionName: "main" })
+  ]);
+  assertEqual(out, [
+    "save_a_save_btn",
+    "cancel_a_cancel_btn",
+    "save_b_save_btn",
+    "cancel_b_cancel_btn"
+  ]);
+});
+test("resolveCollisions: mixed collision and non-collision elements in one input", () => {
+  const out = (0, import_logicalNameResolver.resolveCollisions)([
+    input({ initialName: "unique_btn", testId: "u", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "a", sectionName: "main" }),
+    input({ initialName: "save_btn", testId: "b", sectionName: "main" }),
+    input({ initialName: "another_btn", testId: "x", sectionName: "main" })
+  ]);
+  assertEqual(out, [
+    "unique_btn",
+    "a_save_btn",
+    "b_save_btn",
+    "another_btn"
+  ]);
+});
+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`);

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

@@ -0,0 +1,169 @@
+"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 sectionGrouper_exports = {};
+__export(sectionGrouper_exports, {
+  JUNK_SECTION_NAME_PATTERN: () => JUNK_SECTION_NAME_PATTERN,
+  resolveSections: () => resolveSections
+});
+module.exports = __toCommonJS(sectionGrouper_exports);
+var import_slug = require("./slug");
+const JUNK_SECTION_NAME_PATTERN = /^(content|section|untitled|main|overview|details)$/i;
+function isJunk(candidateSlug) {
+  return !candidateSlug || JUNK_SECTION_NAME_PATTERN.test(candidateSlug);
+}
+function resolveSections(inputs) {
+  const assignments = {};
+  const candidatesByAnchorKey = /* @__PURE__ */ new Map();
+  const elementsByAnchorKey = /* @__PURE__ */ new Map();
+  const headingAnchorChainByElement = /* @__PURE__ */ new Map();
+  for (const inp of inputs) {
+    const { landmarkAncestor, sectioningAncestor, headingAncestry } = inp.ancestry;
+    if (landmarkAncestor) {
+      const name = landmarkAncestor.nameHint;
+      assignments[inp.id] = name;
+      candidatesByAnchorKey.set(landmarkAncestor.anchorKey, {
+        name,
+        landmark: landmarkAncestor.landmark,
+        anchorKey: landmarkAncestor.anchorKey
+      });
+      const arr2 = elementsByAnchorKey.get(landmarkAncestor.anchorKey) ?? [];
+      arr2.push(inp.id);
+      elementsByAnchorKey.set(landmarkAncestor.anchorKey, arr2);
+      continue;
+    }
+    if (sectioningAncestor) {
+      const rawName = sectioningAncestor.accessibleName;
+      if (rawName) {
+        const candidateSlug = (0, import_slug.slug)(rawName);
+        if (!isJunk(candidateSlug)) {
+          assignments[inp.id] = candidateSlug;
+          candidatesByAnchorKey.set(sectioningAncestor.anchorKey, {
+            name: candidateSlug,
+            landmark: "other",
+            landmarkOther: sectioningAncestor.tagName,
+            anchorKey: sectioningAncestor.anchorKey
+          });
+          const arr2 = elementsByAnchorKey.get(sectioningAncestor.anchorKey) ?? [];
+          arr2.push(inp.id);
+          elementsByAnchorKey.set(sectioningAncestor.anchorKey, arr2);
+          continue;
+        }
+      }
+    }
+    let assignedFromHeading = false;
+    for (let i = headingAncestry.length - 1; i >= 0; i--) {
+      const h = headingAncestry[i];
+      const candidateSlug = (0, import_slug.slug)(h.text);
+      if (!isJunk(candidateSlug)) {
+        let finalName = candidateSlug;
+        let suffix = 2;
+        while ([...candidatesByAnchorKey.values()].some((c) => c.name === finalName && c.anchorKey !== h.anchorKey)) {
+          finalName = `${candidateSlug}_${suffix++}`;
+        }
+        assignments[inp.id] = finalName;
+        candidatesByAnchorKey.set(h.anchorKey, {
+          name: finalName,
+          landmark: "other",
+          landmarkOther: "heading",
+          anchorKey: h.anchorKey
+        });
+        const arr2 = elementsByAnchorKey.get(h.anchorKey) ?? [];
+        arr2.push(inp.id);
+        elementsByAnchorKey.set(h.anchorKey, arr2);
+        headingAnchorChainByElement.set(
+          inp.id,
+          headingAncestry.map((hh) => hh.anchorKey)
+        );
+        assignedFromHeading = true;
+        break;
+      }
+    }
+    if (assignedFromHeading) continue;
+    assignments[inp.id] = "page";
+    const pageAnchorKey = "page-fallback";
+    candidatesByAnchorKey.set(pageAnchorKey, { name: "page", landmark: "region", anchorKey: pageAnchorKey });
+    const arr = elementsByAnchorKey.get(pageAnchorKey) ?? [];
+    arr.push(inp.id);
+    elementsByAnchorKey.set(pageAnchorKey, arr);
+  }
+  const candidateAnchorKeysWithElements = new Set(
+    [...elementsByAnchorKey.entries()].filter(([, ids]) => ids.length > 0).map(([k]) => k)
+  );
+  const toDrop = /* @__PURE__ */ new Set();
+  for (const [anchorKey, info] of candidatesByAnchorKey.entries()) {
+    if (info.landmarkOther !== "heading") continue;
+    let isAncestor = false;
+    for (const [, chain] of headingAnchorChainByElement.entries()) {
+      const idx = chain.indexOf(anchorKey);
+      if (idx === -1) continue;
+      for (let j = idx + 1; j < chain.length; j++) {
+        const deeperKey = chain[j];
+        if (candidateAnchorKeysWithElements.has(deeperKey) && deeperKey !== anchorKey) {
+          isAncestor = true;
+          break;
+        }
+      }
+      if (isAncestor) break;
+    }
+    if (isAncestor) toDrop.add(anchorKey);
+  }
+  for (const droppedKey of toDrop) {
+    const affectedIds = elementsByAnchorKey.get(droppedKey) ?? [];
+    for (const id of affectedIds) {
+      const chain = headingAnchorChainByElement.get(id) ?? [];
+      let reassigned = null;
+      for (let i = chain.length - 1; i >= 0; i--) {
+        const k = chain[i];
+        if (k === droppedKey) continue;
+        if (toDrop.has(k)) continue;
+        const cand = candidatesByAnchorKey.get(k);
+        if (cand && cand.landmarkOther === "heading") {
+          reassigned = cand.name;
+          break;
+        }
+      }
+      assignments[id] = reassigned ?? "page";
+    }
+    candidatesByAnchorKey.delete(droppedKey);
+    elementsByAnchorKey.delete(droppedKey);
+  }
+  const sections = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const assignmentOrder = [];
+  for (const inp of inputs) {
+    const name = assignments[inp.id];
+    if (name && !assignmentOrder.includes(name)) assignmentOrder.push(name);
+  }
+  for (const name of assignmentOrder) {
+    if (seenNames.has(name)) continue;
+    seenNames.add(name);
+    const info = [...candidatesByAnchorKey.values()].find((c) => c.name === name);
+    if (info) {
+      sections.push({ name: info.name, landmark: info.landmark, landmarkOther: info.landmarkOther });
+    } else if (name === "page") {
+      sections.push({ name: "page", landmark: "region" });
+    }
+  }
+  return { assignments, sections };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JUNK_SECTION_NAME_PATTERN,
+  resolveSections
+});

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

@@ -0,0 +1,269 @@
+"use strict";
+var import_sectionGrouper = require("./sectionGrouper");
+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 el(overrides) {
+  return {
+    id: "test-el-" + Math.random(),
+    ancestry: { landmarkAncestor: null, sectioningAncestor: null, headingAncestry: [] },
+    ...overrides
+  };
+}
+test("resolveSections: landmark beats sectioning beats heading", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: { landmark: "main", nameHint: "main", anchorKey: "ak1" },
+        sectioningAncestor: { tagName: "section", accessibleName: "Inner", anchorKey: "ak2" },
+        headingAncestry: [{ level: 2, text: "Deepest", anchorKey: "ak3" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "main" });
+});
+test("resolveSections: sectioning without name falls through to implicit heading", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: { tagName: "section", accessibleName: null, anchorKey: "ak1" },
+        headingAncestry: [{ level: 2, text: "Orders", anchorKey: "ak2" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "orders" });
+});
+test("resolveSections: G1 drops empty-interactive implicit heading", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: { landmark: "main", nameHint: "main", anchorKey: "main-ak" },
+        sectioningAncestor: null,
+        headingAncestry: [{ level: 2, text: "Decorative", anchorKey: "ak1" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "main" });
+  assertEqual(out.sections.find((s) => s.name === "decorative"), void 0);
+});
+test("resolveSections: G2 (leaf-only) drops ancestor heading when descendant has elements", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [
+          { level: 1, text: "Dashboard", anchorKey: "dash-ak" },
+          { level: 2, text: "Orders", anchorKey: "orders-ak" }
+        ]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "orders" });
+});
+test("resolveSections: G2 keeps two sibling headings at same level", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [{ level: 2, text: "Orders", anchorKey: "orders-ak" }]
+      }
+    }),
+    el({
+      id: "b",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [{ level: 2, text: "Products", anchorKey: "products-ak" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "orders", b: "products" });
+});
+test("resolveSections: G3 rejects junk slug \u2014 fall through to implicit heading", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: { tagName: "section", accessibleName: "Untitled", anchorKey: "sec-ak" },
+        headingAncestry: [{ level: 2, text: "Orders", anchorKey: "orders-ak" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "orders" });
+});
+test("resolveSections: G3 rejects all signals \u2192 page fallback", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: { tagName: "section", accessibleName: "Content", anchorKey: "sec-ak" },
+        headingAncestry: [{ level: 2, text: "Overview", anchorKey: "ov-ak" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "page" });
+});
+test("resolveSections: sectioning null-name and junk-name behave identically (fall through)", () => {
+  const inputsNull = [
+    el({
+      id: "null-a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: { tagName: "section", accessibleName: null, anchorKey: "s1" },
+        headingAncestry: [{ level: 2, text: "Orders", anchorKey: "o1" }]
+      }
+    })
+  ];
+  const inputsJunk = [
+    el({
+      id: "junk-a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: { tagName: "section", accessibleName: "Untitled", anchorKey: "s2" },
+        headingAncestry: [{ level: 2, text: "Orders", anchorKey: "o2" }]
+      }
+    })
+  ];
+  const outNull = (0, import_sectionGrouper.resolveSections)(inputsNull);
+  const outJunk = (0, import_sectionGrouper.resolveSections)(inputsJunk);
+  assertEqual(outNull.assignments["null-a"], "orders");
+  assertEqual(outJunk.assignments["junk-a"], "orders");
+});
+test("resolveSections: two headings same text different anchorKeys \u2192 separate sections", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [{ level: 2, text: "Orders", anchorKey: "orders-1" }]
+      }
+    }),
+    el({
+      id: "b",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [{ level: 2, text: "Orders", anchorKey: "orders-2" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "orders", b: "orders_2" });
+});
+test("resolveSections: element in landmark with inner heading \u2014 landmark wins", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: { landmark: "main", nameHint: "main", anchorKey: "main-ak" },
+        sectioningAncestor: null,
+        headingAncestry: [{ level: 3, text: "Filters", anchorKey: "h3-ak" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "main" });
+});
+test("resolveSections: element in landmark+sectioning+heading \u2014 landmark wins (strongest)", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: { landmark: "main", nameHint: "main", anchorKey: "main-ak" },
+        sectioningAncestor: { tagName: "section", accessibleName: "Orders", anchorKey: "ord-ak" },
+        headingAncestry: [{ level: 3, text: "Filters", anchorKey: "h3-ak" }]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "main" });
+});
+test("resolveSections: G2 nested drop cascade \u2014 A > B > C, only C has elements", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [
+          { level: 1, text: "Dashboard", anchorKey: "dash-ak" },
+          { level: 2, text: "Orders", anchorKey: "orders-ak" },
+          { level: 3, text: "Recent", anchorKey: "recent-ak" }
+        ]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "recent" });
+  assertEqual(out.sections.find((s) => s.name === "dashboard"), void 0);
+  assertEqual(out.sections.find((s) => s.name === "orders"), void 0);
+});
+test("resolveSections: G2 keeps ancestor heading that has its own elements", () => {
+  const inputs = [
+    el({
+      id: "a",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [
+          { level: 1, text: "Dashboard", anchorKey: "dash-ak" }
+        ]
+      }
+    }),
+    el({
+      id: "b",
+      ancestry: {
+        landmarkAncestor: null,
+        sectioningAncestor: null,
+        headingAncestry: [
+          { level: 1, text: "Dashboard", anchorKey: "dash-ak" },
+          { level: 2, text: "Orders", anchorKey: "orders-ak" }
+        ]
+      }
+    })
+  ];
+  const out = (0, import_sectionGrouper.resolveSections)(inputs);
+  assertEqual(out.assignments, { a: "page", b: "orders" });
+});
+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`);

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

@@ -0,0 +1,75 @@
+"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 serialization_exports = {};
+__export(serialization_exports, {
+  CRAWL_TTL_MS: () => CRAWL_TTL_MS,
+  SCHEMA_VERSION: () => SCHEMA_VERSION,
+  assertSchemaVersion: () => assertSchemaVersion,
+  normalizeUrl: () => normalizeUrl,
+  nowTimestamp: () => nowTimestamp,
+  validateTimestamp: () => validateTimestamp
+});
+module.exports = __toCommonJS(serialization_exports);
+const SCHEMA_VERSION = 1;
+const CRAWL_TTL_MS = 30 * 60 * 1e3;
+function normalizeUrl(raw) {
+  const url = new URL(raw);
+  url.hash = "";
+  if (url.protocol === "http:" && url.port === "80" || url.protocol === "https:" && url.port === "443")
+    url.port = "";
+  if (url.search) {
+    const params = Array.from(url.searchParams.entries());
+    params.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    url.search = "";
+    for (const [k, v] of params)
+      url.searchParams.append(k, v);
+  }
+  let pathname = url.pathname;
+  if (pathname.length > 1 && pathname.endsWith("/"))
+    pathname = pathname.replace(/\/+$/, "");
+  const normalizedPath = pathname.replace(/%[0-9a-f]{2}/g, (m) => m.toUpperCase());
+  const normalizedSearch = url.search.replace(/%[0-9a-f]{2}/g, (m) => m.toUpperCase());
+  const origin = `${url.protocol}//${url.host}`;
+  return `${origin}${normalizedPath}${normalizedSearch}`;
+}
+function validateTimestamp(value) {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime()))
+    throw new Error(`Invalid ISO-8601 timestamp: ${JSON.stringify(value)}`);
+  const roundTripped = parsed.toISOString();
+  if (roundTripped !== value)
+    throw new Error(`Timestamp not in canonical ISO-8601 UTC form (got ${JSON.stringify(value)}, expected ${JSON.stringify(roundTripped)})`);
+  return value;
+}
+function nowTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function assertSchemaVersion(version) {
+  if (version !== SCHEMA_VERSION)
+    throw new Error(`Unsupported schemaVersion: got ${version}, expected ${SCHEMA_VERSION}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CRAWL_TTL_MS,
+  SCHEMA_VERSION,
+  assertSchemaVersion,
+  normalizeUrl,
+  nowTimestamp,
+  validateTimestamp
+});