@urbicon-ui/blocks 6.40.3 → 6.43.0

package/dist/components/Chat/A2UIView/a2ui-validate.js

@@ -21,8 +21,10 @@
  * because "dangling" is a warning mid-stream and an error once settled.
  */
 import { A2UI_ISSUE_CODES } from './a2ui.types.js';
+import { basicA2uiCatalogSpec, resolveCatalog } from './a2ui-catalog.js';
 import { cloneData, deleteAtPointer, getAtPointer, setAtPointer } from './a2ui-data.js';
-import { A2UI_ICON_NAMES, A2UI_IGNORED_PROPS, A2UI_REGISTRY, A2UI_SUPPORTED_VERSIONS, A2UI_SVG_PATH_RE, UNSUPPORTED_A2UI_COMPONENTS } from './a2ui-registry.js';
+import { A2UI_SUPPORTED_VERSIONS, A2UI_SVG_PATH_RE } from './a2ui-registry.js';
+import { validateSchemaWrite } from './a2ui-schema.js';
 const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 // DoS caps. The per-surface render walk is already bounded (depth 32, nodes
 // 512), but that leaves the *number* of surfaces and the per-message component
@@ -96,7 +98,7 @@ function dynamicRefIssues(value, path, surfaceId) {
     }
     return [];
 }
-function validateProp(componentName, key, spec, value, path, surfaceId) {
+function validateProp(componentName, key, spec, value, path, surfaceId, iconNames) {
     const issues = [];
     const mismatch = (detail) => {
         issues.push(issue('error', A2UI_ISSUE_CODES.TYPE_MISMATCH, detail, { surfaceId, path }));
@@ -130,12 +132,20 @@ function validateProp(componentName, key, spec, value, path, surfaceId) {
             return mismatch(`"${key}" on ${componentName} must be a component id (string)`);
         case 'childList':
             return validateChildList(componentName, key, value, path, surfaceId);
+        case 'labeledChildren':
+            return validateLabeledChildren(componentName, key, value, path, surfaceId);
         case 'action':
             return validateAction(componentName, key, value, path, surfaceId);
         case 'options':
-            return validateOptions(componentName, key, value, path, surfaceId);
+            // A dynamic options prop may be a { path } binding to a list the agent
+            // fetched — the shape is checked when it resolves (see collectGraphIssues),
+            // because at envelope time the data model may not carry it yet.
+            if (spec.dynamic && isDynamicRef(value)) {
+                return { store: true, issues: dynamicRefIssues(value, path, surfaceId) };
+            }
+            return validateOptions(componentName, key, value, path, surfaceId, spec.dynamic);
         case 'icon':
-            return validateIcon(value, path, surfaceId);
+            return validateIcon(value, path, surfaceId, iconNames);
         case 'accessibility':
             if (isPlainObject(value))
                 return { store: true, issues };
@@ -168,6 +178,33 @@ function validateChildList(componentName, key, value, path, surfaceId) {
         ]
     };
 }
+/**
+ * A `labeledChildren` value is an array of `{ label, child }` items: `label` is
+ * a (dynamic) string, `child` a component id referenced by the labelled slot
+ * (Accordion items, Tabs later). The whole prop is rejected if ANY item is
+ * malformed, so the render/graph layers may assume every stored item is a valid
+ * `{ label, child: string }` — this keeps the item→child index alignment the
+ * dispatcher relies on when zipping labels with resolved child nodes.
+ */
+function validateLabeledChildren(componentName, key, value, path, surfaceId) {
+    const bad = (detail) => ({
+        store: false,
+        issues: [issue('error', A2UI_ISSUE_CODES.TYPE_MISMATCH, detail, { surfaceId, path })]
+    });
+    if (!Array.isArray(value))
+        return bad(`"${key}" on ${componentName} must be an array of { label, child } items`);
+    const issues = [];
+    for (let i = 0; i < value.length; i++) {
+        const item = value[i];
+        if (!isPlainObject(item) || typeof item.child !== 'string' || !isDynamicString(item.label)) {
+            return bad(`item ${i} on ${componentName} must be { label, child: string }`);
+        }
+        for (const labelIssue of dynamicRefIssues(item.label, `${path}/${i}/label`, surfaceId)) {
+            issues.push(labelIssue);
+        }
+    }
+    return { store: true, issues };
+}
 function validateAction(componentName, key, value, path, surfaceId) {
     const issues = [];
     if (!isPlainObject(value)) {
@@ -219,13 +256,13 @@ function validateAction(componentName, key, value, path, surfaceId) {
     }));
     return { store: false, issues };
 }
-function validateOptions(componentName, key, value, path, surfaceId) {
+function validateOptions(componentName, key, value, path, surfaceId, dynamic) {
     const bad = (detail) => ({
         store: false,
         issues: [issue('error', A2UI_ISSUE_CODES.TYPE_MISMATCH, detail, { surfaceId, path })]
     });
     if (!Array.isArray(value))
-        return bad(`"${key}" on ${componentName} must be an array of { label, value } options`);
+        return bad(`"${key}" on ${componentName} must be an array of { label, value } options${dynamic ? ' or a { path } binding to one' : ''}`);
     const issues = [];
     const seenValues = new Set();
     for (let i = 0; i < value.length; i++) {
@@ -248,9 +285,9 @@ function validateOptions(componentName, key, value, path, surfaceId) {
     }
     return { store: true, issues };
 }
-function validateIcon(value, path, surfaceId) {
+function validateIcon(value, path, surfaceId, iconNames) {
     if (typeof value === 'string') {
-        if (A2UI_ICON_NAMES.includes(value))
+        if (iconNames.includes(value))
             return { store: true, issues: [] };
         return {
             store: true,
@@ -326,9 +363,10 @@ function validateComponent(surface, raw, envelopeIndex, compIndex, idsSeen) {
         surface.components.set(id, { id, component: '', props: new Map(), sourceIndex: envelopeIndex });
         return;
     }
-    const spec = A2UI_REGISTRY[componentName];
+    const catalog = surface.catalog;
+    const spec = catalog.registry[componentName];
     if (!spec) {
-        if (UNSUPPORTED_A2UI_COMPONENTS.has(componentName)) {
+        if (catalog.unsupportedComponents.has(componentName)) {
             surface.issues.push(issue('error', A2UI_ISSUE_CODES.UNSUPPORTED_COMPONENT, `Component "${componentName}" is not part of the rendered subset`, {
                 surfaceId,
                 path: `${base}/component`
@@ -356,7 +394,7 @@ function validateComponent(surface, raw, envelopeIndex, compIndex, idsSeen) {
             surface.issues.push(issue('error', A2UI_ISSUE_CODES.PROTOTYPE_POLLUTION, `Prohibited property "${key}" on "${id}"`, { surfaceId, path: `${base}/${key}` }));
             continue;
         }
-        if (A2UI_IGNORED_PROPS.has(key)) {
+        if (catalog.ignoredProps.has(key)) {
             surface.issues.push(issue('warning', A2UI_ISSUE_CODES.IGNORED_PROP, `Property "${key}" on ${componentName} is not supported and is ignored`, {
                 surfaceId,
                 path: `${base}/${key}`
@@ -368,7 +406,7 @@ function validateComponent(surface, raw, envelopeIndex, compIndex, idsSeen) {
             surface.issues.push(issue('error', A2UI_ISSUE_CODES.UNKNOWN_PROP, `Unknown property "${key}" on ${componentName}`, { surfaceId, path: `${base}/${key}` }));
             continue;
         }
-        const result = validateProp(componentName, key, propSpec, comp[key], `${base}/${key}`, surfaceId);
+        const result = validateProp(componentName, key, propSpec, comp[key], `${base}/${key}`, surfaceId, catalog.iconNames);
         for (const propIssue of result.issues)
             surface.issues.push(propIssue);
         if (result.store)
@@ -382,24 +420,14 @@ function validateComponent(surface, raw, envelopeIndex, compIndex, idsSeen) {
             }));
         }
     }
-    if (componentName === 'ChoicePicker') {
-        if (props.get('displayStyle') === 'chips' || props.get('filterable') === true) {
-            surface.issues.push(issue('warning', A2UI_ISSUE_CODES.CHOICEPICKER_FALLBACK, `ChoicePicker "${id}" chips/filterable are rendered with a fallback`, {
-                surfaceId,
-                path: base
-            }));
-        }
-    }
-    if (componentName === 'DateTimeInput') {
-        // Both flags default to false in the spec — a DateTimeInput without either
-        // would have no input UI at all. We read tolerantly (render a date input)
-        // and report loudly so the agent fixes the payload.
-        if (props.get('enableDate') !== true && props.get('enableTime') !== true) {
-            surface.issues.push(issue('warning', A2UI_ISSUE_CODES.DATETIME_NO_MODE, `DateTimeInput "${id}" sets neither enableDate nor enableTime; rendering a date input`, {
-                surfaceId,
-                path: base
-            }));
-        }
+    // Per-component post-validation checks are catalog DATA (the Basic catalog
+    // owns ChoicePicker chips-fallback and DateTimeInput missing-mode); the engine
+    // stays free of catalog-specific branches. Message strings and issue paths are
+    // byte-identical to the pre-refactor hardcoded blocks.
+    const check = catalog.componentChecks?.[componentName];
+    if (check) {
+        for (const checkIssue of check({ id, props, surfaceId, base }))
+            surface.issues.push(checkIssue);
     }
     surface.components.set(id, { id, component: componentName, props, sourceIndex: envelopeIndex });
 }
@@ -426,9 +454,10 @@ const CREATE_SURFACE_KEYS = new Set([
 const UPDATE_COMPONENTS_KEYS = new Set(['surfaceId', 'components']);
 const UPDATE_DATA_MODEL_KEYS = new Set(['surfaceId', 'path', 'value']);
 const DELETE_SURFACE_KEYS = new Set(['surfaceId']);
-function createProcessor() {
+function createProcessor(catalogs, dataSchema) {
     const surfaces = new Map();
     const globalIssues = [];
+    const defaultCatalog = catalogs[0];
     function handleCreateSurface(env, base) {
         const cs = env.createSurface;
         if (!isPlainObject(cs)) {
@@ -460,7 +489,9 @@ function createProcessor() {
             surfaceId,
             components: new Map(),
             dataModel: undefined,
-            issues: []
+            issues: [],
+            catalog: defaultCatalog,
+            sendDataModel: false
         };
         surfaces.set(surfaceId, surface);
         if (typeof cs.catalogId !== 'string') {
@@ -469,6 +500,17 @@ function createProcessor() {
                 path: `${base}/createSurface/catalogId`
             }));
         }
+        else {
+            const resolved = resolveCatalog(catalogs, cs.catalogId);
+            if (resolved) {
+                surface.catalog = resolved;
+            }
+            else if (catalogs.length >= 2) {
+                // Only a multi-catalog processor can meaningfully reject an id; a single
+                // catalog accepts any string (back-compat) and uses the default silently.
+                surface.issues.push(issue('warning', A2UI_ISSUE_CODES.UNKNOWN_CATALOG, `Unknown catalogId "${cs.catalogId}"; falling back to "${defaultCatalog.catalogId}"`, { surfaceId, path: `${base}/createSurface/catalogId` }));
+            }
+        }
         if ('theme' in cs) {
             surface.issues.push(issue('warning', A2UI_ISSUE_CODES.SURFACE_PROP_IGNORED, 'theme is ignored', {
                 surfaceId,
@@ -476,10 +518,15 @@ function createProcessor() {
             }));
         }
         if ('sendDataModel' in cs) {
-            surface.issues.push(issue('warning', A2UI_ISSUE_CODES.SURFACE_PROP_IGNORED, 'sendDataModel is ignored', {
-                surfaceId,
-                path: `${base}/createSurface/sendDataModel`
-            }));
+            if (typeof cs.sendDataModel === 'boolean') {
+                surface.sendDataModel = cs.sendDataModel;
+            }
+            else {
+                surface.issues.push(issue('warning', A2UI_ISSUE_CODES.TYPE_MISMATCH, 'sendDataModel must be a boolean', {
+                    surfaceId,
+                    path: `${base}/createSurface/sendDataModel`
+                }));
+            }
         }
         flagExtraKeys(cs, CREATE_SURFACE_KEYS, surface.issues, surfaceId, `${base}/createSurface`, 'createSurface');
     }
@@ -558,6 +605,14 @@ function createProcessor() {
             return;
         }
         const hasValue = 'value' in udm;
+        // Schema validation (opt-in): a type mismatch on a declared pointer is an
+        // error, a write to an undeclared top-level branch a warning — both relayed
+        // to the agent. Runs on the raw written value before it enters the model.
+        if (dataSchema) {
+            const schemaIssues = validateSchemaWrite(dataSchema, pathValue, hasValue ? udm.value : undefined, surfaceId);
+            for (const schemaIssue of schemaIssues)
+                surface.issues.push(schemaIssue);
+        }
         const whole = pathValue === undefined || pathValue === '' || pathValue === '/';
         if (whole) {
             surface.dataModel = hasValue ? cloneData(udm.value) : undefined;
@@ -638,8 +693,9 @@ function createProcessor() {
     }
     return { surfaces, globalIssues, apply };
 }
-export function createA2uiProcessor() {
-    return createProcessor();
+export function createA2uiProcessor(options) {
+    const catalogs = options?.catalogs?.length ? options.catalogs : [basicA2uiCatalogSpec];
+    return createProcessor(catalogs, options?.dataSchema);
 }
 /**
  * Normalize a render payload into an envelope list. Accepts an envelope array,
@@ -690,37 +746,65 @@ export function collectGraphIssues(surface, options) {
     let nodeCount = 0;
     let overflowReported = false;
     let aborted = false;
+    // Child references are discovered by prop KIND (childId / childList) from the
+    // surface catalog's registry, not by fixed `child`/`children` names — so a
+    // catalog may name its child slots freely. Behaviour is unchanged for Basic,
+    // whose only child props ARE `child`/`children`.
+    const registry = surface.catalog.registry;
     const childTargets = (comp, scopePrefix) => {
         const out = [];
-        const single = comp.props.get('child');
-        if (typeof single === 'string')
-            out.push({ id: single, scope: scopePrefix });
-        const children = comp.props.get('children');
-        if (Array.isArray(children)) {
-            for (const childId of children)
-                if (typeof childId === 'string')
-                    out.push({ id: childId, scope: scopePrefix });
-        }
-        else if (children && typeof children === 'object') {
-            const template = children;
-            if (typeof template.componentId === 'string' && typeof template.path === 'string') {
-                const absPath = template.path.startsWith('/')
-                    ? template.path
-                    : `${scopePrefix ?? ''}/${template.path}`;
-                const list = getAtPointer(surface.dataModel, absPath);
-                if (Array.isArray(list)) {
-                    for (let i = 0; i < list.length; i++) {
-                        out.push({ id: template.componentId, scope: `${absPath}/${i}` });
+        const spec = registry[comp.component];
+        if (!spec)
+            return out;
+        for (const [key, propSpec] of Object.entries(spec.props)) {
+            if (propSpec.kind === 'childId') {
+                const single = comp.props.get(key);
+                if (typeof single === 'string')
+                    out.push({ id: single, scope: scopePrefix });
+            }
+            else if (propSpec.kind === 'labeledChildren') {
+                const items = comp.props.get(key);
+                if (Array.isArray(items)) {
+                    for (const item of items) {
+                        if (item && typeof item === 'object') {
+                            const child = item.child;
+                            if (typeof child === 'string')
+                                out.push({ id: child, scope: scopePrefix });
+                        }
                         if (out.length > maxNodes)
                             break; // bound expansion
                     }
                 }
-                else if (list !== undefined) {
-                    issues.push(issue('warning', A2UI_ISSUE_CODES.TEMPLATE_PATH_NOT_ARRAY, `Template path "${absPath}" did not resolve to an array`, {
-                        surfaceId
-                    }));
+            }
+            else if (propSpec.kind === 'childList') {
+                const children = comp.props.get(key);
+                if (Array.isArray(children)) {
+                    for (const childId of children)
+                        if (typeof childId === 'string')
+                            out.push({ id: childId, scope: scopePrefix });
+                }
+                else if (children && typeof children === 'object') {
+                    const template = children;
+                    if (typeof template.componentId === 'string' && typeof template.path === 'string') {
+                        const absPath = template.path.startsWith('/')
+                            ? template.path
+                            : `${scopePrefix ?? ''}/${template.path}`;
+                        const list = getAtPointer(surface.dataModel, absPath);
+                        if (Array.isArray(list)) {
+                            for (let i = 0; i < list.length; i++) {
+                                out.push({ id: template.componentId, scope: `${absPath}/${i}` });
+                                if (out.length > maxNodes)
+                                    break; // bound expansion
+                            }
+                        }
+                        else if (list !== undefined) {
+                            issues.push(issue('warning', A2UI_ISSUE_CODES.TEMPLATE_PATH_NOT_ARRAY, `Template path "${absPath}" did not resolve to an array`, {
+                                surfaceId
+                            }));
+                        }
+                        // list === undefined → data not present yet; render nothing (graceful).
+                    }
                 }
-                // list === undefined → data not present yet; render nothing (graceful).
             }
         }
         return out;
@@ -749,7 +833,27 @@ export function collectGraphIssues(surface, options) {
             }
             return;
         }
-        if (comp.props.has('weight') && parentComponent !== 'Row' && parentComponent !== 'Column') {
+        // A bound `options` list is only checkable once it resolves — the envelope
+        // validator saw a { path }, not a list. Silent while the path is still
+        // undefined (the agent fills it in with a later updateDataModel); a warning
+        // once it holds something that is not an option list, because the control
+        // then renders empty and the user is stuck with no way to choose.
+        for (const [key, propSpec] of Object.entries(registry[comp.component]?.props ?? {})) {
+            if (propSpec.kind !== 'options' || !propSpec.dynamic)
+                continue;
+            const bound = comp.props.get(key);
+            if (!isPlainObject(bound) || typeof bound.path !== 'string')
+                continue;
+            // Same absolute/relative rule as a childList template path.
+            const pointer = bound.path.startsWith('/')
+                ? bound.path
+                : `${scopePrefix ?? ''}/${bound.path}`;
+            const resolvedList = getAtPointer(surface.dataModel, pointer);
+            if (resolvedList === undefined || Array.isArray(resolvedList))
+                continue;
+            issues.push(issue('warning', A2UI_ISSUE_CODES.OPTIONS_NOT_A_LIST, `"${key}" on "${id}" is bound to "${pointer}", which is not a list of options`, { surfaceId }));
+        }
+        if (comp.props.has('weight') && !surface.catalog.flexContainers.has(parentComponent ?? '')) {
             issues.push(issue('warning', A2UI_ISSUE_CODES.WEIGHT_CONTEXT, `"weight" on "${id}" is only honored as a direct child of Row or Column`, {
                 surfaceId
             }));

package/dist/components/Chat/A2UIView/a2ui.types.d.ts

@@ -30,6 +30,19 @@ export interface A2uiActionEvent {
     /** ISO 8601 timestamp (`new Date().toISOString()`). */
     timestamp: string;
     context: Record<string, unknown>;
+    /**
+     * The surface's complete data model — present only when the surface was
+     * created with `sendDataModel: true`.
+     *
+     * The spec calls this the client data model and has the client append it to
+     * the metadata of every message sent to the agent, but leaves WHERE metadata
+     * travels to the transport binding (A2A `metadata`, HTTP headers, …). This
+     * field is that payload; put it wherever your transport carries metadata.
+     *
+     * It is the antidote to a half-filled `context`: the agent sees everything the
+     * user entered, including fields it forgot to list on the action.
+     */
+    dataModel?: unknown;
 }
 /** Severity of a validation issue. `error` renders a fault chip; `warning` degrades. */
 export type A2uiIssueSeverity = 'error' | 'warning';
@@ -115,5 +128,42 @@ export declare const A2UI_ISSUE_CODES: {
     readonly CHOICEPICKER_FALLBACK: "CHOICEPICKER_FALLBACK";
     /** A `createSurface`-only prop (`theme`, `sendDataModel`) that the engine ignores. */
     readonly SURFACE_PROP_IGNORED: "SURFACE_PROP_IGNORED";
+    /**
+     * `createSurface.catalogId` names no configured catalog — the surface falls
+     * back to the first (default) catalog. Only emitted in a multi-catalog setup;
+     * a single-catalog processor accepts any id string silently (back-compat).
+     */
+    readonly UNKNOWN_CATALOG: "UNKNOWN_CATALOG";
+    /**
+     * A `Text` value looks like it carries Markdown, but `Text` renders PLAIN.
+     * A heuristic warning steering the agent to `RichText` (Urbicon catalog).
+     */
+    readonly MARKDOWN_IN_TEXT: "MARKDOWN_IN_TEXT";
+    /**
+     * An `updateDataModel` write's value type contradicts the surface data
+     * schema's declared type at that pointer (opt-in `dataSchema`).
+     */
+    readonly SCHEMA_TYPE_MISMATCH: "SCHEMA_TYPE_MISMATCH";
+    /**
+     * An `updateDataModel` write targets a top-level path the surface data schema
+     * does not declare (opt-in `dataSchema`; warning).
+     */
+    readonly SCHEMA_UNDECLARED_PATH: "SCHEMA_UNDECLARED_PATH";
+    /**
+     * `createSurface` re-used a surfaceId that another source (an earlier chat
+     * message) already owns. The spec requires a surfaceId to be unique for the
+     * renderer's lifetime, so this is a protocol violation the agent should hear
+     * about; {@link A2uiSurfaceRouter} still transfers ownership to the newest
+     * source so the fresh surface renders (last writer wins). Router-only —
+     * a single processor reports the same case as `DUPLICATE_SURFACE`.
+     */
+    readonly SURFACE_RECREATED: "SURFACE_RECREATED";
+    /**
+     * An `options` `{ path }` binding resolved to a value that is not a list of
+     * `{ label, value }` options — the control renders empty. Not emitted while
+     * the path is still `undefined`: the agent is expected to fill it in with a
+     * later `updateDataModel`, and an empty chooser mid-flow is normal.
+     */
+    readonly OPTIONS_NOT_A_LIST: "OPTIONS_NOT_A_LIST";
 };
 export type A2uiIssueCode = (typeof A2UI_ISSUE_CODES)[keyof typeof A2UI_ISSUE_CODES];

package/dist/components/Chat/A2UIView/a2ui.types.js

@@ -81,5 +81,42 @@ export const A2UI_ISSUE_CODES = {
     /** `ChoicePicker` `displayStyle: 'chips'` / `filterable` — rendered with a fallback. */
     CHOICEPICKER_FALLBACK: 'CHOICEPICKER_FALLBACK',
     /** A `createSurface`-only prop (`theme`, `sendDataModel`) that the engine ignores. */
-    SURFACE_PROP_IGNORED: 'SURFACE_PROP_IGNORED'
+    SURFACE_PROP_IGNORED: 'SURFACE_PROP_IGNORED',
+    /**
+     * `createSurface.catalogId` names no configured catalog — the surface falls
+     * back to the first (default) catalog. Only emitted in a multi-catalog setup;
+     * a single-catalog processor accepts any id string silently (back-compat).
+     */
+    UNKNOWN_CATALOG: 'UNKNOWN_CATALOG',
+    /**
+     * A `Text` value looks like it carries Markdown, but `Text` renders PLAIN.
+     * A heuristic warning steering the agent to `RichText` (Urbicon catalog).
+     */
+    MARKDOWN_IN_TEXT: 'MARKDOWN_IN_TEXT',
+    /**
+     * An `updateDataModel` write's value type contradicts the surface data
+     * schema's declared type at that pointer (opt-in `dataSchema`).
+     */
+    SCHEMA_TYPE_MISMATCH: 'SCHEMA_TYPE_MISMATCH',
+    /**
+     * An `updateDataModel` write targets a top-level path the surface data schema
+     * does not declare (opt-in `dataSchema`; warning).
+     */
+    SCHEMA_UNDECLARED_PATH: 'SCHEMA_UNDECLARED_PATH',
+    /**
+     * `createSurface` re-used a surfaceId that another source (an earlier chat
+     * message) already owns. The spec requires a surfaceId to be unique for the
+     * renderer's lifetime, so this is a protocol violation the agent should hear
+     * about; {@link A2uiSurfaceRouter} still transfers ownership to the newest
+     * source so the fresh surface renders (last writer wins). Router-only —
+     * a single processor reports the same case as `DUPLICATE_SURFACE`.
+     */
+    SURFACE_RECREATED: 'SURFACE_RECREATED',
+    /**
+     * An `options` `{ path }` binding resolved to a value that is not a list of
+     * `{ label, value }` options — the control renders empty. Not emitted while
+     * the path is still `undefined`: the agent is expected to fill it in with a
+     * later `updateDataModel`, and an empty chooser mid-flow is normal.
+     */
+    OPTIONS_NOT_A_LIST: 'OPTIONS_NOT_A_LIST'
 };

package/dist/components/Chat/A2UIView/index.d.ts

@@ -1,6 +1,8 @@
 import type { HTMLAttributes } from 'svelte/elements';
 import type { MarkdownUrlPolicy } from '../markdown/types.js';
 import type { A2uiActionEvent, A2uiValidationIssue } from './a2ui.types.js';
+import type { A2uiCatalog } from './a2ui-catalog.js';
+import type { A2uiDataSchema } from './a2ui-schema.js';
 import type { A2UIViewSlots } from './a2ui-view.variants.js';
 /**
  * @description Renders a trusted-catalog A2UI (Agent-to-UI, v0.9.1 `basic`
@@ -16,7 +18,13 @@ import type { A2UIViewSlots } from './a2ui-view.variants.js';
  * renderer — wire it in per surface via `partRenderers.a2ui` to keep it out of
  * the base bundle. Generate the agent-side prompt with the shipped
  * `a2uiSystemPrompt()`; validate a payload without a DOM with
- * `createA2uiProcessor()` — never hand-roll either.
+ * `createA2uiProcessor()` — never hand-roll either. Opt into the richer
+ * Urbicon-native catalog (real intents/variants, Section, RichText, Accordion)
+ * by passing `catalogs={[urbiconA2uiCatalog]}` (tree-shaken out otherwise), and
+ * type-check the data model with an optional `dataSchema`. One view owns the
+ * surfaces of ONE payload; to let an agent patch a surface it sent in an earlier
+ * chat turn (multi-step forms), route the later envelopes into that payload with
+ * `A2uiSurfaceRouter` — never give a second view the same surfaceId.
  * @tag ai
  * @related ChatMessage
  * @stability experimental
@@ -77,6 +85,23 @@ export interface A2UIViewProps extends Omit<HTMLAttributes<HTMLDivElement>, 'cla
     blockedImageLabel?: string;
     /** Screen-reader label of the streaming placeholder. @default 'Loading UI' */
     pendingLabel?: string;
+    /**
+     * Additional A2UI catalogs this view can render, beyond the always-present
+     * Basic catalog (which is prepended automatically as the default/fallback). A
+     * surface renders through the catalog whose id its `createSurface.catalogId`
+     * names. Pass the shipped `urbiconA2uiCatalog` to enable the Urbicon-native
+     * catalog. Resolved once at init (icon setup reads context) — keep it
+     * referentially stable.
+     */
+    catalogs?: readonly A2uiCatalog[];
+    /**
+     * Optional surface data schema. When set, every `updateDataModel` write is
+     * validated against it (type mismatch on a declared pointer → error;
+     * undeclared top-level branch → warning), reported via `onValidationError`.
+     * Document the same schema to the agent with `a2uiDataSchemaSection`. Keep it
+     * referentially stable.
+     */
+    dataSchema?: A2uiDataSchema;
     /** Extra classes merged onto the root element. */
     class?: string;
     /** Strip the component's default tv() classes. */
@@ -96,7 +121,15 @@ export interface A2UIViewProps extends Omit<HTMLAttributes<HTMLDivElement>, 'cla
 }
 export { default as A2UIView } from './A2UIView.svelte';
 export { A2UI_ISSUE_CODES, type A2uiActionEvent, type A2uiEnvelope, type A2uiIssueCode, type A2uiIssueSeverity, type A2uiValidationIssue } from './a2ui.types.js';
+export { basicA2uiCatalog } from './a2ui-basic-catalog.js';
+export { type A2uiCatalog, type A2uiCatalogSpec, type A2uiComponentCheck, type A2uiComponentCheckContext, basicA2uiCatalogSpec, resolveCatalog } from './a2ui-catalog.js';
 export { a2uiSystemPrompt } from './a2ui-prompt.js';
 export { A2UI_CATALOG_ID, A2UI_ICON_NAMES, A2UI_REGISTRY, A2UI_SUPPORTED_VERSIONS, type A2uiComponentSpec, type A2uiPropKind, type A2uiPropSpec, UNSUPPORTED_A2UI_COMPONENTS } from './a2ui-registry.js';
-export { type A2uiComponentInstance, type A2uiProcessor, type A2uiSurfaceState, collectGraphIssues, createA2uiProcessor, normalizeA2uiPayload } from './a2ui-validate.js';
+export { type A2uiRoutePatch, type A2uiRouteResult, A2uiSurfaceRouter } from './a2ui-router.js';
+export { type A2uiDataSchema, type A2uiSchemaField, type A2uiSchemaType, a2uiDataSchemaSection, validateSchemaWrite } from './a2ui-schema.js';
+export { A2UI_FENCE_TAG, type A2uiStreamIssue, type A2uiStreamPart, A2uiStreamSplitter, type A2uiStreamTextPart, type A2uiStreamUiPart, type A2uiTransportSectionOptions, a2uiFencedTransportSection } from './a2ui-stream.js';
+export { editA2uiPayload, type PatchedSurface, type RouteMessageResult, revokeMessage, routeMessageParts, sourceKey } from './a2ui-transcript.js';
+export { type A2uiComponentInstance, type A2uiProcessor, type A2uiProcessorOptions, type A2uiSurfaceState, collectGraphIssues, createA2uiProcessor, normalizeA2uiPayload } from './a2ui-validate.js';
 export { type A2UIViewSlots, type A2UIViewVariants, a2uiViewVariants } from './a2ui-view.variants.js';
+export { urbiconA2uiCatalog } from './urbicon/a2ui-urbicon-catalog.js';
+export { SHARED_AXES, UNSUPPORTED_URBICON_A2UI_COMPONENTS, URBICON_A2UI_CATALOG_ID, URBICON_A2UI_ICON_NAMES, URBICON_A2UI_REGISTRY, type UrbiconComponentSpec, type UrbiconPropSpec, urbiconA2uiCatalogSpec } from './urbicon/a2ui-urbicon-registry.js';

package/dist/components/Chat/A2UIView/index.js

@@ -1,7 +1,20 @@
 export { default as A2UIView } from './A2UIView.svelte';
 // ── Engine surface (Svelte-free; a server building the prompt has no DOM) ────
 export { A2UI_ISSUE_CODES } from './a2ui.types.js';
+export { basicA2uiCatalog } from './a2ui-basic-catalog.js';
+// ── Catalog abstraction (the seam for a second, custom catalog) ──────────────
+export { basicA2uiCatalogSpec, resolveCatalog } from './a2ui-catalog.js';
 export { a2uiSystemPrompt } from './a2ui-prompt.js';
 export { A2UI_CATALOG_ID, A2UI_ICON_NAMES, A2UI_REGISTRY, A2UI_SUPPORTED_VERSIONS, UNSUPPORTED_A2UI_COMPONENTS } from './a2ui-registry.js';
+// ── Cross-message surface routing (keeps a surface patchable after its turn) ──
+export { A2uiSurfaceRouter } from './a2ui-router.js';
+export { a2uiDataSchemaSection, validateSchemaWrite } from './a2ui-schema.js';
+// ── Fenced-JSONL transport: the token-stream parser and the prompt that feeds it ──
+export { A2UI_FENCE_TAG, A2uiStreamSplitter, a2uiFencedTransportSection } from './a2ui-stream.js';
+// ── Transcript wiring: deliver routed envelopes into the messages that own them ─
+export { editA2uiPayload, revokeMessage, routeMessageParts, sourceKey } from './a2ui-transcript.js';
 export { collectGraphIssues, createA2uiProcessor, normalizeA2uiPayload } from './a2ui-validate.js';
 export { a2uiViewVariants } from './a2ui-view.variants.js';
+// ── Urbicon-native catalog (opt-in; tree-shaken out unless imported) ─────────
+export { urbiconA2uiCatalog } from './urbicon/a2ui-urbicon-catalog.js';
+export { SHARED_AXES, UNSUPPORTED_URBICON_A2UI_COMPONENTS, URBICON_A2UI_CATALOG_ID, URBICON_A2UI_ICON_NAMES, URBICON_A2UI_REGISTRY, urbiconA2uiCatalogSpec } from './urbicon/a2ui-urbicon-registry.js';