@skyramp/mcp 0.1.8 → 0.2.0-rc.1

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

@@ -0,0 +1,231 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_fingerprint = require("./fingerprint");
+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("normalizeClasses: keeps BEM-ish classes", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("vue-treeselect vue-treeselect__menu vue-treeselect--single"),
+    "vue-treeselect vue-treeselect--single vue-treeselect__menu"
+  );
+});
+test("normalizeClasses: keeps framework-prefixed classes", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("MuiSelect-root MuiSelect-standard"),
+    "MuiSelect-root MuiSelect-standard"
+  );
+});
+test("normalizeClasses: drops tailwind utilities", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("vue-treeselect bg-red-500 p-4 hover:text-white"),
+    "vue-treeselect"
+  );
+});
+test("normalizeClasses: drops CSS-module hashed suffixes", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("button_abc123 vue-treeselect"),
+    "vue-treeselect"
+  );
+});
+test("normalizeClasses: drops numeric-index suffixes", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("item-1 item-2 vue-treeselect"),
+    "vue-treeselect"
+  );
+});
+test("normalizeClasses: drops state tokens", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("vue-treeselect is-active is-open expanded"),
+    "vue-treeselect"
+  );
+});
+test("normalizeClasses: framework prefix beats numeric-suffix deny-list", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("MuiSelect-root MuiSelect-123 ant-select-item-1"),
+    "MuiSelect-123 MuiSelect-root ant-select-item-1"
+  );
+});
+test("normalizeClasses: framework prefix beats tailwind-shape deny-list", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("data-radix-border-blue"),
+    "data-radix-border-blue"
+  );
+});
+test("normalizeClasses: empty string returns empty string", () => {
+  assertEqual((0, import_fingerprint.normalizeClasses)(""), "");
+});
+test("normalizeClasses: sorts alphabetically", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("vue-treeselect__menu vue-treeselect"),
+    "vue-treeselect vue-treeselect__menu"
+  );
+});
+test("normalizeClasses: deduplicates", () => {
+  assertEqual(
+    (0, import_fingerprint.normalizeClasses)("vue-treeselect vue-treeselect"),
+    "vue-treeselect"
+  );
+});
+test("computeFingerprintFromInput: identical input yields identical hash", () => {
+  const input = {
+    root: { tag: "div", role: "combobox", ariaHasPopup: "", classPattern: "vue-treeselect", dataAttrKeys: [] },
+    descendants: [],
+    portal: null
+  };
+  assertEqual((0, import_fingerprint.computeFingerprintFromInput)(input), (0, import_fingerprint.computeFingerprintFromInput)(input));
+});
+test("computeFingerprintFromInput: different tag yields different hash", () => {
+  const a = {
+    root: { tag: "div", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [],
+    portal: null
+  };
+  const b = {
+    root: { tag: "button", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [],
+    portal: null
+  };
+  if ((0, import_fingerprint.computeFingerprintFromInput)(a) === (0, import_fingerprint.computeFingerprintFromInput)(b))
+    throw new Error("expected different hashes");
+});
+test("computeFingerprintFromInput: same descendant order produces same hash (stability)", () => {
+  const d1 = { tag: "div", role: "", ariaHasPopup: "", classPattern: "a", dataAttrKeys: [] };
+  const d2 = { tag: "div", role: "", ariaHasPopup: "", classPattern: "b", dataAttrKeys: [] };
+  const a = {
+    root: { tag: "div", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [d1, d2],
+    portal: null
+  };
+  const b = {
+    root: { tag: "div", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [d1, d2],
+    // same order
+    portal: null
+  };
+  assertEqual((0, import_fingerprint.computeFingerprintFromInput)(a), (0, import_fingerprint.computeFingerprintFromInput)(b));
+});
+test("computeFingerprintFromInput: descendant order DOES affect hash (order is part of the fingerprint)", () => {
+  const d1 = { tag: "div", role: "", ariaHasPopup: "", classPattern: "a", dataAttrKeys: [] };
+  const d2 = { tag: "div", role: "", ariaHasPopup: "", classPattern: "b", dataAttrKeys: [] };
+  const a = {
+    root: { tag: "div", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [d1, d2],
+    portal: null
+  };
+  const b = {
+    root: { tag: "div", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [d2, d1],
+    // reversed
+    portal: null
+  };
+  if ((0, import_fingerprint.computeFingerprintFromInput)(a) === (0, import_fingerprint.computeFingerprintFromInput)(b))
+    throw new Error("expected different hashes when descendant order differs");
+});
+test("computeFingerprintFromInput: returns 16 hex chars", () => {
+  const input = {
+    root: { tag: "div", role: "", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [],
+    portal: null
+  };
+  const hash = (0, import_fingerprint.computeFingerprintFromInput)(input);
+  if (!/^[0-9a-f]{16}$/.test(hash))
+    throw new Error(`expected 16-hex hash, got "${hash}"`);
+});
+test("computeFingerprintFromInput: null portal differs from populated portal", () => {
+  const portalTuple = { tag: "div", role: "", ariaHasPopup: "", classPattern: "data-radix-popper-content-wrapper", dataAttrKeys: [] };
+  const a = {
+    root: { tag: "button", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [],
+    portal: null
+  };
+  const b = {
+    root: { tag: "button", role: "combobox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+    descendants: [],
+    portal: portalTuple
+  };
+  if ((0, import_fingerprint.computeFingerprintFromInput)(a) === (0, import_fingerprint.computeFingerprintFromInput)(b))
+    throw new Error("expected different hashes");
+});
+test("drift detection: blueprint.ts inline rule constants match fingerprint.ts exports", () => {
+  const blueprintSrcPath = path.resolve(__dirname, "..", "..", "src", "dom-analyzer", "blueprint.ts");
+  const src = fs.readFileSync(blueprintSrcPath, "utf-8");
+  const beginMarker = "// INLINE_RULES_BEGIN";
+  const endMarker = "// INLINE_RULES_END";
+  const beginIdx = src.indexOf(beginMarker);
+  const endIdx = src.indexOf(endMarker, beginIdx);
+  if (beginIdx === -1 || endIdx === -1)
+    throw new Error(`blueprint.ts must contain ${beginMarker} / ${endMarker} markers around the inlined fingerprint rule constants`);
+  const newlineAfterBegin = src.indexOf("\n", beginIdx);
+  const block = src.slice(newlineAfterBegin + 1, endIdx);
+  const inlined = new Function(
+    block + "\nreturn { BEM_ISH, FRAMEWORK_PREFIXES, TAILWIND_UTILITY, CSS_MODULE_HASH, NUMERIC_INDEX_SUFFIX, STATE_TOKENS };"
+  )();
+  function regexEq(a, b, name) {
+    if (a.source !== b.source || a.flags !== b.flags)
+      throw new Error(`${name} drift: fingerprint.ts has /${a.source}/${a.flags}, blueprint.ts has /${b.source}/${b.flags}`);
+  }
+  function arrayEq(a, b, name) {
+    if (a.length !== b.length || a.some((v, i) => v !== b[i]))
+      throw new Error(`${name} drift: fingerprint.ts has ${JSON.stringify(a)}, blueprint.ts has ${JSON.stringify(b)}`);
+  }
+  function setEq(a, b, name) {
+    const aSorted = Array.from(a).sort();
+    const bSorted = Array.from(b).sort();
+    arrayEq(aSorted, bSorted, name);
+  }
+  regexEq(import_fingerprint.BEM_ISH, inlined.BEM_ISH, "BEM_ISH");
+  arrayEq(import_fingerprint.FRAMEWORK_PREFIXES, inlined.FRAMEWORK_PREFIXES, "FRAMEWORK_PREFIXES");
+  regexEq(import_fingerprint.TAILWIND_UTILITY, inlined.TAILWIND_UTILITY, "TAILWIND_UTILITY");
+  regexEq(import_fingerprint.CSS_MODULE_HASH, inlined.CSS_MODULE_HASH, "CSS_MODULE_HASH");
+  regexEq(import_fingerprint.NUMERIC_INDEX_SUFFIX, inlined.NUMERIC_INDEX_SUFFIX, "NUMERIC_INDEX_SUFFIX");
+  setEq(import_fingerprint.STATE_TOKENS, inlined.STATE_TOKENS, "STATE_TOKENS");
+});
+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/fingerprintAblation.fixtures.js

@@ -0,0 +1,145 @@
+"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 fingerprintAblation_fixtures_exports = {};
+__export(fingerprintAblation_fixtures_exports, {
+  ABLATION_FIXTURES: () => ABLATION_FIXTURES
+});
+module.exports = __toCommonJS(fingerprintAblation_fixtures_exports);
+const ABLATION_FIXTURES = [
+  {
+    name: "vue-treeselect",
+    description: "Vue-Treeselect combobox trigger (in-DOM custom control)",
+    input: {
+      root: { tag: "div", role: "combobox", ariaHasPopup: "listbox", classPattern: "vue-treeselect vue-treeselect--single", dataAttrKeys: [] },
+      descendants: [
+        { tag: "div", role: "", ariaHasPopup: "", classPattern: "vue-treeselect__control", dataAttrKeys: [] },
+        { tag: "div", role: "", ariaHasPopup: "", classPattern: "vue-treeselect__menu", dataAttrKeys: [] }
+      ],
+      portal: null
+    },
+    expectedHash: "d7e908c767fa68cd"
+  },
+  {
+    name: "radix-select",
+    description: "Radix Select trigger with portal popper",
+    input: {
+      root: { tag: "button", role: "combobox", ariaHasPopup: "listbox", classPattern: "", dataAttrKeys: ["data-radix-select-trigger"] },
+      descendants: [
+        { tag: "span", role: "", ariaHasPopup: "", classPattern: "", dataAttrKeys: ["data-radix-select-value"] }
+      ],
+      portal: { tag: "div", role: "", ariaHasPopup: "", classPattern: "", dataAttrKeys: ["data-radix-popper-content-wrapper"] }
+    },
+    expectedHash: "024c3db1d8f29870"
+  },
+  {
+    name: "stripe-card-number",
+    description: "Stripe CardNumberElement iframe",
+    input: {
+      root: { tag: "iframe", role: "", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+      descendants: [],
+      portal: null
+    },
+    expectedHash: "27114237c0e4a14a"
+  },
+  {
+    name: "mui-select",
+    description: "MUI Select trigger (placeholder for follow-up curated add)",
+    input: {
+      root: { tag: "div", role: "combobox", ariaHasPopup: "listbox", classPattern: "MuiSelect-root MuiSelect-standard", dataAttrKeys: [] },
+      descendants: [
+        { tag: "div", role: "", ariaHasPopup: "", classPattern: "MuiSelect-select", dataAttrKeys: [] }
+      ],
+      portal: null
+    },
+    expectedHash: "bb8e91d32ffd6aa1"
+  },
+  {
+    name: "antd-select",
+    description: "Ant Design Select trigger",
+    input: {
+      root: { tag: "div", role: "combobox", ariaHasPopup: "listbox", classPattern: "ant-select-selector", dataAttrKeys: [] },
+      descendants: [
+        { tag: "span", role: "", ariaHasPopup: "", classPattern: "ant-select-selection-item", dataAttrKeys: [] }
+      ],
+      portal: null
+    },
+    expectedHash: "6787396f9da6022e"
+  },
+  {
+    name: "headlessui-listbox",
+    description: "Headless UI Listbox trigger with portal",
+    input: {
+      root: { tag: "button", role: "combobox", ariaHasPopup: "listbox", classPattern: "", dataAttrKeys: ["data-headlessui-state"] },
+      descendants: [],
+      portal: { tag: "div", role: "listbox", ariaHasPopup: "", classPattern: "", dataAttrKeys: ["data-headlessui-state"] }
+    },
+    expectedHash: "6016cd2641c63075"
+  },
+  {
+    name: "native-button",
+    description: "Plain native button (should not normally be fingerprinted; included to verify low collision surface)",
+    input: {
+      root: { tag: "button", role: "button", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+      descendants: [],
+      portal: null
+    },
+    expectedHash: "15d8dd75a3c6eacf"
+  },
+  {
+    name: "vue-treeselect-multi",
+    description: "Vue-Treeselect in multi-select mode (separate fingerprint from single)",
+    input: {
+      root: { tag: "div", role: "combobox", ariaHasPopup: "listbox", classPattern: "vue-treeselect vue-treeselect--multi", dataAttrKeys: [] },
+      descendants: [
+        { tag: "div", role: "", ariaHasPopup: "", classPattern: "vue-treeselect__control", dataAttrKeys: [] }
+      ],
+      portal: null
+    },
+    expectedHash: "7af3161b147762a3"
+  },
+  {
+    name: "date-picker-custom",
+    description: "Generic custom date-picker (unrecognized; LLM-inference path target)",
+    input: {
+      root: { tag: "div", role: "combobox", ariaHasPopup: "dialog", classPattern: "", dataAttrKeys: [] },
+      descendants: [
+        { tag: "input", role: "textbox", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+        { tag: "button", role: "button", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] }
+      ],
+      portal: null
+    },
+    expectedHash: "3e1cd8161b90817f"
+  },
+  {
+    name: "toast-live-region",
+    description: "ARIA-compliant live region for toasts",
+    input: {
+      root: { tag: "div", role: "status", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] },
+      descendants: [
+        { tag: "div", role: "alert", ariaHasPopup: "", classPattern: "", dataAttrKeys: [] }
+      ],
+      portal: null
+    },
+    expectedHash: "3f1e5b1bc0523ba6"
+  }
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ABLATION_FIXTURES
+});

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

@@ -0,0 +1,41 @@
+"use strict";
+var import_fingerprint = require("./fingerprint");
+var import_fingerprintAblation = require("./fingerprintAblation.fixtures");
+const PLACEHOLDER = "__REPLACE_AFTER_FIRST_RUN__";
+const actual = import_fingerprintAblation.ABLATION_FIXTURES.map((entry) => ({
+  name: entry.name,
+  hash: (0, import_fingerprint.computeFingerprintFromInput)(entry.input),
+  expected: entry.expectedHash
+}));
+const placeholders = actual.filter((a) => a.expected === PLACEHOLDER);
+const locked = actual.filter((a) => a.expected !== PLACEHOLDER);
+let drifted = 0;
+for (const a of locked) {
+  if (a.hash === a.expected) {
+    console.log("  \u2713", a.name, a.hash);
+  } else {
+    drifted++;
+    console.log("  \u2717", a.name);
+    console.log("      expected:", a.expected);
+    console.log("      got     :", a.hash);
+  }
+}
+const uniq = new Set(actual.map((a) => a.hash));
+if (uniq.size !== actual.length) {
+  drifted++;
+  console.log("  \u2717 COLLISION \u2014 two or more fixtures share the same fingerprint hash");
+}
+if (placeholders.length > 0) {
+  console.log("\nBootstrap mode \u2014 paste these hashes into fingerprintAblation.fixtures.ts:");
+  for (const a of placeholders)
+    console.log(`  ${a.name}: '${a.hash}',`);
+  console.log("\nThen re-run the test. (Note: locked entries above were still verified; any \u2717 are real drift and must be investigated, not re-bootstrapped.)");
+  process.exit(1);
+}
+if (drifted > 0) {
+  console.log(`
+${drifted} failed`);
+  process.exit(1);
+}
+console.log(`
+${actual.length} passed`);

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

@@ -0,0 +1,36 @@
+"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 graph_exports = {};
+__export(graph_exports, {
+  urlToFilename: () => urlToFilename
+});
+module.exports = __toCommonJS(graph_exports);
+function urlToFilename(url) {
+  try {
+    const parsed = new URL(url);
+    const path = (parsed.hostname + parsed.pathname).replace(/\/+$/, "").replace(/[^a-zA-Z0-9._-]/g, "__");
+    return path || "index";
+  } catch {
+    return url.replace(/[^a-zA-Z0-9._-]/g, "__") || "page";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  urlToFilename
+});

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

@@ -0,0 +1,43 @@
+"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 liveFingerprints_exports = {};
+__export(liveFingerprints_exports, {
+  fp: () => fp,
+  liveFingerprintNames: () => liveFingerprintNames
+});
+module.exports = __toCommonJS(liveFingerprints_exports);
+const LIVE_FINGERPRINTS = {
+  "vue-treeselect": "b83426fe818e01ee",
+  "radix-select": "738a5387548e9319",
+  "stripe-frame": "74e8e04695fbc142"
+};
+function fp(name) {
+  const hash = LIVE_FINGERPRINTS[name];
+  if (!hash)
+    throw new Error(`live fingerprint '${name}' not found in liveFingerprints.ts`);
+  return hash;
+}
+function liveFingerprintNames() {
+  return Object.keys(LIVE_FINGERPRINTS);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fp,
+  liveFingerprintNames
+});

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

@@ -0,0 +1,72 @@
+"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 logicalNameResolver_exports = {};
+__export(logicalNameResolver_exports, {
+  resolveCollisions: () => resolveCollisions
+});
+module.exports = __toCommonJS(logicalNameResolver_exports);
+var import_slug = require("./slug");
+function resolveCollisions(inputs) {
+  const groupsByKey = /* @__PURE__ */ new Map();
+  inputs.forEach((inp, idx) => {
+    const key = `${inp.sectionName}::${inp.initialName}`;
+    if (!groupsByKey.has(key)) groupsByKey.set(key, []);
+    groupsByKey.get(key).push(idx);
+  });
+  const output = new Array(inputs.length);
+  const slugOrNull = (s) => {
+    if (!s) return null;
+    const slugged = (0, import_slug.slug)(s);
+    return slugged ? slugged : null;
+  };
+  for (const [, indices] of groupsByKey.entries()) {
+    if (indices.length === 1) {
+      output[indices[0]] = inputs[indices[0]].initialName;
+      continue;
+    }
+    const candidateNames = indices.map((i) => {
+      const inp = inputs[i];
+      const testIdSlug = slugOrNull(inp.testId);
+      if (testIdSlug) return `${testIdSlug}_${inp.initialName}`;
+      const stableIdSlug = slugOrNull(inp.stableId);
+      if (stableIdSlug) return `${stableIdSlug}_${inp.initialName}`;
+      const ancestorSlug = slugOrNull(inp.nearestAncestorId);
+      if (ancestorSlug) return `${ancestorSlug}_${inp.initialName}`;
+      return null;
+    });
+    const nonNull = candidateNames.filter((n) => n !== null);
+    const hasDuplicates = new Set(nonNull).size !== nonNull.length;
+    const anyNull = candidateNames.some((n) => n === null);
+    if (anyNull || hasDuplicates) {
+      indices.forEach((idx, posWithinGroup) => {
+        const inp = inputs[idx];
+        output[idx] = `${inp.sectionName}_${inp.initialName}_${posWithinGroup + 1}`;
+      });
+    } else {
+      indices.forEach((idx, k) => {
+        output[idx] = candidateNames[k];
+      });
+    }
+  }
+  return output;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveCollisions
+});