nodality 1.3.0 → 1.3.2

package/lib/webmcp-adapter.js

@@ -1,5 +1,5 @@
 /*!
- * nodality v1.3.0
+ * nodality v1.3.2
  * (c) 2026 Filip Vabrousek
  * License: MIT
  */
@@ -279,18 +279,83 @@ export function installAgentSurface({ mount, elements, nodes, morphs }) {
                 return refuse("MISSING_REQUIRED", missing, Object.keys(props));
             }
 
-            const filled = [];
+            // Setting a control is not the same as the control TAKING the
+            // value, and the difference used to be invisible. Assigning a
+            // `<select>` a value it has no option for leaves it untouched and
+            // throws nothing; the old loop pushed the key onto `filled`
+            // regardless, so the tool answered `ok: true, filled: [... "topic"]`
+            // for a field that never reached the payload. An agent was told
+            // its submission carried something it did not.
+            //
+            // So every field is READ BACK after it is set, and what a control
+            // refused is reported rather than counted as done.
+            const filled = [], rejected = [], absent = [];
+
+            /** The values a control will actually accept, where it is a closed set. */
+            const accepts = (field) => field.tagName === "SELECT"
+                ? [...field.options].map((o) => o.value) : [];
+
             for (const key of Object.keys(props)) {
                 if (args[key] === undefined) continue;
+                const want = args[key];
                 const field = form.querySelector(
                     `[name="${key}"], #${CSS.escape(key)}`);
-                if (!field) continue;
-                if (field.type === "checkbox") field.checked = !!args[key];
-                else field.value = String(args[key]);
+                // Named by the schema and carried by nothing. Also silent
+                // before, and the same lie by omission.
+                if (!field) { absent.push(key); continue; }
+
+                if (field.type === "checkbox") {
+                    field.checked = !!want;
+                } else if (field.type === "radio") {
+                    // A group, not a field: `querySelector` returns the FIRST
+                    // radio, and assigning `.value` to it rewrites that
+                    // button's value instead of choosing the one asked for —
+                    // which then reads back as a match and reports success
+                    // while nothing is selected.
+                    const group = [...form.querySelectorAll(`[name="${key}"]`)];
+                    const hit = group.find((r) => r.value === String(want));
+                    if (hit) hit.checked = true;
+                    else {
+                        rejected.push({ field: key, got: null,
+                            valid: group.map((r) => r.value) });
+                        continue;
+                    }
+                } else {
+                    field.value = String(want);
+                }
                 // Both, because component state may listen for either.
                 field.dispatchEvent(new Event("input", { bubbles: true }));
                 field.dispatchEvent(new Event("change", { bubbles: true }));
-                filled.push(key);
+
+                const got = field.type === "checkbox" ? field.checked
+                    : field.type === "radio" ? String(want) : field.value;
+                const took = field.type === "checkbox"
+                    ? (!!want === got) : (String(want) === got);
+                if (took) filled.push(key);
+                else rejected.push({ field: key, got, valid: accepts(field) });
+            }
+
+            // Nothing is submitted when a field did not take. A partial
+            // payload sent under `ok: true` is the failure this whole
+            // architecture exists to remove, and it is worse on the agent
+            // path than anywhere else: the caller has no eyes on the page and
+            // no reason to doubt the report. The refusal names the field and,
+            // where the control has a closed set, what it would have accepted
+            // — repairable in one turn.
+            if (rejected.length || absent.length) {
+                return {
+                    ...refuse("FIELD_NOT_SET",
+                        [...rejected.map((r) => r.field), ...absent],
+                        [...rejected.map((r) => r.valid.length
+                            ? `"${r.field}" accepts ${r.valid.map((v) => JSON.stringify(v)).join(", ")}`
+                            : `"${r.field}" did not take the value given`),
+                         ...absent.map((k) =>
+                            `"${k}" is named by the schema but no control in the form carries it`)]),
+                    // What DID land, because the form is now partly filled and
+                    // a caller retrying needs to know that.
+                    filled,
+                    submitted: null,
+                };
             }
 
             // Submitted through the form's OWN path, so its listeners,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodality",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "A lightweight library for declarative UI elements.",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",