@skyramp/mcp 0.1.8 → 0.2.0-rc.2

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
+});

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

@@ -0,0 +1,30 @@
+"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 slug_exports = {};
+__export(slug_exports, {
+  slug: () => slug
+});
+module.exports = __toCommonJS(slug_exports);
+function slug(input) {
+  return input.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "_").replace(/^_+|_+$/g, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  slug
+});

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

@@ -0,0 +1,84 @@
+"use strict";
+var import_slug = require("./slug");
+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("slug: lowercases and replaces spaces with underscores", () => {
+  assertEqual((0, import_slug.slug)("Add Product"), "add_product");
+});
+test("slug: replaces punctuation with underscores", () => {
+  assertEqual((0, import_slug.slug)("Next: Select Country"), "next_select_country");
+});
+test("slug: collapses runs of separators", () => {
+  assertEqual((0, import_slug.slug)("Foo   ---   Bar"), "foo_bar");
+});
+test("slug: strips leading and trailing underscores", () => {
+  assertEqual((0, import_slug.slug)("  Hello  "), "hello");
+  assertEqual((0, import_slug.slug)("_leading"), "leading");
+  assertEqual((0, import_slug.slug)("trailing_"), "trailing");
+});
+test("slug: empty input returns empty string", () => {
+  assertEqual((0, import_slug.slug)(""), "");
+});
+test("slug: all-non-alphanumeric input returns empty string", () => {
+  assertEqual((0, import_slug.slug)("---"), "");
+  assertEqual((0, import_slug.slug)("   "), "");
+});
+test("slug: preserves digits", () => {
+  assertEqual((0, import_slug.slug)("Order 12"), "order_12");
+});
+test("slug: is idempotent on already-slug-like input", () => {
+  assertEqual((0, import_slug.slug)("already_slug"), "already_slug");
+});
+test("slug: preserves CJK (Japanese)", () => {
+  assertEqual((0, import_slug.slug)("\u8CC7\u7523\u7BA1\u7406"), "\u8CC7\u7523\u7BA1\u7406");
+  assertEqual((0, import_slug.slug)("\u8CC7\u7523\u60C5\u5831"), "\u8CC7\u7523\u60C5\u5831");
+  assertEqual((0, import_slug.slug)("\u4E00\u62EC\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9"), "\u4E00\u62EC\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9");
+});
+test("slug: preserves Cyrillic and lowercases it", () => {
+  assertEqual((0, import_slug.slug)("\u0420\u0443\u0441\u0441\u043A\u0438\u0439"), "\u0440\u0443\u0441\u0441\u043A\u0438\u0439");
+});
+test("slug: preserves Arabic", () => {
+  assertEqual((0, import_slug.slug)("\u0627\u0644\u0639\u0631\u0628\u064A\u0629"), "\u0627\u0644\u0639\u0631\u0628\u064A\u0629");
+});
+test("slug: preserves Korean", () => {
+  assertEqual((0, import_slug.slug)("\uD55C\uAD6D\uC5B4"), "\uD55C\uAD6D\uC5B4");
+});
+test("slug: preserves accented Latin", () => {
+  assertEqual((0, import_slug.slug)("r\xE9sum\xE9 caf\xE9"), "r\xE9sum\xE9_caf\xE9");
+});
+test("slug: mixed CJK + ASCII digits and whitespace", () => {
+  assertEqual((0, import_slug.slug)("\u901A\u77E5 (1063)"), "\u901A\u77E5_1063");
+});
+test("slug: emoji and symbols are still separators", () => {
+  assertEqual((0, import_slug.slug)("\u{1F600} emoji test"), "emoji_test");
+  assertEqual((0, import_slug.slug)("foo \u2192 bar"), "foo_bar");
+});
+test("slug: output cannot contain the :: separator used by collision groups", () => {
+  assertEqual((0, import_slug.slug)("a::b"), "a_b");
+  assertEqual((0, import_slug.slug)("foo:bar:baz"), "foo_bar_baz");
+});
+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/widgetContract.js

@@ -0,0 +1,127 @@
+"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 widgetContract_exports = {};
+__export(widgetContract_exports, {
+  InferredWidgetContractSchema: () => InferredWidgetContractSchema,
+  WidgetContractSchema: () => WidgetContractSchema,
+  cacheInferredContract: () => cacheInferredContract,
+  lookupContract: () => lookupContract,
+  validateContract: () => validateContract
+});
+module.exports = __toCommonJS(widgetContract_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_curatedWidgets = require("./curatedWidgets");
+const ClickStepSchema = import_mcpBundle.z.object({
+  kind: import_mcpBundle.z.literal("click"),
+  target: import_mcpBundle.z.enum(["trigger", "option"]),
+  matchBy: import_mcpBundle.z.enum(["accessibleName", "role"]).optional(),
+  param: import_mcpBundle.z.string().optional()
+});
+const FillStepSchema = import_mcpBundle.z.discriminatedUnion("target", [
+  import_mcpBundle.z.object({ kind: import_mcpBundle.z.literal("fill"), target: import_mcpBundle.z.literal("activeInput"), param: import_mcpBundle.z.string() }),
+  import_mcpBundle.z.object({ kind: import_mcpBundle.z.literal("fill"), target: import_mcpBundle.z.literal("inputByLabel"), label: import_mcpBundle.z.string(), param: import_mcpBundle.z.string() })
+]);
+const WaitForStepSchema = import_mcpBundle.z.object({
+  kind: import_mcpBundle.z.literal("waitFor"),
+  location: import_mcpBundle.z.enum(["inDom", "portal", "frame"]),
+  signal: import_mcpBundle.z.enum(["visible", "present"])
+});
+const SelectOptionStepSchema = import_mcpBundle.z.object({
+  kind: import_mcpBundle.z.literal("selectOption"),
+  by: import_mcpBundle.z.enum(["accessibleName", "index"]),
+  param: import_mcpBundle.z.string()
+});
+const EnterFrameStepSchema = import_mcpBundle.z.object({
+  kind: import_mcpBundle.z.literal("enterFrame"),
+  framePath: import_mcpBundle.z.array(import_mcpBundle.z.string())
+});
+const ExitFrameStepSchema = import_mcpBundle.z.object({ kind: import_mcpBundle.z.literal("exitFrame") });
+const HandoffStepSchema = import_mcpBundle.z.object({ kind: import_mcpBundle.z.literal("handoff") });
+const ContractStepSchema = import_mcpBundle.z.union([
+  ClickStepSchema,
+  FillStepSchema,
+  WaitForStepSchema,
+  SelectOptionStepSchema,
+  EnterFrameStepSchema,
+  ExitFrameStepSchema,
+  HandoffStepSchema
+]);
+const WidgetContractSchema = import_mcpBundle.z.object({
+  source: import_mcpBundle.z.enum(["curated", "inferred", "unknown"]),
+  confidence: import_mcpBundle.z.enum(["high", "medium", "low"]),
+  widgetIdentification: import_mcpBundle.z.string().max(100),
+  parameters: import_mcpBundle.z.array(import_mcpBundle.z.string()),
+  steps: import_mcpBundle.z.array(ContractStepSchema)
+});
+const InferredWidgetContractSchema = import_mcpBundle.z.object({
+  source: import_mcpBundle.z.enum(["inferred", "unknown"]),
+  confidence: import_mcpBundle.z.enum(["high", "medium", "low"]),
+  widgetIdentification: import_mcpBundle.z.string().max(100),
+  parameters: import_mcpBundle.z.array(import_mcpBundle.z.string()),
+  steps: import_mcpBundle.z.array(ContractStepSchema)
+});
+function validateContract(contract) {
+  const params = new Set(contract.parameters);
+  let enterFrameCount = 0;
+  let sawWaitFor = false;
+  for (const step of contract.steps) {
+    const stepParam = step.param;
+    if (stepParam !== void 0 && !params.has(stepParam))
+      throw new Error(`step param '${stepParam}' not declared in parameters[]`);
+    if (step.kind === "enterFrame") {
+      if (step.framePath.length === 0)
+        throw new Error("EnterFrameStep.framePath must be non-empty");
+      enterFrameCount++;
+      if (enterFrameCount > 1)
+        throw new Error("at most one EnterFrameStep per contract (provisional limit)");
+    }
+    if (step.kind === "waitFor") sawWaitFor = true;
+    if (step.kind === "handoff" && !sawWaitFor) {
+      console.warn("widgetContract: HandoffStep not preceded by WaitForStep \u2014 agent may act on pre-widget-open DOM state");
+    }
+  }
+}
+function lookupContract(fingerprint, inferredCache) {
+  const curated = import_curatedWidgets.CURATED[fingerprint];
+  if (curated) return { status: "found", contract: curated };
+  const inferred = inferredCache.get(fingerprint);
+  if (inferred) return { status: "found", contract: inferred };
+  return { status: "needs_inference_marker" };
+}
+function cacheInferredContract(fingerprint, contract, inferredCache) {
+  if (Object.prototype.hasOwnProperty.call(import_curatedWidgets.CURATED, fingerprint))
+    return { ok: false, error: "fingerprint collides with curated entry; cannot overwrite" };
+  if (contract.source === "curated")
+    return { ok: false, error: "source: 'curated' is reserved for the curated library; use 'inferred' or 'unknown'" };
+  try {
+    validateContract(contract);
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+  inferredCache.set(fingerprint, contract);
+  return { ok: true };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InferredWidgetContractSchema,
+  WidgetContractSchema,
+  cacheInferredContract,
+  lookupContract,
+  validateContract
+});