@ggui-ai/ui-gen 0.24.0 → 0.26.0

package/src/harness/check/runtime-render/adapter.ts

@@ -198,6 +198,8 @@ export function createRuntimeRenderCheck(
         ...queuedField(queuedMs),
         renderMs: result.stats.renderMs,
         ...load,
+        // ggui#1398: report-only — carried to the probe's meta for the bench, never an issue.
+        ...(result.stats.pendingAffordance !== undefined ? { pendingAffordance: result.stats.pendingAffordance } : {}),
       };
     },
   };
@@ -376,6 +378,22 @@ export function toEvalIssue(issue: RenderCheckIssue): EvalIssue | null {
         : `input priming failed: ${diag.inputPriming.error}`
     );
   }
+  if (diag?.walk) {
+    // ggui#1652: how far the walk over the card's screens got, so a
+    // multi-step card reads differently from a control that never rendered.
+    const w = diag.walk;
+    const stopped = {
+      explored: "every reachable control pressed",
+      "press-cap": "stopped at the press cap",
+      deadline: "stopped at the time budget",
+      "no-mount": "the card could not be mounted for the walk",
+    }[w.stoppedBy];
+    const named = w.namedControlSeen
+      ? "a control naming the action rendered, but pressing it did not dispatch the action"
+      : "no screen rendered a control naming the action";
+    const last = w.lastPressed.length ? `; last pressed: ${w.lastPressed.join(", ")}` : "";
+    diagParts.push(`walk: ${w.presses} press(es) across ${w.screens} screen(s), ${stopped}; ${named}${last}`);
+  }
   const diagSuffix = diagParts.length ? ` [observed: ${diagParts.join("; ")}]` : "";
 
   switch (issue.check) {

package/src/harness/check/runtime-render/probe-pending.ts

@@ -0,0 +1,111 @@
+/**
+ * ggui#1398 leg 3 — the render check's stand-in for the runtime's pending
+ * state, and the rule for "the control visibly changed".
+ *
+ * In a served card, the runtime marks an action pending when the card's
+ * dispatch of it commits, and clears it when the session's next frame lands;
+ * `useActionPending` reads that state through wire's `ActionPendingContext`.
+ * The probe has no transport and no next frame, so it marks an action pending
+ * right after its own synthetic click really fired the action, looks at the
+ * clicked control, then clears it: one dispatch, one answer.
+ */
+import type { ActionPendingSource } from "@ggui-ai/wire";
+
+/** An {@link ActionPendingSource} the probe drives by hand. */
+export interface ProbePendingSource extends ActionPendingSource {
+  /** Mark `actionName` pending and notify subscribers. */
+  mark(actionName: string): void;
+  /** Clear every pending action (the "answer landed"), notifying only if something was pending. */
+  clear(): void;
+}
+
+export function createProbePendingSource(): ProbePendingSource {
+  const pending = new Set<string>();
+  const listeners = new Set<() => void>();
+  const notify = (): void => {
+    for (const listener of [...listeners]) listener();
+  };
+  return {
+    isPending: (actionName) => pending.has(actionName),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    mark: (actionName) => {
+      pending.add(actionName);
+      notify();
+    },
+    clear: () => {
+      if (pending.size === 0) return;
+      pending.clear();
+      notify();
+    },
+  };
+}
+
+/** What a control shows, for a before/after comparison around a dispatch. */
+export interface ControlLook {
+  /** Still in the document; `false` when the card replaced the control. */
+  readonly connected: boolean;
+  /** `disabled`, or `aria-disabled="true"`. */
+  readonly disabled: boolean;
+  /** `aria-busy="true"`. */
+  readonly ariaBusy: boolean;
+  /** The control's text. */
+  readonly text: string;
+}
+
+/**
+ * The DOM surface {@link lookOf} reads: the probe's `MinimalElement` plus
+ * the optional `isConnected` a live DOM node carries, and an input's live
+ * `value` (an `<input type="submit">` shows its label through it).
+ */
+export interface LookableElement {
+  readonly tagName?: string;
+  readonly textContent: string | null;
+  getAttribute(name: string): string | null;
+  readonly isConnected?: boolean;
+  readonly value?: unknown;
+}
+
+export function lookOf(el: LookableElement): ControlLook {
+  return {
+    connected: el.isConnected !== false,
+    // React renders `disabled={true}` as `disabled=""`, so presence is the test.
+    disabled: el.getAttribute("disabled") !== null || el.getAttribute("aria-disabled") === "true",
+    ariaBusy: el.getAttribute("aria-busy") === "true",
+    text:
+      el.tagName?.toLowerCase() === "input"
+        ? String(typeof el.value === "string" ? el.value : (el.getAttribute("value") ?? ""))
+        : (el.textContent ?? ""),
+  };
+}
+
+/**
+ * Whether `work` settles within `ms`. It never cancels `work`; it only stops
+ * waiting for it, so a phase can give up on a card that stalls.
+ */
+export async function settlesWithin(ms: number, work: Promise<unknown>): Promise<boolean> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const expired = new Promise<false>((resolve) => {
+    timer = setTimeout(() => resolve(false), Math.max(0, ms));
+  });
+  try {
+    return await Promise.race([work.then(() => true), expired]);
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+  }
+}
+
+/**
+ * Whether the control visibly changed between two looks: it became disabled
+ * or busy, its text changed (whitespace aside), or the card replaced it.
+ */
+export function lookChanged(before: ControlLook, after: ControlLook): boolean {
+  if (before.connected && !after.connected) return true;
+  if (!before.disabled && after.disabled) return true;
+  if (!before.ariaBusy && after.ariaBusy) return true;
+  return before.text.trim() !== after.text.trim();
+}

package/src/harness/check/runtime-render/render-check-host.ts

@@ -46,6 +46,7 @@ import { runSandboxed } from '@ggui-ai/sandbox';
 import type { SandboxResult } from '@ggui-ai/sandbox';
 import type { ProbeHostLoad } from '../../../evaluation/types-public.js';
 import type { RenderCheckResult, RunRenderCheckInput } from './render-check.js';
+import { parseVerdictLine } from '../../../internal/verdict-line.js';
 
 /**
  * The subprocess bounds of one isolated check (ggui#1380). They are
@@ -227,12 +228,9 @@ export function mapSandboxResultToCheckResult(
       t0,
     );
   }
-  const stdout = result.stdout.trim();
-  if (stdout.length === 0) {
-    return unverified('render check worker exited without producing a verdict.', t0);
-  }
+  let verdict: RenderCheckResult | undefined;
   try {
-    return JSON.parse(stdout) as RenderCheckResult;
+    verdict = parseVerdictLine<RenderCheckResult>(result.stdout);
   } catch (err) {
     return unverified(
       `render check worker verdict was not valid JSON — ${
@@ -241,6 +239,10 @@ export function mapSandboxResultToCheckResult(
       t0,
     );
   }
+  if (verdict === undefined) {
+    return unverified('render check worker exited without producing a verdict.', t0);
+  }
+  return verdict;
 }
 
 /**
@@ -269,7 +271,9 @@ export async function runRenderCheckViaWorker(
     gracePeriodMs: bounds.gracePeriodMs,
     maxStdoutBytes: CHECK_STDOUT_CAP,
     nodeHeapMb: bounds.heapMb,
-    stdin: JSON.stringify(input),
+    // ggui#1398: the check learns its own deadline, so its report-only
+    // pending phase can step aside instead of pushing it past the bound.
+    stdin: JSON.stringify({ ...input, deadlineAt: t0 + bounds.timeoutMs }),
     // NODE_ENV steers React's production vs development build — keep
     // parity with the caller; everything else stays on the sandbox's
     // default allowlist.

package/src/harness/check/runtime-render/render-check-worker.ts

@@ -43,7 +43,8 @@ import { resolve as resolvePath } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as esbuild from 'esbuild';
 import { runRenderCheckInProcess } from './render-check.js';
-import type { RunRenderCheckInput } from './render-check.js';
+import type { RenderCheckResult, RunRenderCheckInput } from './render-check.js';
+import { formatVerdictLine } from '../../../internal/verdict-line.js';
 
 async function readAllStdin(): Promise<string> {
   const chunks: Buffer[] = [];
@@ -53,8 +54,10 @@ async function readAllStdin(): Promise<string> {
   return Buffer.concat(chunks).toString('utf8');
 }
 
-function emit(value: unknown): void {
-  process.stdout.write(`${JSON.stringify(value)}\n`);
+function emit(value: RenderCheckResult): void {
+  // One prefixed line: the host reads the last such line, so a card that
+  // writes to stdout while it is checked cannot corrupt the verdict.
+  process.stdout.write(formatVerdictLine(value));
 }
 
 /**