@ggui-ai/ui-gen 0.9.0 → 0.10.0

package/dist/harness/check/runtime-render/index.d.ts

@@ -1,9 +1,9 @@
-export { R as RenderCheckIssue, a as RenderCheckResult, r as runRenderCheck } from '../../../render-check-CNZjHD5g.js';
+export { R as RenderCheckIssue, a as RenderCheckResult, r as runRenderCheck } from '../../../render-check-BNYGVDJd.js';
 import { WireConfig } from '@ggui-ai/wire';
 import { JsonObject, DataContract } from '@ggui-ai/protocol';
 import { RuntimeRenderCheck } from '../../types-public.js';
 import '../../../axes-CzLEMDeB.js';
-import '../../../types-public-C36k1q6s.js';
+import '../../../types-public-DIpjC-OA.js';
 import '../../../types-BOvHNG7K.js';
 import '../../../llm.js';
 import '../../../policy.js';

package/dist/harness/check/runtime-render/index.js

@@ -1,7 +1,49 @@
+import { createRequire } from 'module';
 import { listContractGadgets, HOOK_NAME_RE } from '@ggui-ai/protocol';
 import ts from 'typescript';
 
-// src/harness/check/runtime-render/render-check.ts
+// src/harness/check/runtime-render/production-act-shim.ts
+var installed = false;
+function installProductionActShim() {
+  if (installed) return;
+  installed = true;
+  const require_ = createRequire(import.meta.url);
+  let reactCjs;
+  try {
+    reactCjs = require_("react");
+  } catch {
+    return;
+  }
+  if (typeof reactCjs.act === "function") {
+    return;
+  }
+  try {
+    const testUtils = require_("react-dom/test-utils");
+    const reactDom = require_("react-dom");
+    testUtils.act = createFlushSyncAct(reactDom.flushSync);
+  } catch {
+  }
+}
+function createFlushSyncAct(flushSync) {
+  return (callback) => {
+    let callbackResult;
+    flushSync(() => {
+      callbackResult = callback();
+    });
+    if (isThenable(callbackResult)) {
+      const pending = callbackResult;
+      return new Promise((resolve, reject) => {
+        pending.then(() => resolve(), reject);
+      });
+    }
+    return new Promise((resolve) => {
+      queueMicrotask(resolve);
+    });
+  };
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
 
 // src/harness/check/runtime-render/probe.ts
 function makeInternals() {
@@ -163,8 +205,8 @@ ${cjsResult.code}
 // src/harness/check/runtime-render/load-component.ts
 async function loadComponent(input) {
   const { sourceCode, moduleResolutions = {} } = input;
-  const { createRequire } = await import('module');
-  const require_ = createRequire(import.meta.url);
+  const { createRequire: createRequire2 } = await import('module');
+  const require_ = createRequire2(import.meta.url);
   const sandboxRequire = (id) => {
     if (id in moduleResolutions) return moduleResolutions[id];
     if (id === "react/jsx-runtime" || id === "react/jsx-dev-runtime") {
@@ -537,6 +579,7 @@ async function runRenderCheck(input) {
     const probe = createProbe();
     const wireConfig = createProbeWireConfig(probe);
     uninstallSpy = probe.installPostMessageSpy();
+    installProductionActShim();
     const { render, cleanup } = await import('@testing-library/react');
     const userEventModule = await import('@testing-library/user-event');
     const userEvent = userEventModule.default ?? userEventModule;
@@ -692,6 +735,50 @@ async function runRenderCheck(input) {
           if (issue) issues.push(issue);
         }
       }
+      const declaredProps = input.contract?.propsSpec?.properties;
+      if (declaredProps) {
+        const optionalFilled = Object.entries(declaredProps).filter(
+          ([name, entry]) => entry.required !== true && input.mockupProps[name] !== void 0
+        ).map(([name]) => name);
+        if (optionalFilled.length > 0) {
+          const requiredOnlyProps = { ...input.mockupProps };
+          for (const name of optionalFilled) delete requiredOnlyProps[name];
+          const omitBoundaryRef = {};
+          class OmitErrorBoundary extends React.Component {
+            state = { caught: false };
+            static getDerivedStateFromError() {
+              return { caught: true };
+            }
+            componentDidCatch(error) {
+              omitBoundaryRef.error ??= error;
+            }
+            render() {
+              if (this.state.caught) return null;
+              return this.props.children;
+            }
+          }
+          try {
+            render(
+              React.createElement(GguiWireProvider, {
+                config: wireConfig,
+                children: React.createElement(OmitErrorBoundary, {
+                  children: React.createElement(Component, requiredOnlyProps)
+                })
+              })
+            );
+          } catch (e) {
+            omitBoundaryRef.error ??= e instanceof Error ? e : new Error(String(e));
+          }
+          if (omitBoundaryRef.error) {
+            issues.push({
+              check: "optional-props-omitted",
+              outcome: "failed",
+              subject: optionalFilled.join(", "),
+              reason: `Render crashed when the optional prop(s) ${optionalFilled.map((n) => `'${n}'`).join(", ")} were omitted: ${omitBoundaryRef.error.message}. The contract marks them optional (no \`required: true\`), so a legitimate render may leave them out.`
+            });
+          }
+        }
+      }
     } finally {
       cleanup();
     }
@@ -1263,6 +1350,15 @@ function synthesizeFromSchema(schema, hint, warnings, depth) {
   if (schema.anyOf && schema.anyOf.length > 0) {
     return synthesizeFromSchema(schema.anyOf[0], hint, warnings, depth + 1);
   }
+  if (Array.isArray(schema.type)) {
+    const primary = schema.type.find((t) => t !== "null") ?? "null";
+    return synthesizeFromSchema(
+      { ...schema, type: primary },
+      hint,
+      warnings,
+      depth + 1
+    );
+  }
   switch (schema.type) {
     case "string": {
       switch (schema.format) {
@@ -1433,6 +1529,16 @@ function toEvalIssue(issue) {
         description: `Component crashed at runtime: ${issue.reason}`,
         fix: classifyRenderCrashFix(issue.reason)
       };
+    case "optional-props-omitted":
+      return {
+        tier: 0,
+        result,
+        category: "crash",
+        subcategory,
+        severity: "critical",
+        description: `Component crashed when optional props were omitted: ${issue.reason}`,
+        fix: `Guard every optional prop before member access (props.${subject.split(",")[0]?.trim() ?? "x"}?.map(...), a default via destructuring, or an early empty-state return). Optional props (no \`required: true\` in the contract) may be absent at runtime even though the harness fills them.`
+      };
     case "action-wiring": {
       const fix = issue.outcome === "unverified" ? `Source shows the action callback flowing into a non-native or custom-component prop. If wiring is intentional (e.g., Dropdown.onChange, drag-drop), this warn is informational \u2014 manual/browser verification is required to confirm. Otherwise wire to a native onClick={() => ${subject}(payload)} on <button> or design-system <Button>.` : `Wire ${subject}() to a native event prop. Common fix: <Button onClick={() => ${subject}(payload)}>Label</Button>. Source-AST analysis didn't find this wiring in your JSX.`;
       return {
@@ -1479,6 +1585,7 @@ async function warmupRuntimeRenderProbe() {
       missing += 1;
     }
   };
+  installProductionActShim();
   await Promise.all([
     tryLoad("happy-dom"),
     tryLoad("@testing-library/react"),