@antglobal/copilot-cards-core 1.0.2 → 1.0.3

package/dist/index.js

@@ -385,8 +385,14 @@ async function parseResponseBody(response) {
  *
  * @param silent - If true, only write to ctx.variables without calling
  *   setVariable (avoids triggering re-render during polling iterations).
+ *   When variableWriter is present it owns the write and must synchronously
+ *   update the bound variables draft while honoring this flag.
  */
 function writeResponseVariable(ctx, responseKey, data, silent = false) {
+    if (ctx.variableWriter) {
+        ctx.variableWriter(responseKey, data, { silent, source: 'request' });
+        return;
+    }
     if (ctx.variables) {
         ctx.variables[responseKey] = data;
     }
@@ -569,6 +575,10 @@ const handleUrl = (step, ctx) => {
 };
 const handleSetVariable = (step, ctx) => {
     const { key, value } = step.params;
+    if (ctx.variableWriter) {
+        ctx.variableWriter(key, value, { silent: false, source: 'setVariable' });
+        return;
+    }
     if (ctx.setVariable) {
         ctx.setVariable(key, value);
     }
@@ -628,9 +638,15 @@ async function runActionStep(step, context = {}) {
         return;
     }
     // Resolve expression variables in params (e.g. '${order_id}' → 'ORDER_666')
-    const resolvedStep = context.variables
-        ? { ...step, params: resolveDeep(step.params, context.variables) }
-        : step;
+    const resolutionContext = context.expressionContext ?? context.variables;
+    const resolvedParams = context.parameterResolver
+        ? context.parameterResolver(step.params)
+        : resolutionContext
+            ? resolveDeep(step.params, resolutionContext)
+            : step.params;
+    const resolvedStep = resolvedParams === step.params
+        ? step
+        : { ...step, params: resolvedParams };
     await handler(resolvedStep, context);
 }
 /**
@@ -1098,6 +1114,578 @@ function staticValue(value) {
     return { type: 'static', value };
 }
 
+const UNSAFE_POINTER_SEGMENTS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+]);
+const ARRAY_INDEX_PATTERN = /^(0|[1-9]\d*)$/;
+const MAX_ARRAY_INDEX = 4294967294;
+/** A rejected pointer spelling or array location, rather than a data failure. */
+class JsonPointerPathError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'JsonPointerPathError';
+        this.code = code;
+    }
+}
+function isRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isContainer(value) {
+    return Array.isArray(value) || isRecord(value);
+}
+function isReadableContainer(value) {
+    return value !== null && typeof value === 'object';
+}
+function assertSafeSegment(segment) {
+    if (UNSAFE_POINTER_SEGMENTS.has(segment)) {
+        throw new JsonPointerPathError('UNSAFE_SEGMENT', `Unsafe JSON Pointer segment "${segment}"`);
+    }
+}
+function arrayIndex(segment) {
+    if (!ARRAY_INDEX_PATTERN.test(segment))
+        return undefined;
+    const index = Number(segment);
+    return index <= MAX_ARRAY_INDEX ? index : undefined;
+}
+function assertContainerSegment(container, segment) {
+    if (Array.isArray(container) && arrayIndex(segment) === undefined) {
+        throw new JsonPointerPathError('INVALID_ARRAY_INDEX', `Invalid array index "${segment}" in JSON Pointer`);
+    }
+}
+function assertWritableContainerSegment(container, segment) {
+    assertContainerSegment(container, segment);
+    if (!Array.isArray(container))
+        return;
+    const index = arrayIndex(segment);
+    if (index !== undefined && index > container.length) {
+        throw new JsonPointerPathError('INVALID_ARRAY_INDEX', `Array index "${segment}" exceeds length ${container.length} in JSON Pointer`);
+    }
+}
+function readOwnDataProperty(container, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(container, key);
+    if (!descriptor)
+        return { found: false };
+    if (!('value' in descriptor)) {
+        throw new TypeError(`Cannot traverse JSON Pointer accessor member "${key}"`);
+    }
+    return { found: true, value: descriptor.value };
+}
+function defineDataProperty(target, key, value, recordMutation) {
+    assertWritableContainerSegment(target, key);
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor) {
+        if ('value' in descriptor && descriptor.writable) {
+            recordMutation?.(target, key);
+            Object.defineProperty(target, key, { value });
+            return;
+        }
+        if (!descriptor.configurable) {
+            throw new Error(`Cannot write JSON Pointer member "${key}"`);
+        }
+    }
+    else if (!Object.isExtensible(target)) {
+        throw new Error(`Cannot create JSON Pointer member "${key}"`);
+    }
+    recordMutation?.(target, key);
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+function createDetachedBranch(segments, value) {
+    let branch = value;
+    for (let index = segments.length - 1; index >= 0; index -= 1) {
+        const segment = segments[index];
+        const child = arrayIndex(segment) === undefined ? {} : [];
+        defineDataProperty(child, segment, branch);
+        branch = child;
+    }
+    return branch;
+}
+/**
+ * Decode one RFC 6901 JSON Pointer reference token.
+ *
+ * Only `~0` and `~1` are legal escapes. URI/percent decoding is deliberately
+ * outside this helper's contract.
+ */
+function decodeJsonPointerSegment(segment) {
+    let decoded = '';
+    for (let index = 0; index < segment.length; index += 1) {
+        const character = segment[index];
+        if (character !== '~') {
+            decoded += character;
+            continue;
+        }
+        const escape = segment[index + 1];
+        if (escape === '0') {
+            decoded += '~';
+        }
+        else if (escape === '1') {
+            decoded += '/';
+        }
+        else {
+            throw new JsonPointerPathError('SYNTAX', `Invalid JSON Pointer escape "~${escape ?? ''}"`);
+        }
+        index += 1;
+    }
+    return decoded;
+}
+/**
+ * Parse a strict RFC 6901 JSON Pointer.
+ *
+ * The canonical root is `''`; `/` names an empty-string property.
+ */
+function parseJsonPointer(pointer) {
+    if (pointer === '')
+        return [];
+    if (typeof pointer !== 'string' || !pointer.startsWith('/')) {
+        throw new JsonPointerPathError('SYNTAX', 'JSON Pointer must be empty or start with "/"');
+    }
+    return pointer.slice(1).split('/').map((encoded) => {
+        const segment = decodeJsonPointerSegment(encoded);
+        assertSafeSegment(segment);
+        return segment;
+    });
+}
+/** Read an own-property value through a strict JSON Pointer. */
+function getByJsonPointer(root, pointer) {
+    const segments = parseJsonPointer(pointer);
+    let current = root;
+    for (const segment of segments) {
+        if (!isReadableContainer(current))
+            return undefined;
+        assertContainerSegment(current, segment);
+        const property = readOwnDataProperty(current, segment);
+        if (!property.found)
+            return undefined;
+        current = property.value;
+    }
+    return current;
+}
+function cloneJsonDataInternal(value, ancestors) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new TypeError('JSON data numbers must be finite');
+        }
+        return value;
+    }
+    if (typeof value !== 'object') {
+        throw new TypeError(`Unsupported JSON data value: ${typeof value}`);
+    }
+    if (ancestors.has(value)) {
+        throw new TypeError('Cannot clone cyclic JSON data');
+    }
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const ownKeys = Reflect.ownKeys(value);
+            if (ownKeys.some(key => typeof key === 'symbol')) {
+                throw new TypeError('JSON data arrays cannot contain symbol keys');
+            }
+            const keys = ownKeys.filter(key => key !== 'length');
+            if (keys.length !== value.length ||
+                keys.some((key) => {
+                    const index = arrayIndex(key);
+                    return index === undefined || index >= value.length;
+                })) {
+                throw new TypeError('JSON data arrays must be dense and contain only indexed values');
+            }
+            const result = [];
+            for (let index = 0; index < value.length; index += 1) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                if (!descriptor || !descriptor.enumerable) {
+                    throw new TypeError('JSON data arrays must be dense and contain only indexed values');
+                }
+                if (!('value' in descriptor)) {
+                    throw new TypeError('JSON data arrays cannot contain accessors');
+                }
+                result.push(cloneJsonDataInternal(descriptor.value, ancestors));
+            }
+            return result;
+        }
+        if (!isRecord(value)) {
+            throw new TypeError('JSON data objects must be plain records');
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            throw new TypeError('JSON data objects cannot contain symbol keys');
+        }
+        const result = {};
+        for (const key of Object.keys(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || !('value' in descriptor)) {
+                throw new TypeError('JSON data objects cannot contain accessors');
+            }
+            Object.defineProperty(result, key, {
+                value: cloneJsonDataInternal(descriptor.value, ancestors),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return result;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+/** Deep-clone a value from the JSON data-model domain. */
+function cloneJsonData(value) {
+    return cloneJsonDataInternal(value, new Set());
+}
+/**
+ * Replace a root record's safe own contents while preserving its identity.
+ *
+ * For ordinary non-Proxy JSON records, validation and cloning finish before
+ * the first mutation, so a rejected candidate leaves the target untouched.
+ * JavaScript Proxy traps cannot be identified reliably and are outside this
+ * atomicity guarantee.
+ */
+function replaceRootContentsInternal(root, next, recordMutation) {
+    if (!isRecord(root) || !isRecord(next)) {
+        throw new TypeError('JSON Pointer root replacement requires a record');
+    }
+    const nextKeys = Object.keys(next);
+    for (const key of nextKeys) {
+        if (UNSAFE_POINTER_SEGMENTS.has(key)) {
+            throw new Error(`Unsafe root key "${key}"`);
+        }
+    }
+    const cloned = cloneJsonData(next);
+    const currentSafeKeys = Object.keys(root).filter(key => !UNSAFE_POINTER_SEGMENTS.has(key));
+    for (const key of currentSafeKeys) {
+        if (!Object.prototype.hasOwnProperty.call(cloned, key)) {
+            const descriptor = Object.getOwnPropertyDescriptor(root, key);
+            if (!descriptor?.configurable) {
+                throw new Error(`Cannot remove non-configurable root key "${key}"`);
+            }
+        }
+    }
+    for (const key of nextKeys) {
+        const descriptor = Object.getOwnPropertyDescriptor(root, key);
+        if (!descriptor && !Object.isExtensible(root)) {
+            throw new Error(`Cannot create root key "${key}"`);
+        }
+        if (descriptor &&
+            !descriptor.configurable &&
+            (!('value' in descriptor) || !descriptor.writable)) {
+            throw new Error(`Cannot replace non-writable root key "${key}"`);
+        }
+    }
+    for (const key of currentSafeKeys) {
+        if (!Object.prototype.hasOwnProperty.call(cloned, key)) {
+            recordMutation?.(root, key);
+            delete root[key];
+        }
+    }
+    for (const key of nextKeys) {
+        const descriptor = Object.getOwnPropertyDescriptor(root, key);
+        recordMutation?.(root, key);
+        if (descriptor && !descriptor.configurable) {
+            Object.defineProperty(root, key, { value: cloned[key] });
+        }
+        else {
+            Object.defineProperty(root, key, {
+                value: cloned[key],
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+}
+function replaceRootContents(root, next) {
+    replaceRootContentsInternal(root, next);
+}
+/**
+ * Transactionally write JSON data through a strict JSON Pointer when the
+ * target is an ordinary non-Proxy JSON record. JavaScript Proxy traps are
+ * outside the atomicity guarantee because they cannot be identified reliably.
+ *
+ * The root pointer `''` replaces the root record. Non-root values are cloned
+ * before they become reachable from the target.
+ */
+function setByJsonPointerInternal(root, pointer, value, recordMutation) {
+    if (!isRecord(root)) {
+        throw new TypeError('JSON Pointer writes require a record root');
+    }
+    const segments = parseJsonPointer(pointer);
+    if (segments.length === 0) {
+        if (!isRecord(value)) {
+            throw new TypeError('JSON Pointer root replacement requires a record value');
+        }
+        replaceRootContentsInternal(root, value, recordMutation);
+        return;
+    }
+    const clonedValue = cloneJsonData(value);
+    let current = root;
+    for (let index = 0; index < segments.length - 1; index += 1) {
+        const segment = segments[index];
+        assertWritableContainerSegment(current, segment);
+        const property = readOwnDataProperty(current, segment);
+        if (!property.found) {
+            const branch = createDetachedBranch(segments.slice(index + 1), clonedValue);
+            defineDataProperty(current, segment, branch, recordMutation);
+            return;
+        }
+        const next = property.value;
+        if (next === null || next === undefined) {
+            const branch = createDetachedBranch(segments.slice(index + 1), clonedValue);
+            defineDataProperty(current, segment, branch, recordMutation);
+            return;
+        }
+        if (!isContainer(next)) {
+            throw new Error(`Cannot traverse JSON Pointer member "${segment}"`);
+        }
+        current = next;
+    }
+    defineDataProperty(current, segments[segments.length - 1], clonedValue, recordMutation);
+}
+function setByJsonPointer(root, pointer, value) {
+    setByJsonPointerInternal(root, pointer, value);
+}
+/**
+ * Engine-internal variant that records only properties the strict writer is
+ * about to mutate. It is intentionally not re-exported from the Core package.
+ */
+function setByJsonPointerWithMutationRecorder(root, pointer, value, recordMutation) {
+    setByJsonPointerInternal(root, pointer, value, recordMutation);
+}
+
+function isPlainObject$1(value) {
+    try {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return false;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function getExactOwnDataValues(value, expected) {
+    try {
+        const keys = Reflect.ownKeys(value);
+        if (keys.length !== expected.length
+            || !expected.every(key => Object.prototype.hasOwnProperty.call(value, key))) {
+            return undefined;
+        }
+        const values = [];
+        for (const key of expected) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+                return undefined;
+            }
+            values.push(descriptor.value);
+        }
+        return values;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readDynamicChildList(value) {
+    if (!isPlainObject$1(value))
+        return undefined;
+    const fields = getExactOwnDataValues(value, ['path', 'componentId']);
+    if (!fields
+        || typeof fields[0] !== 'string'
+        || typeof fields[1] !== 'string') {
+        return undefined;
+    }
+    return { path: fields[0], componentId: fields[1] };
+}
+/** Runtime guard for the exact dynamic ChildList common-type shape. */
+function isA2UIDynamicChildList(value) {
+    return readDynamicChildList(value) !== undefined;
+}
+/** Runtime guard for either supported ChildList form. */
+function isA2UIChildList(value) {
+    try {
+        if (Array.isArray(value)) {
+            const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+            const length = lengthDescriptor?.value;
+            if (!Number.isSafeInteger(length) || length < 0)
+                return false;
+            for (let index = 0; index < length; index += 1) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                if (!descriptor
+                    || !Object.prototype.hasOwnProperty.call(descriptor, 'value')
+                    || typeof descriptor.value !== 'string') {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return isA2UIDynamicChildList(value);
+}
+/** Runtime guard for the exact A2UI DataBinding.path common-type shape. */
+function isA2UIPathBinding(value) {
+    return readPathBinding(value) !== undefined;
+}
+function readPathBinding(value) {
+    if (!isPlainObject$1(value))
+        return undefined;
+    const fields = getExactOwnDataValues(value, ['path']);
+    if (!fields || typeof fields[0] !== 'string')
+        return undefined;
+    return { path: fields[0] };
+}
+/**
+ * Resolve one A2UI path from the data-model root or the current item scope.
+ *
+ * Absolute paths use strict JSON Pointer syntax. Relative paths are an A2UI
+ * extension and are appended to the current strict-pointer scope.
+ */
+function resolveA2UIPath(root, path, scopePath) {
+    if (typeof path !== 'string' || typeof scopePath !== 'string') {
+        throw new TypeError('[A2UI] path and scopePath must be strings');
+    }
+    const pointer = path.startsWith('/')
+        ? path
+        : path === ''
+            ? scopePath
+            : `${scopePath}/${path}`;
+    return getByJsonPointer(root, pointer);
+}
+/**
+ * Resolve every exact A2UI `{ path }` binding in a nested value.
+ *
+ * Plain records and arrays are cloned with their property descriptors, so
+ * accessors are preserved but never invoked. Cycles in non-JSON direct API
+ * inputs remain cycles in the cloned output.
+ */
+function resolveA2UIDeep(value, root, scopePath) {
+    return resolveA2UIDeepInternal(value, root, scopePath, new WeakMap());
+}
+function resolveA2UIDeepInternal(value, root, scopePath, seen) {
+    const binding = readPathBinding(value);
+    if (binding) {
+        return resolveA2UIPath(root, binding.path, scopePath);
+    }
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const existing = seen.get(value);
+    if (existing)
+        return existing;
+    let isArray;
+    let prototype;
+    let descriptors;
+    try {
+        isArray = Array.isArray(value);
+        prototype = Object.getPrototypeOf(value);
+        if (!isArray
+            && prototype !== Object.prototype
+            && prototype !== null) {
+            return value;
+        }
+        descriptors = [];
+        for (const key of Reflect.ownKeys(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor)
+                return value;
+            descriptors.push([key, descriptor]);
+        }
+    }
+    catch {
+        return value;
+    }
+    const output = isArray
+        ? []
+        : Object.create(prototype);
+    seen.set(value, output);
+    let arrayLength;
+    for (const [key, descriptor] of descriptors) {
+        if (isArray && key === 'length') {
+            arrayLength = descriptor;
+            continue;
+        }
+        const nextDescriptor = Object.prototype.hasOwnProperty.call(descriptor, 'value')
+            ? {
+                ...descriptor,
+                value: resolveA2UIDeepInternal(descriptor.value, root, scopePath, seen),
+            }
+            : descriptor;
+        Object.defineProperty(output, key, nextDescriptor);
+    }
+    if (isArray && arrayLength) {
+        Object.defineProperty(output, 'length', {
+            value: arrayLength.value,
+            writable: arrayLength.writable,
+        });
+    }
+    return output;
+}
+/** Create an ActionRunner-compatible resolver bound to one item scope. */
+function createA2UIParameterResolver(root, scopePath) {
+    return params => resolveA2UIDeep(params, root, scopePath);
+}
+const A2UI_CHILD_BINDING = Symbol('copilot-cards.a2ui-child-binding');
+/** Attach normalized dynamic-child metadata without widening native JSON. */
+function setA2UIChildBinding(slot, value) {
+    const binding = readDynamicChildList(value);
+    if (!binding) {
+        throw new TypeError('[A2UI] Invalid dynamic ChildList binding');
+    }
+    slot[A2UI_CHILD_BINDING] = {
+        dialect: 'a2ui',
+        path: binding.path,
+        templateId: binding.componentId,
+    };
+}
+/** Read adapter-owned dynamic-child metadata from a slot. */
+function getA2UIChildBinding(slot) {
+    if (!((typeof slot === 'object' && slot !== null)
+        || typeof slot === 'function')) {
+        return undefined;
+    }
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(slot, A2UI_CHILD_BINDING);
+        if (!descriptor
+            || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            return undefined;
+        }
+        return descriptor.value;
+    }
+    catch {
+        return undefined;
+    }
+}
+const A2UI_BINDING_DIALECT = Symbol('copilot-cards.a2ui-binding-dialect');
+/** Mark an adapter-created element as using A2UI path semantics. */
+function markA2UIBindingDialect(element) {
+    element[A2UI_BINDING_DIALECT] = true;
+}
+/** Whether this exact element owns the private adapter dialect marker. */
+function hasA2UIBindingDialect(element) {
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(element, A2UI_BINDING_DIALECT);
+        return !!descriptor
+            && Object.prototype.hasOwnProperty.call(descriptor, 'value')
+            && descriptor.value === true;
+    }
+    catch {
+        return false;
+    }
+}
+
 /**
  * Schema Parser — resolves a CardSchema into a renderable tree.
  *
@@ -1117,6 +1705,85 @@ function normalizeSchema(input) {
     }
     return input;
 }
+/** Whether a schema contains native repeat or adapter-owned dynamic children. */
+function hasDynamicChildren(input) {
+    const schema = normalizeSchema(input);
+    return Object.values(schema.elements).some(element => elementSlotEntries(element).entries.some(([, slot]) => hasOwn(slot, 'repeat') || getA2UIChildBinding(slot) !== undefined));
+}
+/**
+ * Whether a renderer must use the scoped binding/materialization path.
+ *
+ * Literal native/static schemas deliberately remain on the legacy parser path.
+ * The private A2UI marker cannot be forged by JSON input.
+ */
+function requiresBindingMaterialization(input) {
+    const schema = normalizeSchema(input);
+    return hasDynamicChildren(schema)
+        || Object.values(schema.elements).some(hasA2UIBindingDialect);
+}
+/**
+ * Stable fingerprint of the definition graph that controls binding topology.
+ * Runtime data and materialized occurrence counts are intentionally excluded.
+ */
+function bindingTopologyFingerprint(input) {
+    const schema = normalizeSchema(input);
+    const topology = Object.keys(schema.elements)
+        .sort()
+        .map(id => {
+        const element = schema.elements[id];
+        const slotEntries = elementSlotEntries(element);
+        const slots = slotEntries.entries
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([slotName, slot]) => {
+            const a2ui = getA2UIChildBinding(slot);
+            const config = readOwnData(slot, 'config');
+            const overlays = config.kind === 'value'
+                ? readOwnData(config.value, 'overlays')
+                : config;
+            const repeat = readOwnData(slot, 'repeat');
+            const repeatFields = repeat.kind === 'value'
+                && isPlainObject(repeat.value)
+                ? {
+                    source: topologyValue(readOwnData(repeat.value, 'source')),
+                    template: topologyValue(readOwnData(repeat.value, 'template')),
+                    item: topologyValue(readOwnData(repeat.value, 'item')),
+                    index: topologyValue(readOwnData(repeat.value, 'index')),
+                }
+                : topologyValue(repeat);
+            return {
+                name: slotName,
+                children: topologyValue(readOwnData(slot, 'children')),
+                groups: topologyValue(readOwnData(slot, 'groups')),
+                overlays: topologyValue(overlays),
+                repeat: hasOwn(slot, 'repeat')
+                    ? repeatFields
+                    : null,
+                a2ui: a2ui
+                    ? {
+                        path: a2ui.path,
+                        templateId: a2ui.templateId,
+                    }
+                    : null,
+            };
+        });
+        for (const slotName of slotEntries.accessors.sort()) {
+            slots.push({ name: slotName, opaque: '<accessor>' });
+        }
+        if (slotEntries.opaque) {
+            slots.push({ name: '<opaque-slots>', opaque: '<opaque>' });
+        }
+        return {
+            id,
+            type: element.type,
+            a2ui: hasA2UIBindingDialect(element),
+            slots,
+        };
+    });
+    return JSON.stringify({
+        rootID: schema.rootID,
+        topology,
+    });
+}
 // ─── Parser ──────────────────────────────────────────────────────
 /**
  * Parse a CardSchema into a nested RenderTreeNode starting from `rootID`.
@@ -1153,74 +1820,1230 @@ function parseSchema(input) {
                         }
                     }
                 }
-                if (slot.config?.overlays) {
-                    for (const overlay of slot.config.overlays) {
-                        if (overlay.children) {
-                            for (const childId of overlay.children) {
-                                children.push(buildNode(childId));
-                            }
-                        }
-                    }
+                if (slot.config?.overlays) {
+                    for (const overlay of slot.config.overlays) {
+                        if (overlay.children) {
+                            for (const childId of overlay.children) {
+                                children.push(buildNode(childId));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        visited.delete(id); // allow same element across different branches
+        return {
+            id,
+            type: element.type,
+            props: element.props,
+            children,
+            lifecycle: element.lifecycle,
+            events: element.events,
+            directives: element.directives,
+        };
+    }
+    return buildNode(rootID);
+}
+// ─── Validation ──────────────────────────────────────────────────
+/**
+ * Validate a CardSchema and return any error messages.
+ */
+function validateSchema(input) {
+    const schema = normalizeSchema(input);
+    const errors = [];
+    if (!schema.version) {
+        errors.push('Missing "version" field');
+    }
+    if (typeof schema.rootID !== 'string') {
+        errors.push('"rootID" field must be a string');
+    }
+    else if (!schema.rootID) {
+        errors.push('Missing "rootID" field');
+    }
+    else if (!schema.elements[schema.rootID]) {
+        errors.push(`Root element "${schema.rootID}" not found in elements`);
+    }
+    const allIds = new Set(Object.keys(schema.elements));
+    for (const [id, element] of Object.entries(schema.elements)) {
+        if (!element.type) {
+            errors.push(`Element "${id}" is missing a "type" field`);
+        }
+        // Validate slot children and groups references without invoking accessors.
+        const slots = elementSlotEntries(element);
+        for (const slotName of slots.accessors) {
+            errors.push(`Element "${id}" slot "${slotName}" must be an own data property`);
+        }
+        if (slots.opaque) {
+            errors.push(`Element "${id}" slots could not be inspected safely`);
+        }
+        for (const [slotName, slot] of slots.entries) {
+            if (!slot || typeof slot !== 'object') {
+                errors.push(`Element "${id}" slot "${slotName}" must be an object`);
+                continue;
+            }
+            const children = readOwnData(slot, 'children');
+            if (children.kind === 'value') {
+                const values = ownArrayDataValues(children.value);
+                if (!values) {
+                    errors.push(`Element "${id}" slot "${slotName}" children must be an array`);
+                }
+                else {
+                    for (const childId of values) {
+                        if (typeof childId !== 'string' || childId.length === 0) {
+                            errors.push(`Element "${id}" slot "${slotName}" child IDs must be non-empty strings; received "${String(childId)}"`);
+                        }
+                        else if (!allIds.has(childId)) {
+                            errors.push(`Element "${id}" slot "${slotName}" references unknown child "${String(childId)}"`);
+                        }
+                    }
+                }
+            }
+            else if (children.kind === 'accessor' || children.kind === 'opaque') {
+                errors.push(`Element "${id}" slot "${slotName}" children must be an own data property`);
+            }
+            const groups = readOwnData(slot, 'groups');
+            if (groups.kind === 'value') {
+                const groupValues = ownArrayDataValues(groups.value);
+                if (!groupValues) {
+                    errors.push(`Element "${id}" slot "${slotName}" groups must be an array`);
+                }
+                else {
+                    for (const group of groupValues) {
+                        const childrenInGroup = ownArrayDataValues(group);
+                        if (!childrenInGroup) {
+                            errors.push(`Element "${id}" slot "${slotName}" groups must contain arrays`);
+                            continue;
+                        }
+                        for (const childId of childrenInGroup) {
+                            if (typeof childId !== 'string' || childId.length === 0) {
+                                errors.push(`Element "${id}" slot "${slotName}" group child IDs must be non-empty strings; received "${String(childId)}"`);
+                            }
+                            else if (!allIds.has(childId)) {
+                                errors.push(`Element "${id}" slot "${slotName}" group references unknown child "${String(childId)}"`);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (groups.kind === 'accessor' || groups.kind === 'opaque') {
+                errors.push(`Element "${id}" slot "${slotName}" groups must be an own data property`);
+            }
+        }
+    }
+    validateRepeatBindings(schema, errors);
+    return errors;
+}
+const REPEAT_SLOT_LAYOUTS = new Set([
+    'default',
+    'list',
+    'grid',
+    'horizontalScroll',
+    'carousel',
+]);
+const ALIAS_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const RESERVED_ALIASES = new Set(['__proto__', 'constructor', 'prototype']);
+function hasOwn(value, key) {
+    try {
+        return ((typeof value === 'object' && value !== null) ||
+            typeof value === 'function') && Object.prototype.hasOwnProperty.call(value, key);
+    }
+    catch {
+        return false;
+    }
+}
+function isPlainObject(value) {
+    try {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return false;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function readOwnData(value, key) {
+    if (!((typeof value === 'object' && value !== null)
+        || typeof value === 'function')) {
+        return { kind: 'missing' };
+    }
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+            return { kind: 'missing' };
+        if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            return { kind: 'accessor' };
+        }
+        return { kind: 'value', value: descriptor.value };
+    }
+    catch {
+        return { kind: 'opaque' };
+    }
+}
+function ownStringDataEntries(value) {
+    const result = {
+        entries: [],
+        accessors: [],
+        opaque: false,
+    };
+    if (!value || typeof value !== 'object')
+        return result;
+    try {
+        for (const key of Reflect.ownKeys(value)) {
+            if (typeof key !== 'string')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor) {
+                result.opaque = true;
+            }
+            else if (Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+                result.entries.push([key, descriptor.value]);
+            }
+            else {
+                result.accessors.push(key);
+            }
+        }
+    }
+    catch {
+        result.opaque = true;
+    }
+    return result;
+}
+function ownArrayDataValues(value) {
+    try {
+        if (!Array.isArray(value))
+            return undefined;
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+        const length = lengthDescriptor?.value;
+        if (!Number.isSafeInteger(length) || length < 0)
+            return undefined;
+        const output = [];
+        for (let index = 0; index < length; index += 1) {
+            const entry = readOwnData(value, String(index));
+            if (entry.kind !== 'value')
+                return undefined;
+            output.push(entry.value);
+        }
+        return output;
+    }
+    catch {
+        return undefined;
+    }
+}
+function elementSlotEntries(element) {
+    const slots = readOwnData(element.props, 'slots');
+    return slots.kind === 'value'
+        ? ownStringDataEntries(slots.value)
+        : {
+            entries: [],
+            accessors: slots.kind === 'accessor' ? ['slots'] : [],
+            opaque: slots.kind === 'opaque',
+        };
+}
+function readRepeatBindingFields(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    const source = readOwnData(value, 'source');
+    const template = readOwnData(value, 'template');
+    const item = readOwnData(value, 'item');
+    const index = readOwnData(value, 'index');
+    return {
+        source: source.kind === 'value' ? source.value : undefined,
+        template: template.kind === 'value' ? template.value : undefined,
+        item: item.kind === 'value' ? item.value : undefined,
+        ...(index.kind === 'value' ? { index: index.value } : {}),
+    };
+}
+function slotStaticReferences(slot) {
+    const references = [];
+    const children = readOwnData(slot, 'children');
+    if (children.kind === 'value') {
+        for (const child of ownArrayDataValues(children.value) ?? []) {
+            if (typeof child === 'string')
+                references.push(child);
+        }
+    }
+    const groups = readOwnData(slot, 'groups');
+    if (groups.kind === 'value') {
+        for (const group of ownArrayDataValues(groups.value) ?? []) {
+            for (const child of ownArrayDataValues(group) ?? []) {
+                if (typeof child === 'string')
+                    references.push(child);
+            }
+        }
+    }
+    const config = readOwnData(slot, 'config');
+    const overlays = config.kind === 'value'
+        ? readOwnData(config.value, 'overlays')
+        : { kind: 'missing' };
+    if (overlays.kind === 'value') {
+        for (const overlay of ownArrayDataValues(overlays.value) ?? []) {
+            const overlayChildren = readOwnData(overlay, 'children');
+            if (overlayChildren.kind !== 'value')
+                continue;
+            for (const child of ownArrayDataValues(overlayChildren.value) ?? []) {
+                if (typeof child === 'string')
+                    references.push(child);
+            }
+        }
+    }
+    return references;
+}
+function topologyValue(read, seen = new WeakSet()) {
+    if (read.kind !== 'value') {
+        if (read.kind === 'missing')
+            return null;
+        if (read.kind === 'accessor')
+            return '<accessor>';
+        return '<opaque>';
+    }
+    const value = read.value;
+    if (!value || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        return '<cycle>';
+    seen.add(value);
+    const array = ownArrayDataValues(value);
+    if (array) {
+        return array.map(entry => topologyValue({ kind: 'value', value: entry }, seen));
+    }
+    if (!isPlainObject(value))
+        return '<opaque>';
+    const entries = ownStringDataEntries(value);
+    if (entries.opaque)
+        return '<opaque>';
+    const output = {};
+    for (const key of entries.accessors.sort())
+        output[key] = '<accessor>';
+    for (const [key, entry] of entries.entries.sort(([left], [right]) => left.localeCompare(right))) {
+        output[key] = topologyValue({ kind: 'value', value: entry }, seen);
+    }
+    return output;
+}
+function getOwnElement(schema, id) {
+    const element = readOwnData(schema.elements, id);
+    return element.kind === 'value'
+        ? element.value
+        : undefined;
+}
+function isCompleteExpression(source) {
+    if (typeof source !== 'string')
+        return false;
+    const trimmed = source.trim();
+    if (!trimmed.startsWith('${'))
+        return false;
+    if (!trimmed.slice(2, -1).trim())
+        return false;
+    let depth = 1;
+    let quote;
+    let escaped = false;
+    for (let index = 2; index < trimmed.length; index += 1) {
+        const character = trimmed[index];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === '\\') {
+                escaped = true;
+            }
+            else if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === "'" || character === '"' || character === '`') {
+            quote = character;
+        }
+        else if (character === '{') {
+            depth += 1;
+        }
+        else if (character === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return index === trimmed.length - 1;
+        }
+    }
+    return false;
+}
+function elementReferences(element) {
+    const references = [];
+    for (const [, slot] of elementSlotEntries(element).entries) {
+        references.push(...slotStaticReferences(slot));
+        const repeat = readOwnData(slot, 'repeat');
+        const binding = repeat.kind === 'value'
+            ? readRepeatBindingFields(repeat.value)
+            : undefined;
+        if (typeof binding?.template === 'string' && binding.template) {
+            references.push(binding.template);
+        }
+        const a2ui = getA2UIChildBinding(slot);
+        if (typeof a2ui?.templateId === 'string' && a2ui.templateId) {
+            references.push(a2ui.templateId);
+        }
+    }
+    return references;
+}
+function validateRepeatBindings(schema, errors) {
+    const dynamicBindings = [];
+    for (const [id, element] of Object.entries(schema.elements)) {
+        const elementRepeats = elementSlotEntries(element).entries
+            .filter((entry) => hasOwn(entry[1], 'repeat')
+            || getA2UIChildBinding(entry[1]) !== undefined);
+        if (elementRepeats.length > 1) {
+            errors.push(`Element "${id}" has more than one dynamic slot`);
+        }
+        for (const [slotName, slot] of elementRepeats) {
+            const a2ui = getA2UIChildBinding(slot);
+            const repeat = readOwnData(slot, 'repeat');
+            if (repeat.kind === 'missing' && a2ui) {
+                dynamicBindings.push({
+                    owner: id,
+                    slotName,
+                    dialect: 'a2ui',
+                    template: a2ui.templateId,
+                });
+                if (typeof a2ui.templateId !== 'string'
+                    || a2ui.templateId.length === 0) {
+                    errors.push(`Element "${id}" slot "${slotName}" dynamic children template must be a non-empty string`);
+                }
+                else if (!getOwnElement(schema, a2ui.templateId)) {
+                    errors.push(`Element "${id}" slot "${slotName}" dynamic children reference unknown template "${a2ui.templateId}"`);
+                }
+                continue;
+            }
+            const rawBinding = repeat.kind === 'value'
+                ? repeat.value
+                : undefined;
+            if (!isPlainObject(rawBinding)) {
+                errors.push(`Element "${id}" slot "${slotName}" repeat must be a non-null plain object`);
+                continue;
+            }
+            const binding = readRepeatBindingFields(rawBinding);
+            dynamicBindings.push({
+                owner: id,
+                slotName,
+                dialect: 'native',
+                template: binding.template,
+                binding,
+            });
+            if (!REPEAT_SLOT_LAYOUTS.has(slotName)) {
+                errors.push(`Element "${id}" slot "${slotName}" does not support repeat`);
+            }
+            const children = readOwnData(slot, 'children');
+            const groups = readOwnData(slot, 'groups');
+            if ((children.kind === 'value' && !!children.value)
+                || children.kind === 'accessor'
+                || children.kind === 'opaque'
+                || (groups.kind === 'value' && !!groups.value)
+                || groups.kind === 'accessor'
+                || groups.kind === 'opaque') {
+                errors.push(`Element "${id}" slot "${slotName}" cannot combine repeat with children or groups`);
+            }
+            if (typeof binding.source !== 'string') {
+                errors.push(`Element "${id}" slot "${slotName}" repeat source must be a string`);
+            }
+            else if (!isCompleteExpression(binding.source)) {
+                errors.push(`Element "${id}" slot "${slotName}" repeat source must be one complete non-empty \${...} expression`);
+            }
+            if (typeof binding.template !== 'string') {
+                errors.push(`Element "${id}" slot "${slotName}" repeat template must be a string`);
+            }
+            else if (!binding.template) {
+                errors.push(`Element "${id}" slot "${slotName}" repeat template must be a non-empty string`);
+            }
+            else if (!getOwnElement(schema, binding.template)) {
+                errors.push(`Element "${id}" slot "${slotName}" repeat references unknown template "${binding.template}"`);
+            }
+            validateAlias(id, slotName, 'item', binding.item, errors);
+            if (binding.index !== undefined) {
+                validateAlias(id, slotName, 'index', binding.index, errors);
+            }
+            if (binding.index !== undefined && binding.item === binding.index) {
+                errors.push(`Element "${id}" slot "${slotName}" repeat item and index aliases must be different`);
+            }
+        }
+    }
+    validateRepeatNesting(schema, dynamicBindings, errors);
+    validateDynamicClosures(schema, dynamicBindings, errors);
+}
+function validateAlias(owner, slotName, kind, alias, errors) {
+    if (typeof alias !== 'string') {
+        errors.push(`Element "${owner}" slot "${slotName}" repeat ${kind} must be a string`);
+    }
+    else if (!ALIAS_PATTERN.test(alias)) {
+        errors.push(`Element "${owner}" slot "${slotName}" repeat ${kind} alias "${alias}" is invalid`);
+    }
+    else if (RESERVED_ALIASES.has(alias)) {
+        errors.push(`Element "${owner}" slot "${slotName}" repeat ${kind} alias "${alias}" is reserved`);
+    }
+}
+function validateRepeatNesting(schema, bindings, errors) {
+    const reportedCycles = new Set();
+    const reportedCollisions = new Set();
+    function visitElement(id, activeAliases, repeatPath, visitedStatic) {
+        const element = getOwnElement(schema, id);
+        if (!element || visitedStatic.has(id))
+            return;
+        const nextVisitedStatic = new Set(visitedStatic).add(id);
+        for (const [slotName, slotValue] of elementSlotEntries(element).entries) {
+            if (!slotValue || typeof slotValue !== 'object')
+                continue;
+            const slot = slotValue;
+            const repeat = readOwnData(slot, 'repeat');
+            const nativeBinding = repeat.kind === 'value'
+                ? readRepeatBindingFields(repeat.value)
+                : undefined;
+            const a2uiBinding = getA2UIChildBinding(slot);
+            const template = nativeBinding?.template ?? a2uiBinding?.templateId;
+            if (typeof template === 'string' && template) {
+                const cycleAt = repeatPath.indexOf(template);
+                if (cycleAt >= 0) {
+                    const cycle = [...repeatPath.slice(cycleAt), template].join(' -> ');
+                    if (!reportedCycles.has(cycle)) {
+                        reportedCycles.add(cycle);
+                        errors.push(nativeBinding
+                            ? `Element "${id}" slot "${slotName}" has repeat template cycle: ${cycle}`
+                            : `Element "${id}" slot "${slotName}" has dynamic template cycle: ${cycle}`);
+                    }
+                    continue;
+                }
+                const aliases = [nativeBinding?.item, nativeBinding?.index].filter((alias) => typeof alias === 'string');
+                for (const alias of aliases) {
+                    if (activeAliases.has(alias)) {
+                        const key = `${id}:${slotName}:${alias}`;
+                        if (!reportedCollisions.has(key)) {
+                            reportedCollisions.add(key);
+                            errors.push(`Element "${id}" slot "${slotName}" repeat alias "${alias}" conflicts with an active repeat alias`);
+                        }
+                    }
+                }
+                const nestedAliases = new Set(activeAliases);
+                for (const alias of aliases)
+                    nestedAliases.add(alias);
+                visitElement(template, nestedAliases, [...repeatPath, template], new Set());
+            }
+            for (const child of slotStaticReferences(slot)) {
+                visitElement(child, activeAliases, repeatPath, nextVisitedStatic);
+            }
+        }
+    }
+    for (const dynamic of bindings) {
+        const { owner, binding, template } = dynamic;
+        const aliases = new Set([binding?.item, binding?.index].filter((alias) => typeof alias === 'string'));
+        if (typeof template === 'string' && template) {
+            visitElement(template, aliases, [owner, template], new Set());
+        }
+    }
+}
+function validateDynamicClosures(schema, repeats, errors) {
+    for (const { owner } of repeats) {
+        const visited = new Set();
+        function visit(id) {
+            if (visited.has(id))
+                return;
+            visited.add(id);
+            const element = getOwnElement(schema, id);
+            if (!element)
+                return;
+            const lifecycle = readOwnData(element, 'lifecycle');
+            if ((lifecycle.kind === 'value' && !!lifecycle.value)
+                || lifecycle.kind === 'accessor'
+                || lifecycle.kind === 'opaque') {
+                errors.push(`Element "${id}" in dynamic patch closure owned by "${owner}" cannot use lifecycle`);
+            }
+            if (hasOwn(element.props, 'variableKey')) {
+                errors.push(`Element "${id}" in dynamic patch closure owned by "${owner}" cannot use props.variableKey`);
+            }
+            for (const reference of elementReferences(element))
+                visit(reference);
+        }
+        visit(owner);
+    }
+}
+
+/** Build a live expression object whose own properties are the current aliases. */
+function createExpressionContext(scope) {
+    const prototype = scope.parent
+        ? createExpressionContext(scope.parent)
+        : scope.root;
+    return Object.assign(Object.create(prototype), scope.locals);
+}
+function isBoundRenderTreeNode(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const node = value;
+    return (typeof node.id === 'string' &&
+        typeof node.sourceId === 'string' &&
+        typeof node.instancePath === 'string' &&
+        typeof node.dataPath === 'string' &&
+        !!node.scope &&
+        (node.bindingDialect === 'native' || node.bindingDialect === 'a2ui') &&
+        Array.isArray(node.children));
+}
+function cloneValue(value, seen = new WeakMap()) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const existing = seen.get(value);
+    if (existing)
+        return existing;
+    let isArray;
+    let prototype;
+    let descriptors;
+    try {
+        isArray = Array.isArray(value);
+        prototype = Object.getPrototypeOf(value);
+        descriptors = [];
+        for (const key of Reflect.ownKeys(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor)
+                descriptors.push([key, descriptor]);
+        }
+    }
+    catch {
+        return value;
+    }
+    const result = isArray ? [] : Object.create(prototype);
+    seen.set(value, result);
+    for (const [key, descriptor] of descriptors) {
+        if (isArray && key === 'length')
+            continue;
+        if (Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            Object.defineProperty(result, key, {
+                value: cloneValue(descriptor.value, seen),
+                enumerable: descriptor.enumerable,
+                configurable: true,
+                writable: true,
+            });
+        }
+        else {
+            Object.defineProperty(result, key, descriptor);
+        }
+    }
+    return result;
+}
+function escapeRuntimePart(value) {
+    return Array.from(value, character => character.codePointAt(0).toString(16)).join('-');
+}
+function appendOccurrence(outerPath, kind, ownerId, slot, position) {
+    const segments = [
+        kind === 'item' ? 'i' : 'c',
+        ownerId,
+        slot,
+        position,
+    ];
+    return outerPath + segments
+        .map(segment => `${segment.length}:${segment}`)
+        .join('');
+}
+function runtimeId(sourceId, instancePath) {
+    return `r_${escapeRuntimePart(sourceId)}_${escapeRuntimePart(instancePath)}`;
+}
+function pointerSegment(value) {
+    return value.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function joinPointer(base, segments) {
+    return `${base}${segments.map(segment => `/${pointerSegment(segment)}`).join('')}`;
+}
+function collectSlotReferences(slot) {
+    const references = [];
+    slot.children?.forEach((sourceId, index) => {
+        references.push({
+            sourceId,
+            position: `children:${index}`,
+            assign: id => { slot.children[index] = id; },
+        });
+    });
+    slot.groups?.forEach((group, groupIndex) => {
+        group.forEach((sourceId, childIndex) => {
+            references.push({
+                sourceId,
+                position: `groups:${groupIndex}:${childIndex}`,
+                assign: id => { slot.groups[groupIndex][childIndex] = id; },
+            });
+        });
+    });
+    const overlays = slot.config?.overlays;
+    if (Array.isArray(overlays)) {
+        overlays.forEach((overlay, overlayIndex) => {
+            if (!Array.isArray(overlay?.children))
+                return;
+            overlay.children.forEach((sourceId, childIndex) => {
+                references.push({
+                    sourceId,
+                    position: `overlays:${overlayIndex}:${childIndex}`,
+                    assign: id => { overlay.children[childIndex] = id; },
+                });
+            });
+        });
+    }
+    return references;
+}
+function isPointerAncestor(ancestor, descendant) {
+    if (ancestor === '')
+        return descendant !== '';
+    return descendant.startsWith(`${ancestor}/`);
+}
+function pointersOverlap(left, right) {
+    return (left === right ||
+        isPointerAncestor(left, right) ||
+        isPointerAncestor(right, left));
+}
+function ownersInInsertionOrder(card, selectedKeys) {
+    const result = [];
+    for (const [key, owner] of card.repeatOwners) {
+        if (selectedKeys.has(key))
+            result.push(owner);
+    }
+    return result;
+}
+function removeOwnersCoveredByAncestors(card, selectedKeys) {
+    const result = new Set(selectedKeys);
+    for (const key of selectedKeys) {
+        let parentKey = card.repeatOwners.get(key)?.parentKey;
+        while (parentKey) {
+            if (selectedKeys.has(parentKey)) {
+                result.delete(key);
+                break;
+            }
+            parentKey = card.repeatOwners.get(parentKey)?.parentKey;
+        }
+    }
+    return result;
+}
+/** Select repeat owners affected by a JSON Pointer data update. */
+function findAffectedRepeatOwners(card, updatePath) {
+    if (card.unresolvedRepeatOwners.size > 0)
+        return [];
+    const selected = new Set();
+    for (const [dependency, owners] of card.valueDependencies) {
+        if (!dependency.startsWith('data:'))
+            continue;
+        const dependencyPath = dependency.slice('data:'.length);
+        if (!pointersOverlap(updatePath, dependencyPath))
+            continue;
+        for (const owner of owners)
+            selected.add(owner);
+    }
+    const exactStructuralOwners = new Set();
+    const containingStructuralOwners = new Set();
+    let nearestStructuralLength = -1;
+    const nearestStructuralOwners = new Set();
+    for (const owner of card.repeatOwners.values()) {
+        const sourcePath = owner.sourcePath;
+        if (sourcePath === undefined)
+            continue;
+        if (updatePath === sourcePath) {
+            exactStructuralOwners.add(owner.key);
+            continue;
+        }
+        if (isPointerAncestor(updatePath, sourcePath)) {
+            containingStructuralOwners.add(owner.key);
+            continue;
+        }
+        if (isPointerAncestor(sourcePath, updatePath)) {
+            if (sourcePath.length > nearestStructuralLength) {
+                nearestStructuralLength = sourcePath.length;
+                nearestStructuralOwners.clear();
+            }
+            if (sourcePath.length === nearestStructuralLength) {
+                nearestStructuralOwners.add(owner.key);
+            }
+        }
+    }
+    if (exactStructuralOwners.size > 0) {
+        for (const owner of exactStructuralOwners)
+            selected.add(owner);
+        for (const owner of containingStructuralOwners)
+            selected.add(owner);
+    }
+    else {
+        for (const owner of containingStructuralOwners)
+            selected.add(owner);
+        for (const owner of nearestStructuralOwners)
+            selected.add(owner);
+    }
+    return ownersInInsertionOrder(card, removeOwnersCoveredByAncestors(card, selected));
+}
+/** Select repeat owners whose materialized closure contains a source definition. */
+function findTemplateRepeatOwners(card, sourceIds) {
+    const selected = new Set();
+    for (const sourceId of sourceIds) {
+        const owners = card.dependencies.get(`component:${sourceId}`);
+        if (!owners)
+            continue;
+        for (const owner of owners)
+            selected.add(owner);
+    }
+    const runtimeOwnerCounts = new Map();
+    for (const owner of card.repeatOwners.values()) {
+        runtimeOwnerCounts.set(owner.runtimeOwnerId, (runtimeOwnerCounts.get(owner.runtimeOwnerId) ?? 0) + 1);
+    }
+    for (const key of selected) {
+        const runtimeOwnerId = card.repeatOwners.get(key)?.runtimeOwnerId;
+        if (runtimeOwnerId && (runtimeOwnerCounts.get(runtimeOwnerId) ?? 0) > 1) {
+            return [];
+        }
+    }
+    return ownersInInsertionOrder(card, removeOwnersCoveredByAncestors(card, selected));
+}
+/**
+ * Normalize a card and recursively turn native repeat declarations into a
+ * renderer-ready tree with ordinary children and occurrence-specific IDs.
+ */
+function materializeCard(input, variables, options = {}) {
+    const schema = normalizeSchema(input);
+    const rootVariables = variables ?? schema.variables;
+    const maxDepth = options.maxDepth ?? 3;
+    const maxItems = options.maxItems ?? 100;
+    const instances = new Map();
+    const schemaSourceIds = new Set(Object.keys(schema.elements));
+    const publicIds = new Set(schemaSourceIds);
+    const repeatOwners = new Map();
+    const dependencies = new Map();
+    const valueDependencies = new Map();
+    const unresolvedRepeatOwners = new Set();
+    const scopeAliasPaths = new WeakMap();
+    const scopeIndexAliases = new WeakMap();
+    const runtimeOwnerKeys = new Map();
+    const diagnostics = [];
+    let repeatedItemCount = 0;
+    let hasRepeat = false;
+    const rootScope = {
+        root: rootVariables,
+        locals: {},
+        dataPath: '',
+        bindingDialect: 'native',
+    };
+    scopeAliasPaths.set(rootScope, new Map());
+    scopeIndexAliases.set(rootScope, new Set());
+    function addDependency(type, value, ownerKey) {
+        const key = `${type}:${value}`;
+        const owners = dependencies.get(key);
+        if (owners) {
+            owners.add(ownerKey);
+        }
+        else {
+            dependencies.set(key, new Set([ownerKey]));
+        }
+    }
+    function addValueDependency(pointer, ownerKey) {
+        addDependency('data', pointer, ownerKey);
+        const key = `data:${pointer}`;
+        const owners = valueDependencies.get(key);
+        if (owners) {
+            owners.add(ownerKey);
+        }
+        else {
+            valueDependencies.set(key, new Set([ownerKey]));
+        }
+    }
+    function resolveDependencyPath(path, scope) {
+        const segments = path.split('.');
+        const alias = segments[0];
+        let cursor = scope;
+        while (cursor) {
+            if (Object.prototype.hasOwnProperty.call(cursor.locals, alias)) {
+                const aliases = scopeAliasPaths.get(cursor);
+                if (!aliases?.has(alias))
+                    return undefined;
+                const base = aliases.get(alias);
+                if (base === undefined)
+                    return undefined;
+                if (scopeIndexAliases.get(cursor)?.has(alias))
+                    return base;
+                return joinPointer(base, segments.slice(1));
+            }
+            cursor = cursor.parent;
+        }
+        return joinPointer('', segments);
+    }
+    function resolveSimpleExpressionPath(expression, scope) {
+        const match = expression.trim().match(/^\$\{\s*([a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*)\s*\}$/);
+        return match ? resolveDependencyPath(match[1], scope) : undefined;
+    }
+    function resolveA2UIPointer(path, scopePath) {
+        return path.startsWith('/')
+            ? path
+            : path === ''
+                ? scopePath
+                : `${scopePath}/${path}`;
+    }
+    function ownDataEntries(value) {
+        try {
+            const entries = [];
+            for (const key of Reflect.ownKeys(value)) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                if (descriptor &&
+                    Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+                    entries.push([key, descriptor.value]);
+                }
+            }
+            return entries;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function isIndexAliasPath(path, scope) {
+        const alias = path.split('.')[0];
+        let cursor = scope;
+        while (cursor) {
+            if (Object.prototype.hasOwnProperty.call(cursor.locals, alias)) {
+                return scopeIndexAliases.get(cursor)?.has(alias) ?? false;
+            }
+            cursor = cursor.parent;
+        }
+        return false;
+    }
+    function scanExpressionString(value, scope, ownerKey) {
+        if (!value.includes('${'))
+            return;
+        const expressions = [...value.matchAll(/\$\{([^{}]*)\}/g)];
+        const unmatched = value.replace(/\$\{[^{}]*\}/g, '').includes('${');
+        if (expressions.length === 0 || unmatched) {
+            unresolvedRepeatOwners.add(ownerKey);
+            return;
+        }
+        for (const expression of expressions) {
+            const path = expression[1].trim();
+            if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*$/.test(path)) {
+                unresolvedRepeatOwners.add(ownerKey);
+                continue;
+            }
+            const pointer = resolveDependencyPath(path, scope);
+            if (pointer === undefined) {
+                unresolvedRepeatOwners.add(ownerKey);
+            }
+            else if (isIndexAliasPath(path, scope)) {
+                addDependency('data', pointer, ownerKey);
+            }
+            else {
+                addValueDependency(pointer, ownerKey);
+            }
+        }
+    }
+    function scanDependencyValue(value, scope, ownerKey, visited) {
+        if (typeof value === 'string') {
+            scanExpressionString(value, scope, ownerKey);
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        if (visited.has(value))
+            return;
+        visited.add(value);
+        if (scope.bindingDialect === 'a2ui' && isA2UIPathBinding(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, 'path');
+            const path = descriptor?.value;
+            if (typeof path === 'string') {
+                addValueDependency(resolveA2UIPointer(path, scope.dataPath), ownerKey);
+            }
+            return;
+        }
+        const entries = ownDataEntries(value);
+        if (!entries) {
+            unresolvedRepeatOwners.add(ownerKey);
+            return;
+        }
+        for (const [key, child] of entries) {
+            if (Array.isArray(value) && key === 'length')
+                continue;
+            scanDependencyValue(child, scope, ownerKey, visited);
+        }
+    }
+    function scanProps(props, scope, ownerKey, visited) {
+        if (visited.has(props))
+            return;
+        visited.add(props);
+        const propEntries = ownDataEntries(props);
+        if (!propEntries) {
+            unresolvedRepeatOwners.add(ownerKey);
+            return;
+        }
+        for (const [key, value] of propEntries) {
+            if (key !== 'slots') {
+                scanDependencyValue(value, scope, ownerKey, visited);
+                continue;
+            }
+            if (!value || typeof value !== 'object')
+                continue;
+            const slotEntries = ownDataEntries(value);
+            if (!slotEntries) {
+                unresolvedRepeatOwners.add(ownerKey);
+                continue;
+            }
+            for (const [, slot] of slotEntries) {
+                if (!slot || typeof slot !== 'object')
+                    continue;
+                const entries = ownDataEntries(slot);
+                if (!entries) {
+                    unresolvedRepeatOwners.add(ownerKey);
+                    continue;
+                }
+                for (const [slotKey, slotValue] of entries) {
+                    if (slotKey === 'repeat' || slotKey === A2UI_CHILD_BINDING)
+                        continue;
+                    scanDependencyValue(slotValue, scope, ownerKey, visited);
                 }
             }
         }
-        visited.delete(id); // allow same element across different branches
-        return {
+    }
+    function allocateRuntimeId(sourceId, instancePath) {
+        const base = runtimeId(sourceId, instancePath);
+        let id = base;
+        let suffix = 1;
+        while (publicIds.has(id) || instances.has(id)) {
+            id = `${base}_${suffix}`;
+            suffix += 1;
+        }
+        publicIds.add(id);
+        return id;
+    }
+    function allocateStaticInstanceKey(id) {
+        const base = `s_${escapeRuntimePart(id)}`;
+        let suffix = 1;
+        let key = `${base}_${suffix}`;
+        while (schemaSourceIds.has(key) ||
+            publicIds.has(key) ||
+            instances.has(key)) {
+            suffix += 1;
+            key = `${base}_${suffix}`;
+        }
+        return key;
+    }
+    function buildNode(sourceId, scope, instancePath, structuralPath, repeatedOccurrence, parentId, repeatDepth, nearestOwnerKey, activeDefinitions) {
+        if (activeDefinitions.has(sourceId)) {
+            throw new Error(`[CardMaterializer] Circular reference detected at "${sourceId}"`);
+        }
+        const nextActiveDefinitions = new Set(activeDefinitions).add(sourceId);
+        const element = schema.elements[sourceId];
+        if (!element) {
+            throw new Error(`[CardMaterializer] Missing element for id "${sourceId}"`);
+        }
+        const bindingDialect = (scope.bindingDialect === 'a2ui' ||
+            hasA2UIBindingDialect(element)) ? 'a2ui' : 'native';
+        const activeScope = bindingDialect === scope.bindingDialect
+            ? scope
+            : { ...scope, bindingDialect };
+        if (activeScope !== scope) {
+            scopeAliasPaths.set(activeScope, new Map(scopeAliasPaths.get(scope) ?? []));
+            scopeIndexAliases.set(activeScope, new Set(scopeIndexAliases.get(scope) ?? []));
+        }
+        const id = repeatedOccurrence
+            ? allocateRuntimeId(sourceId, instancePath)
+            : sourceId;
+        const props = cloneValue(element.props);
+        const node = {
             id,
+            sourceId,
+            instancePath,
+            dataPath: activeScope.dataPath,
+            scope: activeScope,
+            bindingDialect,
             type: element.type,
-            props: element.props,
-            children,
+            props,
+            children: [],
             lifecycle: element.lifecycle,
             events: element.events,
             directives: element.directives,
         };
-    }
-    return buildNode(rootID);
-}
-// ─── Validation ──────────────────────────────────────────────────
-/**
- * Validate a CardSchema and return any error messages.
- */
-function validateSchema(input) {
-    const schema = normalizeSchema(input);
-    const errors = [];
-    if (!schema.version) {
-        errors.push('Missing "version" field');
-    }
-    if (!schema.rootID) {
-        errors.push('Missing "rootID" field');
-    }
-    else if (!schema.elements[schema.rootID]) {
-        errors.push(`Root element "${schema.rootID}" not found in elements`);
-    }
-    const allIds = new Set(Object.keys(schema.elements));
-    for (const [id, element] of Object.entries(schema.elements)) {
-        if (!element.type) {
-            errors.push(`Element "${id}" is missing a "type" field`);
+        let instanceKey = id;
+        if (!repeatedOccurrence && instances.has(instanceKey)) {
+            instanceKey = allocateStaticInstanceKey(id);
         }
-        // Validate slot children and groups references
-        if (element.props.slots) {
-            for (const [slotName, slot] of Object.entries(element.props.slots)) {
-                if (slot.children) {
-                    for (const childId of slot.children) {
-                        if (!allIds.has(childId)) {
-                            errors.push(`Element "${id}" slot "${slotName}" references unknown child "${childId}"`);
-                        }
+        instances.set(instanceKey, { id, sourceId, parentId, node });
+        const slotsDescriptor = Object.getOwnPropertyDescriptor(props, 'slots');
+        const slots = (slotsDescriptor &&
+            Object.prototype.hasOwnProperty.call(slotsDescriptor, 'value'))
+            ? slotsDescriptor.value
+            : undefined;
+        const slotOwners = new Map();
+        if (slots) {
+            for (const [rawSlotName, rawSlot] of ownDataEntries(slots) ?? []) {
+                if (typeof rawSlotName !== 'string' || !rawSlot || typeof rawSlot !== 'object') {
+                    continue;
+                }
+                const slotName = rawSlotName;
+                const slot = rawSlot;
+                const repeatDescriptor = Object.getOwnPropertyDescriptor(slot, 'repeat');
+                let binding;
+                if (repeatDescriptor &&
+                    Object.prototype.hasOwnProperty.call(repeatDescriptor, 'value')) {
+                    const native = repeatDescriptor.value;
+                    if (!native || typeof native !== 'object') {
+                        throw new Error(`[CardMaterializer] Invalid repeat on "${sourceId}" slot "${slotName}"`);
                     }
+                    binding = {
+                        dialect: 'native',
+                        source: native.source,
+                        template: native.template,
+                        item: native.item,
+                        index: native.index,
+                    };
                 }
-                if (slot.groups) {
-                    for (const group of slot.groups) {
-                        for (const childId of group) {
-                            if (!allIds.has(childId)) {
-                                errors.push(`Element "${id}" slot "${slotName}" group references unknown child "${childId}"`);
-                            }
-                        }
+                else {
+                    const a2ui = getA2UIChildBinding(slot);
+                    if (a2ui) {
+                        binding = {
+                            dialect: 'a2ui',
+                            source: a2ui.path,
+                            template: a2ui.templateId,
+                        };
                     }
                 }
+                if (!binding)
+                    continue;
+                hasRepeat = true;
+                const depth = repeatDepth + 1;
+                const sourcePath = binding.dialect === 'a2ui'
+                    ? resolveA2UIPointer(binding.source, activeScope.dataPath)
+                    : resolveSimpleExpressionPath(binding.source, activeScope);
+                const ownerKey = `o_${escapeRuntimePart(id)}_${escapeRuntimePart(slotName)}_${escapeRuntimePart(structuralPath)}`;
+                const owner = {
+                    key: ownerKey,
+                    ...(nearestOwnerKey ? { parentKey: nearestOwnerKey } : {}),
+                    runtimeOwnerId: id,
+                    sourceOwnerId: sourceId,
+                    slot: slotName,
+                    templateId: binding.template,
+                    ...(sourcePath === undefined ? {} : { sourcePath }),
+                    dataPath: activeScope.dataPath,
+                    instancePath,
+                    depth,
+                };
+                if (repeatOwners.has(ownerKey)) {
+                    throw new Error(`[CardMaterializer] Repeat owner key collision at "${ownerKey}"`);
+                }
+                repeatOwners.set(ownerKey, owner);
+                slotOwners.set(slotName, { owner, binding, sourcePath, depth });
+                addDependency('component', binding.template, ownerKey);
+                const runtimeKeys = runtimeOwnerKeys.get(id) ?? [];
+                if (runtimeKeys.length > 0) {
+                    for (const key of runtimeKeys)
+                        unresolvedRepeatOwners.add(key);
+                    unresolvedRepeatOwners.add(ownerKey);
+                }
+                runtimeKeys.push(ownerKey);
+                runtimeOwnerKeys.set(id, runtimeKeys);
+                if (sourcePath === undefined) {
+                    unresolvedRepeatOwners.add(ownerKey);
+                }
+                else {
+                    addDependency('data', sourcePath, ownerKey);
+                }
             }
         }
+        const ownOwnerKeys = [...slotOwners.values()].map(entry => entry.owner.key);
+        const effectiveOwnerKey = ownOwnerKeys[0] ?? nearestOwnerKey;
+        if (ownOwnerKeys.length > 1) {
+            for (const key of ownOwnerKeys)
+                unresolvedRepeatOwners.add(key);
+        }
+        if (effectiveOwnerKey) {
+            addDependency('component', sourceId, effectiveOwnerKey);
+            const visited = new WeakSet();
+            scanProps(element.props, activeScope, effectiveOwnerKey, visited);
+            scanDependencyValue(element.directives?.visible, activeScope, effectiveOwnerKey, visited);
+            scanDependencyValue(element.directives?.disabled, activeScope, effectiveOwnerKey, visited);
+        }
+        if (!slots)
+            return node;
+        for (const [rawSlotName, rawSlot] of ownDataEntries(slots) ?? []) {
+            if (typeof rawSlotName !== 'string' || !rawSlot || typeof rawSlot !== 'object') {
+                continue;
+            }
+            const slotName = rawSlotName;
+            const slot = rawSlot;
+            const references = collectSlotReferences(slot);
+            for (const reference of references) {
+                const childStructuralPath = appendOccurrence(structuralPath, 'child', sourceId, slotName, reference.position);
+                const childPath = repeatedOccurrence ? childStructuralPath : '';
+                const child = buildNode(reference.sourceId, activeScope, childPath, childStructuralPath, repeatedOccurrence, id, repeatDepth, effectiveOwnerKey, nextActiveDefinitions);
+                reference.assign(child.id);
+                node.children.push(child);
+            }
+            const slotOwner = slotOwners.get(slotName);
+            if (!slotOwner)
+                continue;
+            const { owner, binding, sourcePath, depth } = slotOwner;
+            const value = binding.dialect === 'a2ui'
+                ? resolveA2UIPath(rootVariables, binding.source, activeScope.dataPath)
+                : resolveExpression(binding.source, createExpressionContext(activeScope));
+            let items;
+            if (value == null) {
+                items = [];
+            }
+            else if (!Array.isArray(value)) {
+                const diagnostic = {
+                    code: 'REPEAT_SOURCE_NOT_ARRAY',
+                    message: `Repeat source "${binding.source}" on "${sourceId}" did not resolve to an array`,
+                    ownerId: id,
+                    source: binding.source,
+                };
+                diagnostics.push(diagnostic);
+                options.onDiagnostic?.(diagnostic);
+                items = [];
+            }
+            else {
+                items = value;
+            }
+            if (items.length > 0 && depth > maxDepth) {
+                throw new Error(`[CardMaterializer] maxDepth ${maxDepth} exceeded at "${sourceId}" slot "${slotName}"`);
+            }
+            if (repeatedItemCount + items.length > maxItems) {
+                throw new Error(`[CardMaterializer] maxItems ${maxItems} exceeded at "${sourceId}" slot "${slotName}"`);
+            }
+            repeatedItemCount += items.length;
+            Reflect.deleteProperty(slot, 'repeat');
+            Reflect.deleteProperty(slot, A2UI_CHILD_BINDING);
+            slot.children = [];
+            items.forEach((item, index) => {
+                const dataPath = sourcePath === undefined
+                    ? activeScope.dataPath
+                    : joinPointer(sourcePath, [String(index)]);
+                const locals = binding.dialect === 'native' && binding.item
+                    ? {
+                        [binding.item]: item,
+                        ...(binding.index ? { [binding.index]: index } : {}),
+                    }
+                    : {};
+                const childScope = {
+                    root: rootVariables,
+                    locals,
+                    parent: activeScope,
+                    dataPath,
+                    bindingDialect: binding.dialect,
+                };
+                const aliases = new Map();
+                if (binding.dialect === 'native' && binding.item) {
+                    aliases.set(binding.item, sourcePath === undefined ? undefined : dataPath);
+                    if (binding.index)
+                        aliases.set(binding.index, sourcePath);
+                }
+                scopeAliasPaths.set(childScope, aliases);
+                scopeIndexAliases.set(childScope, new Set(binding.dialect === 'native' && binding.index
+                    ? [binding.index]
+                    : []));
+                const itemPath = appendOccurrence(structuralPath, 'item', sourceId, slotName, `${binding.template}:${index}`);
+                const child = buildNode(binding.template, childScope, itemPath, itemPath, true, id, depth, owner.key, nextActiveDefinitions);
+                slot.children.push(child.id);
+                node.children.push(child);
+            });
+        }
+        return node;
     }
-    return errors;
+    const root = buildNode(schema.rootID, rootScope, '', '', false, undefined, 0, undefined, new Set());
+    return {
+        root,
+        hasRepeat,
+        instances,
+        repeatOwners,
+        dependencies,
+        valueDependencies,
+        unresolvedRepeatOwners,
+        diagnostics,
+    };
 }
 
 /**
@@ -1361,12 +3184,29 @@ function isA2UIEnvelope(msg) {
  */
 function a2uiComponentToElement(comp) {
     const { id, component, children, slots, directives, events, lifecycle, ...props } = comp;
+    if (children !== undefined && !isA2UIChildList(children)) {
+        throw new Error(`[A2UI] Component "${id}" children must be a valid ChildList `
+            + '(string[] or exact { path, componentId } object)');
+    }
     const p = { ...props };
-    if (children) {
+    if (Array.isArray(children)) {
         p.slots = { ...(p.slots ?? {}), default: { children } };
     }
     if (slots) {
-        p.slots = { ...(p.slots ?? {}), ...slots };
+        p.slots = {
+            ...(p.slots ?? {}),
+            ...(isA2UIDynamicChildList(children)
+                ? copyDynamicSlots(id, slots)
+                : slots),
+        };
+    }
+    if (isA2UIDynamicChildList(children)) {
+        p.slots = { ...(p.slots ?? {}) };
+        const defaultSlot = Object.prototype.hasOwnProperty.call(p.slots, 'default')
+            ? cloneDynamicDefaultSlot(id, p.slots.default)
+            : {};
+        p.slots.default = defaultSlot;
+        setA2UIChildBinding(defaultSlot, children);
     }
     const element = { id, type: component, props: p };
     if (directives)
@@ -1375,8 +3215,121 @@ function a2uiComponentToElement(comp) {
         element.events = events;
     if (lifecycle)
         element.lifecycle = lifecycle;
+    if (isA2UIDynamicChildList(children)
+        || containsA2UIPathBinding$1(p)
+        || containsA2UIPathBinding$1(directives)
+        || containsA2UIPathBinding$1(events)
+        || containsA2UIPathBinding$1(lifecycle)) {
+        markA2UIBindingDialect(element);
+    }
     return element;
 }
+function containsA2UIPathBinding$1(value, seen = new WeakSet()) {
+    if (isA2UIPathBinding(value))
+        return true;
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (seen.has(value))
+        return false;
+    seen.add(value);
+    try {
+        for (const key of Reflect.ownKeys(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor
+                && Object.prototype.hasOwnProperty.call(descriptor, 'value')
+                && containsA2UIPathBinding$1(descriptor.value, seen)) {
+                return true;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function isPlainRecord(value) {
+    try {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return false;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function copyDynamicSlots(componentId, slots) {
+    const output = {};
+    let keys;
+    try {
+        keys = Reflect.ownKeys(slots);
+    }
+    catch {
+        throw new Error(`[A2UI] Component "${componentId}" slots must be a readable record`);
+    }
+    for (const key of keys) {
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(slots, key);
+        }
+        catch {
+            throw new Error(`[A2UI] Component "${componentId}" slots must be a readable record`);
+        }
+        if (!descriptor || !descriptor.enumerable)
+            continue;
+        if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            throw new Error(`[A2UI] Component "${componentId}" slots must use data properties`);
+        }
+        Object.defineProperty(output, key, {
+            configurable: true,
+            enumerable: true,
+            value: descriptor.value,
+            writable: true,
+        });
+    }
+    return output;
+}
+function cloneDynamicDefaultSlot(componentId, source) {
+    if (!isPlainRecord(source)) {
+        throw new Error(`[A2UI] Component "${componentId}" slots.default must be a plain record`);
+    }
+    let keys;
+    try {
+        keys = Reflect.ownKeys(source);
+    }
+    catch {
+        throw new Error(`[A2UI] Component "${componentId}" slots.default must be a plain record`);
+    }
+    const conflicts = new Set(['children', 'groups', 'repeat']);
+    const output = {};
+    for (const key of keys) {
+        if (conflicts.has(key)) {
+            throw new Error(`[A2UI] Component "${componentId}" slots.default.${String(key)} `
+                + 'conflicts with dynamic children');
+        }
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(source, key);
+        }
+        catch {
+            throw new Error(`[A2UI] Component "${componentId}" slots.default must be a plain record`);
+        }
+        if (!descriptor || !descriptor.enumerable)
+            continue;
+        if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            throw new Error(`[A2UI] Component "${componentId}" slots.default must be a plain `
+                + 'record with data properties');
+        }
+        Object.defineProperty(output, key, {
+            configurable: true,
+            enumerable: true,
+            value: descriptor.value,
+            writable: true,
+        });
+    }
+    return output;
+}
 /**
  * Convert an A2UI v0.9 envelope message into an internal StreamingCommand.
  * Returns null for unrecognized messages.
@@ -1407,8 +3360,17 @@ function a2uiToCommand(msg) {
         return { type: 'updateComponents', surfaceId, elements, ...(rootID ? { rootID } : {}) };
     }
     if (msg.updateDataModel) {
-        const { surfaceId, path = '/', value = null } = msg.updateDataModel;
-        return { type: 'updateDataModel', surfaceId, path, value };
+        const { surfaceId, path: envelopePath, value = null } = msg.updateDataModel;
+        const path = envelopePath === undefined || envelopePath === '/'
+            ? ''
+            : envelopePath;
+        return {
+            type: 'updateDataModel',
+            surfaceId,
+            path,
+            pathDialect: 'a2ui',
+            value,
+        };
     }
     if (msg.appendContent) {
         const { surfaceId, elementId, content } = msg.appendContent;
@@ -1553,6 +3515,109 @@ class StreamingParser {
  * - Compute parent-child relationships for component changes
  * - Emit typed events for the rendering layer
  */
+function cloneStreamingValue(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    const cached = seen.get(value);
+    if (cached !== undefined)
+        return cached;
+    const output = Array.isArray(value)
+        ? []
+        : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, output);
+    for (const key of Reflect.ownKeys(value)) {
+        if (Array.isArray(value) && key === 'length')
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+            continue;
+        if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            throw new TypeError(`Cannot clone streaming state accessor "${String(key)}"`);
+        }
+        Object.defineProperty(output, key, {
+            value: cloneStreamingValue(descriptor.value, seen),
+            enumerable: descriptor.enumerable,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return output;
+}
+function restoreOwnProperty(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    return descriptor
+        ? () => {
+            Object.defineProperty(target, key, descriptor);
+        }
+        : () => {
+            Reflect.deleteProperty(target, key);
+        };
+}
+function arrayIndexWriteExtendsLength(target, key) {
+    if (!Array.isArray(target))
+        return false;
+    const text = String(key);
+    if (!/^(0|[1-9]\d*)$/.test(text))
+        return false;
+    const index = Number(text);
+    return index <= 4294967294 && index >= target.length;
+}
+function writeProperty(target, key, value, journal) {
+    if (!journal) {
+        target[key] = value;
+        return;
+    }
+    recordPropertyMutation(target, key, journal);
+    target[key] = value;
+}
+function recordPropertyMutation(target, key, journal) {
+    if (arrayIndexWriteExtendsLength(target, key)) {
+        journal.push(restoreOwnProperty(target, 'length'));
+    }
+    journal.push(restoreOwnProperty(target, key));
+}
+function deleteProperty(target, key, journal) {
+    if (!journal)
+        return Reflect.deleteProperty(target, key);
+    const undo = restoreOwnProperty(target, key);
+    const deleted = Reflect.deleteProperty(target, key);
+    if (deleted)
+        journal.push(undo);
+    return deleted;
+}
+function spliceOne(target, index, journal) {
+    if (!journal) {
+        target.splice(index, 1);
+        return;
+    }
+    const removed = target[index];
+    target.splice(index, 1);
+    journal.push(() => {
+        target.splice(index, 0, removed);
+    });
+}
+function rollbackMutations(journal) {
+    for (let index = journal.length - 1; index >= 0; index -= 1) {
+        journal[index]();
+    }
+}
+function containsA2UIPathBinding(value, seen = new WeakSet()) {
+    if (isA2UIPathBinding(value))
+        return true;
+    if (value === null || typeof value !== 'object' || seen.has(value)) {
+        return false;
+    }
+    seen.add(value);
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor
+            && Object.prototype.hasOwnProperty.call(descriptor, 'value')
+            && containsA2UIPathBinding(descriptor.value, seen)) {
+            return true;
+        }
+    }
+    return false;
+}
 // ─── Engine ──────────────────────────────────────────────────────
 class StreamingEngine {
     constructor(listeners) {
@@ -1628,25 +3693,90 @@ class StreamingEngine {
         const schema = cmd.schema
             ? normalizeSchema(cmd.schema)
             : { version: '1.0', rootID: 'root', elements: {}, variables: {} };
+        const previousSchema = this.surfaces.get(cmd.surfaceId);
         this.surfaces.set(cmd.surfaceId, schema);
-        this.listeners.onSurfaceCreated(cmd.surfaceId, cmd.schema ?? null);
+        try {
+            this.listeners.onSurfaceCreated(cmd.surfaceId, cmd.schema ?? null);
+        }
+        catch (error) {
+            if (previousSchema) {
+                this.surfaces.set(cmd.surfaceId, previousSchema);
+            }
+            else {
+                this.surfaces.delete(cmd.surfaceId);
+            }
+            throw error;
+        }
     }
     handleUpdateComponents(cmd) {
-        let schema = this.surfaces.get(cmd.surfaceId);
-        if (!schema) {
-            // Implicit surface creation (v0.8 compatibility)
-            schema = {
-                version: '1.0',
-                rootID: cmd.rootID ?? 'root',
-                elements: {},
-                variables: {},
-            };
+        const previousSchema = this.surfaces.get(cmd.surfaceId);
+        const baseSchema = previousSchema ?? {
+            version: '1.0',
+            rootID: cmd.rootID ?? 'root',
+            elements: {},
+            variables: {},
+        };
+        const previousRequiresBinding = requiresBindingMaterialization(baseSchema);
+        const commandMayIntroduceBinding = this.commandMayIntroduceBinding(cmd);
+        // Preserve the original mutation order, references, and event timing for
+        // the overwhelmingly common static-to-static path.
+        if (!previousRequiresBinding && !commandMayIntroduceBinding) {
+            this.applyStaticComponentMutation(cmd, previousSchema, baseSchema);
+            return;
+        }
+        const candidate = cloneStreamingValue(baseSchema);
+        const candidateChanges = this.applyComponentMutation(candidate, cmd, true);
+        const rootIDChanged = candidate.rootID !== baseSchema.rootID;
+        const candidateRequiresBinding = requiresBindingMaterialization(candidate);
+        // A command may briefly carry binding metadata and remove it again in the
+        // same batch. The final candidate, not that intermediate form, decides
+        // whether the legacy static path remains applicable.
+        if (!previousRequiresBinding && !candidateRequiresBinding) {
+            this.applyStaticComponentMutation(cmd, previousSchema, baseSchema);
+            return;
+        }
+        if (candidateChanges.length === 0 && !rootIDChanged)
+            return;
+        this.surfaces.set(cmd.surfaceId, candidate);
+        try {
+            this.listeners.onComponentsUpdated(cmd.surfaceId, candidateChanges);
+        }
+        catch (error) {
+            if (previousSchema) {
+                this.surfaces.set(cmd.surfaceId, previousSchema);
+            }
+            else {
+                this.surfaces.delete(cmd.surfaceId);
+            }
+            throw error;
+        }
+    }
+    applyStaticComponentMutation(cmd, previousSchema, schema) {
+        const journal = [];
+        if (!previousSchema)
             this.surfaces.set(cmd.surfaceId, schema);
+        try {
+            const changes = this.applyComponentMutation(schema, cmd, false, journal);
+            if (changes.length > 0) {
+                this.listeners.onComponentsUpdated(cmd.surfaceId, changes);
+            }
+        }
+        catch (error) {
+            rollbackMutations(journal);
+            if (previousSchema) {
+                this.surfaces.set(cmd.surfaceId, previousSchema);
+            }
+            else {
+                this.surfaces.delete(cmd.surfaceId);
+            }
+            throw error;
         }
+    }
+    applyComponentMutation(schema, cmd, cloneIncoming, journal) {
         const changes = [];
         // Update rootID if provided
         if (cmd.rootID) {
-            schema.rootID = cmd.rootID;
+            writeProperty(schema, 'rootID', cmd.rootID, journal);
         }
         // Process element additions/updates.
         // Merge ALL elements first, THEN compute parent/index against the final
@@ -1654,12 +3784,15 @@ class StreamingEngine {
         // processed before its parent's updated children array would resolve to
         // no parent, and incremental renderers would silently drop it.
         if (cmd.elements) {
+            const incomingElements = cloneIncoming
+                ? cloneStreamingValue(cmd.elements)
+                : cmd.elements;
             const isNewMap = new Map();
-            for (const [id, element] of Object.entries(cmd.elements)) {
+            for (const [id, element] of Object.entries(incomingElements)) {
                 isNewMap.set(id, !schema.elements[id]);
-                schema.elements[id] = element;
+                writeProperty(schema.elements, id, element, journal);
             }
-            for (const [id, element] of Object.entries(cmd.elements)) {
+            for (const [id, element] of Object.entries(incomingElements)) {
                 const parentId = this.findParentId(schema, id);
                 const index = parentId ? this.findChildIndex(schema, parentId, id) : undefined;
                 changes.push({
@@ -1680,28 +3813,94 @@ class StreamingEngine {
                         elementId: id,
                         parentId: this.findParentId(schema, id),
                     });
-                    delete schema.elements[id];
+                    deleteProperty(schema.elements, id, journal);
                     // Also remove from any parent's children lists
-                    this.removeFromParentSlots(schema, id);
+                    this.removeFromParentSlots(schema, id, journal);
                 }
             }
         }
-        if (changes.length > 0) {
-            this.listeners.onComponentsUpdated(cmd.surfaceId, changes);
-        }
+        return changes;
+    }
+    commandMayIntroduceBinding(cmd) {
+        if (!cmd.elements || Object.keys(cmd.elements).length === 0)
+            return false;
+        return requiresBindingMaterialization({
+            version: '1.0',
+            rootID: cmd.rootID ?? 'root',
+            elements: cmd.elements,
+            variables: {},
+        });
     }
     handleUpdateDataModel(cmd) {
         const schema = this.surfaces.get(cmd.surfaceId);
         if (!schema)
             return;
-        // Set value at path in variables
-        setByPath(schema.variables, cmd.path, cmd.value);
+        if (!requiresBindingMaterialization(schema)) {
+            // Preserve legacy mutation and notification behavior on static cards.
+            // A2UI commands remain strict even when the current surface has no
+            // binding-bearing component.
+            const journal = [];
+            try {
+                this.applyDataModelWrite(schema.variables, cmd, journal);
+                this.emitDataModelUpdated(cmd);
+            }
+            catch (error) {
+                rollbackMutations(journal);
+                throw error;
+            }
+            return;
+        }
+        const candidate = cloneStreamingValue(schema);
+        const candidateCommand = {
+            ...cmd,
+            value: cloneStreamingValue(cmd.value),
+        };
+        if (!this.applyDataModelWrite(candidate.variables, candidateCommand))
+            return;
+        this.surfaces.set(cmd.surfaceId, candidate);
+        try {
+            this.emitDataModelUpdated(cmd);
+        }
+        catch (error) {
+            this.surfaces.set(cmd.surfaceId, schema);
+            throw error;
+        }
+    }
+    applyDataModelWrite(variables, cmd, journal) {
+        if (cmd.pathDialect === 'a2ui') {
+            if (journal) {
+                setByJsonPointerWithMutationRecorder(variables, cmd.path, cmd.value, (target, key) => {
+                    recordPropertyMutation(target, key, journal);
+                });
+            }
+            else {
+                setByJsonPointer(variables, cmd.path, cmd.value);
+            }
+            return true;
+        }
+        return setByLegacyPath(variables, cmd.path, cmd.value, journal);
+    }
+    emitDataModelUpdated(cmd) {
+        if (cmd.pathDialect !== undefined) {
+            this.listeners.onDataModelUpdated(cmd.surfaceId, cmd.path, cmd.value, cmd.pathDialect);
+            return;
+        }
         this.listeners.onDataModelUpdated(cmd.surfaceId, cmd.path, cmd.value);
     }
     handleAppendContent(cmd) {
         const schema = this.surfaces.get(cmd.surfaceId);
         if (!schema)
             return;
+        const isBoundSurface = requiresBindingMaterialization(schema);
+        const isUnknownRuntimeId = (cmd.elementId.startsWith('r_')
+            && !Object.prototype.hasOwnProperty.call(schema.elements, cmd.elementId));
+        if (isBoundSurface
+            && (isUnknownRuntimeId
+                || this.dynamicClosureSourceIds(schema).has(cmd.elementId))) {
+            console.warn(`[StreamingEngine] Rejected appendContent target "${cmd.elementId}" `
+                + 'because dynamic instances must be updated through their data model');
+            return;
+        }
         // Update internal schema state
         const element = schema.elements[cmd.elementId];
         if (element) {
@@ -1764,6 +3963,10 @@ class StreamingEngine {
                 return true;
             if (slot.groups?.some(group => group.includes(childId)))
                 return true;
+            if (slot.repeat?.template === childId)
+                return true;
+            if (getA2UIChildBinding(slot)?.templateId === childId)
+                return true;
             if (slot.config?.overlays) {
                 for (const overlay of slot.config.overlays) {
                     if (overlay.children?.includes(childId))
@@ -1776,7 +3979,7 @@ class StreamingEngine {
     /**
      * Remove a child ID from all parent element slot references.
      */
-    removeFromParentSlots(schema, childId) {
+    removeFromParentSlots(schema, childId, journal) {
         for (const element of Object.values(schema.elements)) {
             if (!element.props.slots)
                 continue;
@@ -1784,17 +3987,84 @@ class StreamingEngine {
                 if (slot.children) {
                     const idx = slot.children.indexOf(childId);
                     if (idx >= 0)
-                        slot.children.splice(idx, 1);
+                        spliceOne(slot.children, idx, journal);
                 }
                 if (slot.groups) {
                     for (const group of slot.groups) {
                         const idx = group.indexOf(childId);
                         if (idx >= 0)
-                            group.splice(idx, 1);
+                            spliceOne(group, idx, journal);
+                    }
+                }
+                if (slot.repeat?.template === childId) {
+                    deleteProperty(slot, 'repeat', journal);
+                }
+                if (getA2UIChildBinding(slot)?.templateId === childId) {
+                    deleteProperty(slot, A2UI_CHILD_BINDING, journal);
+                    if (!this.elementStillUsesA2UIBinding(element)) {
+                        deleteProperty(element, A2UI_BINDING_DIALECT, journal);
+                    }
+                }
+            }
+        }
+    }
+    elementStillUsesA2UIBinding(element) {
+        if (Object.values(element.props.slots ?? {}).some(slot => getA2UIChildBinding(slot) !== undefined)) {
+            return true;
+        }
+        return containsA2UIPathBinding(element.props)
+            || containsA2UIPathBinding(element.directives)
+            || containsA2UIPathBinding(element.events)
+            || containsA2UIPathBinding(element.lifecycle);
+    }
+    /**
+     * Source definitions inside a dynamic template closure have no unique
+     * runtime address. Token appends must therefore target their data model,
+     * not the shared source definition.
+     */
+    dynamicClosureSourceIds(schema) {
+        const dynamicSources = new Set();
+        const pending = [];
+        for (const element of Object.values(schema.elements)) {
+            for (const slot of Object.values(element.props.slots ?? {})) {
+                if (typeof slot.repeat?.template === 'string') {
+                    pending.push(slot.repeat.template);
+                }
+                const a2ui = getA2UIChildBinding(slot);
+                if (typeof a2ui?.templateId === 'string') {
+                    pending.push(a2ui.templateId);
+                }
+            }
+        }
+        while (pending.length > 0) {
+            const sourceId = pending.pop();
+            if (dynamicSources.has(sourceId))
+                continue;
+            dynamicSources.add(sourceId);
+            const source = schema.elements[sourceId];
+            if (!source)
+                continue;
+            for (const slot of Object.values(source.props.slots ?? {})) {
+                pending.push(...(slot.children ?? []));
+                for (const group of slot.groups ?? [])
+                    pending.push(...group);
+                if (Array.isArray(slot.config?.overlays)) {
+                    for (const overlay of slot.config.overlays) {
+                        if (Array.isArray(overlay?.children)) {
+                            pending.push(...overlay.children);
+                        }
                     }
                 }
+                if (typeof slot.repeat?.template === 'string') {
+                    pending.push(slot.repeat.template);
+                }
+                const a2ui = getA2UIChildBinding(slot);
+                if (typeof a2ui?.templateId === 'string') {
+                    pending.push(a2ui.templateId);
+                }
             }
         }
+        return dynamicSources;
     }
 }
 // ─── Utility Functions ────────────────────────────────────────────
@@ -1807,21 +4077,22 @@ class StreamingEngine {
  */
 const UNSAFE_PATH_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 /** Merge only own, non-dangerous keys of `src` into `target`. */
-function safeMerge(target, src) {
+function safeMerge(target, src, journal) {
     for (const key of Object.keys(src)) {
         if (UNSAFE_PATH_KEYS.has(key))
             continue;
-        target[key] = src[key];
+        writeProperty(target, key, src[key], journal);
     }
 }
 /**
  * Set a value at a JSON Pointer-like path in an object.
  *
  * Path format: '/key1/key2/key3' → obj.key1.key2.key3 = value
- * Root path '/' sets the entire object.
+ * Legacy root path '/' merges the value's own safe fields into the object.
  *
  * Prototype-polluting segments (`__proto__` / `constructor` / `prototype`) are
- * rejected — the whole write is dropped rather than silently retargeted.
+ * rejected — the whole write is dropped rather than silently retargeting it.
+ * Other assignments preserve the legacy writer's direct-reference behavior.
  *
  * @example
  * ```ts
@@ -1831,29 +4102,36 @@ function safeMerge(target, src) {
  * ```
  */
 function setByPath(obj, path, value) {
-    // Remove leading slash and split
+    setByLegacyPath(obj, path, value);
+}
+function setByLegacyPath(obj, path, value, journal) {
+    // Preserve the legacy dialect: `/` (and any other all-empty spelling)
+    // means a root merge, paths may omit the leading slash, and empty segments
+    // are ignored.
     const parts = path.replace(/^\//, '').split('/').filter(Boolean);
-    // Reject any dangerous segment outright — never partially apply.
-    if (parts.some((p) => UNSAFE_PATH_KEYS.has(p))) {
+    // Preserve the existing prototype-pollution guard without changing the
+    // historical writer's reference, accessor, or sparse-array semantics.
+    if (parts.some(part => UNSAFE_PATH_KEYS.has(part))) {
         console.warn(`[StreamingEngine] Rejected unsafe data-model path "${path}"`);
-        return;
+        return false;
     }
     if (parts.length === 0) {
         // Root-level update: merge value into obj (own, safe keys only)
         if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            safeMerge(obj, value);
+            safeMerge(obj, value, journal);
         }
-        return;
+        return true;
     }
     let current = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const key = parts[i];
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        const key = parts[index];
         if (current[key] === undefined || current[key] === null) {
-            current[key] = {};
+            writeProperty(current, key, {}, journal);
         }
         current = current[key];
     }
-    current[parts[parts.length - 1]] = value;
+    writeProperty(current, parts[parts.length - 1], value, journal);
+    return true;
 }
 
 /**
@@ -2145,6 +4423,14 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M17.5 16C17.5 16.2967 17.412 16.5867 17.2472 16.8334C17.0824 17.0801 16.8481 17.2723 16.574 17.3859C16.2999 17.4994 15.9983 17.5291 15.7074 17.4712C15.4164 17.4133 15.1491 17.2705 14.9393 17.0607C14.7296 16.8509 14.5867 16.5836 14.5288 16.2927C14.4709 16.0017 14.5006 15.7001 14.6142 15.426C14.7277 15.1519 14.92 14.9177 15.1666 14.7528C15.4133 14.588 15.7033 14.5 16 14.5C16.3978 14.5 16.7794 14.6581 17.0607 14.9394C17.342 15.2207 17.5 15.6022 17.5 16ZM10.5 14.5C10.2033 14.5 9.91332 14.588 9.66664 14.7528C9.41997 14.9177 9.22771 15.1519 9.11418 15.426C9.00065 15.7001 8.97094 16.0017 9.02882 16.2927C9.0867 16.5836 9.22956 16.8509 9.43934 17.0607C9.64912 17.2705 9.91639 17.4133 10.2074 17.4712C10.4983 17.5291 10.7999 17.4994 11.074 17.3859C11.3481 17.2723 11.5824 17.0801 11.7472 16.8334C11.912 16.5867 12 16.2967 12 16C12 15.6022 11.842 15.2207 11.5607 14.9394C11.2794 14.6581 10.8978 14.5 10.5 14.5ZM21.5 14.5C21.2033 14.5 20.9133 14.588 20.6666 14.7528C20.42 14.9177 20.2277 15.1519 20.1142 15.426C20.0007 15.7001 19.9709 16.0017 20.0288 16.2927C20.0867 16.5836 20.2296 16.8509 20.4393 17.0607C20.6491 17.2705 20.9164 17.4133 21.2074 17.4712C21.4983 17.5291 21.7999 17.4994 22.074 17.3859C22.3481 17.2723 22.5824 17.0801 22.7472 16.8334C22.912 16.5867 23 16.2967 23 16C23 15.6022 22.842 15.2207 22.5607 14.9394C22.2794 14.6581 21.8978 14.5 21.5 14.5ZM29 16C29.0005 18.2445 28.4199 20.4508 27.3147 22.4042C26.2095 24.3577 24.6174 25.9917 22.6934 27.1473C20.7693 28.3029 18.5788 28.9407 16.3352 28.9986C14.0915 29.0564 11.8711 28.5324 9.89 27.4775L5.63375 28.8963C5.28136 29.0138 4.9032 29.0309 4.54166 28.9455C4.18012 28.8602 3.84948 28.6759 3.58681 28.4132C3.32414 28.1506 3.13982 27.8199 3.0545 27.4584C2.96918 27.0968 2.98623 26.7187 3.10375 26.3663L4.5225 22.11C3.59519 20.3666 3.07725 18.4348 3.008 16.4613C2.93875 14.4877 3.32001 12.5244 4.12284 10.7202C4.92567 8.91604 6.12897 7.31847 7.6414 6.04878C9.15383 4.77909 10.9356 3.87063 12.8516 3.39238C14.7675 2.91413 16.7672 2.87865 18.699 3.28862C20.6307 3.6986 22.4436 4.54327 24.0001 5.7585C25.5566 6.97374 26.8158 8.52761 27.6822 10.3022C28.5485 12.0767 28.9992 14.0253 29 16ZM27 16C26.9995 14.3127 26.6109 12.6481 25.8641 11.135C25.1174 9.62186 24.0325 8.30083 22.6935 7.27408C21.3545 6.24733 19.7973 5.54238 18.1422 5.21377C16.4872 4.88517 14.7787 4.94171 13.149 5.37904C11.5194 5.81636 10.0121 6.62274 8.74394 7.73578C7.47577 8.84882 6.48065 10.2387 5.83558 11.7979C5.1905 13.357 4.91277 15.0437 5.02387 16.7274C5.13496 18.4111 5.63191 20.0466 6.47625 21.5075C6.54712 21.6302 6.59112 21.7665 6.60534 21.9074C6.61956 22.0484 6.60368 22.1907 6.55875 22.325L5 27L9.675 25.4413C9.77683 25.4066 9.88367 25.3888 9.99125 25.3888C10.1669 25.3891 10.3393 25.4357 10.4912 25.5238C12.1635 26.4913 14.0611 27.0013 15.9931 27.0026C17.925 27.0038 19.8232 26.4961 21.4967 25.5307C23.1702 24.5653 24.5599 23.1762 25.526 21.5031C26.492 19.83 27.0004 17.932 27 16Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "check": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M27.7071 8.29289C28.0976 8.68342 28.0976 9.31658 27.7071 9.70711L13.7071 23.7071C13.3166 24.0976 12.6834 24.0976 12.2929 23.7071L5.29289 16.7071C4.90237 16.3166 4.90237 15.6834 5.29289 15.2929C5.68342 14.9024 6.31658 14.9024 6.70711 15.2929L13 21.5858L26.2929 8.29289C26.6834 7.90237 27.3166 7.90237 27.7071 8.29289Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "check_bold": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M26.66453 8L11.99933 22.6656L5.33333 15.99941\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"5.33333\" stroke-linecap=\"round\"></path>",
+    }),
     "check_circle": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M21.7075 12.2925C21.8005 12.3854 21.8742 12.4957 21.9246 12.6171C21.9749 12.7385 22.0008 12.8686 22.0008 13C22.0008 13.1314 21.9749 13.2615 21.9246 13.3829C21.8742 13.5043 21.8005 13.6146 21.7075 13.7075L14.7075 20.7075C14.6146 20.8005 14.5043 20.8742 14.3829 20.9246C14.2615 20.9749 14.1314 21.0008 14 21.0008C13.8686 21.0008 13.7385 20.9749 13.6171 20.9246C13.4957 20.8742 13.3854 20.8005 13.2925 20.7075L10.2925 17.7075C10.1049 17.5199 9.99945 17.2654 9.99945 17C9.99945 16.7346 10.1049 16.4801 10.2925 16.2925C10.4801 16.1049 10.7346 15.9994 11 15.9994C11.2654 15.9994 11.5199 16.1049 11.7075 16.2925L14 18.5863L20.2925 12.2925C20.3854 12.1995 20.4957 12.1258 20.6171 12.0754C20.7385 12.0251 20.8686 11.9992 21 11.9992C21.1314 11.9992 21.2615 12.0251 21.3829 12.0754C21.5043 12.1258 21.6146 12.1995 21.7075 12.2925ZM29 16C29 18.5712 28.2376 21.0846 26.8091 23.2224C25.3807 25.3603 23.3503 27.0265 20.9749 28.0104C18.5995 28.9944 15.9856 29.2518 13.4638 28.7502C10.9421 28.2486 8.6257 27.0105 6.80762 25.1924C4.98953 23.3743 3.75141 21.0579 3.2498 18.5362C2.74819 16.0144 3.00563 13.4006 3.98957 11.0251C4.97351 8.64968 6.63975 6.61935 8.77759 5.1909C10.9154 3.76244 13.4288 3 16 3C19.4467 3.00364 22.7512 4.37445 25.1884 6.81163C27.6256 9.24882 28.9964 12.5533 29 16ZM27 16C27 13.8244 26.3549 11.6977 25.1462 9.88873C23.9375 8.07979 22.2195 6.66989 20.2095 5.83733C18.1995 5.00476 15.9878 4.78692 13.854 5.21136C11.7202 5.6358 9.76021 6.68345 8.22183 8.22183C6.68345 9.7602 5.63581 11.7202 5.21137 13.854C4.78693 15.9878 5.00477 18.1995 5.83733 20.2095C6.66989 22.2195 8.07979 23.9375 9.88873 25.1462C11.6977 26.3549 13.8244 27 16 27C18.9164 26.9967 21.7123 25.8367 23.7745 23.7745C25.8367 21.7123 26.9967 18.9164 27 16Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2463,4 +4749,4 @@ function getBuiltinIcon(name) {
     return BUILTIN_ICONS[name];
 }
 
-export { ActionRegistry, BUILTIN_ICONS, BUILTIN_ICON_NAMES, LifecycleManager, StreamingEngine, StreamingParser, a2uiComponentToElement, a2uiToCommand, convertLegacySchema, createLifecycleManager, extractPartialSchema, getBuiltinIcon, getByPath$1 as getByPath, hasExpression, interpolate, isA2UIEnvelope, isLegacySchema, normalizeSchema, parseSchema, registerActionHandler, registry, resetIdCounter, resolveActionRef, resolveDeep, resolveExpression, resolveExpressionValue, runActionStep, runActionSteps, setByPath, validateSchema };
+export { ActionRegistry, BUILTIN_ICONS, BUILTIN_ICON_NAMES, JsonPointerPathError, LifecycleManager, StreamingEngine, StreamingParser, a2uiComponentToElement, a2uiToCommand, bindingTopologyFingerprint, cloneJsonData, convertLegacySchema, createA2UIParameterResolver, createExpressionContext, createLifecycleManager, decodeJsonPointerSegment, extractPartialSchema, findAffectedRepeatOwners, findTemplateRepeatOwners, getBuiltinIcon, getByJsonPointer, getByPath$1 as getByPath, hasDynamicChildren, hasExpression, interpolate, isA2UIChildList, isA2UIDynamicChildList, isA2UIEnvelope, isA2UIPathBinding, isBoundRenderTreeNode, isLegacySchema, materializeCard, normalizeSchema, parseJsonPointer, parseSchema, registerActionHandler, registry, replaceRootContents, requiresBindingMaterialization, resetIdCounter, resolveA2UIDeep, resolveA2UIPath, resolveActionRef, resolveDeep, resolveExpression, resolveExpressionValue, runActionStep, runActionSteps, setByJsonPointer, setByPath, validateSchema };