@ggui-ai/ui-gen 0.23.0 → 0.24.0

package/src/policy.ts

@@ -86,12 +86,15 @@ export interface ContextPolicy {
    * Axis-keyed primitives doc slice. When `"axis-keyed"`, the first-turn
    * system prompt injects only the allowlisted primitives derived from
    * the classification, shrinking the ~130 KB monolith to ~30–50 KB.
-   * Default `"full"`.
+   * `"axis-keyed+contract"` adds the input primitives the contract's own
+   * fields imply (ggui#1324: the axis slice alone dropped `Input` /
+   * `TextArea` from a card that edits a string). Default `"full"`.
    */
-  readonly primitiveDocSlice?: "full" | "axis-keyed";
+  readonly primitiveDocSlice?: "full" | "axis-keyed" | "axis-keyed+contract";
   /**
-   * Primitives to exclude from the axis-keyed slice. Only meaningful
-   * when `primitiveDocSlice === "axis-keyed"`.
+   * Primitives to exclude from the axis-keyed slice (applied after the
+   * contract additions under `"axis-keyed+contract"`). Only meaningful
+   * when `primitiveDocSlice` is one of the two slice modes.
    */
   readonly primitiveDocExcludes?: readonly string[];
   /**

package/src/tools/render-check-worker.ts

@@ -27,8 +27,19 @@
  * mechanical compile+vm pipeline is the shared
  * `evaluateComponentSource` helper (also used by the in-loop probe's
  * `loadComponent`); only the resolution policy lives here.
+ *
+ * Shutdown (ggui#1380): the compile runs on esbuild's service, a child
+ * process esbuild keeps alive for the life of this worker. After the
+ * verdict is written the worker calls `esbuild.stop()` so that child is
+ * gone before the worker is. `workerMain` is exported for the
+ * process-shape pins; `main()` runs only when this file is the process
+ * entry, so importing it never reads stdin.
  */
 import { createRequire } from 'node:module';
+import { realpathSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as esbuild from 'esbuild';
 import type { JsonObject } from '@ggui-ai/protocol';
 import { evaluateComponentSource } from '../internal/evaluate-component-source.js';
 import { hostGlobals } from '../internal/open-record.js';
@@ -42,28 +53,49 @@ type WorkerOutput =
   | { readonly ok: true }
   | { readonly ok: false; readonly error: string };
 
-async function main(): Promise<void> {
-  const raw = await readAllStdin();
-  let input: WorkerInput;
+/**
+ * Parse one input document, render once, write the verdict. Whatever
+ * happens, esbuild's service is stopped before this returns (or
+ * rejects). If the service was never started, `stop()` is a no-op.
+ */
+export async function workerMain(raw: string): Promise<void> {
   try {
-    input = JSON.parse(raw) as WorkerInput;
-  } catch (err) {
-    emit({
-      ok: false,
-      error: `worker: malformed input JSON — ${
-        err instanceof Error ? err.message : String(err)
-      }`,
-    });
-    return;
-  }
+    let input: WorkerInput;
+    try {
+      input = JSON.parse(raw) as WorkerInput;
+    } catch (err) {
+      emit({
+        ok: false,
+        error: `worker: malformed input JSON — ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      });
+      return;
+    }
+
+    if (typeof input.sourceCode !== 'string' || input.sourceCode.length === 0) {
+      emit({ ok: false, error: 'worker: sourceCode is required' });
+      return;
+    }
 
-  if (typeof input.sourceCode !== 'string' || input.sourceCode.length === 0) {
-    emit({ ok: false, error: 'worker: sourceCode is required' });
-    return;
+    const result = await renderOnce(input);
+    emit(result);
+  } finally {
+    // Post-verdict work must never turn a written verdict into a failure:
+    // a rejecting `stop()` would otherwise become an unhandled rejection,
+    // exit code 1, and the host discarding the verdict on stdout.
+    try {
+      await esbuild.stop();
+    } catch (err) {
+      process.stderr.write(
+        `render-check worker: esbuild.stop() failed — ${err instanceof Error ? err.message : String(err)}\n`,
+      );
+    }
   }
+}
 
-  const result = await renderOnce(input);
-  emit(result);
+async function main(): Promise<void> {
+  await workerMain(await readAllStdin());
 }
 
 async function renderOnce(input: WorkerInput): Promise<WorkerOutput> {
@@ -192,9 +224,28 @@ async function readAllStdin(): Promise<string> {
   return buffer;
 }
 
-void main().catch((err: unknown) => {
-  emit({
-    ok: false,
-    error: `worker crashed: ${err instanceof Error ? err.message : String(err)}`,
+/** True when this file is the process entry (`node <this file>`), not an import. */
+function isProcessEntry(): boolean {
+  const entry = process.argv[1];
+  if (entry === undefined) return false;
+  // Resolve BOTH sides through the filesystem: `import.meta.url` is this
+  // file's realpath while argv[1] is whatever the spawner passed — a
+  // symlinked spawn path must still read as the entry, or the worker would
+  // exit with no verdict and the host would read a silent `unverified`.
+  let entryReal: string;
+  try {
+    entryReal = realpathSync(resolvePath(entry));
+  } catch {
+    return false;
+  }
+  return entryReal === realpathSync(fileURLToPath(import.meta.url));
+}
+
+if (isProcessEntry()) {
+  void main().catch((err: unknown) => {
+    emit({
+      ok: false,
+      error: `worker crashed: ${err instanceof Error ? err.message : String(err)}`,
+    });
   });
-});
+}

package/dist/render-check-Blwj8gB6.d.ts

@@ -1,105 +0,0 @@
-import { JsonObject, DataContract } from '@ggui-ai/protocol';
-import { P as ProbeHostLoad } from './types-public-Ow-tNtFE.js';
-
-/**
- * 3-state outcome. Internal to runtime-render.
- * The adapter maps this to existing EvalIssue shapes:
- *   verified   → no issue
- *   failed     → fail
- *   unverified → warn
- *   skipped    → no issue
- */
-type CheckOutcome = "verified" | "failed" | "unverified" | "skipped";
-interface RenderCheckIssue {
-    readonly check: "render-no-throw" | "action-wiring" | "selection-identity" | "prop-coverage" | "prop-sensitivity" | "stream-rerender" | "optional-props-omitted";
-    readonly outcome: CheckOutcome;
-    readonly subject?: string;
-    readonly reason: string;
-    /** Optional element description ("button[aria-label='Save']") for action-wiring failures. */
-    readonly elementHint?: string;
-    /**
-     * Diagnostic context from probe + AST analysis. Populated for richer feedback
-     * to the coding agent (which native props the callback flows into, what the
-     * probe observed firing, etc.).
-     */
-    readonly diagnostics?: {
-        readonly observedJsxElements?: readonly string[];
-        readonly observedNativeProps?: readonly string[];
-        readonly observedCustomProps?: readonly string[];
-        /** For action-wiring: which actions DID fire from probe clicks (helps surface mis-wiring). */
-        readonly actionsFiredFromClicks?: readonly string[];
-        /** Surfaced to the agent: prop sourceTool hints from the contract (only if present). */
-        readonly sourceToolHints?: Readonly<Record<string, string>>;
-        /**
-         * For action-wiring (ggui#1187): what input priming did before the
-         * synthetic dispatch — how many controls it filled, or why it could not
-         * run. A "did not dispatch it" on an input-gated action reads differently
-         * beside `{ primed: 0 }` or `{ error }` than beside `{ primed: 1 }`.
-         */
-        readonly inputPriming?: InputPrimingDiagnostic;
-    };
-}
-/**
- * Outcome of `primeInputs` before the action-wiring probe (ggui#1187). A
- * priming failure never aborts the check — it is recorded here, on every
- * action-wiring issue, so it is visible in the feedback instead of vanishing.
- */
-type InputPrimingDiagnostic = {
-    readonly primed: number;
-} | {
-    readonly error: string;
-};
-/**
- * The check started but did not finish (ggui#1299). The only kind is a
- * wall-clock timeout in the isolated worker. It is not a verdict on the
- * component: `issues` is empty and `ok` is false because nothing was
- * verified, never because something failed.
- */
-interface RenderCheckIncomplete {
-    readonly kind: "timeout";
-    /** How long the worker ran before it was stopped. */
-    readonly elapsedMs: number;
-    /** The wall-clock bound it crossed. */
-    readonly boundMs: number;
-}
-interface RenderCheckResult {
-    readonly ok: boolean;
-    readonly issues: readonly RenderCheckIssue[];
-    /** Present only when the check did not finish; see {@link RenderCheckIncomplete}. */
-    readonly incomplete?: RenderCheckIncomplete;
-    readonly stats: {
-        readonly actionsChecked: number;
-        readonly streamsChecked: number;
-        readonly renderMs: number;
-        /** Host load around an isolated check (absent in-process). */
-        readonly hostLoad?: ProbeHostLoad;
-    };
-}
-interface RunRenderCheckInput {
-    readonly sourceCode: string;
-    readonly mockupProps: JsonObject;
-    readonly contract?: DataContract;
-}
-/**
- * Run the in-loop runtime render check.
- *
- * Isolation dispatcher (#592): when the CALLING environment already
- * owns a DOM (`window` + `document` on `globalThis` — e.g. a vitest
- * `happy-dom` environment, where the environment owner installed the
- * globals deliberately), the check runs in-process exactly as before.
- * In a plain Node process it runs in an ISOLATED SUBPROCESS
- * (`render-check-host.ts` → `render-check-worker.ts`), because the
- * in-process path installs happy-dom globals on `globalThis`
- * process-wide — a TOCTOU hazard for anything that sniffs `window`
- * concurrently (provider SDKs throw "browser-like environment" at
- * client construction; two overlapping checks corrupt each other's
- * teardown). See #592 for the measured incident (4 bench cells hard-
- * failed on the 2026-08-19 run).
- *
- * The host is loaded lazily so the worker bundle (which imports this
- * module for `runRenderCheckInProcess`) never drags in the sandbox
- * spawn machinery.
- */
-declare function runRenderCheck(input: RunRenderCheckInput): Promise<RenderCheckResult>;
-
-export { type RenderCheckIssue as R, type RenderCheckResult as a, runRenderCheck as r };