ngx-json-render 0.2.0 → 0.3.0

package/types/ngx-json-render.d.ts

@@ -1,10 +1,11 @@
 import * as _json_render_core from '@json-render/core';
-import { ResolvedAction, ActionHandler, ActionBinding, Catalog, InferCatalogActions, InferActionParams, StateModel, InferCatalogComponents, UIElement, Spec, StateStore, ValidationFunction, ComputedFunction, DirectiveDefinition, ActionConfirm, DirectiveRegistry, ValidationResult, ValidationConfig, JsonPatch, FlatElement } from '@json-render/core';
-export { ActionBinding, ActionHandler, JsonPatch, Spec, StateModel, StateStore, UIElement, VisibilityCondition, createStateStore, nestedToFlat } from '@json-render/core';
+import { ResolvedAction, ActionHandler, ActionBinding, Spec, SpecIssue, Catalog, InferCatalogActions, InferActionParams, StateModel, InferCatalogComponents, UIElement, StateStore, ValidationFunction, ComputedFunction, DirectiveDefinition, ActionConfirm, DirectiveRegistry, ValidationResult, ValidationConfig, JsonPatch, FlatElement } from '@json-render/core';
+export { ActionBinding, ActionHandler, JsonPatch, Spec, SpecIssue, StateModel, StateStore, UIElement, VisibilityCondition, autoFixSpec, createStateStore, formatSpecIssues, nestedToFlat, validateSpec } from '@json-render/core';
 import * as zod from 'zod';
 import * as zod_v4_core from 'zod/v4/core';
 import * as _angular_core from '@angular/core';
 import { Signal, Type, InjectionToken } from '@angular/core';
+import * as ngx_json_render from 'ngx-json-render';
 
 interface PendingConfirmation {
     action: ResolvedAction;
@@ -12,13 +13,15 @@ interface PendingConfirmation {
     resolve: () => void;
     reject: () => void;
 }
+/** True for the rejection produced by cancelling a confirmation dialog. */
+declare function isActionCancelled(error: unknown): boolean;
 /**
  * Action dispatcher of a `<json-render>` subtree.
  *
  * Executes {@link ActionBinding}s: built-in actions (`setState`, `pushState`,
- * `removeState`, `push`, `pop`, `validateForm`) are handled internally;
- * everything else is routed to the host-provided `handlers` (or the
- * `onAction` catch-all), honoring `confirm`, `onSuccess`, and `onError`.
+ * `removeState`, `push`, `pop`, `validateForm`, `submitForm`) are handled
+ * internally; everything else is routed to the host-provided `handlers` (or
+ * the `onAction` catch-all), honoring `confirm`, `onSuccess`, and `onError`.
  */
 declare class JsonRenderActionsService {
     private readonly root;
@@ -41,6 +44,15 @@ declare class JsonRenderActionsService {
     confirm(): void;
     /** Cancel the pending confirmation dialog. */
     cancel(): void;
+    /**
+     * Validate every registered field and write `{ valid, errors }` to the
+     * action's `statePath` (default `/formValidation`). Returns null when there
+     * is no validation service to ask.
+     *
+     * Shared by `validateForm` and `submitForm`: the two must report the same
+     * thing about the same form, and one implementation is how that stays true.
+     */
+    private checkForm;
     private lookupHandler;
     private runHandler;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonRenderActionsService, never>;
@@ -57,6 +69,41 @@ declare function injectAction(binding: ActionBinding): {
     isLoading: Signal<boolean>;
 };
 
+/**
+ * How much a spec has to be trusted.
+ *
+ * - `off` — render whatever arrives. The default, and what every version
+ *   before this one did.
+ * - `warn` — check the spec, apply the lossless fixes, report what is left,
+ *   render it anyway.
+ * - `strict` — the same check, but an error means the spec does not render.
+ */
+type SpecValidationMode = 'off' | 'warn' | 'strict';
+/** What {@link checkSpec} found, and the spec that should render. */
+interface SpecCheck {
+    /**
+     * The spec to render: the input with lossless fixes applied, or the input
+     * untouched when validation is off.
+     */
+    readonly spec: Spec | null;
+    /** Structural issues left after the fixes. */
+    readonly issues: readonly SpecIssue[];
+    /** Descriptions of the fixes that were applied. */
+    readonly fixes: readonly string[];
+    /** Whether an issue of `error` severity survived. */
+    readonly hasErrors: boolean;
+}
+/**
+ * Check a spec the way `validate` asks for.
+ *
+ * Only lossless fixes are applied — `visible`, `on` and `repeat` that a model
+ * put inside `props`, which the renderer would otherwise ignore, moved back
+ * where they belong. The lossy ones prune content, and core's own guidance is
+ * to re-prompt rather than accept that; a renderer that silently deleted
+ * elements would be the worse failure.
+ */
+declare function checkSpec(spec: Spec | null, mode: SpecValidationMode): SpecCheck;
+
 /**
  * State setter function for updating application state.
  * Matches the `SetState` contract of the other json-render renderers
@@ -281,6 +328,19 @@ declare class JsonRenderer {
     readonly loading: _angular_core.InputSignal<boolean>;
     /** Fallback component for unknown types. */
     readonly fallback: _angular_core.InputSignal<RegistryEntry | Type<unknown> | null>;
+    /**
+     * Whether to check the spec's structure before rendering it, and what to do
+     * about what turns up. Off by default.
+     *
+     * `'warn'` reports the issues and renders anyway; `'strict'` renders nothing
+     * when the spec has errors. Both first apply the lossless fixes — `visible`,
+     * `on` and `repeat` misplaced inside `props` are moved back to the element,
+     * where they take effect instead of being ignored.
+     *
+     * The check is skipped while `loading` is true: a spec that is still
+     * arriving is expected to reference children that have not streamed in yet.
+     */
+    readonly validate: _angular_core.InputSignal<SpecValidationMode>;
     /**
      * Initial state model (uncontrolled mode). Defaults to `spec.state`.
      * Ignored when `store` is provided.
@@ -306,11 +366,31 @@ declare class JsonRenderer {
     readonly stateStore: JsonRenderStateService;
     /** The action dispatcher of this renderer. */
     protected readonly actions: JsonRenderActionsService;
+    /**
+     * The spec as checked, and what the check found. While `loading`, the mode
+     * is forced off: the spec is still arriving, and the missing children it
+     * refers to are the normal state of a stream, not a defect.
+     */
+    private readonly checked;
     constructor();
     protected readonly rootKey: _angular_core.Signal<string | null>;
     protected readonly pendingConfirm: _angular_core.Signal<_json_render_core.ActionConfirm | null>;
+    /**
+     * The app's own dialog, if it provided one. Read once: which component
+     * answers a confirmation is an application decision, not something that
+     * changes between two confirmations.
+     */
+    protected readonly customDialog: Type<unknown> | null;
+    private readonly injector;
+    /**
+     * A replacement dialog takes no inputs and emits no outputs — it injects
+     * everything it needs, the way catalog components do. That keeps the seam
+     * one token wide instead of a component contract the renderer would have to
+     * bind to.
+     */
+    protected readonly confirmInjector: _angular_core.Signal<_angular_core.DestroyableInjector | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonRenderer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JsonRenderer, "json-render", never, { "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "registry": { "alias": "registry"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fallback": { "alias": "fallback"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "store": { "alias": "store"; "required": false; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "onAction": { "alias": "onAction"; "required": false; "isSignal": true; }; "navigate": { "alias": "navigate"; "required": false; "isSignal": true; }; "validationFunctions": { "alias": "validationFunctions"; "required": false; "isSignal": true; }; "functions": { "alias": "functions"; "required": false; "isSignal": true; }; "directives": { "alias": "directives"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JsonRenderer, "json-render", never, { "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "registry": { "alias": "registry"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fallback": { "alias": "fallback"; "required": false; "isSignal": true; }; "validate": { "alias": "validate"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "store": { "alias": "store"; "required": false; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "onAction": { "alias": "onAction"; "required": false; "isSignal": true; }; "navigate": { "alias": "navigate"; "required": false; "isSignal": true; }; "validationFunctions": { "alias": "validationFunctions"; "required": false; "isSignal": true; }; "functions": { "alias": "functions"; "required": false; "isSignal": true; }; "directives": { "alias": "directives"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; }, never, never, true, never>;
 }
 
 /**
@@ -416,21 +496,103 @@ declare class JrRepeatScope implements RepeatScope {
  * Default confirmation dialog shown for action bindings with a `confirm`
  * field. Rendered automatically by `<json-render>`; can also be used
  * standalone with a custom action flow.
+ *
+ * It is a real dialog: `role="dialog"` with `aria-modal`, labelled by its own
+ * title and described by its message, focus moved in on open and returned to
+ * wherever it came from on close, Tab kept inside it and Escape cancelling.
+ * A generated UI can ask for confirmation of something destructive, so a
+ * keyboard or screen-reader user has to be able to answer it.
+ *
+ * Colours come from CSS custom properties with light and dark defaults, so an
+ * app can theme it — `--jr-confirm-surface`, `--jr-confirm-ink`,
+ * `--jr-confirm-muted`, `--jr-confirm-border`, `--jr-confirm-scrim`,
+ * `--jr-confirm-accent`, `--jr-confirm-danger`, `--jr-confirm-on-accent`,
+ * `--jr-confirm-radius` — and replace it outright through
+ * {@link JR_CONFIRM_DIALOG} when that is not enough.
  */
 declare class JrConfirmDialog {
     readonly config: _angular_core.InputSignal<ActionConfirm>;
     readonly confirmed: _angular_core.OutputEmitterRef<void>;
     readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    protected readonly labels: ngx_json_render.ConfirmLabels;
+    private readonly id;
+    protected readonly titleId: string;
+    protected readonly messageId: string;
+    private readonly cancelButton;
+    private readonly confirmButton;
     protected readonly isDanger: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Keep Tab inside the dialog. With exactly two buttons the whole trap is
+     * wrapping the ends; a modal that lets focus wander behind it is a modal
+     * only for people using a mouse.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<JrConfirmDialog, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<JrConfirmDialog, "jr-confirm-dialog", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
 }
 
+/** The two words the confirmation dialog says on its own. */
+interface ConfirmLabels {
+    confirm: string;
+    cancel: string;
+}
+/**
+ * Labels for the default confirmation dialog's buttons, when the spec does not
+ * supply `confirmLabel` / `cancelLabel` of its own.
+ *
+ * They are the only strings this package puts on screen, and they were English
+ * with no way to change them. Override once, in an app's providers:
+ *
+ * ```ts
+ * { provide: JR_CONFIRM_LABELS, useValue: { confirm: 'Подтвердить', cancel: 'Отмена' } }
+ * ```
+ */
+declare const JR_CONFIRM_LABELS: InjectionToken<ConfirmLabels>;
+/**
+ * Everything a replacement confirmation dialog is given: the config the spec
+ * asked for, and the two ways to answer it. Inject it with
+ * {@link injectConfirmContext}.
+ */
+interface ConfirmContext {
+    /** Title, message, labels and variant, straight from the action binding. */
+    readonly config: ActionConfirm;
+    /** Let the action proceed. */
+    readonly confirm: () => void;
+    /** Dismiss it — a normal answer, not a failure. */
+    readonly cancel: () => void;
+}
+/** The confirmation a replacement dialog component is rendered for. */
+declare const CONFIRM_CONTEXT: InjectionToken<ConfirmContext>;
+/**
+ * The component `<json-render>` should render for a `confirm` on an action.
+ * Unset means the packaged {@link JrConfirmDialog}.
+ *
+ * The component is rendered with a {@link CONFIRM_CONTEXT} in its injector, so
+ * it takes no inputs and emits no outputs:
+ *
+ * ```ts
+ * @Component({ template: `<my-modal (ok)="ctx.confirm()" (dismiss)="ctx.cancel()">…` })
+ * export class AppConfirm {
+ *   readonly ctx = injectConfirmContext();
+ * }
+ * // providers: [{ provide: JR_CONFIRM_DIALOG, useValue: AppConfirm }]
+ * ```
+ */
+declare const JR_CONFIRM_DIALOG: InjectionToken<Type<unknown>>;
+/** Inject the confirmation a replacement dialog component is rendering for. */
+declare function injectConfirmContext(): ConfirmContext;
+
 /**
  * The render context of the element currently being rendered.
  * Provided by the renderer for every catalog component instance.
  */
 declare const RENDER_CONTEXT: InjectionToken<RenderContext<Record<string, unknown>>>;
+/**
+ * The spec key of the element currently being rendered. Provided alongside
+ * {@link RENDER_CONTEXT} for every catalog component instance.
+ */
+declare const ELEMENT_KEY: InjectionToken<Signal<string>>;
 /**
  * The current repeat scope. Present only for elements rendered inside a
  * `repeat` block.
@@ -451,6 +613,21 @@ declare const REPEAT_SCOPE: InjectionToken<RepeatScope>;
  * ```
  */
 declare function injectRenderContext<P = Record<string, unknown>>(): RenderContext<P>;
+/**
+ * Inject the spec key of the element this component renders.
+ *
+ * Catalog components that collect their children — a tab group discovering
+ * its tabs, for instance — need it to order registrations by the spec's
+ * `children` array rather than by the order the children happened to
+ * announce themselves in.
+ *
+ * @example
+ * ```ts
+ * const key = injectElementKey();
+ * const index = computed(() => parent.element().children?.indexOf(key()) ?? -1);
+ * ```
+ */
+declare function injectElementKey(): Signal<string>;
 /**
  * Inject the current repeat scope, or `null` when the component is not
  * rendered inside a `repeat` block.
@@ -496,17 +673,36 @@ interface FieldValidationState {
  * Form validation state of a `<json-render>` subtree. Fields register their
  * {@link ValidationConfig}; the built-in `validateForm` action validates all
  * registered fields and writes the result to state.
+ *
+ * Registrations are owner-scoped: a path stays registered while at least one
+ * owner holds it, and its config and state are dropped when the last one
+ * releases. A spec that swaps screens or hides fields therefore stops
+ * validating what is no longer on screen.
  */
 declare class JsonRenderValidationService {
     private readonly root;
     private readonly state;
     private readonly _fieldStates;
     private readonly _fieldConfigs;
+    /** Live owners per path — the reference count behind a registration. */
+    private readonly fieldOwners;
     /** Validation state per registered field path. */
     readonly fieldStates: Signal<Record<string, FieldValidationState>>;
     get customFunctions(): Record<string, ValidationFunction>;
-    /** Register (or update) a field's validation config. */
-    registerField(path: string, config: ValidationConfig): void;
+    /**
+     * Register (or update) a field's validation config.
+     *
+     * @param owner Identity holding the registration — pass the same value to
+     * {@link unregisterField} to release it. Field components pass themselves,
+     * so two components bound to one path each hold their own claim.
+     */
+    registerField(path: string, config: ValidationConfig, owner?: object): void;
+    /**
+     * Release one owner's registration of a field. The config and validation
+     * state survive while another owner still holds the path; once the last
+     * one lets go, `validateAll` stops seeing the field.
+     */
+    unregisterField(path: string, owner?: object): void;
     /** Validate a single field and record the result. */
     validate(path: string, config: ValidationConfig): ValidationResult;
     /** Mark a field as touched. */
@@ -523,6 +719,10 @@ declare function injectValidation(): JsonRenderValidationService;
 /**
  * Field-level validation helper for catalog input components: registers the
  * config and exposes the field's validation state as signals.
+ *
+ * The registration follows the component: it moves when the bound path
+ * changes and is released when the component is destroyed, so a field that
+ * has left the screen no longer takes part in `validateForm`.
  */
 declare function injectFieldValidation(path: string | (() => string), config?: ValidationConfig | (() => ValidationConfig | undefined)): {
     state: Signal<FieldValidationState>;
@@ -593,6 +793,73 @@ declare function defineRegistry<C extends Catalog>(catalog: C, options: DefineRe
  */
 declare function createStoreSetState(store: Pick<StateStore, 'getSnapshot' | 'update'>): SetState;
 
+/**
+ * Apply an RFC 6902 JSON patch to a spec, returning a new spec object and
+ * sharing every subtree the patch did not touch.
+ *
+ * This is the only patch engine in the package: `injectUIStream`,
+ * `injectChatUI` and `buildSpecFromParts` all route through it, so the same
+ * stream produces the same spec whichever one an app reached for. The write
+ * primitives come from `@json-render/core`, so `add` splices into an array
+ * where `replace` overwrites, exactly as the other renderers do.
+ *
+ * One deliberate deviation from RFC 6902: a failing `test` op is a no-op
+ * rather than an abort. These patches come off a model's output, where the
+ * established behaviour — see the line parser — is to drop what does not make
+ * sense and keep rendering rather than kill a generation mid-flight.
+ */
+declare function applyPatch(spec: Spec, patch: JsonPatch): Spec;
+
+/**
+ * Convert a flat element list to a Spec.
+ * Input elements use key/parentKey to establish identity and relationships.
+ * Output spec uses the map-based format where key is the map entry key
+ * and parent-child relationships are expressed through children arrays.
+ */
+declare function flatToTree(elements: FlatElement[]): Spec;
+/**
+ * A single part from the AI SDK's `message.parts` array. This is a minimal
+ * structural type so that library helpers do not depend on the AI SDK.
+ */
+interface DataPart {
+    type: string;
+    text?: string;
+    data?: unknown;
+    /**
+     * The SDK's reconciliation key. A part written with one is *replaced* by the
+     * next part carrying the same id, rather than followed by it — so a spec
+     * streamed as patches must be written without an id, and only a whole-spec
+     * part (`flat` / `nested`), which is a snapshot of itself, can share one.
+     */
+    id?: string;
+}
+/**
+ * Build a `Spec` by replaying all spec data parts from a message's
+ * parts array (AI SDK `UIMessage.parts`). Returns `null` if no spec data
+ * parts are present.
+ */
+declare function buildSpecFromParts(parts: DataPart[]): Spec | null;
+/**
+ * Extract and join all text content from a message's parts array.
+ */
+declare function getTextFromParts(parts: DataPart[]): string;
+/**
+ * Extract both the json-render spec and the text content from a message's
+ * parts array, as memoized signals. Angular counterpart of
+ * `useJsonRenderMessage` from the other renderers.
+ *
+ * @example
+ * ```ts
+ * readonly msg = jsonRenderMessage(() => this.message().parts);
+ * // template: @if (msg.hasSpec()) { <json-render [spec]="msg.spec()" ... /> }
+ * ```
+ */
+declare function jsonRenderMessage(parts: Signal<DataPart[]> | (() => DataPart[])): {
+    spec: Signal<Spec | null>;
+    text: Signal<string>;
+    hasSpec: Signal<boolean>;
+};
+
 /**
  * Token usage metadata from AI generation.
  */
@@ -602,11 +869,17 @@ interface TokenUsage {
     totalTokens: number;
 }
 /**
- * Apply an RFC 6902 JSON patch to the current spec, returning a new spec
- * object (structural sharing for untouched elements).
- * Supports add, remove, replace, move, copy, and test operations.
+ * Per-call options for {@link UIStreamReturn.send}.
  */
-declare function applyPatch(spec: Spec, patch: JsonPatch): Spec;
+interface UIStreamSendOptions {
+    /** Arbitrary context forwarded to the endpoint as `context`. */
+    context?: Record<string, unknown>;
+    /**
+     * Spec to refine instead of starting from an empty one. It is sent to the
+     * endpoint as `currentSpec` and the streamed patches apply on top of it.
+     */
+    previousSpec?: Spec;
+}
 /**
  * Options for {@link injectUIStream}.
  */
@@ -617,6 +890,17 @@ interface UIStreamOptions {
     onComplete?: (spec: Spec) => void;
     /** Callback on error */
     onError?: (error: Error) => void;
+    /**
+     * Whether to check the finished spec's structure, and what a problem means.
+     * Off by default.
+     *
+     * The check runs once, when the generation completes — a spec mid-stream is
+     * supposed to be incomplete. Both modes apply the lossless fixes and publish
+     * the fixed spec; `'warn'` reports what is left, while `'strict'` fails the
+     * generation instead of calling `onComplete`, so an app that persists the
+     * spec there does not persist a broken one.
+     */
+    validate?: SpecValidationMode;
     /**
      * Transport, defaulting to the global `fetch`.
      *
@@ -643,9 +927,19 @@ interface UIStreamReturn {
     readonly usage: Signal<TokenUsage | null>;
     /** Raw JSONL lines received from the stream (JSON patch lines) */
     readonly rawLines: Signal<string[]>;
+    /**
+     * Structural issues in the finished spec. Empty until a generation
+     * completes, and always empty while `validate` is off.
+     */
+    readonly issues: Signal<readonly SpecIssue[]>;
     /** Send a prompt to generate UI */
-    send: (prompt: string, context?: Record<string, unknown>) => Promise<void>;
-    /** Clear the current spec */
+    send: (prompt: string, options?: UIStreamSendOptions) => Promise<void>;
+    /**
+     * Stop the in-flight generation, keeping whatever has rendered so far.
+     * A no-op when nothing is streaming.
+     */
+    stop: () => void;
+    /** Stop any generation and clear the spec, error, usage and raw lines. */
     clear: () => void;
 }
 /**
@@ -666,48 +960,7 @@ interface UIStreamReturn {
  * ```
  */
 declare function injectUIStream(options: UIStreamOptions): UIStreamReturn;
-/**
- * Convert a flat element list to a Spec.
- * Input elements use key/parentKey to establish identity and relationships.
- * Output spec uses the map-based format where key is the map entry key
- * and parent-child relationships are expressed through children arrays.
- */
-declare function flatToTree(elements: FlatElement[]): Spec;
-/**
- * A single part from the AI SDK's `message.parts` array. This is a minimal
- * structural type so that library helpers do not depend on the AI SDK.
- */
-interface DataPart {
-    type: string;
-    text?: string;
-    data?: unknown;
-}
-/**
- * Build a `Spec` by replaying all spec data parts from a message's
- * parts array (AI SDK `UIMessage.parts`). Returns `null` if no spec data
- * parts are present.
- */
-declare function buildSpecFromParts(parts: DataPart[]): Spec | null;
-/**
- * Extract and join all text content from a message's parts array.
- */
-declare function getTextFromParts(parts: DataPart[]): string;
-/**
- * Extract both the json-render spec and the text content from a message's
- * parts array, as memoized signals. Angular counterpart of
- * `useJsonRenderMessage` from the other renderers.
- *
- * @example
- * ```ts
- * readonly msg = jsonRenderMessage(() => this.message().parts);
- * // template: @if (msg.hasSpec()) { <json-render [spec]="msg.spec()" ... /> }
- * ```
- */
-declare function jsonRenderMessage(parts: Signal<DataPart[]> | (() => DataPart[])): {
-    spec: Signal<Spec | null>;
-    text: Signal<string>;
-    hasSpec: Signal<boolean>;
-};
+
 /**
  * A single message in the chat, which may contain text, a rendered UI spec,
  * or both.
@@ -734,11 +987,17 @@ interface ChatUIOptions {
     onError?: (error: Error) => void;
     /**
      * Transport, defaulting to the global `fetch`. Same contract as
-     * {@link UIStreamOptions.fetch}: it receives the endpoint and a request
+     * `UIStreamOptions.fetch`: it receives the endpoint and a request
      * carrying the JSON body and the abort signal, and must resolve to a
      * `Response` whose `body` streams the reply.
      */
     fetch?: typeof globalThis.fetch;
+    /**
+     * Whether to check the spec a reply built, and what a problem means. Off by
+     * default; same contract as `UIStreamOptions.validate`, applied once per
+     * reply that produced a spec.
+     */
+    validate?: SpecValidationMode;
 }
 /**
  * Return type for {@link injectChatUI}.
@@ -750,9 +1009,19 @@ interface ChatUIReturn {
     readonly isStreaming: Signal<boolean>;
     /** Error from the last request, if any */
     readonly error: Signal<Error | null>;
+    /**
+     * Structural issues in the spec of the last completed reply. Empty until a
+     * reply completes, and always empty while `validate` is off.
+     */
+    readonly issues: Signal<readonly SpecIssue[]>;
     /** Send a user message */
     send: (text: string) => Promise<void>;
-    /** Clear all messages and reset the conversation */
+    /**
+     * Stop the in-flight reply, keeping whatever the assistant has said so far.
+     * A no-op when nothing is streaming.
+     */
+    stop: () => void;
+    /** Stop any reply and clear all messages and the error. */
     clear: () => void;
 }
 /**
@@ -841,5 +1110,5 @@ type AngularSpec<TCatalog> = typeof schema extends {
  */
 declare function injectDevtoolsActive(): Signal<boolean>;
 
-export { JrChildren, JrConfirmDialog, JrElement, JrRepeatScope, JsonRenderActionsService, JsonRenderRootContext, JsonRenderStateService, JsonRenderValidationService, JsonRenderer, RENDER_CONTEXT, REPEAT_SCOPE, applyPatch, buildSpecFromParts, createStoreSetState, defineRegistry, flatToTree, getTextFromParts, injectAction, injectActions, injectBoundProp, injectChatUI, injectDevtoolsActive, injectFieldValidation, injectRenderContext, injectRepeatScope, injectStateBinding, injectStateStore, injectStateValue, injectUIStream, injectValidation, jsonRenderMessage, schema };
-export type { ActionFn, Actions, AngularSchema, AngularSpec, CatalogHasActions, ChatMessage, ChatUIOptions, ChatUIReturn, ComponentRegistry, Components, DataPart, DefineRegistryResult, EventHandle, FieldValidationState, PendingConfirmation, RegistryEntry, RenderContext, RepeatScope, SetState, StateChange, TokenUsage, UIStreamOptions, UIStreamReturn };
+export { CONFIRM_CONTEXT, ELEMENT_KEY, JR_CONFIRM_DIALOG, JR_CONFIRM_LABELS, JrChildren, JrConfirmDialog, JrElement, JrRepeatScope, JsonRenderActionsService, JsonRenderRootContext, JsonRenderStateService, JsonRenderValidationService, JsonRenderer, RENDER_CONTEXT, REPEAT_SCOPE, applyPatch, buildSpecFromParts, checkSpec, createStoreSetState, defineRegistry, flatToTree, getTextFromParts, injectAction, injectActions, injectBoundProp, injectChatUI, injectConfirmContext, injectDevtoolsActive, injectElementKey, injectFieldValidation, injectRenderContext, injectRepeatScope, injectStateBinding, injectStateStore, injectStateValue, injectUIStream, injectValidation, isActionCancelled, jsonRenderMessage, schema };
+export type { ActionFn, Actions, AngularSchema, AngularSpec, CatalogHasActions, ChatMessage, ChatUIOptions, ChatUIReturn, ComponentRegistry, Components, ConfirmContext, ConfirmLabels, DataPart, DefineRegistryResult, EventHandle, FieldValidationState, PendingConfirmation, RegistryEntry, RenderContext, RepeatScope, SetState, SpecCheck, SpecValidationMode, StateChange, TokenUsage, UIStreamOptions, UIStreamReturn, UIStreamSendOptions };