@ggui-ai/ui-gen 0.28.0 → 0.29.0

package/dist/blueprint-validator.js

@@ -1,2304 +1,9 @@
-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';
-import ts from 'typescript';
-import { primeInputs } from '@ggui-ai/ui-visual-tester/prime-inputs';
-
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/internal/verdict-line.ts
-function parseVerdictLine(stdout) {
-  const lines = stdout.split("\n");
-  for (let i = lines.length - 1; i >= 0; i -= 1) {
-    const line = lines[i];
-    if (line.startsWith(`${VERDICT_PREFIX} `)) return JSON.parse(line.slice(VERDICT_PREFIX.length + 1));
-  }
-  return void 0;
-}
-var VERDICT_PREFIX;
-var init_verdict_line = __esm({
-  "src/internal/verdict-line.ts"() {
-    VERDICT_PREFIX = "@@ggui-render-check-verdict@@";
-  }
-});
-
-// 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/.
-    new URL(`./${WORKER_BASENAME}.js`, import.meta.url),
-    // From dist/index.js.
-    new URL(`./harness/check/runtime-render/${WORKER_BASENAME}.js`, import.meta.url),
-    // From dist/harness/index.js.
-    new URL(`./check/runtime-render/${WORKER_BASENAME}.js`, import.meta.url),
-    // From dist/check/index.js, dist/advanced/index.js, dist/<flat>.js.
-    new URL(`../harness/check/runtime-render/${WORKER_BASENAME}.js`, import.meta.url)
-  ];
-  for (const jsUrl of jsCandidates) {
-    const jsPath = fileURLToPath(jsUrl);
-    if (existsSync(jsPath)) {
-      return { command: process.execPath, args: [jsPath] };
-    }
-  }
-  const tsCandidates = [
-    new URL(`./${WORKER_BASENAME}.ts`, import.meta.url),
-    new URL(`../harness/check/runtime-render/${WORKER_BASENAME}.ts`, import.meta.url)
-  ];
-  for (const tsUrl of tsCandidates) {
-    const tsPath = fileURLToPath(tsUrl);
-    if (existsSync(tsPath)) {
-      const require_ = createRequire(import.meta.url);
-      const tsxLoader = pathToFileURL(require_.resolve("tsx")).href;
-      return { command: process.execPath, args: ["--import", tsxLoader, tsPath] };
-    }
-  }
-  const tried = [...jsCandidates, ...tsCandidates].map((u) => fileURLToPath(u)).join(", ");
-  throw new Error(
-    `render-check: isolated worker not found at any of: ${tried}. Did \`pnpm build\` run?`
-  );
-}
-function failed(reason, t0) {
-  return {
-    ok: false,
-    issues: [{ check: "render-no-throw", outcome: "failed", reason }],
-    stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
-  };
-}
-function unverified(reason, t0) {
-  return {
-    ok: false,
-    issues: [{ check: "render-no-throw", outcome: "unverified", reason }],
-    stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
-  };
-}
-function mapSandboxResultToCheckResult(result, t0, boundMs = DEFAULT_RENDER_CHECK_HOST_BOUNDS.timeoutMs) {
-  if (result.outcome === "timeout") {
-    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(
-      `render check worker produced excessive output (${result.outcome}) \u2014 the component is likely in a pathological logging or error loop.`,
-      t0
-    );
-  }
-  if (result.outcome === "spawn-error") {
-    return unverified(
-      `render check worker failed to start \u2014 ${result.errorMessage}`,
-      t0
-    );
-  }
-  if (result.outcome === "canceled") {
-    return unverified("render check worker was canceled before completing.", t0);
-  }
-  if (result.outcome !== "exit") {
-    return unverified(
-      `render check worker ended with unexpected sandbox outcome '${result.outcome}'.`,
-      t0
-    );
-  }
-  if (result.exitCode !== 0) {
-    const tail = result.stderr.trim() || result.stdout.trim();
-    return unverified(
-      `render check worker exited ${result.exitCode}${tail ? ` \u2014 ${tail.slice(0, 600)}` : ""}`,
-      t0
-    );
-  }
-  let verdict;
-  try {
-    verdict = parseVerdictLine(result.stdout);
-  } catch (err) {
-    return unverified(
-      `render check worker verdict was not valid JSON \u2014 ${err instanceof Error ? err.message : String(err)}`,
-      t0
-    );
-  }
-  if (verdict === void 0) {
-    return unverified("render check worker exited without producing a verdict.", t0);
-  }
-  return verdict;
-}
-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: bounds.timeoutMs,
-    gracePeriodMs: bounds.gracePeriodMs,
-    maxStdoutBytes: CHECK_STDOUT_CAP,
-    nodeHeapMb: bounds.heapMb,
-    // 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.
-    env: { NODE_ENV: process.env.NODE_ENV ?? "production" }
-  });
-  const hostLoad = {
-    start: loadAtStart,
-    end: loadavg()[0] ?? 0,
-    cores: availableParallelism()
-  };
-  const mapped = mapSandboxResultToCheckResult(result, t0, bounds.timeoutMs);
-  return { ...mapped, stats: { ...mapped.stats, hostLoad } };
-}
-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"() {
-    init_verdict_line();
-    DEFAULT_RENDER_CHECK_HOST_BOUNDS = {
-      timeoutMs: 3e4,
-      heapMb: 512,
-      gracePeriodMs: 2e3
-    };
-    CHECK_STDOUT_CAP = 2 * 1024 * 1024;
-    WORKER_BASENAME = "render-check-worker";
-  }
-});
-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/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: createRequire3 } = await import('module');
-  const require_ = createRequire3(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));
-}
-
-// 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/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 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, options);
-}
-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, 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;
-    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,
-      catches: 0
-    };
-    class ProbeErrorBoundary extends React.Component {
-      state = { caught: false };
-      static getDerivedStateFromError() {
-        return { caught: true };
-      }
-      componentDidCatch(error, errorInfo) {
-        boundaryRef.catches += 1;
-        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;
-      }
-    }
-    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(cardTree()));
-      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;
-    let pendingTally;
-    const pendingTargets = [];
-    const walkedTexts = [];
-    try {
-      let inputPriming;
-      try {
-        inputPriming = { primed: primeInputs(renderResult.container) };
-      } catch (err) {
-        inputPriming = { error: err instanceof Error ? err.message : String(err) };
-      }
-      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 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({
-            mount,
-            actionName: name,
-            actionLabel: entry.label,
-            wiring,
-            probe,
-            user,
-            pendingTargets,
-            stopAt: walkStopAt(input.deadlineAt),
-            walkedTexts
-          });
-          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) {
-        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,
-          walkedTexts,
-          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.`
-            });
-          }
-        }
-      }
-      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, pendingTally);
-  } 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, pendingTally) {
-  const ok = !issues.some((i) => i.outcome === "failed");
-  return {
-    ok,
-    issues,
-    stats: {
-      actionsChecked,
-      streamsChecked,
-      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 { 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 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
-  });
-  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 ${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: otherActionsFired,
-      walk: {
-        presses: walk.presses,
-        screens: walk.screens,
-        stoppedBy,
-        namedControlSeen: walk.namedControlSeen,
-        lastPressed: walk.lastPressed
-      }
-    }
-  };
-}
-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 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 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, walkedTexts, propsSpec, mockupProps } = input;
-  const issues = [];
-  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 (!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${where}`
-      });
-    }
-  }
-  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 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 allClickable = container.querySelectorAll(
-    'button, [role="button"], input[type="submit"], input[type="button"], a[href]'
-  );
-  for (const el of allClickable) {
-    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);
-      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/prepare-mockup.ts
-function prepareMockupProps(input) {
-  const { contract, fixtureProps } = input;
-  const propsSpec = contract?.propsSpec;
-  const props = {};
-  const source = {};
-  const warnings = [];
-  if (!propsSpec || !propsSpec.properties) {
-    if (fixtureProps) {
-      Object.assign(props, fixtureProps);
-      for (const k of Object.keys(fixtureProps)) source[k] = "fixture";
-    }
-    return { props, source, warnings };
-  }
-  for (const [key, entry] of Object.entries(propsSpec.properties)) {
-    if (fixtureProps && Object.prototype.hasOwnProperty.call(fixtureProps, key)) {
-      props[key] = fixtureProps[key];
-      source[key] = "fixture";
-      continue;
-    }
-    const synth = synthesizePropValue(entry, key, warnings);
-    if (synth.kind === "ok") {
-      props[key] = synth.value;
-      source[key] = synth.source;
-    } else if (entry.required) {
-      warnings.push(`Required prop '${key}' could not be synthesized (${synth.reason})`);
-    }
-  }
-  return { props, source, warnings };
-}
-function synthesizePropValue(entry, fieldName, warnings) {
-  if (entry.example !== void 0) {
-    return { kind: "ok", value: entry.example, source: "entry-example" };
-  }
-  if (entry.default !== void 0) {
-    return { kind: "ok", value: entry.default, source: "entry-default" };
-  }
-  return synthesizeFromSchema(entry.schema, fieldName, warnings, 0);
-}
-var MAX_DEPTH = 6;
-function synthesizeFromSchema(schema, hint, warnings, depth, ordinal) {
-  if (!schema) return { kind: "fail", reason: "no schema" };
-  if (depth > MAX_DEPTH) return { kind: "fail", reason: "schema too deep" };
-  if (schema.default !== void 0) {
-    return { kind: "ok", value: schema.default, source: "schema-default" };
-  }
-  if (schema.example !== void 0) {
-    return { kind: "ok", value: schema.example, source: "schema-example" };
-  }
-  if (schema.enum && schema.enum.length > 0) {
-    return { kind: "ok", value: schema.enum[0], source: "schema-enum" };
-  }
-  if (schema.oneOf && schema.oneOf.length > 0) {
-    return synthesizeFromSchema(schema.oneOf[0], hint, warnings, depth + 1, ordinal);
-  }
-  if (schema.anyOf && schema.anyOf.length > 0) {
-    return synthesizeFromSchema(schema.anyOf[0], hint, warnings, depth + 1, ordinal);
-  }
-  if (Array.isArray(schema.type)) {
-    const primary = schema.type.find((t) => t !== "null") ?? "null";
-    return synthesizeFromSchema({ ...schema, type: primary }, hint, warnings, depth + 1, ordinal);
-  }
-  switch (schema.type) {
-    case "string": {
-      switch (schema.format) {
-        case "date":
-        case "date-time":
-          return { kind: "ok", value: "2026-04-13T12:00:00Z", source: "schema-synth" };
-        case "email":
-          return { kind: "ok", value: "user@example.com", source: "schema-synth" };
-        case "uri":
-        case "url":
-          return { kind: "ok", value: "https://example.com", source: "schema-synth" };
-        case "uuid":
-          return { kind: "ok", value: "00000000-0000-0000-0000-000000000000", source: "schema-synth" };
-        default: {
-          const cap = hint.charAt(0).toUpperCase() + hint.slice(1);
-          const value = ordinal === void 0 ? `Sample ${cap}` : `Sample ${cap} ${ordinal}`;
-          return { kind: "ok", value, source: "schema-synth" };
-        }
-      }
-    }
-    case "integer":
-    case "number": {
-      const min = typeof schema.minimum === "number" ? schema.minimum : 1;
-      const max = typeof schema.maximum === "number" ? schema.maximum : 100;
-      const value = Math.min(max, Math.max(min, 42));
-      return { kind: "ok", value, source: "schema-synth" };
-    }
-    case "boolean":
-      return { kind: "ok", value: true, source: "schema-synth" };
-    case "null":
-      return { kind: "ok", value: null, source: "schema-synth" };
-    case "array": {
-      if (!schema.items) {
-        return { kind: "ok", value: [], source: "schema-synth" };
-      }
-      const items = [];
-      for (let i = 0; i < 2; i++) {
-        const itemHint = `${hint}Item${i + 1}`;
-        const itemSynth = synthesizeFromSchema(schema.items, itemHint, warnings, depth + 1, i + 1);
-        if (itemSynth.kind === "ok") {
-          if (itemSynth.value !== null && typeof itemSynth.value === "object" && !Array.isArray(itemSynth.value) && !("id" in itemSynth.value)) {
-            itemSynth.value.id = `${hint}-${i + 1}`;
-          }
-          items.push(itemSynth.value);
-        }
-      }
-      return { kind: "ok", value: items, source: "schema-synth" };
-    }
-    case "object": {
-      const obj = {};
-      const propsMap = schema.properties ?? {};
-      const required = new Set(schema.required ?? []);
-      for (const [k, sub] of Object.entries(propsMap)) {
-        const subSynth = synthesizeFromSchema(sub, k, warnings, depth + 1, ordinal);
-        if (subSynth.kind === "ok") {
-          obj[k] = subSynth.value;
-        } else if (required.has(k)) {
-          warnings.push(
-            `Required object field '${hint}.${k}' could not be synthesized (${subSynth.reason})`
-          );
-        }
-      }
-      return { kind: "ok", value: obj, source: "schema-synth" };
-    }
-    default:
-      return { kind: "fail", reason: `unsupported schema type: ${schema.type ?? "unknown"}` };
-  }
-}
-
-// src/harness/check/runtime-render/adapter.ts
-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);
-      });
-    });
-  };
-  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();
-    }
-  };
-}
-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,
-        // ggui#1398: report-only — carried to the probe's meta for the bench, never an issue.
-        ...result.stats.pendingAffordance !== void 0 ? { pendingAffordance: result.stats.pendingAffordance } : {}
-      };
-    }
-  };
-}
-var DEFAULT_RUNTIME_RENDER_CHECK = createRuntimeRenderCheck();
-function classifyRenderCrashFix(reason) {
-  const r = reason.toLowerCase();
-  if (r.includes("too many re-renders") || r.includes("maximum update depth") || r.includes("infinite render loop")) {
-    return "Find the setState/dispatch call in your render body or useEffect. Either: (a) move the setState into an event handler, (b) add a proper useEffect dependency array so it doesn't fire every render, or (c) guard the setState with an equality check `if (next !== current) setX(next)`. Do NOT call setState in render or useEffect-without-deps.";
-  }
-  if (r.includes("cannot access") && r.includes("before initialization")) {
-    const symMatch = reason.match(/'([^']+)'/);
-    const sym = symMatch ? symMatch[1] : "the variable";
-    return `Temporal-dead-zone error on \`${sym}\`. You're referencing ${sym} (likely in a useEffect dependency array or a default value) BEFORE its \`const\`/\`let\` declaration. Move the declaration of ${sym} to the top of the component body, before any useEffect/useMemo/useCallback that reads it.`;
-  }
-  if (r.includes("is not defined")) {
-    const symMatch = reason.match(/(\w+) is not defined/);
-    const sym = symMatch ? symMatch[1] : "the symbol";
-    return `ReferenceError: \`${sym}\` is used in JSX/expression but never declared. Either: (a) add a \`const ${sym} = ...\` declaration in the component body, (b) destructure it from props/state, or (c) fix the typo if you meant a similarly-named local.`;
-  }
-  if (r.includes("is not iterable") || r.includes("symbol(symbol.iterator)")) {
-    return "Render iterated over a non-array. Find the `for...of`, `[...spread]`, or `.map`/`.filter`/`.reduce` call that crashed and either: (a) default the value to `[]` (`const items = props.items ?? []`), or (b) check it's an array before iterating (`Array.isArray(x) && ...`).";
-  }
-  if (r.includes("cannot read") || r.includes("undefined is not") || r.includes("null is not")) {
-    return "Null/undefined access. Add optional chaining (`obj?.field`) and default values for optional props/state before reading nested fields. Check your destructure patterns \u2014 destructuring undefined throws.";
-  }
-  return "Add null guards on optional props, handle empty arrays/strings, and verify all hook outputs before destructuring.";
-}
-function toEvalIssue(issue) {
-  if (issue.outcome === "verified" || issue.outcome === "skipped") return null;
-  const result = issue.outcome === "failed" ? "fail" : "warn";
-  const subject = issue.subject ?? "";
-  const subcategory = subject ? `runtime:${issue.check}:${subject}` : `runtime:${issue.check}`;
-  const elementHint = issue.elementHint ? ` (element: ${issue.elementHint})` : "";
-  const diag = issue.diagnostics;
-  const diagParts = [];
-  if (diag?.observedNativeProps?.length) {
-    diagParts.push(`native props: ${diag.observedNativeProps.join(", ")}`);
-  }
-  if (diag?.observedCustomProps?.length) {
-    diagParts.push(`custom props: ${diag.observedCustomProps.join(", ")}`);
-  }
-  if (diag?.observedJsxElements?.length) {
-    diagParts.push(`elements: ${diag.observedJsxElements.slice(0, 4).join(", ")}`);
-  }
-  if (diag?.actionsFiredFromClicks?.length) {
-    diagParts.push(`other actions fired from clicks: ${diag.actionsFiredFromClicks.join(", ")}`);
-  }
-  if (diag?.inputPriming) {
-    diagParts.push(
-      "primed" in diag.inputPriming ? `input priming: ${diag.inputPriming.primed} control(s) filled before the click` : `input priming failed: ${diag.inputPriming.error}`
-    );
-  }
-  if (diag?.walk) {
-    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) {
-    case "render-no-throw":
-      return {
-        tier: 0,
-        result,
-        category: "crash",
-        subcategory,
-        severity: "critical",
-        description: `Component crashed at runtime: ${issue.reason}`,
-        fix: classifyRenderCrashFix(issue.reason)
-      };
-    case "optional-props-omitted":
-      return {
-        tier: 0,
-        result,
-        category: "crash",
-        subcategory,
-        severity: "critical",
-        description: `Component crashed when optional props were omitted: ${issue.reason}`,
-        fix: `Guard every optional prop before member access (props.${subject.split(",")[0]?.trim() ?? "x"}?.map(...), a default via destructuring, or an early empty-state return). Optional props (no \`required: true\` in the contract) may be absent at runtime even though the harness fills them.`
-      };
-    case "action-wiring": {
-      const fix = issue.outcome === "unverified" ? `Source shows the action callback flowing into a non-native or custom-component prop. If wiring is intentional (e.g., Dropdown.onChange, drag-drop), this warn is informational \u2014 manual/browser verification is required to confirm. Otherwise wire to a native onClick={() => ${subject}(payload)} on <button> or design-system <Button>.` : `Wire ${subject}() to a native event prop. Common fix: <Button onClick={() => ${subject}(payload)}>Label</Button>. Source-AST analysis didn't find this wiring in your JSX.`;
-      return {
-        tier: 0,
-        result,
-        category: "contract",
-        subcategory,
-        severity: result === "fail" ? "critical" : "major",
-        description: `${issue.reason}${elementHint}${diagSuffix}`,
-        fix
-      };
-    }
-    case "selection-identity":
-      return {
-        tier: 0,
-        result,
-        category: "contract",
-        subcategory,
-        severity: "critical",
-        description: `${issue.reason}${elementHint}${diagSuffix}`,
-        fix: `Key the action payload (and any selection state) on the item's ID from the data, never on its display text. Common fix: map over items and pass the item's id into the handler \u2014 onClick={() => ${subject}({ ...payload, id: item.id })} \u2014 and store selection as the id (setSelected(item.id)), not the label.`
-      };
-    case "prop-sensitivity":
-      return {
-        tier: 0,
-        result,
-        category: "contract",
-        subcategory,
-        severity: "critical",
-        description: `${issue.reason}${diagSuffix}`,
-        fix: `Derive the display AND any logic from props.${subject} \u2014 render {props.${subject}} and branch on the prop's value, never on the literal value the request happened to mention (e.g. props.${subject} ?? 'January' followed by January-special-cased logic bakes the request into the component). The contract delivers the value; trust it.`
-      };
-    case "prop-coverage":
-      return {
-        tier: 0,
-        result,
-        category: "contract",
-        subcategory,
-        description: `${issue.reason}${diagSuffix}`,
-        fix: `Render props.${subject} somewhere in the JSX (e.g., <Text>{props.${subject}}</Text>). If you display a derived/formatted version, this warn may be a false positive.`
-      };
-    case "stream-rerender":
-      return {
-        tier: 0,
-        result,
-        category: "contract",
-        subcategory,
-        description: `${issue.reason}${diagSuffix}`,
-        fix: `Subscribe with const ${subject} = useStream('${subject}'); render ${subject}.latest && <Text>{${subject}.latest.field}</Text> or .all.map(...).`
-      };
-  }
-}
+import { DEFAULT_RUNTIME_RENDER_CHECK } from './chunk-BA4QYA6E.js';
+import './chunk-3NNNGNTO.js';
+import './chunk-FXRHWYIQ.js';
+import './chunk-KJWGZL5B.js';
+import './chunk-FLRNMZV2.js';
+import './chunk-G3PMV62Z.js';
 
 // src/blueprint-validator.ts
 function probeDidNotRunCode(status) {