@ggui-ai/ui-gen 0.24.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/boilerplate.js

@@ -315,6 +315,7 @@ function generateBoilerplate(_userPrompt, contract, shellType, screen, composedS
   }
   const actionTypeAliases = [];
   const actionHookCalls = [];
+  let hasOneShotAction = false;
   const actionsMap = contract?.actionSpec ?? {};
   for (const [key, entry] of Object.entries(actionsMap)) {
     const label = entry.label ?? key;
@@ -335,7 +336,20 @@ type ${typeName} = ${tsType};`
     const callSig = tsType === "void" ? "() => void \u2014 fire and forget" : `(data: ${tsType}) => void`;
     const toolHint = tool ? ` \u2192 nextStep: ${tool}` : "";
     const onceHint = " \u2014 if this is meant ONCE, disable its control after it fires";
-    actionHookCalls.push(`  const ${key} = useAction<${typeName}>('${key}'); // ${callSig}${toolHint}${onceHint}`);
+    if (entry.oneShot === true) {
+      hasOneShotAction = true;
+      actionHookCalls.push(
+        `  const ${key} = useAction<${typeName}>('${key}'); // ${callSig}${toolHint} \u2014 declared oneShot: the runtime drops a second dispatch`
+      );
+      actionHookCalls.push(
+        `  const ${key}Spent = useActionSpent('${key}'); // true once fired, also after a reload \u2014 render the control from THIS: disabled={${key}Spent} and a spent label`
+      );
+    } else {
+      actionHookCalls.push(`  const ${key} = useAction<${typeName}>('${key}'); // ${callSig}${toolHint}${onceHint}`);
+    }
+    actionHookCalls.push(
+      `  const ${key}Pending = useActionPending('${key}'); // true from the tap until the agent's answer repaints the card \u2014 render EVERY control that dispatches '${key}' (a Button, a Select's onChange, an Input's Enter) from THIS: disabled={${key}Pending} aria-busy={${key}Pending}, and a working label on a button; no other control carries its aria-busy`
+    );
   }
   const streamChannels = contract?.streamSpec ?? {};
   const streamChannelEntries = Object.entries(streamChannels);
@@ -433,6 +447,8 @@ ${hookLines.join("\n")}
   const hasAnyWireFromWire = hasActions || hasStream || hasContext;
   const wireHooks = [];
   if (hasActions) wireHooks.push("useAction");
+  if (hasOneShotAction) wireHooks.push("useActionSpent");
+  if (hasActions) wireHooks.push("useActionPending");
   if (hasStream) wireHooks.push("useStream");
   if (hasContext) wireHooks.push("useGguiContext");
   const wireImport = hasAnyWireFromWire ? `import { ${wireHooks.join(", ")} } from '@ggui-ai/wire';
@@ -962,21 +978,17 @@ Rules:
 2. Layout and styling are universal. Colors, spacing, structure \u2014 these are the reusable part.
 3. Default values come from the current request \u2014 so the component renders correctly standalone.
 4. Copy comes from the props. NEVER invent display text the contract does not carry \u2014 no eyebrow / kicker / overline (a \`<Text caps>\` label), no helper line, no status text, no tagline. **Do NOT add a caps label above the heading** \u2014 not \`<Text caps>LET'S BEGIN</Text>\`, not \`WELCOME\`, not a section kicker like \`GETTING STARTED\` or \`OVERVIEW\` \u2014 UNLESS a prop supplies that exact text (\`<Text caps>{props.section}</Text>\`). When the request asks for a heading and a line, render the heading and the line and NOTHING above the heading. A heading's fallback is the request's own words, never a slogan of your own. Text the agent cannot change is chatter on every render, and a caps eyebrow you wrote is the most common form of it. An action's control shows the contract's \`label\` VERBATIM \u2014 every character, including \`&\`, \`/\`, \`\u2013\` and quotes \u2014 never paraphrased, shortened or re-cased (\`"Confirm & Schedule"\` is not \`"Confirm Schedule"\`).
-5. Props interface must be typed and exported.`;
+5. Props interface must be typed and exported.
+6. Keys on a mapped list come from the item's own identity: \`key={item.id}\` when the contract gives an id; when the items carry none (KPI tiles \`{label, value}\`, forecast days \`{day, high}\`), key by the field that names each one \u2014 \`key={item.label}\`, \`key={day.day}\` \u2014 never by the map index: a reorder or a stream merge re-keys by index and re-mounts the wrong rows, and the self-check refuses an index key.`;
 var TERMINAL_ACTIONS = `## Actions the user means once
 
 A second press is a mistake only when it would make a SECOND THING HAPPEN IN THE WORLD \u2014 a second booking, a second charge, a second order, a second application sent. If pressing again would only write the SAME STATE AGAIN \u2014 saving, updating, renaming, setting a preference, toggling \u2014 nothing is duplicated and the control stays armed.
 
-Guard a control only where you have evidence, not a feeling about the verb: the request itself names a one-time commitment \u2014 "submit the application", "place the order", "confirm the booking".
-
-**When in doubt, leave it armed.** A control the user cannot press a second time has lost them something that worked \u2014 save, edit, save again is ordinary. A control left armed is only what every interface does by default.
+**The contract says which actions are once.** An action the contract declares \`oneShot: true\` (in the Contract block above) is guarded by the runtime \u2014 a second dispatch is dropped \u2014 and its spent state is DATA you read, never state you hold: render its control from \`const spent = useActionSpent('<name>')\`, \`disabled={spent}\`, and say so in the label or beside it ("Submitted", "Request sent") \u2014 a control that is disabled without explanation reads as broken. The hook's answer survives a reload and a second tab; \`useState(false)\` does not, so a reloaded card built on local state re-arms a control that already fired.
 
-When you do guard one:
-- Hold a small piece of state for it and set it in the handler: \`const [submitted, setSubmitted] = useState(false)\`.
-- \`disabled={submitted}\` on the control that fires it, and say so in the label or beside it ("Submitted", "Request sent") \u2014 a control that is disabled without explanation reads as broken.
-- A card re-rendered with new props starts fresh; the state above lives with the component, not with the request.
+**An action the contract does not declare \`oneShot\` stays armed.** Never guard one from a feeling about the verb \u2014 "confirm", "submit", "place" alone are not evidence. Guard it only where the request itself names a one-time commitment the contract failed to declare ("submit the application", "place the order"), and then with local state as the fallback: \`const [submitted, setSubmitted] = useState(false)\` set in the handler, \`disabled={submitted}\` with a label \u2014 knowing that this state lives with the component, not with the request, and starts fresh on a re-render with new props.
 
-Nothing in the wire DECLARES one-shot-ness yet, which is why the test is what a second press would DO \u2014 not how final the word sounds.`;
+**When in doubt, leave it armed.** A control the user cannot press a second time has lost them something that worked \u2014 save, edit, save again is ordinary. A control left armed is only what every interface does by default.`;
 var FRAME_SIZING = `## Sizing \u2014 the frame owns the height and the width
 
 The host sizes the iframe; the component never sizes itself to the viewport. NEVER write \`100vh\` / \`100dvh\` / \`100svh\` (or an \`h-screen\` / \`min-h-screen\` class) as a height on any element:
@@ -1132,7 +1144,7 @@ With raw elements YOU own the semantics \u2014 nothing is accessible by construc
 3. **Images have \`alt\`** (\`alt=""\` for decorative). Icon-only buttons need \`aria-label\`; decorative icons and emoji are \`aria-hidden="true"\`.
 4. **Live & streaming data** (a \`useStream\` \`.latest\` value, counters, clocks, flashing prices) sits in an \`aria-live="polite"\` (or \`role="status"\`) region so screen readers announce the change.
 5. **Headings nest**: one \`<h1>\` per screen, \`<h2>\` for sections, \`<h3>\` below \u2014 never skipped or inverted.
-6. **Busy state is announced**: \`<button disabled={isLoading} aria-busy={isLoading}>{isLoading ? 'Submitting\u2026' : 'Submit'}</button>\`.
+6. **Busy state is announced**: every control that dispatches an action (a button, a select whose change dispatches, an input that sends on Enter) stays pending from \`useActionPending('<action>')\` until the agent's answer repaints the card \u2014 \`<button disabled={sendPending} aria-busy={sendPending}>{sendPending ? 'Sending\u2026' : 'Send'}</button>\`. Only a control that dispatches the action carries its busy look; while it is pending, other controls of the same record may be disabled \u2014 nothing more (controls of other records, creation controls and the action's own cancel stay enabled); busy state the card owns (\`isLoading\`) the same way.
 7. **Stateful controls announce state**: \`role="checkbox"\` + \`aria-checked\` on a toggleable row, \`aria-pressed\` on a toggle button, \`aria-selected\` on the chosen item, \`aria-expanded\` on an open/close affordance. Styling (strikethrough, color, a check mark) is never the only carrier of state.
 8. **Focus is visible** \u2014 style \`:focus-visible\` with a token color; never \`outline: none\` without a replacement.`;
 var FREE_QUALITY_CHECKLIST = `## Quality Checklist (verify before returning)
@@ -1676,7 +1688,7 @@ The design-system primitives are accessible by construction \u2014 they emit the
 3. **Icons are decorative by default** \u2014 \`<Icon name="check" />\` is hidden from screen readers, which is correct for an icon sitting next to text. Add \`aria-label\` ONLY for a standalone, meaning-bearing icon with no adjacent text. Icon-only \`Button\`s still need \`aria-label\` on the **Button** itself.
 4. **Live & streaming data** \u2014 wrap any region whose content updates on its own (a \`useStream\` \`.latest\` value, a live clock, an "N new" counter, a flashing price) in an element with \`aria-live="polite"\` so screen readers announce the change.
 5. **Headings nest** \u2014 one \`<Heading level={1}>\` per screen, \`level={2}\` for sections, \`level={3}\` for subsections. Never skip or invert levels.
-6. **Buttons** \u2014 descriptive text content; icon-only buttons need \`aria-label\`. Announce busy state: \`<Button disabled={isLoading} aria-busy={isLoading}>{isLoading ? 'Submitting\u2026' : 'Submit'}</Button>\`.
+6. **Buttons** \u2014 descriptive text content; icon-only buttons need \`aria-label\`. Announce busy state. EVERY control that dispatches an action \u2014 a Button, a Select whose change dispatches, an Input that sends on Enter \u2014 stays pending from that action's \`useActionPending\` until the agent's answer repaints the card: with \`const sendPending = useActionPending('send');\`, write \`<Button disabled={sendPending} aria-busy={sendPending} onClick={() => send({ text })}>{sendPending ? 'Sending\u2026' : 'Send'}</Button>\`, and give a dispatching Select or Input the same \`disabled={sendPending} aria-busy={sendPending}\`. Only a control that dispatches the action carries its \`aria-busy\` and a working label. While it is pending, other controls of the SAME record may be \`disabled\` \u2014 nothing more; controls of other records, creation controls and the action's own cancel stay enabled. Busy state the card owns (a local \`isLoading\`) is announced the same way.
 7. **Stateful controls announce their state.** Toggleable / selectable / expandable things use the primitive that carries the semantics (\`Checkbox\`, \`Toggle\`, \`Tabs\`, \`Accordion\`) \u2014 never a styled \`Box\`/\`Icon\` that only *looks* checked. When you hand-roll one with \`as={Clickable}\`, \`Clickable\` adds button + keyboard semantics but NOT state \u2014 add it yourself: \`role="checkbox"\` + \`aria-checked={done}\` on a toggleable row, \`aria-pressed\` on a toggle button, \`aria-selected\` on the chosen item, \`aria-expanded\` on an open/close affordance. Styling (strikethrough, color, a check icon) must never be the only carrier of state.
 
 ## Design System Usage (CRITICAL)