@ggui-ai/ui-gen 0.9.0 → 0.11.0

package/dist/blueprint-validator.js

@@ -1,7 +1,199 @@
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { runSandboxed } from '@ggui-ai/sandbox';
 import { listContractGadgets, HOOK_NAME_RE } from '@ggui-ai/protocol';
 import ts from 'typescript';
 
-// src/harness/check/runtime-render/render-check.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/harness/check/runtime-render/render-check-host.ts
+var render_check_host_exports = {};
+__export(render_check_host_exports, {
+  mapSandboxResultToCheckResult: () => mapSandboxResultToCheckResult,
+  runRenderCheckViaWorker: () => runRenderCheckViaWorker
+});
+function resolveWorkerSpawn() {
+  const jsCandidates = [
+    // Sibling — when import.meta.url is already .../harness/check/runtime-render/.
+    new URL(`./${WORKER_BASENAME}.js`, import.meta.url),
+    // From dist/index.js.
+    new URL(`./harness/check/runtime-render/${WORKER_BASENAME}.js`, import.meta.url),
+    // From dist/harness/index.js.
+    new URL(`./check/runtime-render/${WORKER_BASENAME}.js`, import.meta.url),
+    // From dist/check/index.js, dist/advanced/index.js, dist/<flat>.js.
+    new URL(`../harness/check/runtime-render/${WORKER_BASENAME}.js`, import.meta.url)
+  ];
+  for (const jsUrl of jsCandidates) {
+    const jsPath = fileURLToPath(jsUrl);
+    if (existsSync(jsPath)) {
+      return { command: process.execPath, args: [jsPath] };
+    }
+  }
+  const tsCandidates = [
+    new URL(`./${WORKER_BASENAME}.ts`, import.meta.url),
+    new URL(`../harness/check/runtime-render/${WORKER_BASENAME}.ts`, import.meta.url)
+  ];
+  for (const tsUrl of tsCandidates) {
+    const tsPath = fileURLToPath(tsUrl);
+    if (existsSync(tsPath)) {
+      const require_ = createRequire(import.meta.url);
+      const tsxLoader = pathToFileURL(require_.resolve("tsx")).href;
+      return { command: process.execPath, args: ["--import", tsxLoader, tsPath] };
+    }
+  }
+  const tried = [...jsCandidates, ...tsCandidates].map((u) => fileURLToPath(u)).join(", ");
+  throw new Error(
+    `render-check: isolated worker not found at any of: ${tried}. Did \`pnpm build\` run?`
+  );
+}
+function failed(reason, t0) {
+  return {
+    ok: false,
+    issues: [{ check: "render-no-throw", outcome: "failed", reason }],
+    stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
+  };
+}
+function unverified(reason, t0) {
+  return {
+    ok: false,
+    issues: [{ check: "render-no-throw", outcome: "unverified", reason }],
+    stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
+  };
+}
+function mapSandboxResultToCheckResult(result, t0) {
+  if (result.outcome === "timeout") {
+    return failed(
+      `render check timed out after ${CHECK_TIMEOUT_MS}ms in the isolated worker (likely infinite loop or runaway effect in the component).`,
+      t0
+    );
+  }
+  if (result.outcome === "overflow-stdout" || result.outcome === "overflow-stderr") {
+    return failed(
+      `render check worker produced excessive output (${result.outcome}) \u2014 the component is likely in a pathological logging or error loop.`,
+      t0
+    );
+  }
+  if (result.outcome === "spawn-error") {
+    return unverified(
+      `render check worker failed to start \u2014 ${result.errorMessage}`,
+      t0
+    );
+  }
+  if (result.outcome === "canceled") {
+    return unverified("render check worker was canceled before completing.", t0);
+  }
+  if (result.outcome !== "exit") {
+    return unverified(
+      `render check worker ended with unexpected sandbox outcome '${result.outcome}'.`,
+      t0
+    );
+  }
+  if (result.exitCode !== 0) {
+    const tail = result.stderr.trim() || result.stdout.trim();
+    return unverified(
+      `render check worker exited ${result.exitCode}${tail ? ` \u2014 ${tail.slice(0, 600)}` : ""}`,
+      t0
+    );
+  }
+  const stdout = result.stdout.trim();
+  if (stdout.length === 0) {
+    return unverified("render check worker exited without producing a verdict.", t0);
+  }
+  try {
+    return JSON.parse(stdout);
+  } catch (err) {
+    return unverified(
+      `render check worker verdict was not valid JSON \u2014 ${err instanceof Error ? err.message : String(err)}`,
+      t0
+    );
+  }
+}
+async function runRenderCheckViaWorker(input) {
+  const t0 = Date.now();
+  let spawn;
+  try {
+    spawn = resolveWorkerSpawn();
+  } catch (err) {
+    return unverified(err instanceof Error ? err.message : String(err), t0);
+  }
+  const result = await runSandboxed({
+    command: spawn.command,
+    args: spawn.args,
+    timeoutMs: CHECK_TIMEOUT_MS,
+    maxStdoutBytes: CHECK_STDOUT_CAP,
+    nodeHeapMb: CHECK_NODE_HEAP_MB,
+    stdin: JSON.stringify(input),
+    // NODE_ENV steers React's production vs development build — keep
+    // parity with the caller; everything else stays on the sandbox's
+    // default allowlist.
+    env: { NODE_ENV: process.env.NODE_ENV ?? "production" }
+  });
+  return mapSandboxResultToCheckResult(result, t0);
+}
+var CHECK_TIMEOUT_MS, CHECK_STDOUT_CAP, CHECK_NODE_HEAP_MB, WORKER_BASENAME;
+var init_render_check_host = __esm({
+  "src/harness/check/runtime-render/render-check-host.ts"() {
+    CHECK_TIMEOUT_MS = 3e4;
+    CHECK_STDOUT_CAP = 2 * 1024 * 1024;
+    CHECK_NODE_HEAP_MB = 512;
+    WORKER_BASENAME = "render-check-worker";
+  }
+});
+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 +355,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: createRequire3 } = await import('module');
+  const require_ = createRequire3(import.meta.url);
   const sandboxRequire = (id) => {
     if (id in moduleResolutions) return moduleResolutions[id];
     if (id === "react/jsx-runtime" || id === "react/jsx-dev-runtime") {
@@ -482,6 +674,14 @@ function parentLink(node) {
 
 // src/harness/check/runtime-render/render-check.ts
 async function runRenderCheck(input) {
+  const g = hostGlobals();
+  if ("window" in g && "document" in g) {
+    return runRenderCheckInProcess(input);
+  }
+  const { runRenderCheckViaWorker: runRenderCheckViaWorker2 } = await Promise.resolve().then(() => (init_render_check_host(), render_check_host_exports));
+  return runRenderCheckViaWorker2(input);
+}
+async function runRenderCheckInProcess(input) {
   const t0 = Date.now();
   const issues = [];
   const teardown = await setupHappyDom();
@@ -537,6 +737,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 +893,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 +1508,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) {
@@ -1418,6 +1672,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 {