@ggui-ai/ui-gen 0.22.0 → 0.24.0

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

@@ -1,10 +1,12 @@
-export { R as RenderCheckIssue, a as RenderCheckResult, r as runRenderCheck } from '../../../render-check-C0CqVceF.js';
+import { b as RenderCheckHostBounds } from '../../../adapter-Du7P_5Fx.js';
+export { D as DEFAULT_RUNTIME_RENDER_CHECK, c as RENDER_CHECK_KINDS, d as RenderCheckHostOptions, a as RenderCheckIssue, e as RenderCheckKind, f as RenderCheckResult, R as RuntimeRenderProbeConfig, g as classifyRenderCrashFix, h as createRuntimeRenderCheck, i as isRecoverableRenderCrash, p as parseRuntimeSubcategory, r as runRenderCheck } from '../../../adapter-Du7P_5Fx.js';
 import { WireConfig } from '@ggui-ai/wire';
 import { JsonObject, DataContract } from '@ggui-ai/protocol';
-import { RuntimeRenderCheck } from '../../types-public.js';
+import '../../types-public.js';
 import '../../../styling-profile-CxfvV48g.js';
 import '../../../axes-CzLEMDeB.js';
-import '../../../types-public-mM_-1Yk3.js';
+import '../../../types-public-Bk6d1WLN.js';
+import '@ggui-ai/mcp-server-core';
 import '../../../design-mode-DLufhrNp.js';
 import '../../../types-BOvHNG7K.js';
 import '../../../llm.js';
@@ -109,10 +111,6 @@ interface PrepareMockupInput {
  */
 declare function prepareMockupProps(input: PrepareMockupInput): MockupPropsResult;
 
-declare const DEFAULT_RUNTIME_RENDER_CHECK: RuntimeRenderCheck;
-declare function isRecoverableRenderCrash(reason: string): boolean;
-declare function classifyRenderCrashFix(reason: string): string;
-
 /**
  * Pre-warm the runtime-render probe's runtime dependencies so the first
  * actual probe call hits a warm Node module cache.
@@ -139,5 +137,26 @@ declare function warmupRuntimeRenderProbe(): Promise<{
     loaded: number;
     missing: number;
 }>;
+/**
+ * Warm the PROCESS that runs every probe (ggui#1380): spawn one real check
+ * worker on a trivial component through the same host every probe uses.
+ * Afterwards the node binary, the worker's module tree and esbuild's
+ * service have all run once on this machine (OS page cache warm), and the
+ * result says whether that process can run a check at all — which
+ * `warmupRuntimeRenderProbe` (an import in THIS process) cannot tell.
+ *
+ * `bounds` are the subprocess bounds for the one run; a serving deployment
+ * passes the same bounds it will probe with. Never throws: a worker that
+ * cannot run is `{ ok: false, reason }`, so a boot sequence can log it and
+ * decide, instead of dying in a fire-and-forget.
+ */
+declare function warmupRuntimeRenderWorker(bounds?: Partial<RenderCheckHostBounds>): Promise<{
+    ok: true;
+    ms: number;
+} | {
+    ok: false;
+    ms: number;
+    reason: string;
+}>;
 
-export { DEFAULT_RUNTIME_RENDER_CHECK, type MockupPropsResult, type Probe, classifyRenderCrashFix, createProbe, createProbeWireConfig, isRecoverableRenderCrash, prepareMockupProps, warmupRuntimeRenderProbe };
+export { type MockupPropsResult, type Probe, RenderCheckHostBounds, createProbe, createProbeWireConfig, prepareMockupProps, warmupRuntimeRenderProbe, warmupRuntimeRenderWorker };

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

@@ -1,5 +1,6 @@
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
+import { loadavg, availableParallelism } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { runSandboxed } from '@ggui-ai/sandbox';
 import { listContractGadgets, HOOK_NAME_RE } from '@ggui-ai/protocol';
@@ -19,9 +20,25 @@ var __export = (target, all) => {
 // src/harness/check/runtime-render/render-check-host.ts
 var render_check_host_exports = {};
 __export(render_check_host_exports, {
+  DEFAULT_RENDER_CHECK_HOST_BOUNDS: () => DEFAULT_RENDER_CHECK_HOST_BOUNDS,
   mapSandboxResultToCheckResult: () => mapSandboxResultToCheckResult,
+  resolveRenderCheckHostBounds: () => resolveRenderCheckHostBounds,
+  resolveWorkerSpawn: () => resolveWorkerSpawn,
   runRenderCheckViaWorker: () => runRenderCheckViaWorker
 });
+function resolveRenderCheckHostBounds(bounds = {}) {
+  const timeoutMs = bounds.timeoutMs ?? DEFAULT_RENDER_CHECK_HOST_BOUNDS.timeoutMs;
+  const heapMb = bounds.heapMb ?? DEFAULT_RENDER_CHECK_HOST_BOUNDS.heapMb;
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 2) {
+    throw new RangeError(`render-check: timeoutMs must be an integer \u2265 2, got ${timeoutMs}`);
+  }
+  if (!Number.isInteger(heapMb) || heapMb < 1) {
+    throw new RangeError(`render-check: heapMb must be a positive integer, got ${heapMb}`);
+  }
+  const requestedGrace = bounds.gracePeriodMs ?? DEFAULT_RENDER_CHECK_HOST_BOUNDS.gracePeriodMs;
+  const gracePeriodMs = Math.max(1, Math.min(requestedGrace, Math.floor(timeoutMs / 2)));
+  return { timeoutMs, heapMb, gracePeriodMs };
+}
 function resolveWorkerSpawn() {
   const jsCandidates = [
     // Sibling — when import.meta.url is already .../harness/check/runtime-render/.
@@ -70,12 +87,14 @@ function unverified(reason, t0) {
     stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
   };
 }
-function mapSandboxResultToCheckResult(result, t0) {
+function mapSandboxResultToCheckResult(result, t0, boundMs = DEFAULT_RENDER_CHECK_HOST_BOUNDS.timeoutMs) {
   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
-    );
+    return {
+      ok: false,
+      issues: [],
+      incomplete: { kind: "timeout", elapsedMs: result.durationMs, boundMs },
+      stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
+    };
   }
   if (result.outcome === "overflow-stdout" || result.outcome === "overflow-stderr") {
     return failed(
@@ -118,34 +137,46 @@ function mapSandboxResultToCheckResult(result, t0) {
     );
   }
 }
-async function runRenderCheckViaWorker(input) {
+async function runRenderCheckViaWorker(input, options = {}) {
   const t0 = Date.now();
+  const bounds = resolveRenderCheckHostBounds(options.bounds);
   let spawn;
   try {
     spawn = resolveWorkerSpawn();
   } catch (err) {
     return unverified(err instanceof Error ? err.message : String(err), t0);
   }
+  const loadAtStart = loadavg()[0] ?? 0;
   const result = await runSandboxed({
     command: spawn.command,
     args: spawn.args,
-    timeoutMs: CHECK_TIMEOUT_MS,
+    timeoutMs: bounds.timeoutMs,
+    gracePeriodMs: bounds.gracePeriodMs,
     maxStdoutBytes: CHECK_STDOUT_CAP,
-    nodeHeapMb: CHECK_NODE_HEAP_MB,
+    nodeHeapMb: bounds.heapMb,
     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);
+  const hostLoad = {
+    start: loadAtStart,
+    end: loadavg()[0] ?? 0,
+    cores: availableParallelism()
+  };
+  const mapped = mapSandboxResultToCheckResult(result, t0, bounds.timeoutMs);
+  return { ...mapped, stats: { ...mapped.stats, hostLoad } };
 }
-var CHECK_TIMEOUT_MS, CHECK_STDOUT_CAP, CHECK_NODE_HEAP_MB, WORKER_BASENAME;
+var DEFAULT_RENDER_CHECK_HOST_BOUNDS, CHECK_STDOUT_CAP, WORKER_BASENAME;
 var init_render_check_host = __esm({
   "src/harness/check/runtime-render/render-check-host.ts"() {
-    CHECK_TIMEOUT_MS = 3e4;
+    DEFAULT_RENDER_CHECK_HOST_BOUNDS = {
+      timeoutMs: 3e4,
+      heapMb: 512,
+      gracePeriodMs: 2e3
+    };
     CHECK_STDOUT_CAP = 2 * 1024 * 1024;
-    CHECK_NODE_HEAP_MB = 512;
     WORKER_BASENAME = "render-check-worker";
   }
 });
@@ -667,13 +698,22 @@ function editableSurface(el) {
 function parentLink(node) {
   return node;
 }
-async function runRenderCheck(input) {
+var RENDER_CHECK_KINDS = [
+  "render-no-throw",
+  "prop-sensitivity",
+  "action-wiring",
+  "selection-identity",
+  "prop-coverage",
+  "optional-props-omitted",
+  "stream-rerender"
+];
+async function runRenderCheck(input, options = {}) {
   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);
+  return runRenderCheckViaWorker2(input, options);
 }
 async function runRenderCheckInProcess(input) {
   const t0 = Date.now();
@@ -687,7 +727,7 @@ async function runRenderCheckInProcess(input) {
     const Wire = await import('@ggui-ai/wire');
     const { GguiWireProvider } = Wire;
     const moduleResolutions = {
-      "react": React,
+      react: React,
       "react/jsx-runtime": ReactJsxRuntime,
       "@ggui-ai/wire": Wire
     };
@@ -803,14 +843,23 @@ async function runRenderCheckInProcess(input) {
         )
       );
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(`[runtime-render] render exceeded ${RENDER_TIMEOUT_MS}ms \u2014 classified as runtime-hang`)), RENDER_TIMEOUT_MS).unref?.();
+        setTimeout(
+          () => reject(
+            new Error(
+              `[runtime-render] render exceeded ${RENDER_TIMEOUT_MS}ms \u2014 classified as runtime-hang`
+            )
+          ),
+          RENDER_TIMEOUT_MS
+        ).unref?.();
       });
       renderResult = await Promise.race([renderPromise, timeoutPromise]);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       const errStack = e instanceof Error ? e.stack ?? "" : "";
       const baseReason = loopSignature ? `Infinite render loop (${loopSignature}) \u2014 likely setState/dispatch inside useEffect with missing or unstable dependency` : /runtime-hang/.test(msg) ? `Render wall-clock exceeded ${RENDER_TIMEOUT_MS}ms \u2014 likely async effect loop or unresolved promise` : `Render threw: ${msg}`;
-      const userFrames = errStack.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at ")).filter((l) => !/(node_modules|happy-dom|@testing-library|react-dom|node:internal|node:async)/.test(l)).slice(0, 5);
+      const userFrames = errStack.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at ")).filter(
+        (l) => !/(node_modules|happy-dom|@testing-library|react-dom|node:internal|node:async)/.test(l)
+      ).slice(0, 5);
       const stackSource = boundaryRef.stack ?? capturedComponentStack ?? "";
       const componentFrames = stackSource.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at ")).slice(0, 4);
       const stackBlock = userFrames.length ? `
@@ -1275,9 +1324,7 @@ function idLikeRequiredStringField(schema) {
   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
-  )) {
+  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;
@@ -1308,9 +1355,7 @@ async function checkSelectionIdentity(input) {
         return void 0;
       }
       await flushPromises();
-      const events = probe.getFireLog().slice(before).filter(
-        (e) => e.kind === "action.fired" && e.name === actionName
-      );
+      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]);
@@ -1371,7 +1416,10 @@ async function dispatchTrigger(el, kind, user) {
     case "submit": {
       const form = closestForm(el);
       if (!form) return;
-      const ev = new globalThis.Event("submit", { bubbles: true, cancelable: true });
+      const ev = new globalThis.Event("submit", {
+        bubbles: true,
+        cancelable: true
+      });
       toEventDispatcher(form).dispatchEvent(ev);
       return;
     }
@@ -1708,37 +1756,112 @@ function synthesizeFromSchema(schema, hint, warnings, depth, ordinal) {
 }
 
 // src/harness/check/runtime-render/adapter.ts
-var DEFAULT_RUNTIME_RENDER_CHECK = {
-  id: "runtime-render",
-  run: async (input) => {
-    const { sourceCode, compiledCode, contract, fixtureProps } = input;
-    if (compiledCode === null) {
-      return { status: "not-applicable", issues: [], reason: "no compiled code" };
-    }
-    if (!contract) {
-      return { status: "not-applicable", issues: [], reason: "no contract surface" };
-    }
-    const mockup = prepareMockupProps({ contract, fixtureProps });
-    let result;
-    try {
-      result = await runRenderCheck({
-        sourceCode,
-        mockupProps: mockup.props,
-        contract
+init_render_check_host();
+function createSlotLimiter(maxConcurrent) {
+  if (maxConcurrent === void 0) return (task) => task(0);
+  if (!Number.isInteger(maxConcurrent) || maxConcurrent < 1) {
+    throw new RangeError(
+      `createRuntimeRenderCheck: maxConcurrent must be a positive integer, got ${maxConcurrent}`
+    );
+  }
+  let active = 0;
+  const waiting = [];
+  const acquire = () => {
+    if (active < maxConcurrent) {
+      active += 1;
+      return Promise.resolve(0);
+    }
+    const enqueuedAt = Date.now();
+    return new Promise((resolve) => {
+      waiting.push(() => {
+        active += 1;
+        resolve(Date.now() - enqueuedAt);
       });
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e);
-      console.warn(
-        `[runtime-render] probe skipped \u2014 infra failure: ${message}`
-      );
-      return { status: "infra-skipped", issues: [], reason: message };
+    });
+  };
+  const release = () => {
+    active -= 1;
+    const next = waiting.shift();
+    if (next !== void 0) next();
+  };
+  return async (task) => {
+    const waitedMs = await acquire();
+    try {
+      return await task(waitedMs);
+    } finally {
+      release();
     }
-    return {
-      status: "ran",
-      issues: result.issues.map(toEvalIssue).filter((x) => x !== null)
-    };
-  }
-};
+  };
+}
+function queuedField(queuedMs) {
+  return queuedMs > 0 ? { queuedMs } : {};
+}
+function toRenderCheckOptions(config) {
+  if (config.timeoutMs === void 0 && config.heapMb === void 0) return void 0;
+  return {
+    bounds: {
+      ...config.timeoutMs !== void 0 ? { timeoutMs: config.timeoutMs } : {},
+      ...config.heapMb !== void 0 ? { heapMb: config.heapMb } : {}
+    }
+  };
+}
+function createRuntimeRenderCheck(config = {}) {
+  const limit = createSlotLimiter(config.maxConcurrent);
+  const options = toRenderCheckOptions(config);
+  if (options !== void 0) resolveRenderCheckHostBounds(options.bounds);
+  return {
+    id: "runtime-render",
+    run: async (input) => {
+      const { sourceCode, compiledCode, contract, fixtureProps } = input;
+      if (compiledCode === null) {
+        return { status: "not-applicable", issues: [], reason: "no compiled code" };
+      }
+      if (!contract) {
+        return { status: "not-applicable", issues: [], reason: "no contract surface" };
+      }
+      const mockup = prepareMockupProps({ contract, fixtureProps });
+      let queuedMs = 0;
+      let t0 = Date.now();
+      let result;
+      try {
+        result = await limit((waitedMs) => {
+          queuedMs = waitedMs;
+          t0 = Date.now();
+          return runRenderCheck(
+            {
+              sourceCode,
+              mockupProps: mockup.props,
+              contract
+            },
+            options
+          );
+        });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        console.warn(`[runtime-render] probe skipped \u2014 infra failure: ${message}`);
+        return { status: "infra-skipped", issues: [], reason: message, elapsedMs: Date.now() - t0, ...queuedField(queuedMs) };
+      }
+      const hostLoad = result.stats.hostLoad;
+      const load = hostLoad !== void 0 ? { hostLoad } : {};
+      if (result.incomplete !== void 0) {
+        const { elapsedMs, boundMs } = result.incomplete;
+        const loadNote = hostLoad !== void 0 ? `; host load ${hostLoad.start.toFixed(1)} \u2192 ${hostLoad.end.toFixed(1)} on ${hostLoad.cores} CPUs` : "";
+        const reason = `render check did not finish within ${boundMs} ms (stopped at ${elapsedMs} ms)${loadNote}`;
+        console.warn(`[runtime-render] probe timed out \u2014 ${reason}`);
+        return { status: "timed-out", issues: [], reason, elapsedMs: Date.now() - t0, ...queuedField(queuedMs), ...load };
+      }
+      return {
+        status: "ran",
+        issues: result.issues.map(toEvalIssue).filter((x) => x !== null),
+        elapsedMs: Date.now() - t0,
+        ...queuedField(queuedMs),
+        renderMs: result.stats.renderMs,
+        ...load
+      };
+    }
+  };
+}
+var DEFAULT_RUNTIME_RENDER_CHECK = createRuntimeRenderCheck();
 var CLASS_SPECIFIC_PATTERNS = [
   /too many re-renders/i,
   /maximum update depth/i,
@@ -1777,6 +1900,14 @@ function classifyRenderCrashFix(reason) {
   }
   return "Add null guards on optional props, handle empty arrays/strings, and verify all hook outputs before destructuring.";
 }
+var RUNTIME_SUBCATEGORY_PREFIX = "runtime:";
+function parseRuntimeSubcategory(subcategory) {
+  if (!subcategory.startsWith(RUNTIME_SUBCATEGORY_PREFIX)) return void 0;
+  const rest = subcategory.slice(RUNTIME_SUBCATEGORY_PREFIX.length);
+  const separator = rest.indexOf(":");
+  const check = separator === -1 ? rest : rest.slice(0, separator);
+  return RENDER_CHECK_KINDS.find((kind) => kind === check);
+}
 function toEvalIssue(issue) {
   if (issue.outcome === "verified" || issue.outcome === "skipped") return null;
   const result = issue.outcome === "failed" ? "fail" : "warn";
@@ -1899,7 +2030,39 @@ async function warmupRuntimeRenderProbe() {
   ]);
   return { ms: Date.now() - start, loaded, missing };
 }
+var WARMUP_COMPONENT = "export default function Warmup() { return <div>warm</div>; }";
+async function warmupRuntimeRenderWorker(bounds) {
+  const start = Date.now();
+  try {
+    const { runRenderCheckViaWorker: runRenderCheckViaWorker2 } = await Promise.resolve().then(() => (init_render_check_host(), render_check_host_exports));
+    const result = await runRenderCheckViaWorker2(
+      { sourceCode: WARMUP_COMPONENT, mockupProps: {}, contract: {} },
+      bounds !== void 0 ? { bounds } : {}
+    );
+    const ms = Date.now() - start;
+    if (result.incomplete !== void 0) {
+      return {
+        ok: false,
+        ms,
+        reason: `the warm-up check did not finish within ${result.incomplete.boundMs} ms (stopped at ${result.incomplete.elapsedMs} ms)`
+      };
+    }
+    const blocking = result.issues.find(
+      (i) => i.outcome === "failed" || i.outcome === "unverified"
+    );
+    if (blocking !== void 0) {
+      return { ok: false, ms, reason: `${blocking.check} ${blocking.outcome}: ${blocking.reason}` };
+    }
+    return { ok: true, ms };
+  } catch (err) {
+    return {
+      ok: false,
+      ms: Date.now() - start,
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
 
-export { DEFAULT_RUNTIME_RENDER_CHECK, classifyRenderCrashFix, createProbe, createProbeWireConfig, isRecoverableRenderCrash, prepareMockupProps, runRenderCheck, warmupRuntimeRenderProbe };
+export { DEFAULT_RUNTIME_RENDER_CHECK, RENDER_CHECK_KINDS, classifyRenderCrashFix, createProbe, createProbeWireConfig, createRuntimeRenderCheck, isRecoverableRenderCrash, parseRuntimeSubcategory, prepareMockupProps, runRenderCheck, warmupRuntimeRenderProbe, warmupRuntimeRenderWorker };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map