@ggui-ai/ui-gen 0.23.0 → 0.25.0

package/dist/{axes-CzLEMDeB.d.ts → axes-CKVCzR_x.d.ts}

@@ -37,4 +37,4 @@ interface Classification {
     riskTier: RiskTier;
 }
 
-export type { AxisVector as A, Classification as C, FetchShape as F, LayoutShape as L, RiskTier as R, StreamEventKind as S, ToolingShape as T, WriteTrigger as W, AxisSource as a, RealtimeShape as b, RenderShape as c, StateShape as d, WriteShape as e, AxisProvenance as f };
+export type { AxisVector as A, Classification as C, FetchShape as F, LayoutShape as L, RiskTier as R, StateShape as S, ToolingShape as T, WriteShape as W, RenderShape as a, StreamEventKind as b, AxisSource as c, RealtimeShape as d, WriteTrigger as e, AxisProvenance as f };

package/dist/bank-CT4eEkta.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+
+/**
+ * The visual criteria bank — ggui#1436 (step 1 of the founder's visual-assessment steer).
+ *
+ * The bank is DATA, never code (#1437 authors it; #1060's bar-and-judge policy): a versioned set of
+ * criteria the judge, an instrument or a person answers off the frame, split as the founder ruled —
+ * `severity` is importance, `evaluation` the method, `status` the method's readiness (the only source
+ * of an `n/a`), `scope` where a row applies ({} = every card; {kind} / {canvas} / {preset} = one). The
+ * general rows are `criteria`; a preset's own expression is a `recipes` row carrying `scope.preset`.
+ * This module is the ONE loader: a malformed bank refuses at launch with the offending path named,
+ * never mid-run. Fields the loader does not read (`examples`, `fields`, `groups`, `seed`) are page
+ * matter and are dropped here; an additive field tomorrow does not break today's loader.
+ */
+
+/** Where a row applies; every key named must match the card's context. */
+declare const criteriaScopeSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodString>;
+    canvas: z.ZodOptional<z.ZodString>;
+    preset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const bankRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    scope: z.ZodDefault<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+        canvas: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    severity: z.ZodEnum<{
+        must: "must";
+        should: "should";
+    }>;
+    evaluation: z.ZodEnum<{
+        instrument: "instrument";
+        judge: "judge";
+        human: "human";
+    }>;
+    status: z.ZodEnum<{
+        live: "live";
+        reference: "reference";
+        planned: "planned";
+        manual: "manual";
+    }>;
+    text: z.ZodString;
+    evidence: z.ZodString;
+    fix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const criteriaBankSchema: z.ZodObject<{
+    version: z.ZodString;
+    applies: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        canvases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        scope: z.ZodDefault<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            canvas: z.ZodOptional<z.ZodString>;
+            preset: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        severity: z.ZodEnum<{
+            must: "must";
+            should: "should";
+        }>;
+        evaluation: z.ZodEnum<{
+            instrument: "instrument";
+            judge: "judge";
+            human: "human";
+        }>;
+        status: z.ZodEnum<{
+            live: "live";
+            reference: "reference";
+            planned: "planned";
+            manual: "manual";
+        }>;
+        text: z.ZodString;
+        evidence: z.ZodString;
+        fix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    recipes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        scope: z.ZodDefault<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            canvas: z.ZodOptional<z.ZodString>;
+            preset: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        severity: z.ZodEnum<{
+            must: "must";
+            should: "should";
+        }>;
+        evaluation: z.ZodEnum<{
+            instrument: "instrument";
+            judge: "judge";
+            human: "human";
+        }>;
+        status: z.ZodEnum<{
+            live: "live";
+            reference: "reference";
+            planned: "planned";
+            manual: "manual";
+        }>;
+        text: z.ZodString;
+        evidence: z.ZodString;
+        fix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CriteriaBank = z.infer<typeof criteriaBankSchema>;
+type BankRow = z.infer<typeof bankRowSchema>;
+type CriteriaScope = z.infer<typeof criteriaScopeSchema>;
+/** Every row of the bank — the general criteria, then the recipes. */
+declare function bankRows(bank: CriteriaBank): readonly BankRow[];
+/** The one door for bank data: refuses loudly, naming the path, before anything is judged. */
+declare function parseCriteriaBank(raw: unknown): CriteriaBank;
+
+export { type BankRow as B, type CriteriaBank as C, type CriteriaScope as a, bankRows as b, criteriaBankSchema as c, parseCriteriaBank as p };

package/dist/blueprint-validator.js

@@ -20,9 +20,25 @@ var __export = (target, all) => {
 // src/harness/check/runtime-render/render-check-host.ts
 var render_check_host_exports = {};
 __export(render_check_host_exports, {
+  DEFAULT_RENDER_CHECK_HOST_BOUNDS: () => DEFAULT_RENDER_CHECK_HOST_BOUNDS,
   mapSandboxResultToCheckResult: () => mapSandboxResultToCheckResult,
+  resolveRenderCheckHostBounds: () => resolveRenderCheckHostBounds,
+  resolveWorkerSpawn: () => resolveWorkerSpawn,
   runRenderCheckViaWorker: () => runRenderCheckViaWorker
 });
+function resolveRenderCheckHostBounds(bounds = {}) {
+  const timeoutMs = bounds.timeoutMs ?? DEFAULT_RENDER_CHECK_HOST_BOUNDS.timeoutMs;
+  const heapMb = bounds.heapMb ?? DEFAULT_RENDER_CHECK_HOST_BOUNDS.heapMb;
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 2) {
+    throw new RangeError(`render-check: timeoutMs must be an integer \u2265 2, got ${timeoutMs}`);
+  }
+  if (!Number.isInteger(heapMb) || heapMb < 1) {
+    throw new RangeError(`render-check: heapMb must be a positive integer, got ${heapMb}`);
+  }
+  const requestedGrace = bounds.gracePeriodMs ?? DEFAULT_RENDER_CHECK_HOST_BOUNDS.gracePeriodMs;
+  const gracePeriodMs = Math.max(1, Math.min(requestedGrace, Math.floor(timeoutMs / 2)));
+  return { timeoutMs, heapMb, gracePeriodMs };
+}
 function resolveWorkerSpawn() {
   const jsCandidates = [
     // Sibling — when import.meta.url is already .../harness/check/runtime-render/.
@@ -71,12 +87,12 @@ function unverified(reason, t0) {
     stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
   };
 }
-function mapSandboxResultToCheckResult(result, t0) {
+function mapSandboxResultToCheckResult(result, t0, boundMs = DEFAULT_RENDER_CHECK_HOST_BOUNDS.timeoutMs) {
   if (result.outcome === "timeout") {
     return {
       ok: false,
       issues: [],
-      incomplete: { kind: "timeout", elapsedMs: result.durationMs, boundMs: CHECK_TIMEOUT_MS },
+      incomplete: { kind: "timeout", elapsedMs: result.durationMs, boundMs },
       stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 }
     };
   }
@@ -121,8 +137,9 @@ function mapSandboxResultToCheckResult(result, t0) {
     );
   }
 }
-async function runRenderCheckViaWorker(input) {
+async function runRenderCheckViaWorker(input, options = {}) {
   const t0 = Date.now();
+  const bounds = resolveRenderCheckHostBounds(options.bounds);
   let spawn;
   try {
     spawn = resolveWorkerSpawn();
@@ -133,9 +150,10 @@ async function runRenderCheckViaWorker(input) {
   const result = await runSandboxed({
     command: spawn.command,
     args: spawn.args,
-    timeoutMs: CHECK_TIMEOUT_MS,
+    timeoutMs: bounds.timeoutMs,
+    gracePeriodMs: bounds.gracePeriodMs,
     maxStdoutBytes: CHECK_STDOUT_CAP,
-    nodeHeapMb: CHECK_NODE_HEAP_MB,
+    nodeHeapMb: bounds.heapMb,
     stdin: JSON.stringify(input),
     // NODE_ENV steers React's production vs development build — keep
     // parity with the caller; everything else stays on the sandbox's
@@ -147,15 +165,18 @@ async function runRenderCheckViaWorker(input) {
     end: loadavg()[0] ?? 0,
     cores: availableParallelism()
   };
-  const mapped = mapSandboxResultToCheckResult(result, t0);
+  const mapped = mapSandboxResultToCheckResult(result, t0, bounds.timeoutMs);
   return { ...mapped, stats: { ...mapped.stats, hostLoad } };
 }
-var CHECK_TIMEOUT_MS, CHECK_STDOUT_CAP, CHECK_NODE_HEAP_MB, WORKER_BASENAME;
+var DEFAULT_RENDER_CHECK_HOST_BOUNDS, CHECK_STDOUT_CAP, WORKER_BASENAME;
 var init_render_check_host = __esm({
   "src/harness/check/runtime-render/render-check-host.ts"() {
-    CHECK_TIMEOUT_MS = 3e4;
+    DEFAULT_RENDER_CHECK_HOST_BOUNDS = {
+      timeoutMs: 3e4,
+      heapMb: 512,
+      gracePeriodMs: 2e3
+    };
     CHECK_STDOUT_CAP = 2 * 1024 * 1024;
-    CHECK_NODE_HEAP_MB = 512;
     WORKER_BASENAME = "render-check-worker";
   }
 });
@@ -677,13 +698,13 @@ function editableSurface(el) {
 function parentLink(node) {
   return node;
 }
-async function runRenderCheck(input) {
+async function runRenderCheck(input, options = {}) {
   const g = hostGlobals();
   if ("window" in g && "document" in g) {
     return runRenderCheckInProcess(input);
   }
   const { runRenderCheckViaWorker: runRenderCheckViaWorker2 } = await Promise.resolve().then(() => (init_render_check_host(), render_check_host_exports));
-  return runRenderCheckViaWorker2(input);
+  return runRenderCheckViaWorker2(input, options);
 }
 async function runRenderCheckInProcess(input) {
   const t0 = Date.now();
@@ -697,7 +718,7 @@ async function runRenderCheckInProcess(input) {
     const Wire = await import('@ggui-ai/wire');
     const { GguiWireProvider } = Wire;
     const moduleResolutions = {
-      "react": React,
+      react: React,
       "react/jsx-runtime": ReactJsxRuntime,
       "@ggui-ai/wire": Wire
     };
@@ -813,14 +834,23 @@ async function runRenderCheckInProcess(input) {
         )
       );
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(`[runtime-render] render exceeded ${RENDER_TIMEOUT_MS}ms \u2014 classified as runtime-hang`)), RENDER_TIMEOUT_MS).unref?.();
+        setTimeout(
+          () => reject(
+            new Error(
+              `[runtime-render] render exceeded ${RENDER_TIMEOUT_MS}ms \u2014 classified as runtime-hang`
+            )
+          ),
+          RENDER_TIMEOUT_MS
+        ).unref?.();
       });
       renderResult = await Promise.race([renderPromise, timeoutPromise]);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       const errStack = e instanceof Error ? e.stack ?? "" : "";
       const baseReason = loopSignature ? `Infinite render loop (${loopSignature}) \u2014 likely setState/dispatch inside useEffect with missing or unstable dependency` : /runtime-hang/.test(msg) ? `Render wall-clock exceeded ${RENDER_TIMEOUT_MS}ms \u2014 likely async effect loop or unresolved promise` : `Render threw: ${msg}`;
-      const userFrames = errStack.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at ")).filter((l) => !/(node_modules|happy-dom|@testing-library|react-dom|node:internal|node:async)/.test(l)).slice(0, 5);
+      const userFrames = errStack.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at ")).filter(
+        (l) => !/(node_modules|happy-dom|@testing-library|react-dom|node:internal|node:async)/.test(l)
+      ).slice(0, 5);
       const stackSource = boundaryRef.stack ?? capturedComponentStack ?? "";
       const componentFrames = stackSource.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("at ")).slice(0, 4);
       const stackBlock = userFrames.length ? `
@@ -1285,9 +1315,7 @@ function idLikeRequiredStringField(schema) {
   const required = schema["required"];
   if (properties === null || typeof properties !== "object") return null;
   if (!Array.isArray(required)) return null;
-  for (const [propName, propSchema] of Object.entries(
-    properties
-  )) {
+  for (const [propName, propSchema] of Object.entries(properties)) {
     if (!/id$/i.test(propName)) continue;
     if (!required.includes(propName)) continue;
     const t = propSchema !== null && typeof propSchema === "object" ? propSchema["type"] : void 0;
@@ -1318,9 +1346,7 @@ async function checkSelectionIdentity(input) {
         return void 0;
       }
       await flushPromises();
-      const events = probe.getFireLog().slice(before).filter(
-        (e) => e.kind === "action.fired" && e.name === actionName
-      );
+      const events = probe.getFireLog().slice(before).filter((e) => e.kind === "action.fired" && e.name === actionName);
       return events.length > 0 ? events[events.length - 1].payload : void 0;
     };
     const first = await payloadFor(group[0]);
@@ -1381,7 +1407,10 @@ async function dispatchTrigger(el, kind, user) {
     case "submit": {
       const form = closestForm(el);
       if (!form) return;
-      const ev = new globalThis.Event("submit", { bubbles: true, cancelable: true });
+      const ev = new globalThis.Event("submit", {
+        bubbles: true,
+        cancelable: true
+      });
       toEventDispatcher(form).dispatchEvent(ev);
       return;
     }
@@ -1718,47 +1747,112 @@ function synthesizeFromSchema(schema, hint, warnings, depth, ordinal) {
 }
 
 // src/harness/check/runtime-render/adapter.ts
-var DEFAULT_RUNTIME_RENDER_CHECK = {
-  id: "runtime-render",
-  run: async (input) => {
-    const { sourceCode, compiledCode, contract, fixtureProps } = input;
-    if (compiledCode === null) {
-      return { status: "not-applicable", issues: [], reason: "no compiled code" };
-    }
-    if (!contract) {
-      return { status: "not-applicable", issues: [], reason: "no contract surface" };
-    }
-    const mockup = prepareMockupProps({ contract, fixtureProps });
-    let result;
-    try {
-      result = await runRenderCheck({
-        sourceCode,
-        mockupProps: mockup.props,
-        contract
+init_render_check_host();
+function createSlotLimiter(maxConcurrent) {
+  if (maxConcurrent === void 0) return (task) => task(0);
+  if (!Number.isInteger(maxConcurrent) || maxConcurrent < 1) {
+    throw new RangeError(
+      `createRuntimeRenderCheck: maxConcurrent must be a positive integer, got ${maxConcurrent}`
+    );
+  }
+  let active = 0;
+  const waiting = [];
+  const acquire = () => {
+    if (active < maxConcurrent) {
+      active += 1;
+      return Promise.resolve(0);
+    }
+    const enqueuedAt = Date.now();
+    return new Promise((resolve) => {
+      waiting.push(() => {
+        active += 1;
+        resolve(Date.now() - enqueuedAt);
       });
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e);
-      console.warn(
-        `[runtime-render] probe skipped \u2014 infra failure: ${message}`
-      );
-      return { status: "infra-skipped", issues: [], reason: message };
+    });
+  };
+  const release = () => {
+    active -= 1;
+    const next = waiting.shift();
+    if (next !== void 0) next();
+  };
+  return async (task) => {
+    const waitedMs = await acquire();
+    try {
+      return await task(waitedMs);
+    } finally {
+      release();
     }
-    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, ...load };
+  };
+}
+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 } : {}
     }
-    return {
-      status: "ran",
-      issues: result.issues.map(toEvalIssue).filter((x) => x !== null),
-      ...load
-    };
-  }
-};
+  };
+}
+function createRuntimeRenderCheck(config = {}) {
+  const limit = createSlotLimiter(config.maxConcurrent);
+  const options = toRenderCheckOptions(config);
+  if (options !== void 0) resolveRenderCheckHostBounds(options.bounds);
+  return {
+    id: "runtime-render",
+    run: async (input) => {
+      const { sourceCode, compiledCode, contract, fixtureProps } = input;
+      if (compiledCode === null) {
+        return { status: "not-applicable", issues: [], reason: "no compiled code" };
+      }
+      if (!contract) {
+        return { status: "not-applicable", issues: [], reason: "no contract surface" };
+      }
+      const mockup = prepareMockupProps({ contract, fixtureProps });
+      let queuedMs = 0;
+      let t0 = Date.now();
+      let result;
+      try {
+        result = await limit((waitedMs) => {
+          queuedMs = waitedMs;
+          t0 = Date.now();
+          return runRenderCheck(
+            {
+              sourceCode,
+              mockupProps: mockup.props,
+              contract
+            },
+            options
+          );
+        });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        console.warn(`[runtime-render] probe skipped \u2014 infra failure: ${message}`);
+        return { status: "infra-skipped", issues: [], reason: message, elapsedMs: Date.now() - t0, ...queuedField(queuedMs) };
+      }
+      const hostLoad = result.stats.hostLoad;
+      const load = hostLoad !== void 0 ? { hostLoad } : {};
+      if (result.incomplete !== void 0) {
+        const { elapsedMs, boundMs } = result.incomplete;
+        const loadNote = hostLoad !== void 0 ? `; host load ${hostLoad.start.toFixed(1)} \u2192 ${hostLoad.end.toFixed(1)} on ${hostLoad.cores} CPUs` : "";
+        const reason = `render check did not finish within ${boundMs} ms (stopped at ${elapsedMs} ms)${loadNote}`;
+        console.warn(`[runtime-render] probe timed out \u2014 ${reason}`);
+        return { status: "timed-out", issues: [], reason, elapsedMs: Date.now() - t0, ...queuedField(queuedMs), ...load };
+      }
+      return {
+        status: "ran",
+        issues: result.issues.map(toEvalIssue).filter((x) => x !== null),
+        elapsedMs: Date.now() - t0,
+        ...queuedField(queuedMs),
+        renderMs: result.stats.renderMs,
+        ...load
+      };
+    }
+  };
+}
+var DEFAULT_RUNTIME_RENDER_CHECK = createRuntimeRenderCheck();
 function classifyRenderCrashFix(reason) {
   const r = reason.toLowerCase();
   if (r.includes("too many re-renders") || r.includes("maximum update depth") || r.includes("infinite render loop")) {