@ggui-ai/ui-gen 0.10.0 → 0.12.0

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

@@ -0,0 +1,1458 @@
+import { listContractGadgets, HOOK_NAME_RE } from '@ggui-ai/protocol';
+import ts from 'typescript';
+import { createRequire } from 'module';
+
+// src/harness/check/runtime-render/render-check.ts
+
+// src/harness/check/runtime-render/probe.ts
+function makeInternals() {
+  return {
+    fireLog: [],
+    streamHandlers: /* @__PURE__ */ new Map(),
+    registeredStreams: /* @__PURE__ */ new Set()
+  };
+}
+function createProbe() {
+  let internals = makeInternals();
+  const probe = {
+    emitStream: (eventName, payload) => {
+      const handlers = internals.streamHandlers.get(eventName);
+      if (!handlers) return;
+      for (const handler of handlers) handler(payload);
+    },
+    getFireLog: () => internals.fireLog.slice(),
+    getRegistered: () => ({
+      streams: Array.from(internals.registeredStreams)
+    }),
+    fired: (actionName) => internals.fireLog.some((e) => e.kind === "action.fired" && e.name === actionName),
+    installPostMessageSpy: () => installPostMessageSpy(probe),
+    reset: () => {
+      internals = makeInternals();
+      probe.__internals = internals;
+    },
+    __internals: internals
+  };
+  return probe;
+}
+function installPostMessageSpy(probe) {
+  const parent = globalThis.window?.parent;
+  if (!parent || typeof parent.postMessage !== "function") {
+    return () => {
+    };
+  }
+  const original = parent.postMessage;
+  const spy = (...args) => {
+    const envelope = args[0];
+    recordEnvelope(probe.__internals, envelope);
+    return original.apply(parent, args);
+  };
+  try {
+    Object.defineProperty(parent, "postMessage", {
+      value: spy,
+      configurable: true,
+      writable: true
+    });
+  } catch {
+    return () => {
+    };
+  }
+  return () => {
+    try {
+      Object.defineProperty(parent, "postMessage", {
+        value: original,
+        configurable: true,
+        writable: true
+      });
+    } catch {
+    }
+  };
+}
+function recordEnvelope(internals, envelope) {
+  if (!envelope || typeof envelope !== "object") return;
+  const e = envelope;
+  if (typeof e.method !== "string") return;
+  const params = e.params ?? {};
+  switch (e.method) {
+    case "ui/open-link": {
+      const url = typeof params.url === "string" ? params.url : "";
+      internals.fireLog.push({
+        kind: "link.opened",
+        url,
+        ts: Date.now()
+      });
+      return;
+    }
+    case "ui/request-display-mode": {
+      const mode = typeof params.mode === "string" ? params.mode : "";
+      internals.fireLog.push({
+        kind: "displayMode.requested",
+        mode,
+        ts: Date.now()
+      });
+      return;
+    }
+    case "tools/call": {
+      return;
+    }
+    default:
+      return;
+  }
+}
+function createProbeWireConfig(probe) {
+  return {
+    app: {
+      appId: "probe-app",
+      appName: "Probe",
+      appDescription: "Eval-time probe wire config"
+    },
+    render: {
+      sessionId: "probe-render",
+      isConnected: true
+    },
+    auth: {
+      isAuthenticated: false
+    },
+    dispatch: (actionName, data) => {
+      probe.__internals.fireLog.push({
+        kind: "action.fired",
+        name: actionName,
+        payload: data,
+        ts: Date.now()
+      });
+    },
+    subscribe: (eventType, handler) => {
+      probe.__internals.registeredStreams.add(eventType);
+      let set = probe.__internals.streamHandlers.get(eventType);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        probe.__internals.streamHandlers.set(eventType, set);
+      }
+      const wrapped = handler;
+      set.add(wrapped);
+      return () => {
+        set.delete(wrapped);
+      };
+    }
+    // The WireConfig surface is dispatch + subscribe only. Capability
+    // hooks live in `@ggui-ai/gadgets` and own their own lifecycle —
+    // they never route through WireConfig.
+  };
+}
+
+// src/internal/evaluate-component-source.ts
+async function evaluateComponentSource(sourceCode, sandboxRequire) {
+  const esbuild = await import('esbuild');
+  const { Script } = await import('vm');
+  const cjsResult = await esbuild.transform(sourceCode, {
+    loader: "tsx",
+    target: "es2020",
+    format: "cjs",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    sourcefile: "Component.tsx"
+  });
+  const sandboxModule = { exports: {} };
+  const wrappedCode = `(function(require, exports, module) {
+${cjsResult.code}
+})`;
+  const script = new Script(wrappedCode, { filename: "Component.cjs" });
+  const fn = script.runInThisContext();
+  fn(sandboxRequire, sandboxModule.exports, sandboxModule);
+  return sandboxModule.exports;
+}
+
+// src/harness/check/runtime-render/load-component.ts
+async function loadComponent(input) {
+  const { sourceCode, moduleResolutions = {} } = input;
+  const { createRequire: createRequire2 } = await import('module');
+  const require_ = createRequire2(import.meta.url);
+  const sandboxRequire = (id) => {
+    if (id in moduleResolutions) return moduleResolutions[id];
+    if (id === "react/jsx-runtime" || id === "react/jsx-dev-runtime") {
+      return require_("react/jsx-runtime");
+    }
+    if (id === "react") return require_("react");
+    if (id === "react-dom" || id.startsWith("react-dom/")) {
+      return require_(id);
+    }
+    if (id === "@ggui-ai/wire") return require_("@ggui-ai/wire");
+    if (id.startsWith("@ggui-ai/design")) {
+      try {
+        return require_(id);
+      } catch {
+        throw new Error(
+          `Required dependency not available in render-check sandbox: ${id}. Install @ggui-ai/design or run render-check from an environment that has it.`
+        );
+      }
+    }
+    if (id === "@ggui-ai/gadgets") {
+      try {
+        return require_("@ggui-ai/gadgets");
+      } catch {
+        throw new Error(
+          `Required dependency not available in render-check sandbox: ${id}. Install @ggui-ai/gadgets or pass it through moduleResolutions.`
+        );
+      }
+    }
+    throw new Error(`Import not allowed in render-check sandbox: ${id}`);
+  };
+  const exportsRecord = await evaluateComponentSource(sourceCode, sandboxRequire);
+  const candidate = exportsRecord.default;
+  if (typeof candidate !== "function") {
+    throw new Error("Compiled component has no default-exported function");
+  }
+  return { Component: candidate };
+}
+var NATIVE_CLICK_PROPS = /* @__PURE__ */ new Set(["onClick"]);
+var NATIVE_SUBMIT_PROPS = /* @__PURE__ */ new Set(["onSubmit"]);
+var NATIVE_CHANGE_PROPS = /* @__PURE__ */ new Set(["onChange"]);
+var NATIVE_KEY_PROPS = /* @__PURE__ */ new Set(["onKeyDown", "onKeyUp", "onKeyPress"]);
+var HOST_CLICK_TAGS = /* @__PURE__ */ new Set(["button", "a", "div", "span", "li", "input"]);
+var HOST_CHANGE_TAGS = /* @__PURE__ */ new Set(["select", "input", "textarea"]);
+function findWiring(input) {
+  const { sourceCode, hookName, hookArg } = input;
+  const sf = ts.createSourceFile("Component.tsx", sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  const hookBindings = findHookBindings(sf, hookName, hookArg);
+  if (hookBindings.length === 0) {
+    return {
+      kind: "missing",
+      reason: `Hook ${hookName}('${hookArg}') is not destructured in the component`,
+      observedJsxElements: [],
+      observedNativeProps: [],
+      observedCustomProps: []
+    };
+  }
+  const callableNames = expandAliases(sf, hookBindings);
+  const observedJsxElements = [];
+  const observedNativeProps = [];
+  const observedCustomProps = [];
+  let sawClickOnHost = false;
+  let sawSubmitOnForm = false;
+  let sawChangeOnNativeInput = false;
+  let sawKeyOnAnything = false;
+  let sawNonNativeProp = false;
+  const customPropElements = [];
+  const submitButton = { found: false };
+  function visit(node) {
+    if (ts.isJsxAttribute(node) && node.initializer) {
+      const attrName = node.name.getText(sf);
+      const initRefs = findReferencedNames(node.initializer, callableNames);
+      if (initRefs.size > 0) {
+        const parent = node.parent.parent;
+        const tagName = getTagName(parent);
+        if (tagName) observedJsxElements.push(tagName);
+        const isHostTag = isHostElementTag(tagName ?? "");
+        if (NATIVE_CLICK_PROPS.has(attrName)) {
+          observedNativeProps.push(attrName);
+          if (isHostTag && (HOST_CLICK_TAGS.has((tagName ?? "").toLowerCase()) || tagName === "button")) {
+            sawClickOnHost = true;
+          } else {
+            sawClickOnHost = true;
+          }
+        } else if (NATIVE_SUBMIT_PROPS.has(attrName)) {
+          observedNativeProps.push(attrName);
+          if ((tagName ?? "").toLowerCase() === "form") sawSubmitOnForm = true;
+          else sawSubmitOnForm = true;
+        } else if (NATIVE_CHANGE_PROPS.has(attrName)) {
+          observedNativeProps.push(attrName);
+          if (HOST_CHANGE_TAGS.has((tagName ?? "").toLowerCase())) {
+            sawChangeOnNativeInput = true;
+          } else {
+            observedCustomProps.push(attrName);
+            sawNonNativeProp = true;
+            if (tagName) customPropElements.push(tagName);
+          }
+        } else if (NATIVE_KEY_PROPS.has(attrName)) {
+          observedNativeProps.push(attrName);
+          sawKeyOnAnything = true;
+        } else {
+          observedCustomProps.push(attrName);
+          sawNonNativeProp = true;
+          if (tagName) customPropElements.push(tagName);
+        }
+      }
+    }
+    if (ts.isJsxOpeningLikeElement(node)) {
+      const tag = getTagName(node);
+      if ((tag ?? "").toLowerCase() === "button") {
+        const typeAttr = node.attributes.properties.find(
+          (p) => ts.isJsxAttribute(p) && p.name.getText(sf) === "type"
+        );
+        if (typeAttr && ts.isJsxAttribute(typeAttr) && typeAttr.initializer) {
+          const v = typeAttr.initializer.getText(sf).toLowerCase();
+          if (v.includes("submit")) submitButton.found = true;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  if (sawClickOnHost) {
+    return wrapDetection("click", observedJsxElements, observedNativeProps, observedCustomProps);
+  }
+  if (sawSubmitOnForm || submitButton.found) {
+    return wrapDetection("submit", observedJsxElements, observedNativeProps, observedCustomProps);
+  }
+  if (sawChangeOnNativeInput) {
+    return wrapDetection("change", observedJsxElements, observedNativeProps, observedCustomProps);
+  }
+  if (sawKeyOnAnything) {
+    return wrapDetection("keyboard-enter", observedJsxElements, observedNativeProps, observedCustomProps);
+  }
+  if (sawNonNativeProp) {
+    const props = Array.from(new Set(observedCustomProps)).join(", ");
+    const tags = Array.from(new Set(customPropElements)).join(", ");
+    return {
+      kind: "unverified",
+      reason: `Source indicates non-click or non-native wiring; static probe did not verify execution deterministically. Callback flows into ${props} on <${tags}>.`,
+      observedJsxElements: dedupe(observedJsxElements),
+      observedNativeProps: dedupe(observedNativeProps),
+      observedCustomProps: dedupe(observedCustomProps)
+    };
+  }
+  return {
+    kind: "missing",
+    reason: `Hook ${hookName}('${hookArg}') is destructured but never referenced in any JSX attribute`,
+    observedJsxElements: [],
+    observedNativeProps: [],
+    observedCustomProps: []
+  };
+}
+function findHookBindings(sf, hookName, hookArg) {
+  const bindings = [];
+  function visit(node) {
+    if (ts.isVariableDeclaration(node) && node.initializer && ts.isCallExpression(node.initializer)) {
+      const call = node.initializer;
+      const callee = call.expression.getText(sf);
+      if (callee !== hookName) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+      const firstArg = call.arguments[0];
+      if (!firstArg || !ts.isStringLiteral(firstArg)) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+      if (firstArg.text !== hookArg) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+      if (ts.isIdentifier(node.name)) {
+        bindings.push(node.name.text);
+      } else if (ts.isObjectBindingPattern(node.name)) {
+        for (const elem of node.name.elements) {
+          const target = elem.name;
+          if (ts.isIdentifier(target)) bindings.push(target.text);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  return bindings;
+}
+function expandAliases(sf, bindings) {
+  const all = new Set(bindings);
+  function visit(node) {
+    if (ts.isVariableDeclaration(node) && node.initializer && ts.isIdentifier(node.name)) {
+      const newName = node.name.text;
+      const init = node.initializer;
+      if (ts.isIdentifier(init) && all.has(init.text)) {
+        all.add(newName);
+      }
+      if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+        if (bodyReferences(init.body, all)) {
+          all.add(newName);
+        }
+      }
+      if (ts.isCallExpression(init)) {
+        if (bodyReferences(init, all)) {
+          all.add(newName);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  return all;
+}
+function bodyReferences(body, names) {
+  let found = false;
+  function walk(n) {
+    if (found) return;
+    if (ts.isIdentifier(n) && names.has(n.text)) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(n, walk);
+  }
+  walk(body);
+  return found;
+}
+function findReferencedNames(node, names) {
+  const found = /* @__PURE__ */ new Set();
+  function walk(n) {
+    if (ts.isIdentifier(n) && names.has(n.text)) {
+      found.add(n.text);
+    }
+    ts.forEachChild(n, walk);
+  }
+  walk(node);
+  return found;
+}
+function getTagName(el) {
+  if (ts.isJsxOpeningLikeElement(el)) {
+    return el.tagName.getText();
+  }
+  return null;
+}
+function isHostElementTag(name) {
+  if (!name) return false;
+  return name[0] === name[0].toLowerCase();
+}
+function wrapDetection(kind, jsx, native, custom) {
+  return {
+    kind,
+    observedJsxElements: dedupe(jsx),
+    observedNativeProps: dedupe(native),
+    observedCustomProps: dedupe(custom)
+  };
+}
+function dedupe(arr) {
+  return Array.from(new Set(arr));
+}
+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/internal/open-record.ts
+function openRecord(o) {
+  return o;
+}
+function hostGlobals() {
+  return openRecord(globalThis);
+}
+
+// src/harness/check/runtime-render/host-boundary.ts
+function getMethod(o, name) {
+  if (typeof o !== "object" && typeof o !== "function") return void 0;
+  if (o === null) return void 0;
+  const v = openRecord(o)[name];
+  if (typeof v !== "function") return void 0;
+  return v.bind(o);
+}
+function toMinimalElement(v) {
+  if (typeof v === "object" && v !== null && typeof openRecord(v).tagName === "string" && typeof openRecord(v).getAttribute === "function" && typeof openRecord(v).querySelectorAll === "function") {
+    return v;
+  }
+  throw new Error(
+    "[runtime-render] host value lacks the element surface (tagName/getAttribute/querySelectorAll)"
+  );
+}
+function buildClickUser(userEventModule, doc) {
+  const setup = getMethod(userEventModule, "setup");
+  const instance = setup ? setup({ document: doc }) : userEventModule;
+  const click = getMethod(instance, "click");
+  if (!click) {
+    throw new Error(
+      "[runtime-render] user-event module exposes neither setup().click nor click()"
+    );
+  }
+  return {
+    click: async (el) => {
+      await click(el);
+    }
+  };
+}
+function toEventDispatcher(el) {
+  const dispatch = getMethod(el, "dispatchEvent");
+  if (!dispatch) {
+    throw new Error(
+      `[runtime-render] element <${el.tagName.toLowerCase()}> has no dispatchEvent`
+    );
+  }
+  return {
+    dispatchEvent: (ev) => {
+      dispatch(ev);
+    }
+  };
+}
+function editableSurface(el) {
+  return el;
+}
+function parentLink(node) {
+  return node;
+}
+
+// src/harness/check/runtime-render/render-check.ts
+async function runRenderCheckInProcess(input) {
+  const t0 = Date.now();
+  const issues = [];
+  const teardown = await setupHappyDom();
+  let uninstallSpy;
+  let uninstallGadgetRegistry;
+  try {
+    const React = await import('react');
+    const ReactJsxRuntime = await import('react/jsx-runtime');
+    const Wire = await import('@ggui-ai/wire');
+    const { GguiWireProvider } = Wire;
+    const moduleResolutions = {
+      "react": React,
+      "react/jsx-runtime": ReactJsxRuntime,
+      "@ggui-ai/wire": Wire
+    };
+    const designSpecifiers = [
+      "@ggui-ai/design",
+      "@ggui-ai/design/primitives",
+      "@ggui-ai/design/components",
+      "@ggui-ai/design/compositions",
+      "@ggui-ai/design/interact"
+    ];
+    for (const id of designSpecifiers) {
+      try {
+        moduleResolutions[id] = await import(id);
+      } catch {
+      }
+    }
+    try {
+      moduleResolutions["@ggui-ai/gadgets"] = await import('@ggui-ai/gadgets');
+    } catch {
+    }
+    uninstallGadgetRegistry = installGadgetStubRegistry(input.contract);
+    for (const pkg of collectThirdPartyGadgetPackages(input.contract)) {
+      if (pkg in moduleResolutions) continue;
+      moduleResolutions[pkg] = buildGadgetPackageProbeShim(pkg);
+    }
+    let Component;
+    try {
+      const loaded = await loadComponent({
+        sourceCode: input.sourceCode,
+        moduleResolutions
+      });
+      Component = loaded.Component;
+    } catch (e) {
+      issues.push({
+        check: "render-no-throw",
+        outcome: "failed",
+        reason: `Failed to load component: ${e instanceof Error ? e.message : String(e)}`
+      });
+      return finalize(issues, t0, 0, 0);
+    }
+    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;
+    const originalConsoleError = console.error;
+    let loopSignature = null;
+    let capturedComponentStack = null;
+    const loopPatterns = [
+      [/Maximum update depth exceeded/i, "max-update-depth"],
+      [/Too many re-renders/i, "too-many-renders"],
+      [/Rendered more hooks than during the previous render/i, "hook-count-drift"]
+    ];
+    console.error = (...args) => {
+      const text = args.map((a) => typeof a === "string" ? a : "").join(" ");
+      if (!capturedComponentStack) {
+        for (const arg of args) {
+          if (typeof arg === "string" && /^\s*at\s+\S/m.test(arg) && arg.length > 20) {
+            capturedComponentStack = arg;
+            break;
+          }
+        }
+        if (!capturedComponentStack) {
+          const stackMatch = text.match(/(?:^|\n)((?:\s*at\s+\S[^\n]*\n?){2,})/);
+          if (stackMatch) {
+            capturedComponentStack = stackMatch[1].trim();
+          }
+        }
+      }
+      for (const [pattern, tag] of loopPatterns) {
+        if (pattern.test(text)) {
+          loopSignature = tag;
+          throw new Error(`[runtime-render] infinite render loop detected (${tag})`);
+        }
+      }
+      originalConsoleError.apply(console, args);
+    };
+    const boundaryRef = {
+      stack: null,
+      error: null
+    };
+    class ProbeErrorBoundary extends React.Component {
+      state = { caught: false };
+      static getDerivedStateFromError() {
+        return { caught: true };
+      }
+      componentDidCatch(error, errorInfo) {
+        if (errorInfo.componentStack && !boundaryRef.stack) {
+          boundaryRef.stack = errorInfo.componentStack;
+        }
+        if (!boundaryRef.error) {
+          boundaryRef.error = error;
+        }
+      }
+      render() {
+        if (this.state.caught) return null;
+        return this.props.children;
+      }
+    }
+    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 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?.();
+      });
+      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 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 ? `
+  Stack (user frames): ${userFrames.join(" | ")}` : "";
+      const componentBlock = componentFrames.length ? `
+  Component stack: ${componentFrames.join(" > ")}` : "";
+      const loopReason = `${baseReason}${stackBlock}${componentBlock}`;
+      issues.push({
+        check: "render-no-throw",
+        outcome: "failed",
+        reason: loopReason
+      });
+      console.error = originalConsoleError;
+      return finalize(issues, t0, 0, 0);
+    }
+    console.error = originalConsoleError;
+    if (boundaryRef.stack || boundaryRef.error) {
+      const componentFrames = (boundaryRef.stack ?? "").split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at ")).slice(0, 4);
+      const compBlock = componentFrames.length ? `
+  Component stack: ${componentFrames.join(" > ")}` : "";
+      const errMsg = boundaryRef.error ? boundaryRef.error.message : "(no error message)";
+      issues.push({
+        check: "render-no-throw",
+        outcome: "failed",
+        reason: `Render threw: ${errMsg}${compBlock}`
+      });
+      cleanup();
+      return finalize(issues, t0, 0, 0);
+    }
+    const container = toMinimalElement(renderResult.container);
+    const user = buildClickUser(userEvent, hostGlobals().document);
+    let actionsChecked = 0;
+    let streamsChecked = 0;
+    try {
+      if (input.contract?.actionSpec) {
+        const actionSpec = input.contract.actionSpec;
+        for (const [name, entry] of Object.entries(actionSpec)) {
+          actionsChecked++;
+          const wiring = findWiring({
+            sourceCode: input.sourceCode,
+            hookName: "useAction",
+            hookArg: name
+          });
+          const issue = await checkActionWiring({
+            container,
+            actionName: name,
+            actionLabel: entry.label,
+            wiring,
+            probe,
+            user
+          });
+          if (issue) issues.push(issue);
+        }
+      }
+      if (input.contract?.actionSpec) {
+        for (const [name, entry] of Object.entries(input.contract.actionSpec)) {
+          const idField = idLikeRequiredStringField(
+            entry.schema
+          );
+          if (idField === null) continue;
+          const issue = await checkSelectionIdentity({
+            container,
+            probe,
+            user,
+            actionName: name,
+            idField
+          });
+          if (issue) issues.push(issue);
+        }
+      }
+      if (input.contract?.propsSpec) {
+        for (const issue of checkPropCoverage({
+          container,
+          propsSpec: input.contract.propsSpec,
+          mockupProps: input.mockupProps
+        })) {
+          issues.push(issue);
+        }
+      }
+      if (input.contract?.propsSpec) {
+        const propsSpec5c = input.contract.propsSpec;
+        const normalize = (s) => (s ?? "").replace(/\s+/g, " ").trim();
+        const baseText = normalize(container.textContent);
+        for (const [propName, entry] of Object.entries(propsSpec5c.properties)) {
+          if (!entry.required) continue;
+          const orig = input.mockupProps[propName];
+          if (typeof orig !== "string" && typeof orig !== "number") continue;
+          const marker = pickScalarMarker(orig);
+          if (marker === null || !baseText.includes(marker)) continue;
+          const varied = typeof orig === "string" ? "Zzyzx Qw" : orig + 137731;
+          const variedProbe = createProbe();
+          const variedConfig = createProbeWireConfig(variedProbe);
+          let variedResult;
+          try {
+            variedResult = render(
+              React.createElement(GguiWireProvider, {
+                config: variedConfig,
+                children: React.createElement(ProbeErrorBoundary, {
+                  children: React.createElement(Component, {
+                    ...input.mockupProps,
+                    [propName]: varied
+                  })
+                })
+              })
+            );
+          } catch {
+            continue;
+          }
+          await flushPromises();
+          const variedText = normalize(variedResult.container.textContent);
+          variedResult.unmount();
+          if (variedText === baseText) {
+            issues.push({
+              check: "prop-sensitivity",
+              outcome: "failed",
+              subject: propName,
+              reason: `props.${propName} is displayed ('${marker}' appears in the DOM) but changing its value to '${String(varied)}' left the rendered output BYTE-IDENTICAL \u2014 the value is baked into the component instead of derived from the prop. A cached reuse of this blueprint under a different ${propName} would show the original value.`
+            });
+          }
+        }
+      }
+      if (input.contract?.streamSpec) {
+        const streamSpec = input.contract.streamSpec;
+        for (const [name] of Object.entries(streamSpec)) {
+          streamsChecked++;
+          const issue = await checkStreamRerender({
+            container,
+            eventName: name,
+            probe,
+            React
+          });
+          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();
+    }
+    return finalize(issues, t0, actionsChecked, streamsChecked);
+  } finally {
+    try {
+      uninstallSpy?.();
+    } catch {
+    }
+    try {
+      uninstallGadgetRegistry?.();
+    } catch {
+    }
+    teardown();
+  }
+}
+function installGadgetStubRegistry(contract) {
+  const declared = contract?.clientCapabilities?.gadgets;
+  if (!declared || Object.keys(declared).length === 0) {
+    return () => {
+    };
+  }
+  const noop = () => {
+  };
+  const valueStub = new Proxy(
+    {},
+    {
+      get: (_t, key) => key === "then" || typeof key === "symbol" ? void 0 : noop
+    }
+  );
+  const result = { status: "idle", value: valueStub, start: noop };
+  const resultStub = new Proxy(result, {
+    get: (t, key) => {
+      if (key === "status" || key === "value" || key === "start") {
+        return t[key];
+      }
+      return key === "then" || typeof key === "symbol" ? void 0 : noop;
+    }
+  });
+  const gadgets = {};
+  for (const use of contract ? listContractGadgets(contract) : []) {
+    const pkgSlot = gadgets[use.package] ??= {};
+    if (HOOK_NAME_RE.test(use.name)) {
+      pkgSlot[use.name] = () => resultStub;
+    } else {
+      pkgSlot[use.name] = () => null;
+    }
+  }
+  const root = globalThis;
+  const prior = root.__ggui__;
+  root.__ggui__ = { gadgets, publicEnv: {} };
+  return () => {
+    if (prior === void 0) {
+      delete root.__ggui__;
+    } else {
+      root.__ggui__ = prior;
+    }
+  };
+}
+function collectThirdPartyGadgetPackages(contract) {
+  if (!contract) return [];
+  const packages = /* @__PURE__ */ new Set();
+  for (const use of listContractGadgets(contract)) {
+    if (use.package !== "@ggui-ai/gadgets") packages.add(use.package);
+  }
+  return [...packages];
+}
+function buildGadgetPackageProbeShim(packageName) {
+  const resolveExport = (name) => {
+    const root = globalThis;
+    return root.__ggui__?.gadgets?.[packageName]?.[name];
+  };
+  const makeThunk = (name) => (...args) => {
+    const impl = resolveExport(name);
+    if (typeof impl !== "function") {
+      throw new Error(
+        `[gadget] export '${name}' from '${packageName}' is not loaded in the render-check probe \u2014 the component imports it but the contract's clientCapabilities.gadgets never declared it, so installGadgetStubRegistry planted no stub.`
+      );
+    }
+    return impl(...args);
+  };
+  return new Proxy(
+    {},
+    {
+      get: (_t, key) => {
+        if (typeof key === "symbol" || key === "default" || key === "then") {
+          return void 0;
+        }
+        return makeThunk(key);
+      },
+      // `key in ns` checks (esbuild interop may probe) report true so
+      // the named import binds to the thunk rather than `undefined`.
+      has: (_t, key) => typeof key !== "symbol" && key !== "then" && key !== "default"
+    }
+  );
+}
+async function setupHappyDom() {
+  const g = hostGlobals();
+  const pendingTimeouts = /* @__PURE__ */ new Set();
+  const pendingIntervals = /* @__PURE__ */ new Set();
+  const origSetTimeout = globalThis.setTimeout;
+  const origSetInterval = globalThis.setInterval;
+  const origClearTimeout = globalThis.clearTimeout;
+  const origClearInterval = globalThis.clearInterval;
+  globalThis.setTimeout = ((...args) => {
+    const id = origSetTimeout(...args);
+    pendingTimeouts.add(id);
+    return id;
+  });
+  globalThis.setInterval = ((...args) => {
+    const id = origSetInterval(...args);
+    pendingIntervals.add(id);
+    return id;
+  });
+  globalThis.clearTimeout = (id) => {
+    if (id !== void 0) pendingTimeouts.delete(id);
+    return origClearTimeout(id);
+  };
+  globalThis.clearInterval = (id) => {
+    if (id !== void 0) pendingIntervals.delete(id);
+    return origClearInterval(id);
+  };
+  const isTeardownArtifact = (err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /window is not defined/i.test(msg) || /document is not defined/i.test(msg) || /Cannot read propert(?:y|ies) of undefined \(reading 'event'\)/i.test(msg) || /requestAnimationFrame is not defined/i.test(msg);
+  };
+  const uncaughtHandler = (err) => {
+    if (isTeardownArtifact(err)) {
+      return;
+    }
+    process.nextTick(() => {
+      throw err;
+    });
+  };
+  const unhandledHandler = (reason) => {
+    if (isTeardownArtifact(reason)) return;
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    process.nextTick(() => {
+      throw err;
+    });
+  };
+  process.on("uncaughtException", uncaughtHandler);
+  process.on("unhandledRejection", unhandledHandler);
+  const cleanupAsyncInfra = () => {
+    for (const id of pendingTimeouts) origClearTimeout(id);
+    for (const id of pendingIntervals) origClearInterval(id);
+    pendingTimeouts.clear();
+    pendingIntervals.clear();
+    globalThis.setTimeout = origSetTimeout;
+    globalThis.setInterval = origSetInterval;
+    globalThis.clearTimeout = origClearTimeout;
+    globalThis.clearInterval = origClearInterval;
+    origSetTimeout(() => {
+      process.off("uncaughtException", uncaughtHandler);
+      process.off("unhandledRejection", unhandledHandler);
+    }, 100).unref?.();
+  };
+  if ("window" in g && "document" in g) {
+    const priorActFlag = g.IS_REACT_ACT_ENVIRONMENT;
+    g.IS_REACT_ACT_ENVIRONMENT = true;
+    return () => {
+      cleanupAsyncInfra();
+      if (priorActFlag === void 0) delete g.IS_REACT_ACT_ENVIRONMENT;
+      else g.IS_REACT_ACT_ENVIRONMENT = priorActFlag;
+    };
+  }
+  const { Window } = await import('happy-dom');
+  const window = new Window({ url: "https://render-check.local" });
+  const windowAny = openRecord(window);
+  const keys = [
+    "window",
+    "document",
+    "navigator",
+    "HTMLElement",
+    "Node",
+    "Element",
+    "Event",
+    "MouseEvent",
+    "KeyboardEvent",
+    "getComputedStyle",
+    "requestAnimationFrame",
+    "cancelAnimationFrame"
+  ];
+  const prior = {};
+  for (const k of keys) {
+    prior[k] = { value: g[k], existed: k in g };
+    try {
+      Object.defineProperty(g, k, {
+        value: windowAny[k],
+        writable: true,
+        configurable: true
+      });
+    } catch {
+    }
+  }
+  g.IS_REACT_ACT_ENVIRONMENT = true;
+  return () => {
+    cleanupAsyncInfra();
+    for (const k of keys) {
+      try {
+        if (prior[k].existed) {
+          Object.defineProperty(g, k, {
+            value: prior[k].value,
+            writable: true,
+            configurable: true
+          });
+        } else {
+          delete g[k];
+        }
+      } catch {
+      }
+    }
+    delete g.IS_REACT_ACT_ENVIRONMENT;
+  };
+}
+function finalize(issues, t0, actionsChecked, streamsChecked) {
+  const ok = !issues.some((i) => i.outcome === "failed");
+  return {
+    ok,
+    issues,
+    stats: {
+      actionsChecked,
+      streamsChecked,
+      renderMs: Date.now() - t0
+    }
+  };
+}
+async function checkActionWiring(input) {
+  const { container, actionName, actionLabel, wiring, probe, user } = input;
+  const baseDiagnostics = {
+    observedJsxElements: wiring.observedJsxElements,
+    observedNativeProps: wiring.observedNativeProps,
+    observedCustomProps: wiring.observedCustomProps
+  };
+  if (wiring.kind === "missing") {
+    return {
+      check: "action-wiring",
+      outcome: "failed",
+      subject: actionName,
+      reason: wiring.reason ?? `Action '${actionName}' is declared in contract but useAction('${actionName}') is not wired to any UI element`,
+      diagnostics: baseDiagnostics
+    };
+  }
+  if (wiring.kind === "unverified") {
+    return {
+      check: "action-wiring",
+      outcome: "unverified",
+      subject: actionName,
+      reason: wiring.reason ?? "Source indicates non-click or non-native wiring; static probe did not verify execution deterministically.",
+      diagnostics: baseDiagnostics
+    };
+  }
+  const fired = await simulateAndCheck({
+    container,
+    user,
+    probe,
+    wiringKind: wiring.kind,
+    actionName,
+    actionLabel,
+    eventKind: "action.fired"
+  });
+  if (fired.fired) return null;
+  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,
+    diagnostics: {
+      ...baseDiagnostics,
+      actionsFiredFromClicks: fired.otherActionsFired
+    }
+  };
+}
+function idLikeRequiredStringField(schema) {
+  if (schema === void 0) return null;
+  const properties = schema["properties"];
+  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
+  )) {
+    if (!/id$/i.test(propName)) continue;
+    if (!required.includes(propName)) continue;
+    const t = propSchema !== null && typeof propSchema === "object" ? propSchema["type"] : void 0;
+    if (t === "string") return propName;
+  }
+  return null;
+}
+async function checkSelectionIdentity(input) {
+  const { container, probe, user, actionName, idField } = input;
+  const clickables = Array.from(
+    container.querySelectorAll('button, [role="button"]')
+  );
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const el of clickables) {
+    const label = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+    if (label.length === 0) continue;
+    const group = byLabel.get(label);
+    if (group) group.push(el);
+    else byLabel.set(label, [el]);
+  }
+  for (const [label, group] of byLabel) {
+    if (group.length < 2) continue;
+    const payloadFor = async (el) => {
+      const before = probe.getFireLog().length;
+      try {
+        await user.click(el);
+      } catch {
+        return void 0;
+      }
+      await flushPromises();
+      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]);
+    const second = await payloadFor(group[1]);
+    if (first === void 0 || second === void 0) continue;
+    const idOf = (payload) => {
+      if (payload === null || typeof payload !== "object") return void 0;
+      const v = payload[idField];
+      return typeof v === "string" ? v : void 0;
+    };
+    const firstId = idOf(first);
+    const secondId = idOf(second);
+    if (firstId === void 0 || secondId === void 0) continue;
+    if (firstId === secondId) {
+      return {
+        check: "selection-identity",
+        outcome: "failed",
+        subject: actionName,
+        reason: `Two clickable elements share the visible label '${label}', and clicking EACH fired '${actionName}' with the same ${idField} ('${firstId}') \u2014 the action payload is keyed on the display value, not the element's identity. Distinct cells must send their own ${idField} (the contract requires it), or selecting one "${label}" acts on every "${label}".`,
+        elementHint: describeElement(group[0])
+      };
+    }
+    return null;
+  }
+  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":
+      await user.click(el);
+      return;
+    case "submit": {
+      const form = closestForm(el);
+      if (!form) return;
+      const ev = new globalThis.Event("submit", { bubbles: true, cancelable: true });
+      toEventDispatcher(form).dispatchEvent(ev);
+      return;
+    }
+    case "change": {
+      setSyntheticValue(el);
+      const ev = new globalThis.Event("change", { bubbles: true });
+      toEventDispatcher(el).dispatchEvent(ev);
+      return;
+    }
+    case "keyboard-enter": {
+      try {
+        await user.click(el);
+      } catch {
+      }
+      const KeyboardEventCtor = globalThis.KeyboardEvent;
+      if (KeyboardEventCtor) {
+        const ev = new KeyboardEventCtor("keydown", { key: "Enter", bubbles: true });
+        toEventDispatcher(el).dispatchEvent(ev);
+      }
+      return;
+    }
+  }
+}
+function setSyntheticValue(el) {
+  try {
+    const tag = el.tagName.toLowerCase();
+    const node = editableSurface(el);
+    if (tag === "select") {
+      const opts = node.options;
+      if (opts && opts.length > 0) {
+        const current = node.value ?? "";
+        let pick = opts[0].value;
+        for (let i = 0; i < opts.length; i++) {
+          if (opts[i].value !== current) {
+            pick = opts[i].value;
+            break;
+          }
+        }
+        node.value = pick;
+      }
+      return;
+    }
+    if (tag === "input") {
+      const type = (node.type ?? "text").toLowerCase();
+      if (type === "checkbox" || type === "radio") {
+        node.checked = !node.checked;
+        return;
+      }
+      if (type === "number" || type === "range") {
+        const cur = Number(node.value ?? "");
+        node.value = String(Number.isFinite(cur) ? cur + 1 : 1);
+        return;
+      }
+      node.value = node.value && node.value.length > 0 ? `${node.value}x` : "test";
+      return;
+    }
+    if (tag === "textarea") {
+      node.value = node.value && node.value.length > 0 ? `${node.value}x` : "test";
+      return;
+    }
+  } catch {
+  }
+}
+function closestForm(el) {
+  let cur = parentLink(el);
+  while (cur) {
+    if (cur.tagName && cur.tagName.toLowerCase() === "form") {
+      return toMinimalElement(cur);
+    }
+    cur = typeof cur.parentNode === "object" && cur.parentNode !== null ? parentLink(cur.parentNode) : null;
+  }
+  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 checkPropCoverage(input) {
+  const { container, propsSpec, mockupProps } = input;
+  const issues = [];
+  const text = container.textContent ?? "";
+  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)) {
+      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`
+      });
+    }
+  }
+  return issues;
+}
+async function checkStreamRerender(input) {
+  const { container, eventName, probe } = input;
+  if (!probe.getRegistered().streams.includes(eventName)) {
+    return {
+      check: "stream-rerender",
+      outcome: "unverified",
+      subject: eventName,
+      reason: `useStream('${eventName}') was never called \u2014 the stream event is declared in the contract but the component does not subscribe to it`
+    };
+  }
+  const before = container.textContent ?? "";
+  const marker = `__probe_marker_${Date.now()}__`;
+  const payload = { id: marker, text: marker, value: marker, message: marker, name: marker };
+  await new Promise((resolve) => {
+    setTimeout(() => {
+      probe.emitStream(eventName, payload);
+      resolve();
+    }, 0);
+  });
+  await flushPromises();
+  const after = container.textContent ?? "";
+  if (after === before) {
+    return {
+      check: "stream-rerender",
+      outcome: "unverified",
+      subject: eventName,
+      reason: `useStream('${eventName}') is subscribed but emitting a payload did not change the DOM`
+    };
+  }
+  if (!after.includes(marker)) {
+    return null;
+  }
+  return null;
+}
+function findActionElements(container, name, label) {
+  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 (!seen.has(el)) {
+        seen.add(el);
+        candidates.push(el);
+      }
+    }
+  }
+  for (const el of allClickable) {
+    if (!seen.has(el)) {
+      seen.add(el);
+      candidates.push(el);
+    }
+  }
+  return candidates;
+}
+function describeElement(el) {
+  const tag = el.tagName.toLowerCase();
+  const aria = el.getAttribute("aria-label");
+  const txt = (el.textContent ?? "").trim().slice(0, 30);
+  if (aria) return `<${tag} aria-label="${aria}">`;
+  if (txt) return `<${tag}>${txt}</${tag}>`;
+  return `<${tag}>`;
+}
+function pickScalarMarker(value) {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (typeof value === "number") return String(value);
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const m = pickScalarMarker(item);
+      if (m) return m;
+    }
+    return null;
+  }
+  if (value && typeof value === "object") {
+    for (const v of Object.values(value)) {
+      const m = pickScalarMarker(v);
+      if (m) return m;
+    }
+  }
+  return null;
+}
+function flushPromises() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+// src/harness/check/runtime-render/render-check-worker.ts
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function emit(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+async function main() {
+  const raw = await readAllStdin();
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch (err) {
+    process.stderr.write(
+      `render-check worker: malformed input JSON \u2014 ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (typeof input.sourceCode !== "string" || input.sourceCode.length === 0) {
+    process.stderr.write(
+      "render-check worker: input.sourceCode must be a non-empty string\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const result = await runRenderCheckInProcess(input);
+  emit(result);
+}
+void main();
+//# sourceMappingURL=render-check-worker.js.map
+//# sourceMappingURL=render-check-worker.js.map