@ggui-ai/ui-gen 0.10.0 → 0.11.0

package/dist/advanced/index.d.ts

@@ -2,7 +2,7 @@ import { GeneratorTier, UiGenerator } from '@ggui-ai/mcp-server-core';
 import { JsonObject } from '@ggui-ai/protocol';
 import { BehaviorFailure, PlaywrightModule } from '@ggui-ai/ui-visual-tester';
 import { C as CreateUiGeneratorOptions } from '../create-ui-generator-CF0EL0Li.js';
-import { R as RenderCheckIssue } from '../render-check-BNYGVDJd.js';
+import { R as RenderCheckIssue } from '../render-check-BZoIE8-u.js';
 import '@ggui-ai/gadgets';
 import '../types-public-DIpjC-OA.js';
 import '../axes-CzLEMDeB.js';

package/dist/advanced/index.js

@@ -3,22 +3,22 @@ import * as esbuild2 from 'esbuild';
 import { build } from 'esbuild';
 import Anthropic from '@anthropic-ai/sdk';
 import { classifyUi, MODEL_REGISTRY, DANGEROUS_PATTERNS as DANGEROUS_PATTERNS$1, listContractGadgets, HOOK_NAME_RE, STDLIB_GADGETS_PACKAGE, resolveAppGadgets } from '@ggui-ai/protocol';
-import fs, { mkdirSync, writeFileSync, unlinkSync, readFileSync, existsSync, rm, createReadStream, createWriteStream } from 'fs';
+import fs, { mkdirSync, writeFileSync, unlinkSync, existsSync, readFileSync, rm, createReadStream, createWriteStream } from 'fs';
 import { contentHash } from '@ggui-ai/protocol/content-hash';
 import ts7 from 'typescript';
 import path, { dirname, resolve, join, basename } from 'path';
 import { createRequire } from 'module';
 import { Linter } from 'eslint';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { runSandboxed } from '@ggui-ai/sandbox';
 import { createHash } from 'crypto';
 import 'fs/promises';
 import { tmpdir } from 'os';
 import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
 import { createBrotliDecompress, createUnzip } from 'zlib';
-import { fileURLToPath, pathToFileURL } from 'url';
 import { PlaywrightNotAvailableError, validateContractBehavior } from '@ggui-ai/ui-visual-tester';
 import { parseGeneratorSlug, formatGeneratorSlug, isValidGeneratorSlug } from '@ggui-ai/mcp-server-core';
-import { runSandboxed } from '@ggui-ai/sandbox';
 import git from 'isomorphic-git';
 import { Volume, createFsFromVolume } from 'memfs';
 import { createPatch, applyPatch } from 'diff';
@@ -5442,6 +5442,140 @@ var init_policy2 = __esm({
   }
 });
 
+// src/harness/check/runtime-render/render-check-host.ts
+var render_check_host_exports = {};
+__export(render_check_host_exports, {
+  mapSandboxResultToCheckResult: () => mapSandboxResultToCheckResult,
+  runRenderCheckViaWorker: () => runRenderCheckViaWorker
+});
+function resolveWorkerSpawn2() {
+  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 = resolveWorkerSpawn2();
+  } 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";
+  }
+});
+
 // src/harness/hashline.ts
 var hashline_exports = {};
 __export(hashline_exports, {
@@ -15523,8 +15657,8 @@ ${cjsResult.code}
 // src/harness/check/runtime-render/load-component.ts
 async function loadComponent(input) {
   const { sourceCode, moduleResolutions = {} } = input;
-  const { createRequire: createRequire4 } = await import('module');
-  const require_ = createRequire4(import.meta.url);
+  const { createRequire: createRequire5 } = await import('module');
+  const require_ = createRequire5(import.meta.url);
   const sandboxRequire = (id) => {
     if (id in moduleResolutions) return moduleResolutions[id];
     if (id === "react/jsx-runtime" || id === "react/jsx-dev-runtime") {
@@ -15883,6 +16017,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();
@@ -19826,12 +19968,12 @@ async function runSlowStage(input) {
   };
 }
 function scoreFromRenderCheck(issues) {
-  const failed = issues.filter((i) => i.outcome === "failed").length;
-  const unverified = issues.filter((i) => i.outcome === "unverified").length;
-  if (failed === 0 && unverified === 0) return 1;
-  if (failed === 0) return 0.85;
-  if (failed === 1) return 0.4;
-  if (failed === 2) return 0.3;
+  const failed2 = issues.filter((i) => i.outcome === "failed").length;
+  const unverified2 = issues.filter((i) => i.outcome === "unverified").length;
+  if (failed2 === 0 && unverified2 === 0) return 1;
+  if (failed2 === 0) return 0.85;
+  if (failed2 === 1) return 0.4;
+  if (failed2 === 2) return 0.3;
   return 0.2;
 }
 function scoreFromSlowStage(contract, failures) {