@ggui-ai/ui-gen 0.25.0 → 0.26.0

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

@@ -7,7 +7,22 @@ import ts from 'typescript';
 import { createRequire } from 'module';
 import { primeInputs } from '@ggui-ai/ui-visual-tester/prime-inputs';
 
-// src/harness/check/runtime-render/render-check-worker.ts
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/internal/verdict-line.ts
+function formatVerdictLine(value) {
+  return `${VERDICT_PREFIX} ${JSON.stringify(value)}
+`;
+}
+var VERDICT_PREFIX;
+var init_verdict_line = __esm({
+  "src/internal/verdict-line.ts"() {
+    VERDICT_PREFIX = "@@ggui-render-check-verdict@@";
+  }
+});
 
 // src/harness/check/runtime-render/probe.ts
 function makeInternals() {
@@ -526,6 +541,169 @@ function editableSurface(el) {
 function parentLink(node) {
   return node;
 }
+
+// src/harness/check/runtime-render/probe-pending.ts
+function createProbePendingSource() {
+  const pending = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    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();
+    }
+  };
+}
+function lookOf(el) {
+  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 ?? ""
+  };
+}
+async function settlesWithin(ms, work) {
+  let timer;
+  const expired = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(false), Math.max(0, ms));
+  });
+  try {
+    return await Promise.race([work.then(() => true), expired]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function lookChanged(before, after) {
+  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();
+}
+
+// src/harness/check/runtime-render/walk.ts
+var LAST_PRESSED_KEPT = 4;
+function isDisabled(el) {
+  return el.getAttribute("disabled") !== null || el.getAttribute("aria-disabled") === "true";
+}
+function labelOf(el) {
+  const named = el.getAttribute("aria-label") ?? el.getAttribute("placeholder");
+  return (named ?? el.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 60);
+}
+function screenFingerprint(container) {
+  const parts = [];
+  for (const el of container.querySelectorAll(
+    'button, [role="button"], a[href], input, select, textarea, form'
+  )) {
+    parts.push(
+      [el.tagName.toLowerCase(), el.getAttribute("type") ?? "", labelOf(el), isDisabled(el) ? "disabled" : ""].join("|")
+    );
+  }
+  return parts.join("\n");
+}
+function keyed(controls, describe) {
+  const seen = /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Map();
+  for (const c of controls) {
+    const d = describe(c.element);
+    const n = seen.get(d) ?? 0;
+    seen.set(d, n + 1);
+    out.set(`${d}#${n}`, c);
+  }
+  return out;
+}
+function firstStepToUnpressed(screens, from) {
+  const firstStep = /* @__PURE__ */ new Map([[from, void 0]]);
+  const queue = [from];
+  while (queue.length > 0) {
+    const at = queue.shift();
+    const screen = screens.get(at);
+    if (screen === void 0) continue;
+    if (at !== from && screen.order.some((k) => !screen.led.has(k))) return firstStep.get(at);
+    for (const [key, to] of screen.led) {
+      if (to === at || firstStep.has(to)) continue;
+      firstStep.set(to, firstStep.get(at) ?? key);
+      queue.push(to);
+    }
+  }
+  return void 0;
+}
+async function walkToAction(input) {
+  const lastPressed = [];
+  const screenTexts = [];
+  const screens = /* @__PURE__ */ new Map();
+  let presses = 0;
+  let namedControlSeen = false;
+  const outcome = (stoppedBy, extra = {}) => ({
+    fired: false,
+    presses,
+    screens: screens.size,
+    stoppedBy,
+    namedControlSeen,
+    lastPressed: [...lastPressed],
+    screenTexts: [...screenTexts],
+    ...extra
+  });
+  const mounted = await input.mount();
+  if (mounted === void 0) return outcome("no-mount");
+  const { container } = mounted;
+  const arrive = () => {
+    mounted.prime();
+    const controls = keyed(input.controls(container), input.describe);
+    if ([...controls.values()].some((c) => c.namesAction)) namedControlSeen = true;
+    const id = screenFingerprint(container);
+    if (!screens.has(id)) {
+      screens.set(id, { order: [...controls.keys()], led: /* @__PURE__ */ new Map() });
+      screenTexts.push(container.textContent ?? "");
+    }
+    return { id, controls };
+  };
+  let here = arrive();
+  const first = here.id;
+  for (; ; ) {
+    const screen = screens.get(here.id);
+    const onOpenFirstScreen = here.id === first && screen.order.some((k) => !screen.led.has(k));
+    if (!onOpenFirstScreen) {
+      if (presses >= input.maxPresses) return outcome("press-cap");
+      if (Date.now() >= input.stopAt) return outcome("deadline");
+    }
+    const key = screen.order.find((k) => !screen.led.has(k)) ?? firstStepToUnpressed(screens, here.id);
+    if (key === void 0) return outcome("explored");
+    const control = here.controls.get(key);
+    if (control === void 0) {
+      screen.led.set(key, here.id);
+      continue;
+    }
+    presses += 1;
+    lastPressed.push(input.describe(control.element));
+    if (lastPressed.length > LAST_PRESSED_KEPT) lastPressed.shift();
+    if (await input.press(control)) {
+      return outcome("dispatched", { fired: true, element: control.element, container });
+    }
+    here = arrive();
+    if (!screen.led.has(key)) screen.led.set(key, here.id);
+  }
+}
+
+// src/harness/check/runtime-render/render-check.ts
+var PENDING_PHASE_RESERVE_MS = 5e3;
+var WALK_MAX_PRESSES = 60;
+var WALK_ACTION_CAP_MS = 3e3;
+var WALK_DEADLINE_MARGIN_MS = 2e3;
 async function runRenderCheckInProcess(input) {
   const t0 = Date.now();
   const issues = [];
@@ -583,7 +761,9 @@ async function runRenderCheckInProcess(input) {
     const wireConfig = createProbeWireConfig(probe);
     uninstallSpy = probe.installPostMessageSpy();
     installProductionActShim();
-    const { render, cleanup } = await import('@testing-library/react');
+    const { render, cleanup, act } = await import('@testing-library/react');
+    const { ActionPendingContext } = await import('@ggui-ai/wire/internal');
+    const pendingSource = createProbePendingSource();
     const userEventModule = await import('@testing-library/user-event');
     const userEvent = userEventModule.default ?? userEventModule;
     const originalConsoleError = console.error;
@@ -620,7 +800,8 @@ async function runRenderCheckInProcess(input) {
     };
     const boundaryRef = {
       stack: null,
-      error: null
+      error: null,
+      catches: 0
     };
     class ProbeErrorBoundary extends React.Component {
       state = { caught: false };
@@ -628,6 +809,7 @@ async function runRenderCheckInProcess(input) {
         return { caught: true };
       }
       componentDidCatch(error, errorInfo) {
+        boundaryRef.catches += 1;
         if (errorInfo.componentStack && !boundaryRef.stack) {
           boundaryRef.stack = errorInfo.componentStack;
         }
@@ -640,19 +822,19 @@ async function runRenderCheckInProcess(input) {
         return this.props.children;
       }
     }
+    const cardTree = () => React.createElement(GguiWireProvider, {
+      config: wireConfig,
+      children: React.createElement(ProbeErrorBoundary, {
+        children: React.createElement(ActionPendingContext.Provider, {
+          value: pendingSource,
+          children: React.createElement(Component, input.mockupProps)
+        })
+      })
+    });
     let renderResult;
     const RENDER_TIMEOUT_MS = 5e3;
     try {
-      const renderPromise = Promise.resolve().then(
-        () => render(
-          React.createElement(GguiWireProvider, {
-            config: wireConfig,
-            children: React.createElement(ProbeErrorBoundary, {
-              children: React.createElement(Component, input.mockupProps)
-            })
-          })
-        )
-      );
+      const renderPromise = Promise.resolve().then(() => render(cardTree()));
       const timeoutPromise = new Promise((_, reject) => {
         setTimeout(
           () => reject(
@@ -704,6 +886,9 @@ async function runRenderCheckInProcess(input) {
     const user = buildClickUser(userEvent, hostGlobals().document);
     let actionsChecked = 0;
     let streamsChecked = 0;
+    let pendingTally;
+    const pendingTargets = [];
+    const walkedTexts = [];
     try {
       let inputPriming;
       try {
@@ -720,15 +905,42 @@ async function runRenderCheckInProcess(input) {
             hookName: "useAction",
             hookArg: name
           });
+          const walkPriming = {};
+          const mount = async () => {
+            let mounted;
+            try {
+              mounted = render(cardTree());
+            } catch {
+              return void 0;
+            }
+            await flushPromises();
+            const root = mounted.container;
+            return {
+              container: toMinimalElement(root),
+              prime: () => {
+                try {
+                  primeInputs(root);
+                } catch (err) {
+                  walkPriming.error ??= err instanceof Error ? err.message : String(err);
+                }
+              }
+            };
+          };
           const issue = await checkActionWiring({
-            container,
+            mount,
             actionName: name,
             actionLabel: entry.label,
             wiring,
             probe,
-            user
+            user,
+            pendingTargets,
+            stopAt: walkStopAt(input.deadlineAt),
+            walkedTexts
           });
-          if (issue) issues.push({ ...issue, diagnostics: { ...issue.diagnostics, inputPriming } });
+          if (issue) {
+            const priming = "primed" in inputPriming && walkPriming.error !== void 0 ? { error: `on a screen the action walk reached: ${walkPriming.error}` } : inputPriming;
+            issues.push({ ...issue, diagnostics: { ...issue.diagnostics, inputPriming: priming } });
+          }
         }
       }
       if (input.contract?.actionSpec) {
@@ -750,6 +962,7 @@ async function runRenderCheckInProcess(input) {
       if (input.contract?.propsSpec) {
         for (const issue of checkPropCoverage({
           container,
+          walkedTexts,
           propsSpec: input.contract.propsSpec,
           mockupProps: input.mockupProps
         })) {
@@ -855,10 +1068,21 @@ async function runRenderCheckInProcess(input) {
           }
         }
       }
+      const timeLeft = input.deadlineAt === void 0 ? Number.POSITIVE_INFINITY : input.deadlineAt - Date.now();
+      if (input.contract?.actionSpec && timeLeft >= PENDING_PHASE_RESERVE_MS) {
+        pendingTally = await runPendingPhase({
+          targets: pendingTargets,
+          source: pendingSource,
+          act,
+          catches: () => boundaryRef.catches,
+          actions: Object.entries(input.contract.actionSpec).map(([name, entry]) => ({ name, label: entry.label })),
+          ...input.deadlineAt !== void 0 ? { deadlineAt: input.deadlineAt } : {}
+        });
+      }
     } finally {
       cleanup();
     }
-    return finalize(issues, t0, actionsChecked, streamsChecked);
+    return finalize(issues, t0, actionsChecked, streamsChecked, pendingTally);
   } finally {
     try {
       uninstallSpy?.();
@@ -1070,7 +1294,7 @@ async function setupHappyDom() {
     delete g.IS_REACT_ACT_ENVIRONMENT;
   };
 }
-function finalize(issues, t0, actionsChecked, streamsChecked) {
+function finalize(issues, t0, actionsChecked, streamsChecked, pendingTally) {
   const ok = !issues.some((i) => i.outcome === "failed");
   return {
     ok,
@@ -1078,12 +1302,86 @@ function finalize(issues, t0, actionsChecked, streamsChecked) {
     stats: {
       actionsChecked,
       streamsChecked,
-      renderMs: Date.now() - t0
+      renderMs: Date.now() - t0,
+      ...pendingTally !== void 0 ? {
+        pendingAffordance: {
+          dispatched: pendingTally.dispatched,
+          visible: pendingTally.visible,
+          missing: [...pendingTally.missing],
+          gone: [...pendingTally.gone]
+        }
+      } : {}
     }
   };
 }
+var PENDING_TARGET_CAP_MS = 2e3;
+var PENDING_PHASE_TAIL_MS = 1e3;
+async function runPendingPhase(input) {
+  const tally = { dispatched: 0, visible: 0, missing: [], gone: [] };
+  let stopped = false;
+  for (const target of input.targets) {
+    const budget = Math.min(
+      PENDING_TARGET_CAP_MS,
+      input.deadlineAt === void 0 ? Number.POSITIVE_INFINITY : input.deadlineAt - Date.now() - PENDING_PHASE_TAIL_MS
+    );
+    const found = stopped || budget <= 0 ? void 0 : pendingControlOf(target, input.actions);
+    if (found === void 0) {
+      tally.gone.push(target.actionName);
+      if (budget <= 0) stopped = true;
+      continue;
+    }
+    const el = controlToRead(found, target);
+    const before = lookOf(el);
+    const caughtBefore = input.catches();
+    const settled = await settlesWithin(
+      budget,
+      (async () => {
+        await input.act(async () => {
+          input.source.mark(target.actionName);
+        });
+        await flushPromises();
+      })()
+    );
+    const crashed = input.catches() !== caughtBefore;
+    tally.dispatched += 1;
+    if (settled && !crashed && lookChanged(before, lookOf(el))) tally.visible += 1;
+    else tally.missing.push(target.actionName);
+    if (!settled) {
+      stopped = true;
+      continue;
+    }
+    await input.act(async () => {
+      input.source.clear();
+    });
+    await flushPromises();
+    if (crashed) stopped = true;
+  }
+  return tally;
+}
+function pendingControlOf(target, actions) {
+  const movedToAnother = !matchesActionIdentity(target.element, target.actionName, target.actionLabel) && actions.some((a) => a.name !== target.actionName && matchesActionIdentity(target.element, a.name, a.label));
+  if (lookOf(target.element).connected && !movedToAnother) return target.element;
+  if (target.wiringKind !== "click") return void 0;
+  return findActionElements(target.container, target.actionName, target.actionLabel, { identityOnly: true })[0];
+}
+function controlToRead(el, target) {
+  if (el.tagName.toLowerCase() !== "form") return el;
+  for (const c of el.querySelectorAll('button, input[type="submit"], input[type="button"], [role="button"]')) {
+    if (matchesActionIdentity(c, target.actionName, target.actionLabel)) return c;
+  }
+  for (const submitter of el.querySelectorAll(
+    'button[type="submit"], input[type="submit"], button:not([type])'
+  )) {
+    return submitter;
+  }
+  return el;
+}
+function walkStopAt(deadlineAt) {
+  const cap = Date.now() + WALK_ACTION_CAP_MS;
+  return deadlineAt === void 0 ? cap : Math.min(cap, deadlineAt - PENDING_PHASE_RESERVE_MS - WALK_DEADLINE_MARGIN_MS);
+}
 async function checkActionWiring(input) {
-  const { container, actionName, actionLabel, wiring, probe, user } = input;
+  const { actionName, actionLabel, wiring, probe, user } = input;
   const baseDiagnostics = {
     observedJsxElements: wiring.observedJsxElements,
     observedNativeProps: wiring.observedNativeProps,
@@ -1107,25 +1405,56 @@ async function checkActionWiring(input) {
       diagnostics: baseDiagnostics
     };
   }
-  const fired = await simulateAndCheck({
-    container,
-    user,
-    probe,
-    wiringKind: wiring.kind,
-    actionName,
-    actionLabel,
-    eventKind: "action.fired"
+  const kind = wiring.kind;
+  const walk = await walkToAction({
+    mount: input.mount,
+    controls: (container) => actionControls(container, kind, actionName, actionLabel),
+    press: async (control) => {
+      const before = probe.getFireLog().length;
+      try {
+        await dispatchTrigger(control.element, control.how, user);
+      } catch {
+        return false;
+      }
+      await flushPromises();
+      return probe.getFireLog().slice(before).some((e) => e.kind === "action.fired" && e.name === actionName);
+    },
+    describe: describeElement,
+    stopAt: input.stopAt,
+    maxPresses: WALK_MAX_PRESSES
   });
-  if (fired.fired) return null;
+  input.walkedTexts.push(...walk.screenTexts);
+  if (walk.fired) {
+    if (input.pendingTargets && walk.element && walk.container && (kind === "click" || kind === "submit")) {
+      input.pendingTargets.push({
+        actionName,
+        actionLabel,
+        wiringKind: kind,
+        element: walk.element,
+        container: walk.container
+      });
+    }
+    return null;
+  }
+  const allFired = probe.getFireLog().filter((e) => e.kind === "action.fired").map((e) => e.name);
+  const otherActionsFired = Array.from(new Set(allFired)).filter((n) => n !== actionName);
+  const stoppedBy = walk.stoppedBy === "dispatched" ? "explored" : walk.stoppedBy;
   return {
     check: "action-wiring",
     outcome: "unverified",
     subject: actionName,
-    reason: `Source confirms ${wiring.kind} wiring exists for action '${actionName}', but synthetic ${wiring.kind} did not dispatch it. Likely cause: conditional rendering, required input/form fill, or a multi-step interaction the static probe cannot complete.`,
-    elementHint: fired.attemptedHint,
+    reason: `Source confirms ${kind} wiring exists for action '${actionName}', but synthetic ${kind} did not dispatch it. Likely cause: conditional rendering, required input/form fill, or a multi-step interaction the static probe cannot complete.`,
+    ...walk.presses === 0 && stoppedBy === "explored" ? { elementHint: `No ${kind}-eligible element found in DOM` } : {},
     diagnostics: {
       ...baseDiagnostics,
-      actionsFiredFromClicks: fired.otherActionsFired
+      actionsFiredFromClicks: otherActionsFired,
+      walk: {
+        presses: walk.presses,
+        screens: walk.screens,
+        stoppedBy,
+        namedControlSeen: walk.namedControlSeen,
+        lastPressed: walk.lastPressed
+      }
     }
   };
 }
@@ -1193,32 +1522,6 @@ async function checkSelectionIdentity(input) {
   }
   return null;
 }
-async function simulateAndCheck(input) {
-  const { container, user, probe, wiringKind, actionName, actionLabel, eventKind } = input;
-  const candidates = findCandidateElements(container, wiringKind, actionName, actionLabel);
-  if (candidates.length === 0) {
-    return { fired: false, attemptedHint: `No ${wiringKind}-eligible element found in DOM` };
-  }
-  for (const el of candidates) {
-    const before = probe.getFireLog().length;
-    try {
-      await dispatchTrigger(el, wiringKind, user);
-    } catch {
-      continue;
-    }
-    await flushPromises();
-    const newEvents = probe.getFireLog().slice(before);
-    const matched = newEvents.some((e) => e.kind === eventKind && e.name === actionName);
-    if (matched) return { fired: true };
-  }
-  const allFired = probe.getFireLog().filter((e) => e.kind === "action.fired").map((e) => e.name);
-  const otherActionsFired = Array.from(new Set(allFired)).filter((n) => n !== actionName);
-  return {
-    fired: false,
-    attemptedHint: candidates.length ? describeElement(candidates[0]) : void 0,
-    otherActionsFired
-  };
-}
 async function dispatchTrigger(el, kind, user) {
   switch (kind) {
     case "click":
@@ -1304,40 +1607,40 @@ function closestForm(el) {
   }
   return null;
 }
-function findCandidateElements(container, kind, name, label) {
-  switch (kind) {
-    case "click":
-      return findActionElements(container, name, label);
-    case "submit": {
-      const all = container.querySelectorAll(
-        'form, button[type="submit"], input[type="submit"]'
-      );
-      return Array.from(all);
-    }
-    case "change": {
-      const all = container.querySelectorAll("select, input, textarea");
-      return Array.from(all);
-    }
-    case "keyboard-enter":
-      return findActionElements(container, name, label);
+function actionControls(container, kind, name, label) {
+  const clickables = findActionElements(container, name, label);
+  const named = (el) => matchesActionIdentity(el, name, label);
+  if (kind === "click" || kind === "keyboard-enter") {
+    return clickables.map((element) => ({ element, namesAction: named(element), how: kind }));
   }
+  const eligible = Array.from(
+    container.querySelectorAll(
+      kind === "submit" ? 'form, button[type="submit"], input[type="submit"]' : "select, input, textarea"
+    )
+  );
+  const seen = new Set(eligible);
+  return [
+    ...eligible.map((element) => ({ element, namesAction: named(element), how: kind })),
+    ...clickables.filter((el) => !seen.has(el)).map((element) => ({ element, namesAction: named(element), how: "click" }))
+  ];
 }
 function checkPropCoverage(input) {
-  const { container, propsSpec, mockupProps } = input;
+  const { container, walkedTexts, propsSpec, mockupProps } = input;
   const issues = [];
-  const text = container.textContent ?? "";
+  const texts = [container.textContent ?? "", ...walkedTexts];
   for (const [propName, entry] of Object.entries(propsSpec.properties)) {
     if (!entry.required) continue;
     const value = mockupProps[propName];
     if (value === void 0 || value === null) continue;
     const marker = pickScalarMarker(value);
     if (marker === null) continue;
-    if (!text.includes(marker)) {
+    if (!texts.some((text) => text.includes(marker))) {
+      const where = walkedTexts.length > 0 ? ", on the first screen or any screen the action walk reached" : "";
       issues.push({
         check: "prop-coverage",
         outcome: "unverified",
         subject: propName,
-        reason: `Required prop '${propName}' value (${JSON.stringify(marker).slice(0, 60)}) not visible in rendered DOM`
+        reason: `Required prop '${propName}' value (${JSON.stringify(marker).slice(0, 60)}) not visible in rendered DOM${where}`
       });
     }
   }
@@ -1377,26 +1680,28 @@ async function checkStreamRerender(input) {
   }
   return null;
 }
-function findActionElements(container, name, label) {
+function matchesActionIdentity(el, name, label) {
+  const norm = (s) => s.toLowerCase().replace(/[\s_-]+/g, "");
+  const aria = (el.getAttribute("aria-label") ?? "").toLowerCase();
+  const txt = (el.textContent ?? "").toLowerCase();
+  const dataAction = (el.getAttribute("data-action") ?? "").toLowerCase();
+  return aria.includes(label.toLowerCase()) || txt.includes(label.toLowerCase()) || norm(aria).includes(norm(name)) || norm(txt).includes(norm(name)) || dataAction === name.toLowerCase() || norm(txt).includes(norm(label));
+}
+function findActionElements(container, name, label, options = {}) {
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
-  const norm = (s) => s.toLowerCase().replace(/[\s_-]+/g, "");
-  const nameKey = norm(name);
-  const labelKey = norm(label);
   const allClickable = container.querySelectorAll(
     'button, [role="button"], input[type="submit"], input[type="button"], a[href]'
   );
   for (const el of allClickable) {
-    const aria = (el.getAttribute("aria-label") ?? "").toLowerCase();
-    const txt = (el.textContent ?? "").toLowerCase();
-    const dataAction = (el.getAttribute("data-action") ?? "").toLowerCase();
-    if (aria.includes(label.toLowerCase()) || txt.includes(label.toLowerCase()) || norm(aria).includes(nameKey) || norm(txt).includes(nameKey) || dataAction === name.toLowerCase() || norm(txt).includes(labelKey)) {
+    if (matchesActionIdentity(el, name, label)) {
       if (!seen.has(el)) {
         seen.add(el);
         candidates.push(el);
       }
     }
   }
+  if (options.identityOnly) return candidates;
   for (const el of allClickable) {
     if (!seen.has(el)) {
       seen.add(el);
@@ -1436,6 +1741,7 @@ function flushPromises() {
 }
 
 // src/harness/check/runtime-render/render-check-worker.ts
+init_verdict_line();
 async function readAllStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -1444,8 +1750,7 @@ async function readAllStdin() {
   return Buffer.concat(chunks).toString("utf8");
 }
 function emit(value) {
-  process.stdout.write(`${JSON.stringify(value)}
-`);
+  process.stdout.write(formatVerdictLine(value));
 }
 async function workerMain(raw) {
   try {