@urbicon-ui/blocks 6.37.2 → 6.39.0

package/dist/components/Chat/A2UIView/A2UIView.svelte

@@ -0,0 +1,272 @@
+<script lang="ts">
+  import { Alert } from '../../../primitives';
+  import { untrack } from 'svelte';
+  import { getBlocksConfig, resolveSlotClasses } from '../../../provider';
+  import { type IconComponent, resolveIcon } from '../../../icons';
+  import PlusIconDefault from '../../../icons/PlusIcon.svelte';
+  import ArrowLeftIconDefault from '../../../icons/ArrowLeftIcon.svelte';
+  import CheckIconDefault from '../../../icons/CheckIcon.svelte';
+  import CloseIconDefault from '../../../icons/CloseIcon.svelte';
+  import TrashIconDefault from '../../../icons/TrashIcon.svelte';
+  import EditIconDefault from '../../../icons/EditIcon.svelte';
+  import DangerCircleIconDefault from '../../../icons/DangerCircleIcon.svelte';
+  import HomeIconDefault from '../../../icons/HomeIcon.svelte';
+  import InfoCircleIconDefault from '../../../icons/InfoCircleIcon.svelte';
+  import MailIconDefault from '../../../icons/MailIcon.svelte';
+  import MenuIconDefault from '../../../icons/MenuIcon.svelte';
+  import SearchIconDefault from '../../../icons/SearchIcon.svelte';
+  import SendIconDefault from '../../../icons/SendIcon.svelte';
+  import SettingsIconDefault from '../../../icons/SettingsIcon.svelte';
+  import StarIconDefault from '../../../icons/StarIcon.svelte';
+  import WarningTriangleIconDefault from '../../../icons/WarningTriangleIcon.svelte';
+  import CircleHelpIconDefault from '../../../icons/CircleHelpIcon.svelte';
+  import A2UINode from './A2UINode.svelte';
+  import type { A2uiValidationIssue } from './a2ui.types';
+  import { deleteAtPointer, resolveDynamic, setAtPointer } from './a2ui-data';
+  import {
+    type A2uiProcessor,
+    collectGraphIssues,
+    createA2uiProcessor,
+    normalizeA2uiPayload
+  } from './a2ui-validate';
+  import { type A2uiRenderContext, type A2uiRenderNode, buildRenderTree } from './a2ui-render';
+  import { a2uiViewVariants } from './a2ui-view.variants';
+  import type { A2UIViewProps } from './index';
+
+  let {
+    payload,
+    streaming: streamingProp = false,
+    urlPolicy,
+    onAction,
+    onValidationError,
+    errorTitle = 'Invalid UI payload',
+    unsupportedLabel = 'Unsupported component',
+    blockedImageLabel = 'Image blocked',
+    pendingLabel = 'Loading UI',
+    class: className,
+    unstyled: unstyledProp = false,
+    slotClasses: slotClassesProp = {},
+    preset,
+    ...restProps
+  }: A2UIViewProps = $props();
+
+  const blocksConfig = getBlocksConfig();
+  const unstyled = $derived(unstyledProp || blocksConfig?.unstyled || false);
+
+  // A2UI icon-enum name → resolved Urbicon icon. Resolved ONCE via direct
+  // imports (tree-shakeable — never getIcon()); an IconProvider override still
+  // wins, the direct import is the fallback. Built here (not per node) and
+  // threaded through the render context.
+  const icons: Readonly<Record<string, IconComponent>> = {
+    add: resolveIcon('plus', PlusIconDefault),
+    arrowBack: resolveIcon('arrowLeft', ArrowLeftIconDefault),
+    check: resolveIcon('check', CheckIconDefault),
+    close: resolveIcon('close', CloseIconDefault),
+    delete: resolveIcon('trash', TrashIconDefault),
+    edit: resolveIcon('edit', EditIconDefault),
+    error: resolveIcon('danger', DangerCircleIconDefault),
+    home: resolveIcon('home', HomeIconDefault),
+    info: resolveIcon('info', InfoCircleIconDefault),
+    mail: resolveIcon('mail', MailIconDefault),
+    menu: resolveIcon('menu', MenuIconDefault),
+    search: resolveIcon('search', SearchIconDefault),
+    send: resolveIcon('send', SendIconDefault),
+    settings: resolveIcon('settings', SettingsIconDefault),
+    star: resolveIcon('star', StarIconDefault),
+    warning: resolveIcon('warning', WarningTriangleIconDefault)
+  };
+  const fallbackIcon = resolveIcon('circleHelp', CircleHelpIconDefault);
+
+  // ── Processor (plain, non-reactive) + version counter ────────────────────
+  // The processor mutates plain Maps in place (the streaming-markdown engine
+  // pattern). A $state version counter is the single reactive primitive; the
+  // render tree derives from it, so reading it is a real subscription (unlike a
+  // `void messages` proxy read). `processor`/`consumed` are plain lets: their
+  // reassignment must NOT itself trigger reactivity — the bump does.
+  let processor: A2uiProcessor = createA2uiProcessor();
+  let consumed: unknown[] = [];
+  let normalizeIssue = $state<A2uiValidationIssue | undefined>(undefined);
+  let version = $state(0);
+  // Bumped ONLY on a full rebuild (payload replaced, not appended). It keys the
+  // surface `{#each}`, so a rebuild remounts the node tree and A2UINode's local
+  // input fallbacks reset — otherwise a typed-then-replaced literal input keeps
+  // the stale text (a rebuild is documented to discard local edits). An
+  // incremental append leaves it unchanged, so focus and edits survive.
+  let generation = $state(0);
+
+  function bump(): void {
+    version++;
+  }
+
+  // Incremental consumption: if the first `consumed.length` envelopes are
+  // referentially identical to the new payload, apply only the appended ones
+  // (two-way edits in the data model survive). Otherwise rebuild from scratch.
+  // Reads `payload` (tracked) to re-run on every immutable payload change; the
+  // mutation is untracked so the `version++`/`normalizeIssue` writes never make
+  // this effect depend on the state it drives (avoids an update-depth loop).
+  $effect(() => {
+    const { envelopes, issue } = normalizeA2uiPayload(payload);
+    untrack(() => {
+      const prefixMatches =
+        envelopes.length >= consumed.length && consumed.every((env, i) => env === envelopes[i]);
+      if (!prefixMatches) {
+        processor = createA2uiProcessor();
+        consumed = [];
+        generation++;
+      }
+      for (let i = consumed.length; i < envelopes.length; i++) {
+        processor.apply(envelopes[i], i);
+      }
+      consumed = envelopes.slice();
+      normalizeIssue = issue;
+      version++;
+    });
+  });
+
+  function isContainer(value: unknown): boolean {
+    return value !== null && typeof value === 'object';
+  }
+
+  // Two-way write-back: mutate the surface data model in place, then bump so the
+  // render tree re-derives with the new value (bound labels update live).
+  function writeBinding(surfaceId: string, pointer: string, value: unknown): void {
+    const surface = processor.surfaces.get(surfaceId);
+    if (!surface) return;
+    if (!isContainer(surface.dataModel)) {
+      const firstSegment = pointer.replace(/^\//, '').split('/')[0];
+      surface.dataModel = /^(?:0|[1-9]\d*|-)$/.test(firstSegment) ? [] : {};
+    }
+    setAtPointer(surface.dataModel, pointer, value);
+    bump();
+  }
+  function removeBinding(surfaceId: string, pointer: string): void {
+    const surface = processor.surfaces.get(surfaceId);
+    if (!surface) return;
+    deleteAtPointer(surface.dataModel, pointer);
+    bump();
+  }
+
+  // ── Resolved slot classes ────────────────────────────────────────────────
+  const styles = a2uiViewVariants();
+  const resolvedSlots = $derived(
+    resolveSlotClasses(blocksConfig, 'A2UIView', preset, {}, slotClassesProp)
+  );
+  const classes = $derived.by(() => {
+    const out: Record<string, string> = {};
+    for (const [name, slotFn] of Object.entries(styles)) {
+      const override = resolvedSlots?.[name];
+      out[name] = unstyled ? (override ?? '') : slotFn({ class: override });
+    }
+    return out;
+  });
+  const rootClass = $derived(
+    unstyled
+      ? [resolvedSlots?.root, className].filter(Boolean).join(' ')
+      : styles.root({ class: [resolvedSlots?.root, className] })
+  );
+
+  // ── Render tree + issue collection (re-derives on every version bump) ────
+  interface SurfaceView {
+    surfaceId: string;
+    root: A2uiRenderNode | null;
+    context: A2uiRenderContext;
+  }
+
+  const view = $derived.by(() => {
+    version; // subscription to processing + edits
+    const isStreaming = streamingProp;
+    const currentClasses = classes;
+    const surfaces: SurfaceView[] = [];
+    const summaryIssues: A2uiValidationIssue[] = [];
+    const allIssues: A2uiValidationIssue[] = [];
+
+    if (normalizeIssue) {
+      summaryIssues.push(normalizeIssue);
+      allIssues.push(normalizeIssue);
+    }
+    for (const globalIssue of processor.globalIssues) {
+      allIssues.push(globalIssue);
+      if (globalIssue.severity === 'error') summaryIssues.push(globalIssue);
+    }
+
+    for (const surface of processor.surfaces.values()) {
+      for (const surfaceIssue of surface.issues) allIssues.push(surfaceIssue);
+      for (const graphIssue of collectGraphIssues(surface, { streaming: isStreaming })) {
+        allIssues.push(graphIssue);
+      }
+      const root = buildRenderTree(surface);
+      const context: A2uiRenderContext = {
+        classes: currentClasses,
+        urlPolicy,
+        streaming: isStreaming,
+        inline: false,
+        surfaceId: surface.surfaceId,
+        onAction,
+        resolve: (value, scope) => resolveDynamic(value, surface.dataModel, scope),
+        write: (pointer, value) => writeBinding(surface.surfaceId, pointer, value),
+        remove: (pointer) => removeBinding(surface.surfaceId, pointer),
+        icons,
+        fallbackIcon,
+        labels: {
+          unsupported: unsupportedLabel,
+          blockedImage: blockedImageLabel,
+          pending: pendingLabel
+        }
+      };
+      surfaces.push({ surfaceId: surface.surfaceId, root, context });
+    }
+    return { surfaces, summaryIssues, allIssues };
+  });
+
+  // Fire onValidationError only when the issue list actually changes. Seeded
+  // with the empty signature so an issue-free first render stays silent.
+  let lastIssueSig = '[]';
+  $effect(() => {
+    const issues = view.allIssues;
+    const signature = JSON.stringify(
+      issues.map((issue) => [
+        issue.severity,
+        issue.code,
+        issue.surfaceId ?? '',
+        issue.path ?? '',
+        issue.message
+      ])
+    );
+    if (signature !== lastIssueSig) {
+      lastIssueSig = signature;
+      onValidationError?.(issues);
+    }
+  });
+</script>
+
+<!--
+  The render tree recurses through this self-referencing snippet rather than a
+  self-import inside A2UINode: a snippet that renders A2UINode and passes ITSELF
+  down as `renderChild` gives clean recursion without the circular component-type
+  resolution that self-imports trip in svelte-check.
+-->
+{#snippet renderNode(node: A2uiRenderNode, context: A2uiRenderContext)}
+  <A2UINode {node} {context} renderChild={renderNode} />
+{/snippet}
+
+<div class={rootClass} {...restProps}>
+  {#if view.summaryIssues.length}
+    <Alert intent="danger" title={errorTitle}>
+      <ul class={classes.errorList}>
+        {#each view.summaryIssues as issue, index (`${issue.code}#${index}`)}
+          <li>{issue.message}</li>
+        {/each}
+      </ul>
+    </Alert>
+  {/if}
+
+  {#each view.surfaces as surface (`${surface.surfaceId}#${generation}`)}
+    <div class={classes.surface}>
+      {#if surface.root}
+        {@render renderNode(surface.root, surface.context)}
+      {:else if !streamingProp}
+        <span class={classes.errorChip}>{errorTitle}</span>
+      {/if}
+    </div>
+  {/each}
+</div>

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

@@ -0,0 +1,4 @@
+import type { A2UIViewProps } from './index.js';
+declare const A2UIView: import("svelte").Component<A2UIViewProps, {}, "">;
+type A2UIView = ReturnType<typeof A2UIView>;
+export default A2UIView;

package/dist/components/Chat/A2UIView/a2ui-data.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Data-model primitives for the A2UI engine: RFC 6901 JSON Pointer get/set/delete
+ * and the `resolveDynamic` union resolver. Pure TS, no Svelte.
+ *
+ * Security posture (this file is on the untrusted-payload path):
+ * - `__proto__` / `constructor` / `prototype` are rejected at **every** pointer
+ *   segment — prototype pollution never reaches the model.
+ * - Writes never merge or spread payload objects; they navigate and assign a
+ *   single leaf, creating intermediate containers explicitly.
+ * - Array index deletion leaves a hole (length preserved), matching the spec's
+ *   sparse-array semantics.
+ *
+ * A2UI convention (deviation from strict RFC 6901): the pointers `''` **and**
+ * `'/'` both address the whole model. Strict RFC treats `'/'` as the key `""`;
+ * A2UI's `updateDataModel` uses `'/'` to mean "the entire data model", and no
+ * A2UI payload ever addresses an empty-string key, so we honor the spec's own
+ * convention here for ergonomics.
+ */
+import { type A2uiValidationIssue } from './a2ui.types.js';
+/** Property names that must never be used as an object key on the write path. */
+export declare const PROTO_KEYS: ReadonlySet<string>;
+/**
+ * Read the value at `pointer`. `''` / `'/'` return the whole model. Missing
+ * paths, holes and type-mismatches resolve to `undefined` (never throw) — the
+ * spec renders an empty string / skeleton for unresolved bindings.
+ */
+export declare function getAtPointer(model: unknown, pointer: string): unknown;
+/**
+ * Write `value` at `pointer`, creating intermediate objects/arrays as needed.
+ * The document root cannot be replaced through this function (the processor
+ * assigns `dataModel` directly for whole-model updates); a root pointer returns
+ * `ok: false`. Prototype-pollution segments are rejected with an issue.
+ */
+export declare function setAtPointer(model: unknown, pointer: string, value: unknown): {
+    ok: boolean;
+    issue?: A2uiValidationIssue;
+};
+/**
+ * Delete the leaf at `pointer`. Object keys are removed; array indices are
+ * `delete`d in place (leaving a hole, preserving length). No-ops for missing
+ * paths, non-container parents, and root pointers (the processor clears
+ * `dataModel` directly for whole-model deletes).
+ */
+export declare function deleteAtPointer(model: unknown, pointer: string): void;
+/**
+ * Resolve a Dynamic value union to a concrete value.
+ * - `{ path }` (data binding) → the pointed-at model value (relative paths are
+ *   resolved against `scopePrefix`, the current template item).
+ * - `{ call, ... }` (function call) → `undefined` + a warning (unsupported in v1).
+ * - anything else (string/number/boolean/array/plain object) → returned as-is.
+ *
+ * Never throws; unresolved bindings yield `undefined` for graceful rendering.
+ */
+export declare function resolveDynamic(value: unknown, model: unknown, scopePrefix: string | undefined): {
+    value: unknown;
+    issue?: A2uiValidationIssue;
+};
+/**
+ * Deep-clone JSON data for ingest into the model, stripping any own
+ * `__proto__`/`constructor`/`prototype` keys (harmless as own props, but never
+ * addressable, so we drop them). Functions/symbols are dropped. Used by the
+ * processor so that later two-way edits never mutate the source payload and no
+ * prototype key ever enters the model.
+ */
+export declare function cloneData(value: unknown): unknown;

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

@@ -0,0 +1,283 @@
+/**
+ * Data-model primitives for the A2UI engine: RFC 6901 JSON Pointer get/set/delete
+ * and the `resolveDynamic` union resolver. Pure TS, no Svelte.
+ *
+ * Security posture (this file is on the untrusted-payload path):
+ * - `__proto__` / `constructor` / `prototype` are rejected at **every** pointer
+ *   segment — prototype pollution never reaches the model.
+ * - Writes never merge or spread payload objects; they navigate and assign a
+ *   single leaf, creating intermediate containers explicitly.
+ * - Array index deletion leaves a hole (length preserved), matching the spec's
+ *   sparse-array semantics.
+ *
+ * A2UI convention (deviation from strict RFC 6901): the pointers `''` **and**
+ * `'/'` both address the whole model. Strict RFC treats `'/'` as the key `""`;
+ * A2UI's `updateDataModel` uses `'/'` to mean "the entire data model", and no
+ * A2UI payload ever addresses an empty-string key, so we honor the spec's own
+ * convention here for ergonomics.
+ */
+import { A2UI_ISSUE_CODES } from './a2ui.types.js';
+/** Property names that must never be used as an object key on the write path. */
+export const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+/** RFC 6901 token unescape: `~1`→`/` then `~0`→`~` (order is significant). */
+function unescapeToken(token) {
+    return token.replaceAll('~1', '/').replaceAll('~0', '~');
+}
+/** Non-negative array index per RFC 6901 (`0` or `[1-9][0-9]*`); else `null`. */
+function toIndex(segment) {
+    return /^(?:0|[1-9]\d*)$/.test(segment) ? Number(segment) : null;
+}
+/**
+ * Parse a pointer into decoded segments, guarding every segment against
+ * prototype-pollution keys. Absolute pointers start with `/`; anything else is
+ * treated as relative (segments split on `/`). `''` yields zero segments.
+ */
+function parsePointer(pointer) {
+    if (typeof pointer !== 'string') {
+        return {
+            segments: [],
+            issue: {
+                severity: 'error',
+                code: A2UI_ISSUE_CODES.POINTER_ERROR,
+                message: 'Pointer must be a string'
+            }
+        };
+    }
+    let rawTokens;
+    if (pointer === '')
+        rawTokens = [];
+    else if (pointer.startsWith('/'))
+        rawTokens = pointer.slice(1).split('/');
+    else
+        rawTokens = pointer.split('/');
+    const segments = [];
+    for (const token of rawTokens) {
+        const segment = unescapeToken(token);
+        if (PROTO_KEYS.has(segment)) {
+            return {
+                segments: [],
+                issue: {
+                    severity: 'error',
+                    code: A2UI_ISSUE_CODES.PROTOTYPE_POLLUTION,
+                    path: pointer,
+                    message: `Prohibited property name "${segment}" in pointer "${pointer}"`
+                }
+            };
+        }
+        segments.push(segment);
+    }
+    return { segments };
+}
+function isContainer(value) {
+    return value !== null && typeof value === 'object';
+}
+/**
+ * Read the value at `pointer`. `''` / `'/'` return the whole model. Missing
+ * paths, holes and type-mismatches resolve to `undefined` (never throw) — the
+ * spec renders an empty string / skeleton for unresolved bindings.
+ */
+export function getAtPointer(model, pointer) {
+    if (pointer === '' || pointer === '/')
+        return model;
+    const { segments, issue } = parsePointer(pointer);
+    if (issue)
+        return undefined;
+    let node = model;
+    for (const segment of segments) {
+        if (node == null)
+            return undefined;
+        if (Array.isArray(node)) {
+            const index = toIndex(segment);
+            node = index === null ? undefined : node[index];
+        }
+        else if (typeof node === 'object') {
+            node = node[segment];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return node;
+}
+/**
+ * Write `value` at `pointer`, creating intermediate objects/arrays as needed.
+ * The document root cannot be replaced through this function (the processor
+ * assigns `dataModel` directly for whole-model updates); a root pointer returns
+ * `ok: false`. Prototype-pollution segments are rejected with an issue.
+ */
+export function setAtPointer(model, pointer, value) {
+    if (pointer === '' || pointer === '/') {
+        return {
+            ok: false,
+            issue: {
+                severity: 'error',
+                code: A2UI_ISSUE_CODES.POINTER_ERROR,
+                path: pointer,
+                message: 'Cannot replace the document root through setAtPointer'
+            }
+        };
+    }
+    const { segments, issue } = parsePointer(pointer);
+    if (issue)
+        return { ok: false, issue };
+    if (segments.length === 0) {
+        return {
+            ok: false,
+            issue: {
+                severity: 'error',
+                code: A2UI_ISSUE_CODES.POINTER_ERROR,
+                path: pointer,
+                message: 'Cannot replace the document root through setAtPointer'
+            }
+        };
+    }
+    if (!isContainer(model)) {
+        return {
+            ok: false,
+            issue: {
+                severity: 'error',
+                code: A2UI_ISSUE_CODES.POINTER_ERROR,
+                path: pointer,
+                message: 'Cannot write into a non-object data model'
+            }
+        };
+    }
+    let node = model;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        const nextIsIndex = toIndex(segments[i + 1]) !== null || segments[i + 1] === '-';
+        if (Array.isArray(node)) {
+            const index = toIndex(segment);
+            if (index === null) {
+                return { ok: false, issue: pointerTypeIssue(pointer, segment) };
+            }
+            if (!isContainer(node[index]))
+                node[index] = nextIsIndex ? [] : {};
+            node = node[index];
+        }
+        else {
+            if (!isContainer(node[segment]))
+                node[segment] = nextIsIndex ? [] : {};
+            node = node[segment];
+        }
+    }
+    const last = segments[segments.length - 1];
+    if (Array.isArray(node)) {
+        const index = last === '-' ? node.length : toIndex(last);
+        if (index === null)
+            return { ok: false, issue: pointerTypeIssue(pointer, last) };
+        node[index] = value;
+    }
+    else {
+        node[last] = value;
+    }
+    return { ok: true };
+}
+function pointerTypeIssue(pointer, segment) {
+    return {
+        severity: 'error',
+        code: A2UI_ISSUE_CODES.POINTER_ERROR,
+        path: pointer,
+        message: `Segment "${segment}" is not a valid array index in pointer "${pointer}"`
+    };
+}
+/**
+ * Delete the leaf at `pointer`. Object keys are removed; array indices are
+ * `delete`d in place (leaving a hole, preserving length). No-ops for missing
+ * paths, non-container parents, and root pointers (the processor clears
+ * `dataModel` directly for whole-model deletes).
+ */
+export function deleteAtPointer(model, pointer) {
+    if (pointer === '' || pointer === '/')
+        return;
+    const { segments, issue } = parsePointer(pointer);
+    if (issue || segments.length === 0)
+        return;
+    let node = model;
+    for (let i = 0; i < segments.length - 1; i++) {
+        if (!isContainer(node))
+            return;
+        if (Array.isArray(node)) {
+            const index = toIndex(segments[i]);
+            node = index === null ? undefined : node[index];
+        }
+        else {
+            node = node[segments[i]];
+        }
+    }
+    if (!isContainer(node))
+        return;
+    const last = segments[segments.length - 1];
+    if (Array.isArray(node)) {
+        const index = toIndex(last);
+        if (index !== null)
+            delete node[index];
+    }
+    else {
+        delete node[last];
+    }
+}
+/**
+ * Resolve a Dynamic value union to a concrete value.
+ * - `{ path }` (data binding) → the pointed-at model value (relative paths are
+ *   resolved against `scopePrefix`, the current template item).
+ * - `{ call, ... }` (function call) → `undefined` + a warning (unsupported in v1).
+ * - anything else (string/number/boolean/array/plain object) → returned as-is.
+ *
+ * Never throws; unresolved bindings yield `undefined` for graceful rendering.
+ */
+export function resolveDynamic(value, model, scopePrefix) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        const object = value;
+        if (typeof object.call === 'string') {
+            return {
+                value: undefined,
+                issue: {
+                    severity: 'warning',
+                    code: A2UI_ISSUE_CODES.FUNCTION_CALL_UNSUPPORTED,
+                    message: `Function call "${object.call}" is not supported; resolved to undefined`
+                }
+            };
+        }
+        if (typeof object.path === 'string') {
+            const relative = object.path;
+            const full = relative.startsWith('/') ? relative : `${scopePrefix ?? ''}/${relative}`;
+            const { issue } = parsePointer(full);
+            if (issue)
+                return { value: undefined, issue };
+            return { value: getAtPointer(model, full) };
+        }
+        // A literal object argument (rare, e.g. a raw config object) — pass through.
+        return { value };
+    }
+    return { value };
+}
+/**
+ * Deep-clone JSON data for ingest into the model, stripping any own
+ * `__proto__`/`constructor`/`prototype` keys (harmless as own props, but never
+ * addressable, so we drop them). Functions/symbols are dropped. Used by the
+ * processor so that later two-way edits never mutate the source payload and no
+ * prototype key ever enters the model.
+ */
+export function cloneData(value) {
+    if (Array.isArray(value)) {
+        const out = [];
+        for (let i = 0; i < value.length; i++) {
+            if (i in value)
+                out[i] = cloneData(value[i]);
+        }
+        return out;
+    }
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const key of Object.keys(value)) {
+            if (PROTO_KEYS.has(key))
+                continue;
+            out[key] = cloneData(value[key]);
+        }
+        return out;
+    }
+    if (typeof value === 'function' || typeof value === 'symbol')
+        return undefined;
+    return value;
+}

package/dist/components/Chat/A2UIView/a2ui-prompt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * System-prompt generator for the A2UI subset. Renders the agent-facing catalog
+ * description straight from `A2UI_REGISTRY`, so the prompt and the validator can
+ * never drift (a drift-guard test asserts every component and enum value is
+ * covered). Pure TS, no Svelte — a server building the prompt has no DOM.
+ *
+ * Deliberately excludes any TRANSPORT section (how envelopes reach the client):
+ * that is app-specific and each app appends it (the chat-demo appends its fenced
+ * `a2ui` JSONL protocol).
+ */
+/**
+ * Build the A2UI system prompt for this subset. Pass `catalogId` to override the
+ * default `createSurface` catalog identifier (the value must round-trip
+ * unchanged in every envelope).
+ */
+export declare function a2uiSystemPrompt(options?: {
+    catalogId?: string;
+}): string;