auto-webmcp 0.3.14 → 0.3.16

package/dist/auto-webmcp.cjs.js

@@ -3,9 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,76 +17,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  getAllRegisteredTools: () => getAllRegisteredTools,
-  getRegisteredToolName: () => getRegisteredToolName,
-  isWebMCPSupported: () => isWebMCPSupported,
-  registerFormTool: () => registerFormTool,
-  unregisterAll: () => unregisterAll,
-  unregisterFormTool: () => unregisterFormTool
-});
-function isWebMCPSupported() {
-  return typeof navigator !== "undefined" && typeof navigator.modelContext !== "undefined";
-}
-async function registerFormTool(form, metadata, execute) {
-  if (!isWebMCPSupported())
-    return;
-  const existing = registeredTools.get(form);
-  if (existing) {
-    await unregisterFormTool(form);
-  }
-  const toolDef = {
-    name: metadata.name,
-    description: metadata.description,
-    inputSchema: metadata.inputSchema,
-    execute
-  };
-  if (metadata.annotations && Object.keys(metadata.annotations).length > 0) {
-    toolDef.annotations = metadata.annotations;
-  }
-  try {
-    await navigator.modelContext.registerTool(toolDef);
-  } catch {
-    try {
-      await navigator.modelContext.unregisterTool(metadata.name);
-      await navigator.modelContext.registerTool(toolDef);
-    } catch {
-    }
-  }
-  registeredTools.set(form, metadata.name);
-}
-async function unregisterFormTool(form) {
-  if (!isWebMCPSupported())
-    return;
-  const name = registeredTools.get(form);
-  if (!name)
-    return;
-  try {
-    await navigator.modelContext.unregisterTool(name);
-  } catch {
-  }
-  registeredTools.delete(form);
-}
-function getRegisteredToolName(form) {
-  return registeredTools.get(form);
-}
-function getAllRegisteredTools() {
-  return Array.from(registeredTools.entries()).map(([form, name]) => ({ form, name }));
-}
-async function unregisterAll() {
-  const entries = Array.from(registeredTools.entries());
-  await Promise.all(entries.map(([form]) => unregisterFormTool(form)));
-}
-var registeredTools;
-var init_registry = __esm({
-  "src/registry.ts"() {
-    "use strict";
-    registeredTools = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -250,19 +177,19 @@ function mapSelectElement(select) {
   return { type: "string", enum: enumValues, oneOf };
 }
 function collectCheckboxEnum(form, name) {
-  return Array.from(
-    form.querySelectorAll(`input[type="checkbox"][name="${CSS.escape(name)}"]`)
+  return Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === "checkbox" && el.name === name
   ).map((cb) => cb.value).filter((v) => v !== "" && v !== "on");
 }
 function collectRadioEnum(form, name) {
-  const radios = Array.from(
-    form.querySelectorAll(`input[type="radio"][name="${CSS.escape(name)}"]`)
+  const radios = Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === "radio" && el.name === name
   );
   return radios.map((r) => r.value).filter((v) => v !== "");
 }
 function collectRadioOneOf(form, name) {
-  const radios = Array.from(
-    form.querySelectorAll(`input[type="radio"][name="${CSS.escape(name)}"]`)
+  const radios = Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === "radio" && el.name === name
   ).filter((r) => r.value !== "");
   return radios.map((r) => {
     const title = getRadioLabelText(r);
@@ -509,32 +436,39 @@ function collectShadowControls(root, visited = /* @__PURE__ */ new Set()) {
   const results = [];
   for (const el of Array.from(root.querySelectorAll("*"))) {
     if (el.shadowRoot) {
-      results.push(
-        ...Array.from(
-          el.shadowRoot.querySelectorAll(
-            "input, textarea, select"
-          )
-        ),
-        ...collectShadowControls(el.shadowRoot, visited)
+      const found = Array.from(
+        el.shadowRoot.querySelectorAll(
+          "input, textarea, select"
+        )
       );
+      if (found.length > 0) {
+        console.log(`[auto-webmcp] shadow: found ${found.length} control(s) in ${el.tagName.toLowerCase()} shadow root:`, found.map((f) => `${f.tagName.toLowerCase()}[type=${f.type ?? "?"}][name="${f.name}"][id="${f.id}"]`));
+      }
+      results.push(...found, ...collectShadowControls(el.shadowRoot, visited));
     }
   }
   return results;
 }
+function collectFormAssociatedControls(form) {
+  const controls = Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement
+  );
+  const seen = new Set(controls);
+  for (const shadowControl of collectShadowControls(form)) {
+    if (!seen.has(shadowControl)) {
+      controls.push(shadowControl);
+      seen.add(shadowControl);
+    }
+  }
+  return controls;
+}
 function buildSchema(form) {
   const properties = {};
   const required = [];
   const fieldElements = /* @__PURE__ */ new Map();
   const processedRadioGroups = /* @__PURE__ */ new Set();
   const processedCheckboxGroups = /* @__PURE__ */ new Set();
-  const controls = [
-    ...Array.from(
-      form.querySelectorAll(
-        "input, textarea, select"
-      )
-    ),
-    ...collectShadowControls(form)
-  ];
+  const controls = collectFormAssociatedControls(form);
   for (const control of controls) {
     const name = control.name;
     const fieldKey = name || resolveNativeControlFallbackKey(control);
@@ -567,8 +501,8 @@ function buildSchema(form) {
       const radioOneOf = collectRadioOneOf(form, fieldKey);
       if (radioOneOf.length > 0)
         schemaProp.oneOf = radioOneOf;
-      const checkedRadio = form.querySelector(
-        `input[type="radio"][name="${CSS.escape(fieldKey)}"]:checked`
+      const checkedRadio = Array.from(form.elements).find(
+        (el) => el instanceof HTMLInputElement && el.type === "radio" && el.name === fieldKey && el.checked
       );
       if (checkedRadio?.value)
         schemaProp.default = checkedRadio.value;
@@ -583,10 +517,8 @@ function buildSchema(form) {
         };
         if (schemaProp.description)
           arrayProp.description = schemaProp.description;
-        const checkedBoxes = Array.from(
-          form.querySelectorAll(
-            `input[type="checkbox"][name="${CSS.escape(fieldKey)}"]:checked`
-          )
+        const checkedBoxes = Array.from(form.elements).filter(
+          (el) => el instanceof HTMLInputElement && el.type === "checkbox" && el.name === fieldKey && el.checked
         ).map((b) => b.value);
         if (checkedBoxes.length > 0)
           arrayProp.default = checkedBoxes;
@@ -600,9 +532,23 @@ function buildSchema(form) {
     if (!name) {
       fieldElements.set(fieldKey, control);
     }
-    if (control.required) {
-      required.push(fieldKey);
+    let isRequired = control.required;
+    if (!isRequired) {
+      let hostNode = control;
+      while (true) {
+        const root = hostNode.getRootNode();
+        if (!(root instanceof ShadowRoot))
+          break;
+        const host = root.host;
+        if (host.hasAttribute("required") || host.getAttribute("aria-required") === "true") {
+          isRequired = true;
+          break;
+        }
+        hostNode = host;
+      }
     }
+    if (isRequired)
+      required.push(fieldKey);
   }
   const ariaControls = collectAriaControls(form);
   const processedAriaRadioGroups = /* @__PURE__ */ new Set();
@@ -645,11 +591,40 @@ function resolveNativeControlFallbackKey(control) {
   if ((control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement) && control.placeholder?.trim()) {
     return sanitizeName(control.placeholder.trim());
   }
+  const hostKey = resolveShadowHostKey(control);
+  if (hostKey)
+    return hostKey;
   if (control instanceof HTMLInputElement && control.type !== "text") {
     return control.type;
   }
   return null;
 }
+function resolveShadowHostKey(el) {
+  let node = el;
+  while (true) {
+    const root = node.getRootNode();
+    if (!(root instanceof ShadowRoot))
+      break;
+    const host = root.host;
+    const fieldName = host.getAttribute("field-name");
+    if (fieldName) {
+      console.log("[auto-webmcp] shadow host key: field-name=", fieldName);
+      return sanitizeName(fieldName);
+    }
+    const hostLabel = host.getAttribute("label") || host.getAttribute("aria-label");
+    if (hostLabel) {
+      console.log("[auto-webmcp] shadow host key: label=", hostLabel);
+      return sanitizeName(hostLabel);
+    }
+    const hostName = host.getAttribute("name");
+    if (hostName) {
+      console.log("[auto-webmcp] shadow host key: name=", hostName);
+      return sanitizeName(hostName);
+    }
+    node = host;
+  }
+  return null;
+}
 function resolveAriaElementKey(el) {
   if (el.dataset["webmcpName"])
     return sanitizeName(el.dataset["webmcpName"]);
@@ -811,12 +786,40 @@ function getAssociatedLabelText(control) {
         return text;
     }
   }
+  const ownRoot = control.getRootNode();
+  if (ownRoot instanceof ShadowRoot) {
+    if (control.id) {
+      const shadowLabel = ownRoot.querySelector(`label[for="${CSS.escape(control.id)}"]`);
+      if (shadowLabel) {
+        const text = labelTextWithoutNested(shadowLabel);
+        if (text)
+          return text;
+      }
+    }
+    const anyLabel = ownRoot.querySelector("label");
+    if (anyLabel) {
+      const text = labelTextWithoutNested(anyLabel);
+      if (text)
+        return text;
+    }
+  }
   const parent = control.closest("label");
   if (parent) {
     const text = labelTextWithoutNested(parent);
     if (text)
       return text;
   }
+  let node = control;
+  while (true) {
+    const root = node.getRootNode();
+    if (!(root instanceof ShadowRoot))
+      break;
+    const host = root.host;
+    const hostLabel = host.getAttribute("label") || host.getAttribute("aria-label");
+    if (hostLabel)
+      return hostLabel;
+    node = host;
+  }
   return "";
 }
 function labelTextWithoutNested(label) {
@@ -985,8 +988,68 @@ function buildSchemaFromInputs(inputs) {
   return { schema: { "$schema": "https://json-schema.org/draft/2020-12/schema", type: "object", properties, required }, fieldElements };
 }
 
-// src/discovery.ts
-init_registry();
+// src/registry.ts
+var registeredTools = /* @__PURE__ */ new Map();
+var registrationControllers = /* @__PURE__ */ new Map();
+function isWebMCPSupported() {
+  return typeof navigator !== "undefined" && typeof navigator.modelContext !== "undefined";
+}
+async function registerFormTool(form, metadata, execute) {
+  if (!isWebMCPSupported())
+    return;
+  const existing = registeredTools.get(form);
+  if (existing) {
+    await unregisterFormTool(form);
+  }
+  const toolDef = {
+    name: metadata.name,
+    description: metadata.description,
+    inputSchema: metadata.inputSchema,
+    execute
+  };
+  if (metadata.annotations && Object.keys(metadata.annotations).length > 0) {
+    toolDef.annotations = metadata.annotations;
+  }
+  const controller = new AbortController();
+  registrationControllers.set(form, controller);
+  try {
+    await navigator.modelContext.registerTool(toolDef, { signal: controller.signal });
+  } catch {
+    try {
+      await navigator.modelContext.unregisterTool?.(metadata.name);
+      await navigator.modelContext.registerTool(toolDef, { signal: controller.signal });
+    } catch {
+    }
+  }
+  registeredTools.set(form, metadata.name);
+}
+async function unregisterFormTool(form) {
+  if (!isWebMCPSupported())
+    return;
+  const name = registeredTools.get(form);
+  if (!name)
+    return;
+  const controller = registrationControllers.get(form);
+  if (controller) {
+    controller.abort();
+    registrationControllers.delete(form);
+  }
+  try {
+    await navigator.modelContext.unregisterTool?.(name);
+  } catch {
+  }
+  registeredTools.delete(form);
+}
+function getRegisteredToolName(form) {
+  return registeredTools.get(form);
+}
+function getAllRegisteredTools() {
+  return Array.from(registeredTools.entries()).map(([form, name]) => ({ form, name }));
+}
+async function unregisterAll() {
+  const entries = Array.from(registeredTools.entries());
+  await Promise.all(entries.map(([form]) => unregisterFormTool(form)));
+}
 
 // src/interceptor.ts
 var pendingExecutions = /* @__PURE__ */ new WeakMap();
@@ -1003,7 +1066,20 @@ function buildExecuteHandler(form, config, toolName, metadata) {
     formFieldElements.set(form, metadata.fieldElements);
   }
   attachSubmitInterceptor(form, toolName);
-  return async (params) => {
+  return async (params, client) => {
+    const modelContextClient = client;
+    if (config.autoSubmit && metadata?.annotations?.destructiveHint === true && typeof modelContextClient?.requestUserInteraction === "function") {
+      const approved = await modelContextClient.requestUserInteraction(async () => {
+        return new Promise((resolve) => {
+          const ok = window.confirm(`Agent requested a destructive action via "${toolName}". Continue?`);
+          resolve(ok);
+        });
+      });
+      if (!approved) {
+        window.dispatchEvent(new CustomEvent("toolcancel", { detail: { toolName } }));
+        return { content: [{ type: "text", text: `Cancelled "${toolName}" by user.` }] };
+      }
+    }
     pendingFillWarnings.set(form, []);
     pendingWarnings.delete(form);
     fillFormFields(form, params);
@@ -1140,7 +1216,23 @@ function findInShadowRoots(root, selector) {
   }
   return null;
 }
+function getAssociatedInputsByName(form, type, name) {
+  return Array.from(form.elements).filter(
+    (el) => el instanceof HTMLInputElement && el.type === type && el.name === name
+  );
+}
 function findNativeField(form, key) {
+  const named = form.elements.namedItem(key);
+  if (typeof named === "object" && named !== null && (named instanceof HTMLInputElement || named instanceof HTMLTextAreaElement || named instanceof HTMLSelectElement)) {
+    return named;
+  }
+  if (named instanceof RadioNodeList) {
+    const first = named[0];
+    const firstObj = first;
+    if (firstObj instanceof HTMLInputElement || firstObj instanceof HTMLTextAreaElement || firstObj instanceof HTMLSelectElement) {
+      return firstObj;
+    }
+  }
   const esc = CSS.escape(key);
   const light = form.querySelector(`[name="${esc}"]`) ?? form.querySelector(
     `input#${esc}, textarea#${esc}, select#${esc}`
@@ -1160,10 +1252,7 @@ function fillFormFields(form, params) {
         fillInput(input, form, key, value);
         if (input.type === "checkbox") {
           if (Array.isArray(value)) {
-            const esc = CSS.escape(key);
-            snapshot[key] = Array.from(
-              form.querySelectorAll(`input[type="checkbox"][name="${esc}"]`)
-            ).filter((b) => b.checked).map((b) => b.value);
+            snapshot[key] = getAssociatedInputsByName(form, "checkbox", key).filter((b) => b.checked).map((b) => b.value);
           } else {
             snapshot[key] = input.checked;
           }
@@ -1212,8 +1301,7 @@ function fillInput(input, form, key, value) {
   const type = input.type.toLowerCase();
   if (type === "checkbox") {
     if (Array.isArray(value)) {
-      const esc = CSS.escape(key);
-      const allBoxes = form.querySelectorAll(`input[type="checkbox"][name="${esc}"]`);
+      const allBoxes = getAssociatedInputsByName(form, "checkbox", key);
       for (const box of allBoxes) {
         setReactChecked(box, value.map(String).includes(box.value));
       }
@@ -1254,10 +1342,7 @@ function fillInput(input, form, key, value) {
     return;
   }
   if (type === "radio") {
-    const esc = CSS.escape(key);
-    const radios = form.querySelectorAll(
-      `input[type="radio"][name="${esc}"]`
-    );
+    const radios = getAssociatedInputsByName(form, "radio", key);
     for (const radio of radios) {
       if (radio.value === String(value)) {
         if (_checkedSetter) {
@@ -1516,6 +1601,51 @@ function getMissingRequired(metadata, params) {
     return [];
   return metadata.inputSchema.required.filter((fieldKey) => !(fieldKey in params));
 }
+async function fillComboboxButton(el, value) {
+  const text = String(value ?? "").trim();
+  console.log("[auto-webmcp] fillComboboxButton: clicking button, value=", JSON.stringify(text));
+  el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+  const listbox = await new Promise((resolve) => {
+    const deadline = Date.now() + 1e3;
+    const poll = () => {
+      const candidate = document.querySelector('[role="listbox"]') ?? document.querySelector('[role="option"]')?.closest('[role="listbox"]') ?? null;
+      if (candidate) {
+        resolve(candidate);
+        return;
+      }
+      if (Date.now() >= deadline) {
+        resolve(null);
+        return;
+      }
+      setTimeout(poll, 50);
+    };
+    poll();
+  });
+  if (!listbox) {
+    console.warn("[auto-webmcp] fillComboboxButton: listbox did not appear after 1s");
+    return;
+  }
+  const options = Array.from(listbox.querySelectorAll('[role="option"]'));
+  console.log("[auto-webmcp] fillComboboxButton: listbox has", options.length, "options");
+  const lowerValue = text.toLowerCase();
+  const match = options.find((opt) => {
+    const dataValue = (opt.getAttribute("data-value") ?? "").toLowerCase();
+    const ariaLabel = (opt.getAttribute("aria-label") ?? "").toLowerCase();
+    const optText = (opt.textContent ?? "").trim().toLowerCase();
+    return dataValue === lowerValue || ariaLabel === lowerValue || optText === lowerValue;
+  });
+  if (match) {
+    console.log("[auto-webmcp] fillComboboxButton: clicking option", match.textContent?.trim());
+    match.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+  } else {
+    console.warn(
+      "[auto-webmcp] fillComboboxButton: no option matched",
+      JSON.stringify(text),
+      "available:",
+      options.map((o) => o.textContent?.trim())
+    );
+  }
+}
 
 // src/discovery.ts
 function emit(type, form, toolName) {
@@ -1535,9 +1665,35 @@ function isExcluded(form, config) {
   }
   return false;
 }
+function withNumericSuffix(baseName, n) {
+  const suffix = `_${n}`;
+  return `${baseName.slice(0, Math.max(1, 64 - suffix.length))}${suffix}`;
+}
+function getUsedToolNames(excludeForm) {
+  const names = new Set(registeredOrphanToolNames);
+  for (const { form, name } of getAllRegisteredTools()) {
+    if (excludeForm && form === excludeForm)
+      continue;
+    names.add(name);
+  }
+  return names;
+}
+function ensureUniqueToolName(baseName, excludeForm) {
+  const used = getUsedToolNames(excludeForm);
+  if (!used.has(baseName))
+    return baseName;
+  let i = 2;
+  let candidate = withNumericSuffix(baseName, i);
+  while (used.has(candidate)) {
+    i++;
+    candidate = withNumericSuffix(baseName, i);
+  }
+  return candidate;
+}
 async function registerForm(form, config) {
   if (isExcluded(form, config))
     return;
+  const previousName = getRegisteredToolName(form);
   let override;
   for (const [selector, ovr] of Object.entries(config.overrides)) {
     try {
@@ -1549,6 +1705,11 @@ async function registerForm(form, config) {
     }
   }
   const metadata = analyzeForm(form, override);
+  const resolvedName = ensureUniqueToolName(metadata.name, form);
+  if (resolvedName !== metadata.name && config.debug) {
+    console.warn(`[auto-webmcp] tool name collision: "${metadata.name}" renamed to "${resolvedName}"`);
+  }
+  metadata.name = resolvedName;
   if (config.debug) {
     warnToolQuality(metadata.name, metadata.description);
   }
@@ -1560,6 +1721,9 @@ async function registerForm(form, config) {
     '[type="submit"], button[data-variant="primary"], button:not([type])'
   ) ?? null;
   const pendingBtns = window["__pendingSubmitBtns"] ??= {};
+  if (previousName && previousName !== metadata.name) {
+    delete pendingBtns[previousName];
+  }
   pendingBtns[metadata.name] = formSubmitBtn;
   if (config.debug) {
     console.log(`[auto-webmcp] Registered: ${metadata.name}`, metadata);
@@ -1567,12 +1731,14 @@ async function registerForm(form, config) {
   emit("form:registered", form, metadata.name);
 }
 async function unregisterForm(form, config) {
-  const { getRegisteredToolName: getRegisteredToolName2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  const name = getRegisteredToolName2(form);
+  const name = getRegisteredToolName(form);
   if (!name)
     return;
   await unregisterFormTool(form);
   registeredForms.delete(form);
+  const pendingBtns = window["__pendingSubmitBtns"];
+  if (pendingBtns)
+    delete pendingBtns[name];
   if (config.debug) {
     console.log(`[auto-webmcp] Unregistered: ${name}`);
   }
@@ -1583,6 +1749,17 @@ var registeredForms = /* @__PURE__ */ new WeakSet();
 var registeredFormCount = 0;
 var reAnalysisTimers = /* @__PURE__ */ new Map();
 var RE_ANALYSIS_DEBOUNCE_MS = 300;
+var orphanRescanTimer = null;
+var ORPHAN_RESCAN_DEBOUNCE_MS = 500;
+var registeredOrphanToolNames = /* @__PURE__ */ new Set();
+function scheduleOrphanRescan(config) {
+  if (orphanRescanTimer)
+    clearTimeout(orphanRescanTimer);
+  orphanRescanTimer = setTimeout(() => {
+    orphanRescanTimer = null;
+    void scanOrphanInputs(config);
+  }, ORPHAN_RESCAN_DEBOUNCE_MS);
+}
 function isInterestingNode(node) {
   const tag = node.tagName.toLowerCase();
   if (tag === "input" || tag === "textarea" || tag === "select")
@@ -1610,11 +1787,47 @@ function scheduleReAnalysis(form, config) {
     }, RE_ANALYSIS_DEBOUNCE_MS)
   );
 }
+function scheduleFormReAnalysisById(formId, config) {
+  const owner = document.getElementById(formId);
+  if (owner instanceof HTMLFormElement && registeredForms.has(owner)) {
+    scheduleReAnalysis(owner, config);
+  }
+}
+function resolveOwnerForm(el) {
+  const closest = el.closest("form");
+  if (closest instanceof HTMLFormElement)
+    return closest;
+  const explicitOwner = el.form;
+  if (explicitOwner instanceof HTMLFormElement)
+    return explicitOwner;
+  const formId = el.getAttribute("form");
+  if (formId) {
+    const byId = document.getElementById(formId);
+    if (byId instanceof HTMLFormElement)
+      return byId;
+  }
+  return null;
+}
 function startObserver(config) {
   if (observer)
     return;
   observer = new MutationObserver((mutations) => {
     for (const mutation of mutations) {
+      if (mutation.type === "attributes" && mutation.target instanceof Element) {
+        const target = mutation.target;
+        const ownerForm = resolveOwnerForm(target);
+        if (ownerForm && registeredForms.has(ownerForm)) {
+          scheduleReAnalysis(ownerForm, config);
+        } else if (target instanceof HTMLFormElement) {
+          void registerForm(target, config);
+        } else if (isInterestingNode(target) && !target.closest("form")) {
+          scheduleOrphanRescan(config);
+        }
+        if (mutation.attributeName === "form" && mutation.oldValue) {
+          scheduleFormReAnalysisById(mutation.oldValue, config);
+        }
+        continue;
+      }
       for (const node of mutation.addedNodes) {
         if (!(node instanceof Element))
           continue;
@@ -1629,6 +1842,9 @@ function startObserver(config) {
         for (const form of Array.from(node.querySelectorAll("form"))) {
           void registerForm(form, config);
         }
+        if (isInterestingNode(node) && !node.closest("form")) {
+          scheduleOrphanRescan(config);
+        }
       }
       for (const node of mutation.removedNodes) {
         if (!(node instanceof Element))
@@ -1640,7 +1856,12 @@ function startObserver(config) {
       }
     }
   });
-  observer.observe(document.body, { childList: true, subtree: true });
+  observer.observe(document.body, {
+    childList: true,
+    subtree: true,
+    attributes: true,
+    attributeOldValue: true
+  });
 }
 function listenForRouteChanges(config) {
   window.addEventListener("hashchange", () => scanForms(config));
@@ -1676,10 +1897,10 @@ async function scanOrphanInputs(config) {
     return;
   const SUBMIT_BTN_SELECTOR = '[type="submit"]:not([disabled]), button[data-variant="primary"]:not([disabled])';
   const SUBMIT_BTN_GROUPING_SELECTOR = '[type="submit"], button[data-variant="primary"]';
-  const SUBMIT_TEXT_RE = /subscribe|submit|sign[\s-]?up|send|join|go|search|post|tweet|publish/i;
+  const SUBMIT_TEXT_RE = /subscribe|submit|sign[\s-]?up|send|join|go|search|post|tweet|publish|save/i;
   const orphanInputs = Array.from(
     document.querySelectorAll(
-      'input:not(form input), textarea:not(form textarea), select:not(form select), [role="textbox"]:not(form [role="textbox"]):not(input):not(textarea), [role="searchbox"]:not(form [role="searchbox"]):not(input):not(textarea), [contenteditable="true"]:not(form [contenteditable="true"]):not(input):not(textarea)'
+      'input:not(form input), textarea:not(form textarea), select:not(form select), [role="textbox"]:not(form [role="textbox"]):not(input):not(textarea), [role="searchbox"]:not(form [role="searchbox"]):not(input):not(textarea), [contenteditable="true"]:not(form [contenteditable="true"]):not(input):not(textarea), button[role="combobox"]:not(form button[role="combobox"])'
     )
   ).filter((el) => {
     if (el instanceof HTMLInputElement && ORPHAN_EXCLUDED_TYPES.has(el.type.toLowerCase())) {
@@ -1784,6 +2005,15 @@ async function scanOrphanInputs(config) {
     }
     console.log(`[auto-webmcp] orphan: submit button for group:`, submitBtn ? `"${submitBtn.textContent?.trim()}" disabled=${submitBtn.disabled}` : "none");
     const metadata = analyzeOrphanInputGroup(container, inputs, submitBtn);
+    if (registeredOrphanToolNames.has(metadata.name)) {
+      console.log(`[auto-webmcp] orphan: "${metadata.name}" already registered, skipping`);
+      continue;
+    }
+    const orphanName = ensureUniqueToolName(metadata.name);
+    if (orphanName !== metadata.name && config.debug) {
+      console.warn(`[auto-webmcp] orphan tool name collision: "${metadata.name}" renamed to "${orphanName}"`);
+    }
+    metadata.name = orphanName;
     console.log(`[auto-webmcp] orphan: tool="${metadata.name}" schema keys:`, Object.keys(metadata.inputSchema.properties));
     const inputPairs = [];
     const schemaProps = metadata.inputSchema.properties;
@@ -1804,13 +2034,17 @@ async function scanOrphanInputs(config) {
       continue;
     }
     const toolName = metadata.name;
-    const execute = async (params) => {
+    const execute = async (params, _client) => {
       console.log(`[auto-webmcp] orphan execute: tool="${toolName}" params=`, params);
       console.log(`[auto-webmcp] orphan execute: inputPairs=`, inputPairs.map((p) => p.key));
       for (const { key, el } of inputPairs) {
         if (params[key] !== void 0) {
           console.log(`[auto-webmcp] orphan execute: filling key="${key}" value=`, params[key], "element=", el);
-          fillElement(el, params[key]);
+          if (el.getAttribute("role") === "combobox" && el.tagName.toLowerCase() === "button") {
+            await fillComboboxButton(el, params[key]);
+          } else {
+            fillElement(el, params[key]);
+          }
           console.log(`[auto-webmcp] orphan execute: after fill, element value=`, el.value);
         } else {
           console.log(`[auto-webmcp] orphan execute: key="${key}" not in params, skipping`);
@@ -1822,22 +2056,43 @@ async function scanOrphanInputs(config) {
         console.log(`[auto-webmcp] orphan execute: autoSubmit=false, returning without clicking submit`);
         return { content: [{ type: "text", text: "Fields filled. Ready to submit." }] };
       }
-      console.log(`[auto-webmcp] orphan execute: polling for enabled submit button (up to 2s)...`);
+      console.log(`[auto-webmcp] orphan execute: resolving submit button (up to 2s)...`);
       let btn = null;
-      const deadline = Date.now() + 2e3;
-      while (Date.now() < deadline) {
-        const candidates = Array.from(
-          container.querySelectorAll(SUBMIT_BTN_SELECTOR)
+      if (submitBtn && document.contains(submitBtn)) {
+        const isEnabled = !submitBtn.disabled && submitBtn.getAttribute("aria-disabled") !== "true";
+        const r = submitBtn.getBoundingClientRect();
+        if (isEnabled && r.width > 0 && r.height > 0) {
+          btn = submitBtn;
+          console.log(`[auto-webmcp] orphan execute: using captured submit button "${btn.textContent?.trim()}"`);
+        }
+      }
+      if (!btn) {
+        const deadline = Date.now() + 2e3;
+        while (Date.now() < deadline) {
+          const candidates = Array.from(
+            container.querySelectorAll(SUBMIT_BTN_SELECTOR)
+          ).filter((b) => {
+            const r = b.getBoundingClientRect();
+            return r.width > 0 && r.height > 0;
+          });
+          const last = candidates[candidates.length - 1] ?? null;
+          if (last) {
+            btn = last;
+            break;
+          }
+          await new Promise((r) => setTimeout(r, 100));
+        }
+      }
+      if (!btn) {
+        const textBtns = Array.from(
+          (container !== document.body ? container : document).querySelectorAll('button, [role="button"]')
         ).filter((b) => {
           const r = b.getBoundingClientRect();
-          return r.width > 0 && r.height > 0;
+          return r.width > 0 && r.height > 0 && !b.disabled && b.getAttribute("aria-disabled") !== "true" && SUBMIT_TEXT_RE.test(b.textContent ?? "");
         });
-        const last = candidates[candidates.length - 1] ?? null;
-        if (last) {
-          btn = last;
-          break;
-        }
-        await new Promise((r) => setTimeout(r, 100));
+        btn = textBtns[textBtns.length - 1] ?? null;
+        if (btn)
+          console.log(`[auto-webmcp] orphan execute: using text-matched fallback button "${btn.textContent?.trim()}"`);
       }
       if (!btn) {
         console.warn(`[auto-webmcp] orphan execute: submit button still disabled after 2s`);
@@ -1858,6 +2113,7 @@ async function scanOrphanInputs(config) {
         toolDef.annotations = metadata.annotations;
       }
       await navigator.modelContext.registerTool(toolDef);
+      registeredOrphanToolNames.add(metadata.name);
       const pendingBtns = window["__pendingSubmitBtns"] ??= {};
       pendingBtns[metadata.name] = submitBtn;
       if (config.debug) {
@@ -1885,6 +2141,7 @@ async function startDiscovery(config) {
     );
   }
   registeredFormCount = 0;
+  registeredOrphanToolNames.clear();
   startObserver(config);
   listenForRouteChanges(config);
   await scanForms(config);
@@ -1896,7 +2153,6 @@ function stopDiscovery() {
 }
 
 // src/index.ts
-init_registry();
 async function autoWebMCP(config) {
   const resolved = resolveConfig(config);
   if (resolved.debug) {