@ggui-ai/ui-gen 0.11.0 → 0.13.0

package/dist/blueprint-validator.js

@@ -871,6 +871,22 @@ async function runRenderCheckInProcess(input) {
           if (issue) issues.push(issue);
         }
       }
+      if (input.contract?.actionSpec) {
+        for (const [name, entry] of Object.entries(input.contract.actionSpec)) {
+          const idField = idLikeRequiredStringField(
+            entry.schema
+          );
+          if (idField === null) continue;
+          const issue = await checkSelectionIdentity({
+            container,
+            probe,
+            user,
+            actionName: name,
+            idField
+          });
+          if (issue) issues.push(issue);
+        }
+      }
       if (input.contract?.propsSpec) {
         for (const issue of checkPropCoverage({
           container,
@@ -880,6 +896,48 @@ async function runRenderCheckInProcess(input) {
           issues.push(issue);
         }
       }
+      if (input.contract?.propsSpec) {
+        const propsSpec5c = input.contract.propsSpec;
+        const normalize = (s) => (s ?? "").replace(/\s+/g, " ").trim();
+        const baseText = normalize(container.textContent);
+        for (const [propName, entry] of Object.entries(propsSpec5c.properties)) {
+          if (!entry.required) continue;
+          const orig = input.mockupProps[propName];
+          if (typeof orig !== "string" && typeof orig !== "number") continue;
+          const marker = pickScalarMarker(orig);
+          if (marker === null || !baseText.includes(marker)) continue;
+          const varied = typeof orig === "string" ? "Zzyzx Qw" : orig + 137731;
+          const variedProbe = createProbe();
+          const variedConfig = createProbeWireConfig(variedProbe);
+          let variedResult;
+          try {
+            variedResult = render(
+              React.createElement(GguiWireProvider, {
+                config: variedConfig,
+                children: React.createElement(ProbeErrorBoundary, {
+                  children: React.createElement(Component, {
+                    ...input.mockupProps,
+                    [propName]: varied
+                  })
+                })
+              })
+            );
+          } catch {
+            continue;
+          }
+          await flushPromises();
+          const variedText = normalize(variedResult.container.textContent);
+          variedResult.unmount();
+          if (variedText === baseText) {
+            issues.push({
+              check: "prop-sensitivity",
+              outcome: "failed",
+              subject: propName,
+              reason: `props.${propName} is displayed ('${marker}' appears in the DOM) but changing its value to '${String(varied)}' left the rendered output BYTE-IDENTICAL \u2014 the value is baked into the component instead of derived from the prop. A cached reuse of this blueprint under a different ${propName} would show the original value.`
+            });
+          }
+        }
+      }
       if (input.contract?.streamSpec) {
         const streamSpec = input.contract.streamSpec;
         for (const [name] of Object.entries(streamSpec)) {
@@ -1211,6 +1269,74 @@ async function checkActionWiring(input) {
     }
   };
 }
+function idLikeRequiredStringField(schema) {
+  if (schema === void 0) return null;
+  const properties = schema["properties"];
+  const required = schema["required"];
+  if (properties === null || typeof properties !== "object") return null;
+  if (!Array.isArray(required)) return null;
+  for (const [propName, propSchema] of Object.entries(
+    properties
+  )) {
+    if (!/id$/i.test(propName)) continue;
+    if (!required.includes(propName)) continue;
+    const t = propSchema !== null && typeof propSchema === "object" ? propSchema["type"] : void 0;
+    if (t === "string") return propName;
+  }
+  return null;
+}
+async function checkSelectionIdentity(input) {
+  const { container, probe, user, actionName, idField } = input;
+  const clickables = Array.from(
+    container.querySelectorAll('button, [role="button"]')
+  );
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const el of clickables) {
+    const label = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+    if (label.length === 0) continue;
+    const group = byLabel.get(label);
+    if (group) group.push(el);
+    else byLabel.set(label, [el]);
+  }
+  for (const [label, group] of byLabel) {
+    if (group.length < 2) continue;
+    const payloadFor = async (el) => {
+      const before = probe.getFireLog().length;
+      try {
+        await user.click(el);
+      } catch {
+        return void 0;
+      }
+      await flushPromises();
+      const events = probe.getFireLog().slice(before).filter(
+        (e) => e.kind === "action.fired" && e.name === actionName
+      );
+      return events.length > 0 ? events[events.length - 1].payload : void 0;
+    };
+    const first = await payloadFor(group[0]);
+    const second = await payloadFor(group[1]);
+    if (first === void 0 || second === void 0) continue;
+    const idOf = (payload) => {
+      if (payload === null || typeof payload !== "object") return void 0;
+      const v = payload[idField];
+      return typeof v === "string" ? v : void 0;
+    };
+    const firstId = idOf(first);
+    const secondId = idOf(second);
+    if (firstId === void 0 || secondId === void 0) continue;
+    if (firstId === secondId) {
+      return {
+        check: "selection-identity",
+        outcome: "failed",
+        subject: actionName,
+        reason: `Two clickable elements share the visible label '${label}', and clicking EACH fired '${actionName}' with the same ${idField} ('${firstId}') \u2014 the action payload is keyed on the display value, not the element's identity. Distinct cells must send their own ${idField} (the contract requires it), or selecting one "${label}" acts on every "${label}".`,
+        elementHint: describeElement(group[0])
+      };
+    }
+    return null;
+  }
+  return null;
+}
 async function simulateAndCheck(input) {
   const { container, user, probe, wiringKind, actionName, actionLabel, eventKind } = input;
   const candidates = findCandidateElements(container, wiringKind, actionName, actionLabel);
@@ -1694,6 +1820,26 @@ function toEvalIssue(issue) {
         fix
       };
     }
+    case "selection-identity":
+      return {
+        tier: 0,
+        result,
+        category: "contract",
+        subcategory,
+        severity: "critical",
+        description: `${issue.reason}${elementHint}${diagSuffix}`,
+        fix: `Key the action payload (and any selection state) on the item's ID from the data, never on its display text. Common fix: map over items and pass the item's id into the handler \u2014 onClick={() => ${subject}({ ...payload, id: item.id })} \u2014 and store selection as the id (setSelected(item.id)), not the label.`
+      };
+    case "prop-sensitivity":
+      return {
+        tier: 0,
+        result,
+        category: "contract",
+        subcategory,
+        severity: "critical",
+        description: `${issue.reason}${diagSuffix}`,
+        fix: `Derive the display AND any logic from props.${subject} \u2014 render {props.${subject}} and branch on the prop's value, never on the literal value the request happened to mention (e.g. props.${subject} ?? 'January' followed by January-special-cased logic bakes the request into the component). The contract delivers the value; trust it.`
+      };
     case "prop-coverage":
       return {
         tier: 0,