@antglobal/copilot-cards-core 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -387,8 +387,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;
     }
@@ -571,6 +577,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);
     }
@@ -630,9 +640,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);
 }
 /**
@@ -1100,6 +1116,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.
  *
@@ -1119,6 +1707,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`.
@@ -1189,7 +1856,10 @@ function validateSchema(input) {
     if (!schema.version) {
         errors.push('Missing "version" field');
     }
-    if (!schema.rootID) {
+    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]) {
@@ -1200,29 +1870,1182 @@ function validateSchema(input) {
         if (!element.type) {
             errors.push(`Element "${id}" is missing a "type" field`);
         }
-        // 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}"`);
-                        }
+        // 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);
+                }
+            }
+        }
+    }
+    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,
+            children: [],
+            lifecycle: element.lifecycle,
+            events: element.events,
+            directives: element.directives,
+        };
+        let instanceKey = id;
+        if (!repeatedOccurrence && instances.has(instanceKey)) {
+            instanceKey = allocateStaticInstanceKey(id);
+        }
+        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,
+    };
 }
 
 /**
@@ -1363,12 +3186,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)
@@ -1377,8 +3217,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.
@@ -1409,8 +3362,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;
@@ -1555,6 +3517,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) {
@@ -1630,25 +3695,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
@@ -1656,12 +3786,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({
@@ -1682,28 +3815,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) {
@@ -1766,6 +3965,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))
@@ -1778,7 +3981,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;
@@ -1786,17 +3989,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 ────────────────────────────────────────────
@@ -1809,21 +4079,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
@@ -1833,29 +4104,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;
 }
 
 /**
@@ -2079,6 +4357,14 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M25.7075 18.7075L16.7075 27.7075C16.6146 27.8005 16.5043 27.8742 16.3829 27.9246C16.2615 27.9749 16.1314 28.0008 16 28.0008C15.8686 28.0008 15.7385 27.9749 15.6171 27.9246C15.4957 27.8742 15.3854 27.8005 15.2925 27.7075L6.29251 18.7075C6.10487 18.5199 5.99945 18.2654 5.99945 18C5.99945 17.7346 6.10487 17.4801 6.29251 17.2925C6.48015 17.1049 6.73464 16.9994 7.00001 16.9994C7.26537 16.9994 7.51987 17.1049 7.70751 17.2925L15 24.5863V5C15 4.73478 15.1054 4.48043 15.2929 4.29289C15.4804 4.10536 15.7348 4 16 4C16.2652 4 16.5196 4.10536 16.7071 4.29289C16.8947 4.48043 17 4.73478 17 5V24.5863L24.2925 17.2925C24.4801 17.1049 24.7346 16.9994 25 16.9994C25.2654 16.9994 25.5199 17.1049 25.7075 17.2925C25.8951 17.4801 26.0006 17.7346 26.0006 18C26.0006 18.2654 25.8951 18.5199 25.7075 18.7075Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "arrow_down_bold": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path transform=\"matrix(2 0 0 2 1 2)\" d=\"M6.6239 12.4741L6.6706 12.5184C7.15745 12.9588 7.92805 12.9346 8.39112 12.4644L12.2294 8.53381L12.2829 8.46923C12.5697 8.09216 12.4999 7.56406 12.1141 7.21793L12.048 7.16763C11.6699 6.90341 11.1334 6.95718 10.8044 7.29126L8.37533 9.77882L8.37533 2.04183C8.37533 1.55858 7.98358 1.16683 7.50033 1.16683C7.01708 1.16683 6.62533 1.55858 6.62533 2.04183L6.62533 9.77813L4.15453 7.25113L4.09339 7.19907C3.73156 6.9145 3.19286 6.93851 2.84615 7.25253C2.45674 7.60523 2.43887 8.19861 2.80627 8.57135L6.6239 12.4741Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "arrow_square_out": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M28 13C28 13.2652 27.8946 13.5196 27.7071 13.7071C27.5196 13.8946 27.2652 14 27 14C26.7348 14 26.4804 13.8946 26.2929 13.7071C26.1054 13.5196 26 13.2652 26 13V7.415L17.7087 15.7075C17.5211 15.8951 17.2666 16.0006 17.0012 16.0006C16.7359 16.0006 16.4814 15.8951 16.2938 15.7075C16.1061 15.5199 16.0007 15.2654 16.0007 15C16.0007 14.7346 16.1061 14.4801 16.2938 14.2925L24.585 6H19C18.7348 6 18.4804 5.89464 18.2929 5.70711C18.1054 5.51957 18 5.26522 18 5C18 4.73478 18.1054 4.48043 18.2929 4.29289C18.4804 4.10536 18.7348 4 19 4H27C27.2652 4 27.5196 4.10536 27.7071 4.29289C27.8946 4.48043 28 4.73478 28 5V13ZM23 16C22.7348 16 22.4804 16.1054 22.2929 16.2929C22.1054 16.4804 22 16.7348 22 17V26H6V10H15C15.2652 10 15.5196 9.89464 15.7071 9.70711C15.8946 9.51957 16 9.26522 16 9C16 8.73478 15.8946 8.48043 15.7071 8.29289C15.5196 8.10536 15.2652 8 15 8H6C5.46957 8 4.96086 8.21071 4.58579 8.58579C4.21071 8.96086 4 9.46957 4 10V26C4 26.5304 4.21071 27.0391 4.58579 27.4142C4.96086 27.7893 5.46957 28 6 28H22C22.5304 28 23.0391 27.7893 23.4142 27.4142C23.7893 27.0391 24 26.5304 24 26V17C24 16.7348 23.8946 16.4804 23.7071 16.2929C23.5196 16.1054 23.2652 16 23 16Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "arrow_up": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M25.7075 14.7075C25.6146 14.8005 25.5043 14.8742 25.3829 14.9246C25.2615 14.9749 25.1314 15.0008 25 15.0008C24.8686 15.0008 24.7385 14.9749 24.6171 14.9246C24.4957 14.8742 24.3854 14.8005 24.2925 14.7075L17 7.41374V27C17 27.2652 16.8947 27.5196 16.7071 27.7071C16.5196 27.8946 16.2652 28 16 28C15.7348 28 15.4804 27.8946 15.2929 27.7071C15.1054 27.5196 15 27.2652 15 27V7.41374L7.70751 14.7075C7.51987 14.8951 7.26537 15.0005 7.00001 15.0005C6.73464 15.0005 6.48015 14.8951 6.29251 14.7075C6.10487 14.5199 5.99945 14.2654 5.99945 14C5.99945 13.7346 6.10487 13.4801 6.29251 13.2925L15.2925 4.29249C15.3854 4.19952 15.4957 4.12576 15.6171 4.07543C15.7385 4.02511 15.8686 3.99921 16 3.99921C16.1314 3.99921 16.2615 4.02511 16.3829 4.07543C16.5043 4.12576 16.6146 4.19952 16.7075 4.29249L25.7075 13.2925C25.8005 13.3854 25.8742 13.4957 25.9246 13.6171C25.9749 13.7385 26.0008 13.8686 26.0008 14C26.0008 14.1314 25.9749 14.2615 25.9246 14.3829C25.8742 14.5043 25.8005 14.6146 25.7075 14.7075Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2087,6 +4373,14 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M27 8H22C22 6.4087 21.3679 4.88258 20.2426 3.75736C19.1174 2.63214 17.5913 2 16 2C14.4087 2 12.8826 2.63214 11.7574 3.75736C10.6321 4.88258 10 6.4087 10 8H5C4.46957 8 3.96086 8.21071 3.58579 8.58579C3.21071 8.96086 3 9.46957 3 10V25C3 25.5304 3.21071 26.0391 3.58579 26.4142C3.96086 26.7893 4.46957 27 5 27H27C27.5304 27 28.0391 26.7893 28.4142 26.4142C28.7893 26.0391 29 25.5304 29 25V10C29 9.46957 28.7893 8.96086 28.4142 8.58579C28.0391 8.21071 27.5304 8 27 8ZM16 4C17.0609 4 18.0783 4.42143 18.8284 5.17157C19.5786 5.92172 20 6.93913 20 8H12C12 6.93913 12.4214 5.92172 13.1716 5.17157C13.9217 4.42143 14.9391 4 16 4ZM27 25H5V10H10V12C10 12.2652 10.1054 12.5196 10.2929 12.7071C10.4804 12.8946 10.7348 13 11 13C11.2652 13 11.5196 12.8946 11.7071 12.7071C11.8946 12.5196 12 12.2652 12 12V10H20V12C20 12.2652 20.1054 12.5196 20.2929 12.7071C20.4804 12.8946 20.7348 13 21 13C21.2652 13 21.5196 12.8946 21.7071 12.7071C21.8946 12.5196 22 12.2652 22 12V10H27V25Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "bell": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M27.725 21.9925C27.0313 20.7975 26 17.4163 26 13C26 10.3478 24.9464 7.8043 23.0711 5.92893C21.1957 4.05357 18.6522 3 16 3C13.3479 3 10.8043 4.05357 8.92895 5.92893C7.05358 7.8043 6.00002 10.3478 6.00002 13C6.00002 17.4175 4.96752 20.7975 4.27377 21.9925C4.0966 22.2963 4.00268 22.6415 4.00148 22.9931C4.00027 23.3448 4.09182 23.6906 4.26689 23.9956C4.44196 24.3006 4.69437 24.5541 4.99865 24.7304C5.30293 24.9068 5.64833 24.9997 6.00002 25H11.1013C11.332 26.1289 11.9455 27.1436 12.8382 27.8722C13.7308 28.6009 14.8477 28.9989 16 28.9989C17.1523 28.9989 18.2692 28.6009 19.1618 27.8722C20.0545 27.1436 20.6681 26.1289 20.8988 25H26C26.3516 24.9995 26.6968 24.9064 27.0009 24.73C27.3051 24.5535 27.5573 24.3 27.7322 23.9951C27.9071 23.6901 27.9986 23.3444 27.9973 22.9928C27.996 22.6412 27.9021 22.2962 27.725 21.9925ZM16 27C15.3798 26.9998 14.7749 26.8074 14.2685 26.4492C13.7622 26.0911 13.3793 25.5848 13.1725 25H18.8275C18.6208 25.5848 18.2379 26.0911 17.7315 26.4492C17.2252 26.8074 16.6202 26.9998 16 27ZM6.00002 23C6.96252 21.345 8.00002 17.51 8.00002 13C8.00002 10.8783 8.84287 8.84344 10.3432 7.34315C11.8435 5.84285 13.8783 5 16 5C18.1217 5 20.1566 5.84285 21.6569 7.34315C23.1572 8.84344 24 10.8783 24 13C24 17.5063 25.035 21.3412 26 23H6.00002Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "bookmark_simple": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M23 4H9C8.46957 4 7.96086 4.21071 7.58579 4.58579C7.21071 4.96086 7 5.46957 7 6V28C7.00009 28.1785 7.04793 28.3537 7.13857 28.5074C7.22921 28.6611 7.35934 28.7878 7.51545 28.8743C7.67156 28.9607 7.84797 29.0039 8.02637 28.9992C8.20477 28.9944 8.37866 28.9421 8.53 28.8475L16 24.1787L23.4713 28.8475C23.6226 28.9418 23.7963 28.9939 23.9745 28.9984C24.1528 29.0029 24.3289 28.9598 24.4849 28.8733C24.6408 28.7869 24.7707 28.6603 24.8613 28.5068C24.9519 28.3532 24.9998 28.1783 25 28V6C25 5.46957 24.7893 4.96086 24.4142 4.58579C24.0391 4.21071 23.5304 4 23 4ZM23 26.1963L16.5287 22.1525C16.3698 22.0532 16.1862 22.0005 15.9987 22.0005C15.8113 22.0005 15.6277 22.0532 15.4688 22.1525L9 26.1963V6H23V26.1963Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "calendar": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M26 4H23V3C23 2.73478 22.8946 2.48043 22.7071 2.29289C22.5196 2.10536 22.2652 2 22 2C21.7348 2 21.4804 2.10536 21.2929 2.29289C21.1054 2.48043 21 2.73478 21 3V4H11V3C11 2.73478 10.8946 2.48043 10.7071 2.29289C10.5196 2.10536 10.2652 2 10 2C9.73478 2 9.48043 2.10536 9.29289 2.29289C9.10536 2.48043 9 2.73478 9 3V4H6C5.46957 4 4.96086 4.21071 4.58579 4.58579C4.21071 4.96086 4 5.46957 4 6V26C4 26.5304 4.21071 27.0391 4.58579 27.4142C4.96086 27.7893 5.46957 28 6 28H26C26.5304 28 27.0391 27.7893 27.4142 27.4142C27.7893 27.0391 28 26.5304 28 26V6C28 5.46957 27.7893 4.96086 27.4142 4.58579C27.0391 4.21071 26.5304 4 26 4ZM9 6V7C9 7.26522 9.10536 7.51957 9.29289 7.70711C9.48043 7.89464 9.73478 8 10 8C10.2652 8 10.5196 7.89464 10.7071 7.70711C10.8946 7.51957 11 7.26522 11 7V6H21V7C21 7.26522 21.1054 7.51957 21.2929 7.70711C21.4804 7.89464 21.7348 8 22 8C22.2652 8 22.5196 7.89464 22.7071 7.70711C22.8946 7.51957 23 7.26522 23 7V6H26V10H6V6H9ZM26 26H6V12H26V26Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2103,6 +4397,10 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M26 4H23V3C23 2.73478 22.8946 2.48043 22.7071 2.29289C22.5196 2.10536 22.2652 2 22 2C21.7348 2 21.4804 2.10536 21.2929 2.29289C21.1054 2.48043 21 2.73478 21 3V4H11V3C11 2.73478 10.8946 2.48043 10.7071 2.29289C10.5196 2.10536 10.2652 2 10 2C9.73478 2 9.48043 2.10536 9.29289 2.29289C9.10536 2.48043 9 2.73478 9 3V4H6C5.46957 4 4.96086 4.21071 4.58579 4.58579C4.21071 4.96086 4 5.46957 4 6V26C4 26.5304 4.21071 27.0391 4.58579 27.4142C4.96086 27.7893 5.46957 28 6 28H26C26.5304 28 27.0391 27.7893 27.4142 27.4142C27.7893 27.0391 28 26.5304 28 26V6C28 5.46957 27.7893 4.96086 27.4142 4.58579C27.0391 4.21071 26.5304 4 26 4ZM9 6V7C9 7.26522 9.10536 7.51957 9.29289 7.70711C9.48043 7.89464 9.73478 8 10 8C10.2652 8 10.5196 7.89464 10.7071 7.70711C10.8946 7.51957 11 7.26522 11 7V6H21V7C21 7.26522 21.1054 7.51957 21.2929 7.70711C21.4804 7.89464 21.7348 8 22 8C22.2652 8 22.5196 7.89464 22.7071 7.70711C22.8946 7.51957 23 7.26522 23 7V6H26V10H6V6H9ZM26 26H6V12H26V26ZM19.7075 16.7075L17.4137 19L19.7075 21.2925C19.8004 21.3854 19.8741 21.4957 19.9244 21.6171C19.9747 21.7385 20.0006 21.8686 20.0006 22C20.0006 22.1314 19.9747 22.2615 19.9244 22.3829C19.8741 22.5043 19.8004 22.6146 19.7075 22.7075C19.6146 22.8004 19.5043 22.8741 19.3829 22.9244C19.2615 22.9747 19.1314 23.0006 19 23.0006C18.8686 23.0006 18.7385 22.9747 18.6171 22.9244C18.4957 22.8741 18.3854 22.8004 18.2925 22.7075L16 20.4137L13.7075 22.7075C13.6146 22.8004 13.5043 22.8741 13.3829 22.9244C13.2615 22.9747 13.1314 23.0006 13 23.0006C12.8686 23.0006 12.7385 22.9747 12.6171 22.9244C12.4957 22.8741 12.3854 22.8004 12.2925 22.7075C12.1996 22.6146 12.1259 22.5043 12.0756 22.3829C12.0253 22.2615 11.9994 22.1314 11.9994 22C11.9994 21.8686 12.0253 21.7385 12.0756 21.6171C12.1259 21.4957 12.1996 21.3854 12.2925 21.2925L14.5863 19L12.2925 16.7075C12.1049 16.5199 11.9994 16.2654 11.9994 16C11.9994 15.7346 12.1049 15.4801 12.2925 15.2925C12.4801 15.1049 12.7346 14.9994 13 14.9994C13.2654 14.9994 13.5199 15.1049 13.7075 15.2925L16 17.5863L18.2925 15.2925C18.3854 15.1996 18.4957 15.1259 18.6171 15.0756C18.7385 15.0253 18.8686 14.9994 19 14.9994C19.1314 14.9994 19.2615 15.0253 19.3829 15.0756C19.5043 15.1259 19.6146 15.1996 19.7075 15.2925C19.8004 15.3854 19.8741 15.4957 19.9244 15.6171C19.9747 15.7385 20.0006 15.8686 20.0006 16C20.0006 16.1314 19.9747 16.2615 19.9244 16.3829C19.8741 16.5043 19.8004 16.6146 19.7075 16.7075Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "camera": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M26 7H22.535L20.8312 4.445C20.74 4.30819 20.6164 4.196 20.4714 4.11838C20.3264 4.04076 20.1645 4.0001 20 4H12C11.8355 4.0001 11.6736 4.04076 11.5286 4.11838C11.3836 4.196 11.26 4.30819 11.1687 4.445L9.46375 7H6C5.20435 7 4.44129 7.31607 3.87868 7.87868C3.31607 8.44129 3 9.20435 3 10V24C3 24.7956 3.31607 25.5587 3.87868 26.1213C4.44129 26.6839 5.20435 27 6 27H26C26.7956 27 27.5587 26.6839 28.1213 26.1213C28.6839 25.5587 29 24.7956 29 24V10C29 9.20435 28.6839 8.44129 28.1213 7.87868C27.5587 7.31607 26.7956 7 26 7ZM27 24C27 24.2652 26.8946 24.5196 26.7071 24.7071C26.5196 24.8946 26.2652 25 26 25H6C5.73478 25 5.48043 24.8946 5.29289 24.7071C5.10536 24.5196 5 24.2652 5 24V10C5 9.73478 5.10536 9.48043 5.29289 9.29289C5.48043 9.10536 5.73478 9 6 9H10C10.1647 9.00011 10.3268 8.95954 10.4721 8.88191C10.6173 8.80428 10.7411 8.69199 10.8325 8.555L12.535 6H19.4638L21.1675 8.555C21.2589 8.69199 21.3827 8.80428 21.5279 8.88191C21.6732 8.95954 21.8353 9.00011 22 9H26C26.2652 9 26.5196 9.10536 26.7071 9.29289C26.8946 9.48043 27 9.73478 27 10V24ZM16 11C14.9122 11 13.8488 11.3226 12.9444 11.9269C12.0399 12.5313 11.3349 13.3902 10.9187 14.3952C10.5024 15.4002 10.3935 16.5061 10.6057 17.573C10.8179 18.6399 11.3417 19.6199 12.1109 20.3891C12.8801 21.1583 13.8601 21.6821 14.927 21.8943C15.9939 22.1065 17.0998 21.9976 18.1048 21.5813C19.1098 21.1651 19.9687 20.4601 20.5731 19.5556C21.1774 18.6512 21.5 17.5878 21.5 16.5C21.4983 15.0418 20.9184 13.6438 19.8873 12.6127C18.8562 11.5816 17.4582 11.0017 16 11ZM16 20C15.3078 20 14.6311 19.7947 14.0555 19.4101C13.4799 19.0256 13.0313 18.4789 12.7664 17.8394C12.5015 17.1999 12.4322 16.4961 12.5673 15.8172C12.7023 15.1383 13.0356 14.5146 13.5251 14.0251C14.0146 13.5356 14.6383 13.2023 15.3172 13.0673C15.9961 12.9322 16.6999 13.0015 17.3394 13.2664C17.9789 13.5313 18.5256 13.9799 18.9101 14.5555C19.2947 15.1311 19.5 15.8078 19.5 16.5C19.5 17.4283 19.1313 18.3185 18.4749 18.9749C17.8185 19.6313 16.9283 20 16 20Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "car": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M30 13H28.65L25.1775 5.1875C25.0204 4.83403 24.7641 4.53372 24.4397 4.32296C24.1153 4.11219 23.7368 4 23.35 4H8.65C8.26317 4 7.88465 4.11219 7.56029 4.32296C7.23593 4.53372 6.97965 4.83403 6.8225 5.1875L3.35 13H2C1.73478 13 1.48043 13.1054 1.29289 13.2929C1.10536 13.4804 1 13.7348 1 14C1 14.2652 1.10536 14.5196 1.29289 14.7071C1.48043 14.8946 1.73478 15 2 15H3V25C3 25.5304 3.21071 26.0391 3.58579 26.4142C3.96086 26.7893 4.46957 27 5 27H8C8.53043 27 9.03914 26.7893 9.41421 26.4142C9.78929 26.0391 10 25.5304 10 25V23H22V25C22 25.5304 22.2107 26.0391 22.5858 26.4142C22.9609 26.7893 23.4696 27 24 27H27C27.5304 27 28.0391 26.7893 28.4142 26.4142C28.7893 26.0391 29 25.5304 29 25V15H30C30.2652 15 30.5196 14.8946 30.7071 14.7071C30.8946 14.5196 31 14.2652 31 14C31 13.7348 30.8946 13.4804 30.7071 13.2929C30.5196 13.1054 30.2652 13 30 13ZM8.65 6H23.35L26.4613 13H5.53875L8.65 6ZM8 25H5V23H8V25ZM24 25V23H27V25H24ZM27 21H5V15H27V21ZM7 18C7 17.7348 7.10536 17.4804 7.29289 17.2929C7.48043 17.1054 7.73478 17 8 17H10C10.2652 17 10.5196 17.1054 10.7071 17.2929C10.8946 17.4804 11 17.7348 11 18C11 18.2652 10.8946 18.5196 10.7071 18.7071C10.5196 18.8946 10.2652 19 10 19H8C7.73478 19 7.48043 18.8946 7.29289 18.7071C7.10536 18.5196 7 18.2652 7 18ZM21 18C21 17.7348 21.1054 17.4804 21.2929 17.2929C21.4804 17.1054 21.7348 17 22 17H24C24.2652 17 24.5196 17.1054 24.7071 17.2929C24.8946 17.4804 25 17.7348 25 18C25 18.2652 24.8946 18.5196 24.7071 18.7071C24.5196 18.8946 24.2652 19 24 19H22C21.7348 19 21.4804 18.8946 21.2929 18.7071C21.1054 18.5196 21 18.2652 21 18Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2123,6 +4421,18 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M26.7075 20.7076C26.6146 20.8005 26.5043 20.8743 26.3829 20.9246C26.2615 20.9749 26.1314 21.0008 26 21.0008C25.8686 21.0008 25.7385 20.9749 25.6171 20.9246C25.4957 20.8743 25.3854 20.8005 25.2925 20.7076L16 11.4138L6.70751 20.7076C6.51987 20.8952 6.26537 21.0006 6.00001 21.0006C5.73464 21.0006 5.48015 20.8952 5.29251 20.7076C5.10487 20.5199 4.99945 20.2654 4.99945 20.0001C4.99945 19.7347 5.10487 19.4802 5.29251 19.2926L15.2925 9.29255C15.3854 9.19958 15.4957 9.12582 15.6171 9.07549C15.7385 9.02517 15.8686 8.99927 16 8.99927C16.1314 8.99927 16.2615 9.02517 16.3829 9.07549C16.5043 9.12582 16.6146 9.19958 16.7075 9.29255L26.7075 19.2926C26.8005 19.3854 26.8742 19.4957 26.9246 19.6171C26.9749 19.7385 27.0008 19.8686 27.0008 20.0001C27.0008 20.1315 26.9749 20.2616 26.9246 20.383C26.8742 20.5044 26.8005 20.6147 26.7075 20.7076Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "chat_circle_dots": 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>",
@@ -2179,6 +4489,10 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M27 4H11C10.7348 4 10.4804 4.10536 10.2929 4.29289C10.1054 4.48043 10 4.73478 10 5V10H5C4.73478 10 4.48043 10.1054 4.29289 10.2929C4.10536 10.4804 4 10.7348 4 11V27C4 27.2652 4.10536 27.5196 4.29289 27.7071C4.48043 27.8946 4.73478 28 5 28H21C21.2652 28 21.5196 27.8946 21.7071 27.7071C21.8946 27.5196 22 27.2652 22 27V22H27C27.2652 22 27.5196 21.8946 27.7071 21.7071C27.8946 21.5196 28 21.2652 28 21V5C28 4.73478 27.8946 4.48043 27.7071 4.29289C27.5196 4.10536 27.2652 4 27 4ZM20 26H6V12H20V26ZM26 20H22V11C22 10.7348 21.8946 10.4804 21.7071 10.2929C21.5196 10.1054 21.2652 10 21 10H12V6H26V20Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "credit_card": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M28 6H4C3.46957 6 2.96086 6.21071 2.58579 6.58579C2.21071 6.96086 2 7.46957 2 8V24C2 24.5304 2.21071 25.0391 2.58579 25.4142C2.96086 25.7893 3.46957 26 4 26H28C28.5304 26 29.0391 25.7893 29.4142 25.4142C29.7893 25.0391 30 24.5304 30 24V8C30 7.46957 29.7893 6.96086 29.4142 6.58579C29.0391 6.21071 28.5304 6 28 6ZM28 8V11H4V8H28ZM28 24H4V13H28V24ZM26 21C26 21.2652 25.8946 21.5196 25.7071 21.7071C25.5196 21.8946 25.2652 22 25 22H21C20.7348 22 20.4804 21.8946 20.2929 21.7071C20.1054 21.5196 20 21.2652 20 21C20 20.7348 20.1054 20.4804 20.2929 20.2929C20.4804 20.1054 20.7348 20 21 20H25C25.2652 20 25.5196 20.1054 25.7071 20.2929C25.8946 20.4804 26 20.7348 26 21ZM18 21C18 21.2652 17.8946 21.5196 17.7071 21.7071C17.5196 21.8946 17.2652 22 17 22H15C14.7348 22 14.4804 21.8946 14.2929 21.7071C14.1054 21.5196 14 21.2652 14 21C14 20.7348 14.1054 20.4804 14.2929 20.2929C14.4804 20.1054 14.7348 20 15 20H17C17.2652 20 17.5196 20.1054 17.7071 20.2929C17.8946 20.4804 18 20.7348 18 21Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "crown": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M30.9999 9.99999C31.0004 9.45181 30.8721 8.91119 30.6254 8.42167C30.3787 7.93215 30.0204 7.50743 29.5795 7.18172C29.1386 6.85601 28.6273 6.63843 28.0869 6.5465C27.5465 6.45457 26.992 6.49086 26.4682 6.65246C25.9444 6.81405 25.4658 7.09643 25.0711 7.47683C24.6764 7.85724 24.3766 8.32504 24.1958 8.84254C24.015 9.36004 23.9583 9.91278 24.0302 10.4562C24.1021 10.9997 24.3007 11.5186 24.6099 11.9712L21.2612 16.0962L18.2499 9.17499C18.7991 8.71277 19.1929 8.09285 19.3779 7.39928C19.563 6.70571 19.5302 5.97202 19.2842 5.29767C19.0382 4.62332 18.5908 4.04092 18.0026 3.62941C17.4145 3.2179 16.714 2.99719 15.9962 2.99719C15.2784 2.99719 14.5779 3.2179 13.9897 3.62941C13.4016 4.04092 12.9542 4.62332 12.7082 5.29767C12.4621 5.97202 12.4294 6.70571 12.6144 7.39928C12.7994 8.09285 13.1932 8.71277 13.7424 9.17499L10.7387 16.0925L7.38994 11.9675C7.82011 11.3372 8.0325 10.5835 7.99474 9.82135C7.95699 9.05917 7.67116 8.3302 7.18079 7.74549C6.69043 7.16077 6.0224 6.75234 5.27844 6.5824C4.53448 6.41246 3.75537 6.49033 3.05976 6.80414C2.36415 7.11795 1.79016 7.6505 1.42521 8.3207C1.06026 8.9909 0.924354 9.76201 1.03818 10.5166C1.15201 11.2712 1.50935 11.9679 2.05576 12.5006C2.60217 13.0333 3.30771 13.3728 4.06494 13.4675L5.87494 24.3287C5.95275 24.7957 6.19367 25.2199 6.55485 25.5259C6.91603 25.8319 7.37405 25.9999 7.84744 26H24.1524C24.6258 25.9999 25.0838 25.8319 25.445 25.5259C25.8062 25.2199 26.0471 24.7957 26.1249 24.3287L27.9337 13.4725C28.7802 13.3668 29.5589 12.9556 30.1235 12.3161C30.6881 11.6767 30.9998 10.853 30.9999 9.99999ZM15.9999 4.99999C16.2966 4.99999 16.5866 5.08797 16.8333 5.25279C17.08 5.41761 17.2722 5.65188 17.3858 5.92597C17.4993 6.20006 17.529 6.50166 17.4711 6.79263C17.4132 7.0836 17.2704 7.35087 17.0606 7.56065C16.8508 7.77043 16.5835 7.91329 16.2926 7.97117C16.0016 8.02905 15.7 7.99934 15.4259 7.88581C15.1518 7.77228 14.9176 7.58002 14.7527 7.33335C14.5879 7.08667 14.4999 6.79666 14.4999 6.49999C14.4999 6.10217 14.658 5.72064 14.9393 5.43933C15.2206 5.15803 15.6021 4.99999 15.9999 4.99999ZM2.99994 9.99999C2.99994 9.70332 3.08791 9.41331 3.25273 9.16664C3.41756 8.91996 3.65182 8.7277 3.92591 8.61417C4.2 8.50064 4.5016 8.47094 4.79257 8.52881C5.08355 8.58669 5.35082 8.72955 5.5606 8.93933C5.77038 9.14911 5.91324 9.41638 5.97112 9.70736C6.02899 9.99833 5.99929 10.2999 5.88576 10.574C5.77223 10.8481 5.57997 11.0824 5.33329 11.2472C5.08662 11.412 4.79661 11.5 4.49994 11.5C4.10211 11.5 3.72058 11.342 3.43928 11.0607C3.15797 10.7793 2.99994 10.3978 2.99994 9.99999ZM24.1524 24H7.84744L6.10744 13.565L10.2237 18.625C10.3169 18.7414 10.435 18.8356 10.5693 18.9004C10.7036 18.9653 10.8508 18.9993 10.9999 19C11.0451 19.0002 11.0902 18.9973 11.1349 18.9912C11.3053 18.9681 11.4668 18.9014 11.6039 18.7976C11.741 18.6938 11.8489 18.5564 11.9174 18.3987L15.5799 9.97374C15.8588 10.0087 16.141 10.0087 16.4199 9.97374L20.0824 18.3987C20.1509 18.5564 20.2589 18.6938 20.396 18.7976C20.5331 18.9014 20.6946 18.9681 20.8649 18.9912C20.9097 18.9973 20.9548 19.0002 20.9999 19C21.1491 18.9993 21.2962 18.9653 21.4305 18.9004C21.5649 18.8356 21.683 18.7414 21.7762 18.625L25.8924 13.56L24.1524 24ZM27.4999 11.5C27.2033 11.5 26.9133 11.412 26.6666 11.2472C26.4199 11.0824 26.2277 10.8481 26.1141 10.574C26.0006 10.2999 25.9709 9.99833 26.0288 9.70736C26.0866 9.41638 26.2295 9.14911 26.4393 8.93933C26.6491 8.72955 26.9163 8.58669 27.2073 8.52881C27.4983 8.47094 27.7999 8.50064 28.074 8.61417C28.3481 8.7277 28.5823 8.91996 28.7471 9.16664C28.912 9.41331 28.9999 9.70332 28.9999 9.99999C28.9999 10.3978 28.8419 10.7793 28.5606 11.0607C28.2793 11.342 27.8978 11.5 27.4999 11.5Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2203,6 +4517,10 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M28.4138 9.17122L22.8288 3.58497C22.643 3.39921 22.4225 3.25185 22.1799 3.15131C21.9372 3.05077 21.6771 2.99902 21.4144 2.99902C21.1517 2.99902 20.8916 3.05077 20.6489 3.15131C20.4062 3.25185 20.1857 3.39921 20 3.58497L4.58626 19C4.39973 19.185 4.25185 19.4053 4.15121 19.648C4.05057 19.8907 3.99917 20.151 4.00001 20.4137V26C4.00001 26.5304 4.21072 27.0391 4.5858 27.4142C4.96087 27.7893 5.46958 28 6.00001 28H11.5863C11.849 28.0008 12.1093 27.9494 12.352 27.8488C12.5947 27.7481 12.815 27.6002 13 27.4137L28.4138 12C28.5995 11.8142 28.7469 11.5937 28.8474 11.3511C28.948 11.1084 28.9997 10.8483 28.9997 10.5856C28.9997 10.3229 28.948 10.0628 28.8474 9.82012C28.7469 9.57744 28.5995 9.35695 28.4138 9.17122ZM11.5863 26H6.00001V20.4137L17 9.41372L22.5863 15L11.5863 26ZM24 13.585L18.4138 7.99997L21.4138 4.99997L27 10.585L24 13.585Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "envelope_simple": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M28 6H4C3.73478 6 3.48043 6.10536 3.29289 6.29289C3.10536 6.48043 3 6.73478 3 7V24C3 24.5304 3.21071 25.0391 3.58579 25.4142C3.96086 25.7893 4.46957 26 5 26H27C27.5304 26 28.0391 25.7893 28.4142 25.4142C28.7893 25.0391 29 24.5304 29 24V7C29 6.73478 28.8946 6.48043 28.7071 6.29289C28.5196 6.10536 28.2652 6 28 6ZM25.4287 8L16 16.6437L6.57125 8H25.4287ZM27 24H5V9.27375L15.3237 18.7375C15.5082 18.9069 15.7496 19.0008 16 19.0008C16.2504 19.0008 16.4918 18.9069 16.6763 18.7375L27 9.27375V24Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "eye": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M30.9137 15.595C30.87 15.4963 29.8112 13.1475 27.4575 10.7937C24.3212 7.6575 20.36 6 16 6C11.64 6 7.67874 7.6575 4.54249 10.7937C2.18874 13.1475 1.12499 15.5 1.08624 15.595C1.02938 15.7229 1 15.8613 1 16.0012C1 16.1412 1.02938 16.2796 1.08624 16.4075C1.12999 16.5062 2.18874 18.8538 4.54249 21.2075C7.67874 24.3425 11.64 26 16 26C20.36 26 24.3212 24.3425 27.4575 21.2075C29.8112 18.8538 30.87 16.5062 30.9137 16.4075C30.9706 16.2796 31 16.1412 31 16.0012C31 15.8613 30.9706 15.7229 30.9137 15.595ZM16 24C12.1525 24 8.79124 22.6012 6.00874 19.8438C4.86704 18.7084 3.89572 17.4137 3.12499 16C3.89551 14.5862 4.86686 13.2915 6.00874 12.1562C8.79124 9.39875 12.1525 8 16 8C19.8475 8 23.2087 9.39875 25.9912 12.1562C27.1352 13.2912 28.1086 14.5859 28.8812 16C27.98 17.6825 24.0537 24 16 24ZM16 10C14.8133 10 13.6533 10.3519 12.6666 11.0112C11.6799 11.6705 10.9108 12.6075 10.4567 13.7039C10.0026 14.8003 9.88377 16.0067 10.1153 17.1705C10.3468 18.3344 10.9182 19.4035 11.7573 20.2426C12.5965 21.0818 13.6656 21.6532 14.8294 21.8847C15.9933 22.1162 17.1997 21.9974 18.2961 21.5433C19.3924 21.0892 20.3295 20.3201 20.9888 19.3334C21.6481 18.3467 22 17.1867 22 16C21.9983 14.4092 21.3657 12.884 20.2408 11.7592C19.1159 10.6343 17.5908 10.0017 16 10ZM16 20C15.2089 20 14.4355 19.7654 13.7777 19.3259C13.1199 18.8864 12.6072 18.2616 12.3045 17.5307C12.0017 16.7998 11.9225 15.9956 12.0768 15.2196C12.2312 14.4437 12.6122 13.731 13.1716 13.1716C13.731 12.6122 14.4437 12.2312 15.2196 12.0769C15.9956 11.9225 16.7998 12.0017 17.5307 12.3045C18.2616 12.6072 18.8863 13.1199 19.3259 13.7777C19.7654 14.4355 20 15.2089 20 16C20 17.0609 19.5786 18.0783 18.8284 18.8284C18.0783 19.5786 17.0609 20 16 20Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2211,10 +4529,22 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M6.73999 4.32752C6.65217 4.22853 6.54558 4.14795 6.42639 4.09046C6.3072 4.03297 6.17778 3.9997 6.04564 3.99259C5.91351 3.98549 5.78127 4.00467 5.6566 4.04905C5.53193 4.09342 5.41731 4.1621 5.31938 4.2511C5.22144 4.3401 5.14215 4.44765 5.08609 4.56752C5.03003 4.68739 4.99832 4.81719 4.9928 4.94941C4.98727 5.08162 5.00804 5.21362 5.05391 5.33775C5.09978 5.46187 5.16982 5.57567 5.25999 5.67252L7.66499 8.31877C3.12499 11.105 1.17249 15.4 1.08624 15.595C1.02938 15.7229 1 15.8613 1 16.0013C1 16.1412 1.02938 16.2796 1.08624 16.4075C1.12999 16.5063 2.18874 18.8538 4.54249 21.2075C7.67874 24.3425 11.64 26 16 26C18.2408 26.0128 20.4589 25.5514 22.5087 24.6463L25.2587 27.6725C25.3466 27.7715 25.4531 27.8521 25.5723 27.9096C25.6915 27.9671 25.8209 28.0003 25.9531 28.0075C26.0852 28.0146 26.2175 27.9954 26.3421 27.951C26.4668 27.9066 26.5814 27.8379 26.6793 27.7489C26.7773 27.66 26.8566 27.5524 26.9126 27.4325C26.9687 27.3127 27.0004 27.1829 27.0059 27.0506C27.0115 26.9184 26.9907 26.7864 26.9448 26.6623C26.899 26.5382 26.8289 26.4244 26.7387 26.3275L6.73999 4.32752ZM12.6562 13.8075L17.865 19.5388C17.0806 19.9514 16.1814 20.0919 15.3085 19.9381C14.4357 19.7843 13.6386 19.3449 13.0425 18.689C12.4464 18.0331 12.085 17.1978 12.0151 16.3143C11.9452 15.4308 12.1707 14.549 12.6562 13.8075ZM16 24C12.1525 24 8.79124 22.6013 6.00874 19.8438C4.86663 18.7087 3.89526 17.414 3.12499 16C3.71124 14.9013 5.58249 11.8263 9.04374 9.82752L11.2937 12.2963C10.4227 13.4119 9.97403 14.7996 10.0272 16.214C10.0803 17.6284 10.6317 18.9785 11.584 20.0257C12.5363 21.0728 13.8282 21.7496 15.2312 21.9363C16.6343 22.1231 18.0582 21.8078 19.2512 21.0463L21.0925 23.0713C19.4675 23.6947 17.7405 24.0097 16 24ZM16.75 12.0713C16.4894 12.0215 16.2593 11.8703 16.1102 11.6509C15.9611 11.4315 15.9053 11.1618 15.955 10.9013C16.0047 10.6407 16.1559 10.4105 16.3753 10.2615C16.5948 10.1124 16.8644 10.0565 17.125 10.1063C18.3995 10.3534 19.56 11.0058 20.4333 11.9664C21.3067 12.9269 21.8462 14.1441 21.9712 15.4363C21.9959 15.7003 21.9147 15.9634 21.7455 16.1676C21.5762 16.3717 21.3328 16.5003 21.0687 16.525C21.0375 16.5269 21.0062 16.5269 20.975 16.525C20.725 16.5261 20.4838 16.4335 20.2987 16.2656C20.1136 16.0976 19.9981 15.8664 19.975 15.6175C19.8908 14.758 19.5315 13.9486 18.9504 13.3097C18.3694 12.6708 17.5977 12.2364 16.75 12.0713ZM30.91 16.4075C30.8575 16.525 29.5912 19.3288 26.74 21.8825C26.6426 21.9726 26.5282 22.0423 26.4036 22.0877C26.2789 22.1331 26.1465 22.1533 26.014 22.147C25.8814 22.1407 25.7515 22.1082 25.6317 22.0512C25.5119 21.9942 25.4047 21.9139 25.3162 21.8151C25.2277 21.7162 25.1598 21.6008 25.1163 21.4754C25.0729 21.3501 25.0549 21.2173 25.0633 21.0849C25.0716 20.9525 25.1063 20.8231 25.1652 20.7043C25.2241 20.5854 25.306 20.4794 25.4062 20.3925C26.8051 19.1358 27.9801 17.6505 28.8812 16C28.1093 14.5847 27.1358 13.2891 25.9912 12.1538C23.2087 9.39877 19.8475 8.00002 16 8.00002C15.1893 7.99903 14.3799 8.06467 13.58 8.19627C13.4499 8.21928 13.3166 8.21628 13.1876 8.18745C13.0587 8.15863 12.9368 8.10454 12.8289 8.02833C12.721 7.95211 12.6293 7.85527 12.559 7.7434C12.4887 7.63153 12.4413 7.50685 12.4196 7.37656C12.3978 7.24627 12.402 7.11295 12.432 6.9843C12.462 6.85566 12.5172 6.73424 12.5945 6.62705C12.6717 6.51986 12.7694 6.42904 12.8819 6.35982C12.9944 6.2906 13.1195 6.24436 13.25 6.22377C14.1589 6.07369 15.0787 5.99885 16 6.00002C20.36 6.00002 24.3212 7.65752 27.4575 10.7938C29.8112 13.1475 30.87 15.4963 30.9137 15.595C30.9706 15.7229 31 15.8613 31 16.0013C31 16.1412 30.9706 16.2796 30.9137 16.4075H30.91Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "file": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M26.7075 10.2925L19.7075 3.2925C19.6146 3.19967 19.5042 3.12605 19.3829 3.07586C19.2615 3.02568 19.1314 2.9999 19 3H7C6.46957 3 5.96086 3.21071 5.58579 3.58579C5.21071 3.96086 5 4.46957 5 5V27C5 27.5304 5.21071 28.0391 5.58579 28.4142C5.96086 28.7893 6.46957 29 7 29H25C25.5304 29 26.0391 28.7893 26.4142 28.4142C26.7893 28.0391 27 27.5304 27 27V11C27.0001 10.8686 26.9743 10.7385 26.9241 10.6172C26.8739 10.4958 26.8003 10.3854 26.7075 10.2925ZM20 6.41375L23.5863 10H20V6.41375ZM25 27H7V5H18V11C18 11.2652 18.1054 11.5196 18.2929 11.7071C18.4804 11.8946 18.7348 12 19 12H25V27Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "fire_fill": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M17.9225 2.23129C17.7992 2.1288 17.6531 2.05745 17.4965 2.02326C17.3399 1.98906 17.1773 1.99303 17.0225 2.03481C16.8678 2.0766 16.7253 2.15499 16.6072 2.26337C16.489 2.37174 16.3987 2.50693 16.3438 2.65754L13.5938 10.2088L10.5737 7.28254C10.4723 7.18417 10.3512 7.10841 10.2184 7.06025C10.0856 7.01209 9.94403 6.99263 9.80313 7.00314C9.66223 7.01365 9.52516 7.0539 9.40095 7.12123C9.27674 7.18857 9.1682 7.28146 9.0825 7.39379C6.375 10.9413 5 14.51 5 18C5 20.9174 6.15893 23.7153 8.22183 25.7782C10.2847 27.8411 13.0826 29 16 29C18.9174 29 21.7153 27.8411 23.7782 25.7782C25.8411 23.7153 27 20.9174 27 18C27 10.5688 20.6513 4.50004 17.9225 2.23129ZM22.9862 19.1675C22.7269 20.6159 22.0301 21.9501 20.9896 22.9904C19.949 24.0308 18.6147 24.7273 17.1663 24.9863C17.1113 24.9957 17.0557 25.0003 17 25C16.7492 25 16.5075 24.9056 16.323 24.7357C16.1384 24.5659 16.0245 24.3328 16.0037 24.0828C15.9829 23.8328 16.0569 23.5842 16.2108 23.3862C16.3648 23.1882 16.5876 23.0552 16.835 23.0138C18.9062 22.665 20.6637 20.9075 21.015 18.8325C21.0594 18.571 21.2059 18.3378 21.4223 18.1842C21.6387 18.0307 21.9072 17.9694 22.1688 18.0138C22.4303 18.0582 22.6635 18.2047 22.8171 18.4211C22.9706 18.6375 23.0319 18.906 22.9875 19.1675H22.9862Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "folder": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M27 9.00001H16.4137L13 5.58626C12.815 5.39973 12.5947 5.25185 12.352 5.15121C12.1093 5.05057 11.849 4.99917 11.5863 5.00001H5C4.46957 5.00001 3.96086 5.21072 3.58579 5.5858C3.21071 5.96087 3 6.46958 3 7.00001V25.0775C3.00066 25.5872 3.20342 26.0758 3.56382 26.4362C3.92421 26.7966 4.41282 26.9993 4.9225 27H27.1112C27.612 26.9993 28.092 26.8001 28.4461 26.4461C28.8001 26.092 28.9993 25.612 29 25.1113V11C29 10.4696 28.7893 9.96087 28.4142 9.5858C28.0391 9.21072 27.5304 9.00001 27 9.00001ZM5 7.00001H11.5863L13.5863 9.00001H5V7.00001ZM27 25H5V11H27V25Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "funnel": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M28.825 6.19122C28.6711 5.83561 28.416 5.53309 28.0915 5.32129C27.767 5.10949 27.3875 4.99775 27 4.99997H4.99997C4.61288 5.00073 4.23433 5.11381 3.91025 5.32548C3.58616 5.53715 3.33047 5.83832 3.17418 6.19245C3.01789 6.54658 2.96772 6.93846 3.02977 7.32054C3.09181 7.70262 3.2634 8.05849 3.52372 8.34497L3.53372 8.35622L12 17.3962V27C11.9999 27.3619 12.098 27.7172 12.284 28.0277C12.4699 28.3383 12.7366 28.5926 13.0557 28.7635C13.3748 28.9344 13.7343 29.0155 14.0958 28.9981C14.4574 28.9808 14.8075 28.8656 15.1087 28.665L19.1087 25.9975C19.3829 25.8148 19.6078 25.5673 19.7632 25.2768C19.9187 24.9863 20 24.6619 20 24.3325V17.3962L28.4675 8.35622L28.4775 8.34497C28.7405 8.0598 28.9138 7.70346 28.9756 7.32043C29.0374 6.93741 28.985 6.54466 28.825 6.19122ZM18.2725 16.3225C18.0995 16.5059 18.0021 16.7479 18 17V24.3325L14 27V17C14 16.746 13.9035 16.5016 13.73 16.3162L4.99997 6.99997H27L18.2725 16.3225Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "game_controller": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M22 14H19C18.7348 14 18.4805 13.8946 18.2929 13.7071C18.1054 13.5196 18 13.2652 18 13C18 12.7348 18.1054 12.4804 18.2929 12.2929C18.4805 12.1054 18.7348 12 19 12H22C22.2653 12 22.5196 12.1054 22.7072 12.2929C22.8947 12.4804 23 12.7348 23 13C23 13.2652 22.8947 13.5196 22.7072 13.7071C22.5196 13.8946 22.2653 14 22 14ZM13 12H12V11C12 10.7348 11.8947 10.4804 11.7072 10.2929C11.5196 10.1054 11.2653 10 11 10C10.7348 10 10.4805 10.1054 10.2929 10.2929C10.1054 10.4804 10 10.7348 10 11V12H9.00004C8.73483 12 8.48047 12.1054 8.29294 12.2929C8.1054 12.4804 8.00004 12.7348 8.00004 13C8.00004 13.2652 8.1054 13.5196 8.29294 13.7071C8.48047 13.8946 8.73483 14 9.00004 14H10V15C10 15.2652 10.1054 15.5196 10.2929 15.7071C10.4805 15.8946 10.7348 16 11 16C11.2653 16 11.5196 15.8946 11.7072 15.7071C11.8947 15.5196 12 15.2652 12 15V14H13C13.2653 14 13.5196 13.8946 13.7072 13.7071C13.8947 13.5196 14 13.2652 14 13C14 12.7348 13.8947 12.4804 13.7072 12.2929C13.5196 12.1054 13.2653 12 13 12ZM30.185 25.0812C29.8082 25.6194 29.318 26.0686 28.749 26.3971C28.18 26.7256 27.546 26.9255 26.8915 26.9828C26.2369 27.0401 25.5778 26.9534 24.9604 26.7288C24.343 26.5041 23.7822 26.147 23.3175 25.6825C23.3025 25.6675 23.2875 25.6525 23.2738 25.6362L18.31 20H13.685L8.72629 25.6362L8.68254 25.6825C7.8378 26.5254 6.69341 26.9992 5.50004 27C4.84309 26.9998 4.19416 26.8557 3.59883 26.5779C3.00351 26.3001 2.47623 25.8953 2.05403 25.392C1.63183 24.8886 1.32496 24.299 1.15497 23.6644C0.984977 23.0298 0.955991 22.3657 1.07004 21.7188C1.06944 21.7129 1.06944 21.7071 1.07004 21.7013L3.11629 11.19C3.42083 9.45634 4.32662 7.88546 5.67449 6.75339C7.02236 5.62133 8.72609 5.0005 10.4863 5H21.5C23.2549 5.0028 24.9534 5.62008 26.3007 6.74466C27.6479 7.86924 28.5587 9.4301 28.875 11.1562C28.875 11.1638 28.875 11.1712 28.875 11.1788L30.9213 21.7C30.9219 21.7058 30.9219 21.7117 30.9213 21.7175C31.0272 22.299 31.0167 22.8958 30.8903 23.4732C30.7639 24.0506 30.5242 24.5971 30.185 25.0812ZM21.5 18C22.9587 18 24.3577 17.4205 25.3891 16.3891C26.4206 15.3576 27 13.9587 27 12.5C27 11.0413 26.4206 9.64236 25.3891 8.61091C24.3577 7.57946 22.9587 7 21.5 7H10.4863C9.19498 7.00116 7.94545 7.45767 6.95751 8.28922C5.96958 9.12076 5.30654 10.2741 5.08504 11.5463V11.5625L3.03754 22.0737C2.94704 22.5949 3.02415 23.1313 3.25777 23.6058C3.49139 24.0803 3.86949 24.4685 4.33769 24.7145C4.80589 24.9606 5.34006 25.0518 5.86338 24.9751C6.3867 24.8983 6.87219 24.6576 7.25004 24.2875L12.49 18.3388C12.5839 18.2323 12.6993 18.1471 12.8286 18.0886C12.9579 18.0302 13.0982 18 13.24 18H21.5ZM28.9625 22.0737L27.87 16.4487C27.1981 17.5337 26.2604 18.4293 25.1458 19.0508C24.0311 19.6722 22.7763 19.9989 21.5 20H20.975L24.75 24.2887C25.0347 24.5656 25.3809 24.771 25.7603 24.8881C26.1396 25.0052 26.5414 25.0307 26.9325 24.9625C27.5842 24.8475 28.1636 24.4788 28.5439 23.9374C28.9242 23.3959 29.0743 22.7257 28.9613 22.0737H28.9625Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2227,6 +4557,14 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M30 12.75C30 21.5 17.0262 28.5825 16.4737 28.875C16.3281 28.9533 16.1654 28.9943 16 28.9943C15.8346 28.9943 15.6719 28.9533 15.5262 28.875C14.9738 28.5825 2 21.5 2 12.75C2.00232 10.6953 2.81958 8.72539 4.27248 7.27248C5.72539 5.81958 7.69528 5.00232 9.75 5C12.3313 5 14.5912 6.11 16 7.98625C17.4088 6.11 19.6688 5 22.25 5C24.3047 5.00232 26.2746 5.81958 27.7275 7.27248C29.1804 8.72539 29.9977 10.6953 30 12.75Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "house": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M27.4138 13.585L17.4138 3.58496C17.0387 3.21017 16.5302 2.99963 16 2.99963C15.4698 2.99963 14.9613 3.21017 14.5863 3.58496L4.58626 13.585C4.39964 13.7702 4.25171 13.9907 4.15107 14.2336C4.05042 14.4765 3.99908 14.737 4.00001 15V27C4.00001 27.2652 4.10537 27.5195 4.29291 27.7071C4.48044 27.8946 4.7348 28 5.00001 28H13C13.2652 28 13.5196 27.8946 13.7071 27.7071C13.8947 27.5195 14 27.2652 14 27V20H18V27C18 27.2652 18.1054 27.5195 18.2929 27.7071C18.4804 27.8946 18.7348 28 19 28H27C27.2652 28 27.5196 27.8946 27.7071 27.7071C27.8947 27.5195 28 27.2652 28 27V15C28.0009 14.737 27.9496 14.4765 27.849 14.2336C27.7483 13.9907 27.6004 13.7702 27.4138 13.585ZM26 26H20V19C20 18.7347 19.8947 18.4804 19.7071 18.2928C19.5196 18.1053 19.2652 18 19 18H13C12.7348 18 12.4804 18.1053 12.2929 18.2928C12.1054 18.4804 12 18.7347 12 19V26H6.00001V15L16 4.99996L26 15V26Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "image": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M27 5H5C4.46957 5 3.96086 5.21071 3.58579 5.58579C3.21071 5.96086 3 6.46957 3 7V25C3 25.5304 3.21071 26.0391 3.58579 26.4142C3.96086 26.7893 4.46957 27 5 27H27C27.5304 27 28.0391 26.7893 28.4142 26.4142C28.7893 26.0391 29 25.5304 29 25V7C29 6.46957 28.7893 5.96086 28.4142 5.58579C28.0391 5.21071 27.5304 5 27 5ZM27 7V19.8438L23.7412 16.5863C23.5555 16.4005 23.335 16.2531 23.0923 16.1526C22.8497 16.052 22.5896 16.0003 22.3269 16.0003C22.0642 16.0003 21.8041 16.052 21.5614 16.1526C21.3187 16.2531 21.0982 16.4005 20.9125 16.5863L18.4125 19.0863L12.9125 13.5863C12.5375 13.2115 12.029 13.0009 11.4987 13.0009C10.9685 13.0009 10.46 13.2115 10.085 13.5863L5 18.6712V7H27ZM5 21.5L11.5 15L21.5 25H5V21.5ZM27 25H24.3288L19.8288 20.5L22.3288 18L27 22.6725V25ZM18 12.5C18 12.2033 18.088 11.9133 18.2528 11.6666C18.4176 11.42 18.6519 11.2277 18.926 11.1142C19.2001 11.0006 19.5017 10.9709 19.7926 11.0288C20.0836 11.0867 20.3509 11.2296 20.5607 11.4393C20.7704 11.6491 20.9133 11.9164 20.9712 12.2074C21.0291 12.4983 20.9993 12.7999 20.8858 13.074C20.7723 13.3481 20.58 13.5824 20.3334 13.7472C20.0867 13.912 19.7967 14 19.5 14C19.1022 14 18.7206 13.842 18.4393 13.5607C18.158 13.2794 18 12.8978 18 12.5Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "info": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M16 3C13.4288 3 10.9154 3.76244 8.77759 5.1909C6.63975 6.61935 4.97351 8.64968 3.98957 11.0251C3.00563 13.4006 2.74819 16.0144 3.2498 18.5362C3.75141 21.0579 4.98953 23.3743 6.80762 25.1924C8.6257 27.0105 10.9421 28.2486 13.4638 28.7502C15.9856 29.2518 18.5995 28.9944 20.9749 28.0104C23.3503 27.0265 25.3807 25.3603 26.8091 23.2224C28.2376 21.0846 29 18.5712 29 16C28.9964 12.5533 27.6256 9.24882 25.1884 6.81163C22.7512 4.37445 19.4467 3.00364 16 3ZM16 27C13.8244 27 11.6977 26.3549 9.88873 25.1462C8.07979 23.9375 6.66989 22.2195 5.83733 20.2095C5.00477 18.1995 4.78693 15.9878 5.21137 13.854C5.63581 11.7202 6.68345 9.7602 8.22183 8.22183C9.76021 6.68345 11.7202 5.6358 13.854 5.21136C15.9878 4.78692 18.1995 5.00476 20.2095 5.83733C22.2195 6.66989 23.9375 8.07979 25.1462 9.88873C26.3549 11.6977 27 13.8244 27 16C26.9967 18.9164 25.8367 21.7123 23.7745 23.7745C21.7123 25.8367 18.9164 26.9967 16 27ZM18 22C18 22.2652 17.8946 22.5196 17.7071 22.7071C17.5196 22.8946 17.2652 23 17 23C16.4696 23 15.9609 22.7893 15.5858 22.4142C15.2107 22.0391 15 21.5304 15 21V16C14.7348 16 14.4804 15.8946 14.2929 15.7071C14.1054 15.5196 14 15.2652 14 15C14 14.7348 14.1054 14.4804 14.2929 14.2929C14.4804 14.1054 14.7348 14 15 14C15.5304 14 16.0391 14.2107 16.4142 14.5858C16.7893 14.9609 17 15.4696 17 16V21C17.2652 21 17.5196 21.1054 17.7071 21.2929C17.8946 21.4804 18 21.7348 18 22ZM14 10.5C14 10.2033 14.088 9.91332 14.2528 9.66665C14.4176 9.41997 14.6519 9.22771 14.926 9.11418C15.2001 9.00065 15.5017 8.97094 15.7926 9.02882C16.0836 9.0867 16.3509 9.22956 16.5607 9.43934C16.7704 9.64912 16.9133 9.91639 16.9712 10.2074C17.0291 10.4983 16.9994 10.7999 16.8858 11.074C16.7723 11.3481 16.58 11.5824 16.3334 11.7472C16.0867 11.912 15.7967 12 15.5 12C15.1022 12 14.7206 11.842 14.4393 11.5607C14.158 11.2794 14 10.8978 14 10.5Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2243,6 +4581,18 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M29.25 10.015C28.9684 9.69591 28.6222 9.44037 28.2342 9.26537C27.8463 9.09037 27.4256 8.99991 27 9H20V7C20 5.67392 19.4732 4.40215 18.5355 3.46447C17.5979 2.52678 16.3261 2 15 2C14.8142 1.99987 14.6321 2.05149 14.474 2.14908C14.3159 2.24667 14.1881 2.38636 14.105 2.5525L9.3825 12H4C3.46957 12 2.96086 12.2107 2.58579 12.5858C2.21071 12.9609 2 13.4696 2 14V25C2 25.5304 2.21071 26.0391 2.58579 26.4142C2.96086 26.7893 3.46957 27 4 27H25.5C26.2309 27.0003 26.9367 26.7337 27.485 26.2503C28.0332 25.767 28.3861 25.1001 28.4775 24.375L29.9775 12.375C30.0307 11.9525 29.9933 11.5236 29.8679 11.1167C29.7424 10.7098 29.5318 10.3342 29.25 10.015ZM4 14H9V25H4V14ZM27.9925 12.125L26.4925 24.125C26.462 24.3667 26.3444 24.589 26.1617 24.7501C25.9789 24.9112 25.7436 25.0001 25.5 25H11V13.2362L15.5887 4.0575C16.2689 4.19362 16.8808 4.5612 17.3204 5.09768C17.76 5.63416 18.0002 6.3064 18 7V10C18 10.2652 18.1054 10.5196 18.2929 10.7071C18.4804 10.8946 18.7348 11 19 11H27C27.1419 11 27.2822 11.0301 27.4115 11.0885C27.5409 11.1468 27.6563 11.232 27.7502 11.3384C27.8441 11.4448 27.9143 11.57 27.956 11.7056C27.9978 11.8413 28.0102 11.9842 27.9925 12.125Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "link_simple": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M20.7074 11.2925C20.8003 11.3854 20.8741 11.4957 20.9244 11.6171C20.9748 11.7385 21.0007 11.8686 21.0007 12C21.0007 12.1314 20.9748 12.2616 20.9244 12.383C20.8741 12.5044 20.8003 12.6146 20.7074 12.7075L12.7074 20.7075C12.6145 20.8004 12.5042 20.8741 12.3828 20.9244C12.2614 20.9747 12.1313 21.0006 11.9999 21.0006C11.8685 21.0006 11.7384 20.9747 11.617 20.9244C11.4956 20.8741 11.3853 20.8004 11.2924 20.7075C11.1995 20.6146 11.1258 20.5043 11.0755 20.3829C11.0252 20.2615 10.9993 20.1314 10.9993 20C10.9993 19.8686 11.0252 19.7385 11.0755 19.6171C11.1258 19.4957 11.1995 19.3854 11.2924 19.2925L19.2924 11.2925C19.3852 11.1995 19.4955 11.1258 19.6169 11.0755C19.7383 11.0251 19.8685 10.9992 19.9999 10.9992C20.1313 10.9992 20.2614 11.0251 20.3828 11.0755C20.5042 11.1258 20.6145 11.1995 20.7074 11.2925ZM26.9499 5.05002C26.2999 4.39993 25.5281 3.88425 24.6788 3.53242C23.8295 3.1806 22.9192 2.99951 21.9999 2.99951C21.0806 2.99951 20.1702 3.1806 19.3209 3.53242C18.4716 3.88425 17.6999 4.39993 17.0499 5.05002L13.2924 8.80627C13.1047 8.99391 12.9993 9.2484 12.9993 9.51377C12.9993 9.77913 13.1047 10.0336 13.2924 10.2213C13.48 10.4089 13.7345 10.5143 13.9999 10.5143C14.2652 10.5143 14.5197 10.4089 14.7074 10.2213L18.4649 6.47127C19.406 5.55083 20.6721 5.03866 21.9885 5.04591C23.3048 5.05316 24.5652 5.57924 25.4962 6.50999C26.4271 7.44074 26.9534 8.70105 26.9608 10.0174C26.9683 11.3338 26.4564 12.6 25.5361 13.5413L21.7774 17.2988C21.5897 17.4862 21.4842 17.7406 21.4841 18.0058C21.484 18.2711 21.5893 18.5255 21.7767 18.7131C21.9642 18.9008 22.2186 19.0063 22.4838 19.0064C22.749 19.0065 23.0035 18.9012 23.1911 18.7138L26.9499 14.95C27.6 14.3 28.1156 13.5283 28.4675 12.679C28.8193 11.8296 29.0004 10.9193 29.0004 10C29.0004 9.0807 28.8193 8.17039 28.4675 7.32107C28.1156 6.47174 27.6 5.70004 26.9499 5.05002ZM17.2924 21.7775L13.5349 25.535C13.0725 26.0078 12.5209 26.3842 11.912 26.6423C11.3032 26.9004 10.6491 27.0352 9.98784 27.0389C9.32653 27.0425 8.67107 26.9149 8.05941 26.6635C7.44774 26.4121 6.89203 26.0418 6.42445 25.5742C5.95687 25.1065 5.58671 24.5507 5.3354 23.939C5.08409 23.3273 4.95662 22.6718 4.96038 22.0105C4.96414 21.3492 5.09905 20.6952 5.3573 20.0864C5.61555 19.4776 5.992 18.9261 6.46487 18.4638L10.2211 14.7075C10.4088 14.5199 10.5142 14.2654 10.5142 14C10.5142 13.7347 10.4088 13.4802 10.2211 13.2925C10.0335 13.1049 9.77898 12.9995 9.51362 12.9995C9.24825 12.9995 8.99376 13.1049 8.80612 13.2925L5.04987 17.05C3.73705 18.3628 2.99951 20.1434 2.99951 22C2.99951 23.8566 3.73705 25.6372 5.04987 26.95C6.36269 28.2628 8.14326 29.0004 9.99987 29.0004C11.8565 29.0004 13.637 28.2628 14.9499 26.95L18.7074 23.1913C18.8948 23.0036 19.0001 22.7492 19 22.4839C18.9999 22.2187 18.8944 21.9644 18.7067 21.7769C18.5191 21.5894 18.2647 21.4842 17.9994 21.4843C17.7342 21.4844 17.4798 21.5899 17.2924 21.7775Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "list": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M28 16C28 16.2652 27.8946 16.5196 27.7071 16.7071C27.5196 16.8946 27.2652 17 27 17H5C4.73478 17 4.48043 16.8946 4.29289 16.7071C4.10536 16.5196 4 16.2652 4 16C4 15.7348 4.10536 15.4804 4.29289 15.2929C4.48043 15.1054 4.73478 15 5 15H27C27.2652 15 27.5196 15.1054 27.7071 15.2929C27.8946 15.4804 28 15.7348 28 16ZM5 9H27C27.2652 9 27.5196 8.89464 27.7071 8.70711C27.8946 8.51957 28 8.26522 28 8C28 7.73478 27.8946 7.48043 27.7071 7.29289C27.5196 7.10536 27.2652 7 27 7H5C4.73478 7 4.48043 7.10536 4.29289 7.29289C4.10536 7.48043 4 7.73478 4 8C4 8.26522 4.10536 8.51957 4.29289 8.70711C4.48043 8.89464 4.73478 9 5 9ZM27 23H5C4.73478 23 4.48043 23.1054 4.29289 23.2929C4.10536 23.4804 4 23.7348 4 24C4 24.2652 4.10536 24.5196 4.29289 24.7071C4.48043 24.8946 4.73478 25 5 25H27C27.2652 25 27.5196 24.8946 27.7071 24.7071C27.8946 24.5196 28 24.2652 28 24C28 23.7348 27.8946 23.4804 27.7071 23.2929C27.5196 23.1054 27.2652 23 27 23Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "lock": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M26 10H22V7C22 5.4087 21.3679 3.88258 20.2426 2.75736C19.1174 1.63214 17.5913 1 16 1C14.4087 1 12.8826 1.63214 11.7574 2.75736C10.6321 3.88258 10 5.4087 10 7V10H6C5.46957 10 4.96086 10.2107 4.58579 10.5858C4.21071 10.9609 4 11.4696 4 12V26C4 26.5304 4.21071 27.0391 4.58579 27.4142C4.96086 27.7893 5.46957 28 6 28H26C26.5304 28 27.0391 27.7893 27.4142 27.4142C27.7893 27.0391 28 26.5304 28 26V12C28 11.4696 27.7893 10.9609 27.4142 10.5858C27.0391 10.2107 26.5304 10 26 10ZM12 7C12 5.93913 12.4214 4.92172 13.1716 4.17157C13.9217 3.42143 14.9391 3 16 3C17.0609 3 18.0783 3.42143 18.8284 4.17157C19.5786 4.92172 20 5.93913 20 7V10H12V7ZM26 26H6V12H26V26ZM17.5 19C17.5 19.2967 17.412 19.5867 17.2472 19.8334C17.0824 20.08 16.8481 20.2723 16.574 20.3858C16.2999 20.4993 15.9983 20.5291 15.7074 20.4712C15.4164 20.4133 15.1491 20.2704 14.9393 20.0607C14.7296 19.8509 14.5867 19.5836 14.5288 19.2926C14.4709 19.0017 14.5006 18.7001 14.6142 18.426C14.7277 18.1519 14.92 17.9176 15.1666 17.7528C15.4133 17.588 15.7033 17.5 16 17.5C16.3978 17.5 16.7794 17.658 17.0607 17.9393C17.342 18.2206 17.5 18.6022 17.5 19Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "magnifying_glass": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M28.7073 27.2925L22.4485 21.035C24.2626 18.8572 25.1672 16.0638 24.9741 13.236C24.781 10.4081 23.5052 7.76361 21.412 5.85251C19.3188 3.9414 16.5694 2.91086 13.7357 2.97526C10.902 3.03966 8.20225 4.19404 6.19802 6.19827C4.1938 8.20249 3.03941 10.9023 2.97501 13.7359C2.91061 16.5696 3.94116 19.319 5.85226 21.4122C7.76337 23.5054 10.4079 24.7813 13.2357 24.9743C16.0635 25.1674 18.8569 24.2628 21.0348 22.4488L27.2923 28.7075C27.3852 28.8005 27.4955 28.8742 27.6169 28.9244C27.7383 28.9747 27.8684 29.0006 27.9998 29.0006C28.1312 29.0006 28.2613 28.9747 28.3827 28.9244C28.5041 28.8742 28.6144 28.8005 28.7073 28.7075C28.8002 28.6146 28.8739 28.5043 28.9242 28.3829C28.9745 28.2615 29.0004 28.1314 29.0004 28C29.0004 27.8686 28.9745 27.7385 28.9242 27.6171C28.8739 27.4958 28.8002 27.3855 28.7073 27.2925ZM4.9998 14C4.9998 12.22 5.52764 10.48 6.51657 8.99991C7.5055 7.51987 8.91111 6.36631 10.5556 5.68513C12.2002 5.00394 14.0098 4.82571 15.7556 5.17297C17.5014 5.52024 19.1051 6.37741 20.3638 7.63608C21.6224 8.89475 22.4796 10.4984 22.8269 12.2442C23.1741 13.9901 22.9959 15.7997 22.3147 17.4442C21.6335 19.0887 20.48 20.4943 18.9999 21.4833C17.5199 22.4722 15.7798 23 13.9998 23C11.6137 22.9974 9.32601 22.0483 7.63876 20.3611C5.95151 18.6738 5.00244 16.3862 4.9998 14Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2267,6 +4617,10 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M26.2875 7.04246L16.2875 4.04246C16.1382 3.99765 15.9805 3.98836 15.827 4.01533C15.6734 4.0423 15.5283 4.1048 15.4032 4.19782C15.2782 4.29084 15.1766 4.41182 15.1065 4.55109C15.0365 4.69037 15 4.84408 15 4.99996V18.5325C13.9759 17.6165 12.6684 17.0797 11.2961 17.0119C9.92376 16.9441 8.56974 17.3494 7.46031 18.16C6.35089 18.9705 5.55329 20.1373 5.2008 21.4654C4.84832 22.7934 4.96231 24.2021 5.52373 25.4562C6.08514 26.7103 7.05997 27.7337 8.28528 28.3553C9.5106 28.977 10.9122 29.1593 12.2557 28.8717C13.5993 28.5842 14.8035 27.8442 15.667 26.7754C16.5305 25.7067 17.0011 24.374 17 23V12.3437L25.7125 14.9575C25.8618 15.0023 26.0195 15.0116 26.173 14.9846C26.3266 14.9576 26.4717 14.8951 26.5968 14.8021C26.7218 14.7091 26.8234 14.5881 26.8935 14.4488C26.9635 14.3096 27 14.1558 27 14V7.99996C26.9999 7.78498 26.9306 7.57574 26.8023 7.40326C26.6739 7.23079 26.4934 7.10427 26.2875 7.04246ZM11 27C10.2089 27 9.43552 26.7654 8.77772 26.3258C8.11992 25.8863 7.60723 25.2616 7.30448 24.5307C7.00173 23.7998 6.92252 22.9955 7.07686 22.2196C7.2312 21.4437 7.61216 20.7309 8.17157 20.1715C8.73098 19.6121 9.44372 19.2312 10.2196 19.0768C10.9956 18.9225 11.7998 19.0017 12.5307 19.3044C13.2616 19.6072 13.8864 20.1199 14.3259 20.7777C14.7654 21.4355 15 22.2088 15 23C15 24.0608 14.5786 25.0782 13.8284 25.8284C13.0783 26.5785 12.0609 27 11 27ZM25 12.6562L17 10.2562V6.34371L25 8.74996V12.6562Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "paperclip": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M26.2075 15.2925C26.3005 15.3854 26.3743 15.4957 26.4246 15.6171C26.4749 15.7385 26.5008 15.8686 26.5008 16C26.5008 16.1314 26.4749 16.2616 26.4246 16.383C26.3743 16.5044 26.3005 16.6146 26.2075 16.7075L15.9513 26.9575C14.6383 28.2703 12.8576 29.0078 11.0008 29.0077C9.14412 29.0076 7.36348 28.2699 6.05066 26.9569C4.73784 25.6439 4.00037 23.8632 4.00049 22.0065C4.00061 20.1497 4.7383 18.3691 6.05129 17.0563L18.4588 4.46627C19.3962 3.5279 20.6679 3.00034 21.9943 2.99963C23.3206 2.99893 24.5929 3.52515 25.5313 4.46252C26.4697 5.3999 26.9972 6.67164 26.9979 7.998C26.9986 9.32435 26.4724 10.5967 25.535 11.535L13.125 24.125C12.5615 24.6886 11.7971 25.0052 11 25.0052C10.203 25.0052 9.43862 24.6886 8.87504 24.125C8.31145 23.5614 7.99483 22.7971 7.99483 22C7.99483 21.203 8.31145 20.4386 8.87504 19.875L19.2875 9.29752C19.3787 9.20022 19.4885 9.12215 19.6103 9.06789C19.7322 9.01364 19.8636 8.98431 19.997 8.98163C20.1303 8.97895 20.2629 9.00296 20.3868 9.05227C20.5107 9.10157 20.6235 9.17516 20.7186 9.26872C20.8136 9.36227 20.889 9.47389 20.9403 9.59702C20.9915 9.72014 21.0177 9.85227 21.0171 9.98564C21.0165 10.119 20.9893 10.2509 20.937 10.3736C20.8847 10.4963 20.8084 10.6073 20.7125 10.7L10.2988 21.2888C10.2055 21.3813 10.1314 21.4912 10.0807 21.6124C10.03 21.7335 10.0036 21.8635 10.003 21.9948C10.0025 22.1261 10.0279 22.2563 10.0777 22.3778C10.1274 22.4994 10.2007 22.6099 10.2932 22.7031C10.3857 22.7964 10.4956 22.8705 10.6168 22.9212C10.7379 22.972 10.8678 22.9984 10.9992 22.9989C11.1305 22.9994 11.2607 22.9741 11.3822 22.9243C11.5038 22.8745 11.6143 22.8013 11.7075 22.7088L24.1163 10.125C24.6799 9.5626 24.997 8.79932 24.9978 8.00312C24.9986 7.20691 24.6831 6.44298 24.1207 5.8794C23.5582 5.31581 22.795 4.99873 21.9988 4.99791C21.2025 4.99709 20.4386 5.3126 19.875 5.87502L7.47004 18.46C7.00532 18.924 6.63654 19.475 6.38476 20.0815C6.13297 20.688 6.00311 21.3381 6.00259 21.9948C6.00207 22.6515 6.1309 23.3018 6.38171 23.9087C6.63253 24.5156 7.00044 25.0672 7.46441 25.5319C7.92839 25.9966 8.47935 26.3654 9.08585 26.6172C9.69235 26.869 10.3425 26.9988 10.9992 26.9993C11.6559 26.9999 12.3062 26.871 12.9131 26.6202C13.52 26.3694 14.0716 26.0015 14.5363 25.5375L24.7938 15.2875C24.982 15.1008 25.2366 14.9964 25.5017 14.9974C25.7668 14.9983 26.0207 15.1045 26.2075 15.2925Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "pause_fill": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M27 6V26C27 26.5304 26.7893 27.0391 26.4142 27.4142C26.0391 27.7893 25.5304 28 25 28H20C19.4696 28 18.9609 27.7893 18.5858 27.4142C18.2107 27.0391 18 26.5304 18 26V6C18 5.46957 18.2107 4.96086 18.5858 4.58579C18.9609 4.21071 19.4696 4 20 4H25C25.5304 4 26.0391 4.21071 26.4142 4.58579C26.7893 4.96086 27 5.46957 27 6ZM12 4H7C6.46957 4 5.96086 4.21071 5.58579 4.58579C5.21071 4.96086 5 5.46957 5 6V26C5 26.5304 5.21071 27.0391 5.58579 27.4142C5.96086 27.7893 6.46957 28 7 28H12C12.5304 28 13.0391 27.7893 13.4142 27.4142C13.7893 27.0391 14 26.5304 14 26V6C14 5.46957 13.7893 4.96086 13.4142 4.58579C13.0391 4.21071 12.5304 4 12 4Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2291,10 +4645,18 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M16.0001 10C14.8134 10 13.6533 10.3519 12.6666 11.0112C11.6799 11.6705 10.9109 12.6075 10.4568 13.7039C10.0027 14.8003 9.88383 16.0067 10.1153 17.1705C10.3469 18.3344 10.9183 19.4035 11.7574 20.2426C12.5965 21.0818 13.6656 21.6532 14.8295 21.8847C15.9934 22.1162 17.1998 21.9974 18.2962 21.5433C19.3925 21.0891 20.3296 20.3201 20.9889 19.3334C21.6482 18.3467 22.0001 17.1867 22.0001 16C21.9984 14.4092 21.3657 12.884 20.2409 11.7592C19.116 10.6343 17.5908 10.0017 16.0001 10ZM16.0001 20C15.2089 20 14.4356 19.7654 13.7778 19.3259C13.12 18.8863 12.6073 18.2616 12.3045 17.5307C12.0018 16.7998 11.9226 15.9956 12.0769 15.2196C12.2313 14.4437 12.6122 13.731 13.1716 13.1716C13.731 12.6122 14.4438 12.2312 15.2197 12.0769C15.9956 11.9225 16.7999 12.0017 17.5308 12.3045C18.2617 12.6072 18.8864 13.1199 19.3259 13.7777C19.7655 14.4355 20.0001 15.2089 20.0001 16C20.0001 17.0609 19.5786 18.0783 18.8285 18.8284C18.0783 19.5786 17.0609 20 16.0001 20ZM27.0001 16.27C27.0051 16.09 27.0051 15.91 27.0001 15.73L28.8651 13.4C28.9628 13.2777 29.0305 13.1341 29.0627 12.9808C29.0948 12.8275 29.0905 12.6688 29.0501 12.5175C28.7443 11.3682 28.287 10.2648 27.6901 9.23625C27.6119 9.10164 27.5034 8.98714 27.3732 8.90186C27.243 8.81658 27.0947 8.76286 26.9401 8.745L23.9751 8.415C23.8517 8.285 23.7267 8.16 23.6001 8.04L23.2501 5.0675C23.2321 4.91276 23.1782 4.76437 23.0926 4.63416C23.0071 4.50395 22.8924 4.39551 22.7576 4.3175C21.7286 3.72168 20.6253 3.26479 19.4763 2.95875C19.3249 2.91849 19.1662 2.91438 19.0129 2.94673C18.8596 2.97908 18.716 3.04699 18.5938 3.145L16.2701 5C16.0901 5 15.9101 5 15.7301 5L13.4001 3.13875C13.2777 3.04096 13.1341 2.97327 12.9808 2.94114C12.8276 2.909 12.6689 2.91332 12.5176 2.95375C11.3685 3.26003 10.2651 3.71735 9.23631 4.31375C9.1017 4.3919 8.9872 4.5004 8.90192 4.63061C8.81664 4.76081 8.76292 4.90913 8.74506 5.06375L8.41506 8.03375C8.28506 8.15791 8.16006 8.28291 8.04006 8.40875L5.06756 8.75C4.91282 8.768 4.76443 8.8219 4.63422 8.90741C4.50401 8.99291 4.39557 9.10766 4.31756 9.2425C3.72174 10.2715 3.26485 11.3748 2.95881 12.5237C2.91855 12.6752 2.91444 12.8339 2.94679 12.9872C2.97914 13.1405 3.04705 13.284 3.14506 13.4062L5.00006 15.73C5.00006 15.91 5.00006 16.09 5.00006 16.27L3.13881 18.6C3.04102 18.7223 2.97333 18.8659 2.9412 19.0192C2.90906 19.1725 2.91338 19.3312 2.95381 19.4825C3.25954 20.6317 3.71689 21.7352 4.31381 22.7637C4.39196 22.8983 4.50046 23.0128 4.63067 23.0981C4.76087 23.1834 4.90919 23.2371 5.06381 23.255L8.02881 23.585C8.15297 23.715 8.27797 23.84 8.40381 23.96L8.75006 26.9325C8.76806 27.0872 8.82196 27.2356 8.90747 27.3658C8.99298 27.496 9.10772 27.6045 9.24256 27.6825C10.2715 28.2783 11.3749 28.7352 12.5238 29.0412C12.6752 29.0815 12.834 29.0856 12.9872 29.0533C13.1405 29.0209 13.2841 28.953 13.4063 28.855L15.7301 27C15.9101 27.005 16.0901 27.005 16.2701 27L18.6001 28.865C18.7224 28.9628 18.866 29.0305 19.0193 29.0626C19.1726 29.0947 19.3312 29.0904 19.4826 29.05C20.6318 28.7443 21.7352 28.2869 22.7638 27.69C22.8984 27.6118 23.0129 27.5033 23.0982 27.3731C23.1835 27.2429 23.2372 27.0946 23.2551 26.94L23.5851 23.975C23.7151 23.8517 23.8401 23.7267 23.9601 23.6L26.9326 23.25C27.0873 23.232 27.2357 23.1781 27.3659 23.0926C27.4961 23.0071 27.6045 22.8923 27.6826 22.7575C28.2784 21.7285 28.7353 20.6252 29.0413 19.4762C29.0816 19.3248 29.0857 19.1661 29.0533 19.0128C29.021 18.8595 28.9531 18.716 28.8551 18.5937L27.0001 16.27ZM24.9876 15.4575C25.0088 15.8189 25.0088 16.1811 24.9876 16.5425C24.9727 16.7899 25.0502 17.034 25.2051 17.2275L26.9788 19.4437C26.7753 20.0906 26.5147 20.718 26.2001 21.3187L23.3751 21.6387C23.129 21.6661 22.9019 21.7836 22.7376 21.9687C22.4969 22.2394 22.2407 22.4956 21.9701 22.7362C21.7849 22.9006 21.6674 23.1277 21.6401 23.3737L21.3263 26.1962C20.7257 26.511 20.0982 26.7716 19.4513 26.975L17.2338 25.2012C17.0564 25.0595 16.8359 24.9823 16.6088 24.9825H16.5488C16.1875 25.0037 15.8252 25.0037 15.4638 24.9825C15.2164 24.9676 14.9723 25.0451 14.7788 25.2L12.5563 26.975C11.9095 26.7715 11.282 26.5109 10.6813 26.1962L10.3613 23.375C10.334 23.129 10.2164 22.9018 10.0313 22.7375C9.76069 22.4969 9.50442 22.2406 9.26381 21.97C9.09947 21.7849 8.87233 21.6673 8.62631 21.64L5.80381 21.325C5.48905 20.7244 5.22843 20.0969 5.02506 19.45L6.79881 17.2325C6.95369 17.039 7.0312 16.7949 7.01631 16.5475C6.99506 16.1861 6.99506 15.8239 7.01631 15.4625C7.0312 15.2151 6.95369 14.971 6.79881 14.7775L5.02506 12.5562C5.22859 11.9094 5.4892 11.2819 5.80381 10.6812L8.62506 10.3612C8.87108 10.3339 9.09822 10.2164 9.26256 10.0312C9.50317 9.76063 9.75944 9.50436 10.0301 9.26375C10.2159 9.09931 10.334 8.87164 10.3613 8.625L10.6751 5.80375C11.2757 5.48899 11.9032 5.22837 12.5501 5.025L14.7676 6.79875C14.961 6.95363 15.2052 7.03114 15.4526 7.01625C15.8139 6.995 16.1762 6.995 16.5376 7.01625C16.785 7.03114 17.0291 6.95363 17.2226 6.79875L19.4438 5.025C20.0906 5.22853 20.7181 5.48914 21.3188 5.80375L21.6388 8.625C21.6661 8.87101 21.7837 9.09816 21.9688 9.2625C22.2394 9.50311 22.4957 9.75938 22.7363 10.03C22.9006 10.2151 23.1278 10.3327 23.3738 10.36L26.1963 10.6737C26.5111 11.2744 26.7717 11.9019 26.9751 12.5487L25.2013 14.7662C25.0449 14.9614 24.9673 15.208 24.9838 15.4575H24.9876Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "share_fat": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M29.7075 13.2938L19.7075 3.29378C19.5678 3.15384 19.3896 3.0585 19.1957 3.01981C19.0017 2.98112 18.8006 3.00082 18.6178 3.07641C18.4351 3.15201 18.2788 3.28011 18.1688 3.44451C18.0589 3.60892 18.0001 3.80224 18 4.00003V9.04378C14.7575 9.32128 11.1763 10.9088 8.23005 13.4075C4.68255 16.4175 2.4738 20.2963 2.01005 24.3288C1.97381 24.6423 2.03737 24.9592 2.1917 25.2345C2.34603 25.5098 2.58325 25.7294 2.86962 25.8621C3.15598 25.9947 3.47689 26.0337 3.78667 25.9734C4.09646 25.9131 4.37933 25.7566 4.59505 25.5263C5.97005 24.0625 10.8625 19.4338 18 19.0263V24C18.0001 24.1978 18.0589 24.3911 18.1688 24.5555C18.2788 24.7199 18.4351 24.848 18.6178 24.9236C18.8006 24.9992 19.0017 25.0189 19.1957 24.9802C19.3896 24.9416 19.5678 24.8462 19.7075 24.7063L29.7075 14.7063C29.8946 14.5188 29.9996 14.2648 29.9996 14C29.9996 13.7352 29.8946 13.4812 29.7075 13.2938ZM20 21.5863V18C20 17.7348 19.8947 17.4805 19.7072 17.2929C19.5196 17.1054 19.2653 17 19 17C15.49 17 12.0713 17.9163 8.8388 19.725C7.19248 20.6503 5.65856 21.7627 4.26755 23.04C4.99255 20.06 6.82005 17.2263 9.5238 14.9325C12.4263 12.4713 15.9688 11 19 11C19.2653 11 19.5196 10.8947 19.7072 10.7071C19.8947 10.5196 20 10.2652 20 10V6.41503L27.5863 14L20 21.5863Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "shield": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M26 5H6C5.46957 5 4.96086 5.21071 4.58579 5.58579C4.21071 5.96086 4 6.46957 4 7V14C4 20.59 7.19 24.5837 9.86625 26.7738C12.7487 29.1313 15.6163 29.9325 15.7413 29.965C15.9131 30.0118 16.0944 30.0118 16.2663 29.965C16.3913 29.9325 19.255 29.1313 22.1413 26.7738C24.81 24.5837 28 20.59 28 14V7C28 6.46957 27.7893 5.96086 27.4142 5.58579C27.0391 5.21071 26.5304 5 26 5ZM26 14C26 18.6337 24.2925 22.395 20.925 25.1775C19.4591 26.3846 17.7919 27.324 16 27.9525C14.2315 27.335 12.5849 26.4123 11.135 25.2262C7.7275 22.4387 6 18.6625 6 14V7H26V14Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "shopping_cart_simple": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M13 27C13 27.3956 12.8827 27.7822 12.6629 28.1111C12.4432 28.44 12.1308 28.6964 11.7654 28.8478C11.3999 28.9991 10.9978 29.0387 10.6098 28.9616C10.2219 28.8844 9.86549 28.6939 9.58579 28.4142C9.30608 28.1345 9.1156 27.7781 9.03843 27.3902C8.96126 27.0022 9.00087 26.6001 9.15224 26.2346C9.30362 25.8692 9.55996 25.5568 9.88886 25.3371C10.2178 25.1173 10.6044 25 11 25C11.5304 25 12.0391 25.2107 12.4142 25.5858C12.7893 25.9609 13 26.4696 13 27ZM24 25C23.6044 25 23.2178 25.1173 22.8889 25.3371C22.56 25.5568 22.3036 25.8692 22.1522 26.2346C22.0009 26.6001 21.9613 27.0022 22.0384 27.3902C22.1156 27.7781 22.3061 28.1345 22.5858 28.4142C22.8655 28.6939 23.2219 28.8844 23.6098 28.9616C23.9978 29.0387 24.3999 28.9991 24.7654 28.8478C25.1308 28.6964 25.4432 28.44 25.6629 28.1111C25.8827 27.7822 26 27.3956 26 27C26 26.4696 25.7893 25.9609 25.4142 25.5858C25.0391 25.2107 24.5304 25 24 25ZM29.9638 9.2675L26.7588 20.8025C26.5825 21.4326 26.2056 21.9881 25.6852 22.3846C25.1648 22.7812 24.5293 22.9973 23.875 23H11.52C10.8638 22.9997 10.2257 22.7848 9.703 22.388C9.18031 21.9913 8.80173 21.4345 8.625 20.8025L4.24 5H2C1.73478 5 1.48043 4.89464 1.29289 4.70711C1.10536 4.51957 1 4.26522 1 4C1 3.73478 1.10536 3.48043 1.29289 3.29289C1.48043 3.10536 1.73478 3 2 3H5C5.21863 2.99996 5.43124 3.07156 5.6053 3.20386C5.77936 3.33615 5.90527 3.52184 5.96375 3.7325L7.14875 8H29C29.1542 7.99997 29.3062 8.03558 29.4444 8.10406C29.5825 8.17254 29.7029 8.27202 29.7962 8.39474C29.8895 8.51746 29.9532 8.66009 29.9823 8.81149C30.0113 8.96289 30.005 9.11895 29.9638 9.2675ZM27.6838 10H7.705L10.5562 20.2675C10.6147 20.4782 10.7406 20.6638 10.9147 20.7961C11.0888 20.9284 11.3014 21 11.52 21H23.875C24.0936 21 24.3062 20.9284 24.4803 20.7961C24.6544 20.6638 24.7803 20.4782 24.8388 20.2675L27.6838 10Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "shuffle": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M29.7075 22.2924C29.8005 22.3853 29.8742 22.4956 29.9246 22.617C29.9749 22.7384 30.0008 22.8685 30.0008 22.9999C30.0008 23.1314 29.9749 23.2615 29.9246 23.3829C29.8742 23.5043 29.8005 23.6146 29.7075 23.7074L26.7075 26.7074C26.5199 26.8951 26.2654 27.0005 26 27.0005C25.7346 27.0005 25.4801 26.8951 25.2925 26.7074C25.1049 26.5198 24.9994 26.2653 24.9994 25.9999C24.9994 25.7346 25.1049 25.4801 25.2925 25.2924L26.5863 23.9999H25.1175C23.6851 23.9988 22.2737 23.6563 21.0001 23.0009C19.7264 22.3455 18.6273 21.396 17.7938 20.2312L12.5787 12.9312C11.9304 12.0253 11.0755 11.2868 10.0849 10.7771C9.09433 10.2673 7.99655 10.0009 6.8825 9.99995H4C3.73478 9.99995 3.48043 9.89459 3.29289 9.70705C3.10536 9.51952 3 9.26516 3 8.99995C3 8.73473 3.10536 8.48038 3.29289 8.29284C3.48043 8.1053 3.73478 7.99995 4 7.99995H6.8825C8.31486 8.00114 9.72632 8.34362 10.9999 8.99901C12.2736 9.65441 13.3727 10.6039 14.2063 11.7687L19.4212 19.0687C20.0696 19.9746 20.9245 20.7131 21.9151 21.2228C22.9057 21.7325 24.0035 21.999 25.1175 21.9999H26.5863L25.2925 20.7074C25.1049 20.5198 24.9994 20.2653 24.9994 19.9999C24.9994 19.7346 25.1049 19.4801 25.2925 19.2924C25.4801 19.1048 25.7346 18.9994 26 18.9994C26.2654 18.9994 26.5199 19.1048 26.7075 19.2924L29.7075 22.2924ZM17.875 13.3749C17.9819 13.4513 18.1027 13.5058 18.2307 13.5354C18.3586 13.5651 18.4911 13.5692 18.6207 13.5476C18.7502 13.526 18.8742 13.4791 18.9856 13.4096C19.097 13.3401 19.1937 13.2493 19.27 13.1424L19.42 12.9337C20.0682 12.0271 20.9232 11.2881 21.914 10.7779C22.9049 10.2677 24.003 10.001 25.1175 9.99995H26.5863L25.2925 11.2924C25.1049 11.4801 24.9994 11.7346 24.9994 11.9999C24.9994 12.2653 25.1049 12.5198 25.2925 12.7074C25.4801 12.8951 25.7346 13.0005 26 13.0005C26.2654 13.0005 26.5199 12.8951 26.7075 12.7074L29.7075 9.70745C29.8005 9.61457 29.8742 9.50428 29.9246 9.38289C29.9749 9.26149 30.0008 9.13136 30.0008 8.99995C30.0008 8.86853 29.9749 8.7384 29.9246 8.61701C29.8742 8.49561 29.8005 8.38532 29.7075 8.29245L26.7075 5.29245C26.5199 5.10481 26.2654 4.99939 26 4.99939C25.7346 4.99939 25.4801 5.1048 25.2925 5.29245C25.1049 5.48009 24.9994 5.73458 24.9994 5.99995C24.9994 6.26531 25.1049 6.5198 25.2925 6.70745L26.5863 7.99995H25.1175C23.6851 8.00114 22.2737 8.34362 21.0001 8.99901C19.7264 9.65441 18.6273 10.6039 17.7938 11.7687L17.6437 11.9774C17.567 12.0843 17.512 12.2053 17.4821 12.3334C17.4521 12.4616 17.4478 12.5944 17.4693 12.7242C17.4908 12.854 17.5377 12.9783 17.6073 13.09C17.6769 13.2017 17.7679 13.2985 17.875 13.3749ZM14.125 18.6249C14.0181 18.5486 13.8973 18.4941 13.7693 18.4644C13.6414 18.4348 13.5089 18.4307 13.3793 18.4523C13.2498 18.4739 13.1258 18.5208 13.0144 18.5903C12.903 18.6598 12.8063 18.7506 12.73 18.8574L12.58 19.0662C11.9318 19.9728 11.0768 20.7118 10.086 21.222C9.09514 21.7322 7.99698 21.9989 6.8825 21.9999H4C3.73478 21.9999 3.48043 22.1053 3.29289 22.2928C3.10536 22.4804 3 22.7347 3 22.9999C3 23.2652 3.10536 23.5195 3.29289 23.7071C3.48043 23.8946 3.73478 23.9999 4 23.9999H6.8825C8.31486 23.9988 9.72632 23.6563 10.9999 23.0009C12.2736 22.3455 13.3727 21.396 14.2063 20.2312L14.3562 20.0224C14.433 19.9156 14.488 19.7946 14.5179 19.6665C14.5479 19.5383 14.5522 19.4055 14.5307 19.2757C14.5092 19.1459 14.4623 19.0216 14.3927 18.9099C14.3231 18.7982 14.2321 18.7014 14.125 18.6249Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2311,6 +4673,14 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M24.6977 16.1325L18.2502 13.75L15.8752 7.2975C15.7346 6.91541 15.4801 6.58566 15.1461 6.35273C14.8122 6.11981 14.4149 5.99492 14.0077 5.99492C13.6005 5.99492 13.2032 6.11981 12.8692 6.35273C12.5353 6.58566 12.2808 6.91541 12.1402 7.2975L9.7502 13.75L3.2977 16.125C2.91561 16.2656 2.58586 16.5201 2.35293 16.854C2.12001 17.188 1.99512 17.5853 1.99512 17.9925C1.99512 18.3997 2.12001 18.797 2.35293 19.131C2.58586 19.4649 2.91561 19.7194 3.2977 19.86L9.7502 22.25L12.1252 28.7025C12.2658 29.0846 12.5203 29.4143 12.8542 29.6473C13.1882 29.8802 13.5855 30.0051 13.9927 30.0051C14.3999 30.0051 14.7972 29.8802 15.1311 29.6473C15.4651 29.4143 15.7196 29.0846 15.8602 28.7025L18.2502 22.25L24.7027 19.875C25.0848 19.7344 25.4145 19.4799 25.6475 19.146C25.8804 18.812 26.0053 18.4147 26.0053 18.0075C26.0053 17.6003 25.8804 17.203 25.6475 16.869C25.4145 16.5351 25.0848 16.2806 24.7027 16.14L24.6977 16.1325ZM17.1252 20.5275C16.9895 20.5775 16.8662 20.6564 16.7639 20.7587C16.6616 20.861 16.5827 20.9843 16.5327 21.12L14.0002 27.9813L11.4727 21.125C11.4228 20.9878 11.3434 20.8633 11.2402 20.76C11.1369 20.6568 11.0124 20.5774 10.8752 20.5275L4.01895 18L10.8752 15.4725C11.0124 15.4226 11.1369 15.3432 11.2402 15.24C11.3434 15.1367 11.4228 15.0122 11.4727 14.875L14.0002 8.01875L16.5277 14.875C16.5777 15.0107 16.6566 15.134 16.7589 15.2363C16.8612 15.3386 16.9845 15.4175 17.1202 15.4675L23.9814 18L17.1252 20.5275ZM18.0002 5C18.0002 4.73478 18.1056 4.48043 18.2931 4.29289C18.4806 4.10536 18.735 4 19.0002 4H21.0002V2C21.0002 1.73478 21.1056 1.48043 21.2931 1.29289C21.4806 1.10536 21.735 1 22.0002 1C22.2654 1 22.5198 1.10536 22.7073 1.29289C22.8948 1.48043 23.0002 1.73478 23.0002 2V4H25.0002C25.2654 4 25.5198 4.10536 25.7073 4.29289C25.8948 4.48043 26.0002 4.73478 26.0002 5C26.0002 5.26522 25.8948 5.51957 25.7073 5.70711C25.5198 5.89464 25.2654 6 25.0002 6H23.0002V8C23.0002 8.26522 22.8948 8.51957 22.7073 8.70711C22.5198 8.89464 22.2654 9 22.0002 9C21.735 9 21.4806 8.89464 21.2931 8.70711C21.1056 8.51957 21.0002 8.26522 21.0002 8V6H19.0002C18.735 6 18.4806 5.89464 18.2931 5.70711C18.1056 5.51957 18.0002 5.26522 18.0002 5ZM31.0002 11C31.0002 11.2652 30.8948 11.5196 30.7073 11.7071C30.5198 11.8946 30.2654 12 30.0002 12H29.0002V13C29.0002 13.2652 28.8948 13.5196 28.7073 13.7071C28.5198 13.8946 28.2654 14 28.0002 14C27.735 14 27.4806 13.8946 27.2931 13.7071C27.1056 13.5196 27.0002 13.2652 27.0002 13V12H26.0002C25.735 12 25.4806 11.8946 25.2931 11.7071C25.1056 11.5196 25.0002 11.2652 25.0002 11C25.0002 10.7348 25.1056 10.4804 25.2931 10.2929C25.4806 10.1054 25.735 10 26.0002 10H27.0002V9C27.0002 8.73478 27.1056 8.48043 27.2931 8.29289C27.4806 8.10536 27.735 8 28.0002 8C28.2654 8 28.5198 8.10536 28.7073 8.29289C28.8948 8.48043 29.0002 8.73478 29.0002 9V10H30.0002C30.2654 10 30.5198 10.1054 30.7073 10.2929C30.8948 10.4804 31.0002 10.7348 31.0002 11Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "star": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M29.8975 12.1576C29.7725 11.7732 29.5365 11.4345 29.2193 11.184C28.9021 10.9335 28.5179 10.7826 28.115 10.7501L20.74 10.1551L17.8925 3.26882C17.7385 2.89359 17.4764 2.57263 17.1396 2.34674C16.8027 2.12086 16.4062 2.00024 16.0006 2.00024C15.595 2.00024 15.1986 2.12086 14.8617 2.34674C14.5249 2.57263 14.2628 2.89359 14.1088 3.26882L11.2638 10.1538L3.88502 10.7501C3.48149 10.7842 3.09701 10.9367 2.77974 11.1883C2.46247 11.44 2.22653 11.7797 2.10147 12.1649C1.97642 12.5501 1.96781 12.9636 2.07673 13.3536C2.18565 13.7437 2.40725 14.0929 2.71377 14.3576L8.33877 19.2113L6.62502 26.4688C6.52918 26.8631 6.55265 27.277 6.69245 27.6579C6.83225 28.0388 7.08208 28.3696 7.41022 28.6083C7.73837 28.847 8.13003 28.9828 8.53549 28.9984C8.94095 29.0141 9.34193 28.909 9.68752 28.6963L16 24.8113L22.3163 28.6963C22.662 28.9064 23.0621 29.0096 23.4664 28.9927C23.8706 28.9759 24.2607 28.8398 24.5878 28.6016C24.9148 28.3635 25.1641 28.0339 25.3041 27.6544C25.4442 27.2748 25.4689 26.8623 25.375 26.4688L23.655 19.2101L29.28 14.3563C29.589 14.0921 29.8127 13.7421 29.9226 13.3507C30.0325 12.9593 30.0238 12.544 29.8975 12.1576ZM27.98 12.8413L21.8925 18.0913C21.7537 18.211 21.6504 18.3665 21.594 18.5409C21.5376 18.7152 21.5301 18.9018 21.5725 19.0801L23.4325 26.9301C23.4373 26.9409 23.4378 26.9531 23.4339 26.9643C23.4299 26.9755 23.4218 26.9847 23.4113 26.9901C23.3888 27.0076 23.3825 27.0038 23.3638 26.9901L16.5238 22.7838C16.3662 22.687 16.1849 22.6357 16 22.6357C15.8151 22.6357 15.6338 22.687 15.4763 22.7838L8.63627 26.9926C8.61752 27.0038 8.61252 27.0076 8.58877 26.9926C8.57822 26.9872 8.57014 26.978 8.56618 26.9668C8.56223 26.9556 8.56271 26.9434 8.56752 26.9326L10.4275 19.0826C10.4699 18.9043 10.4625 18.7177 10.4061 18.5434C10.3496 18.369 10.2463 18.2135 10.1075 18.0938L4.02002 12.8438C4.00502 12.8313 3.99127 12.8201 4.00377 12.7813C4.01627 12.7426 4.02627 12.7476 4.04502 12.7451L12.035 12.1001C12.2183 12.0844 12.3937 12.0184 12.5419 11.9094C12.6901 11.8005 12.8053 11.6528 12.875 11.4826L15.9525 4.03132C15.9625 4.01007 15.9663 4.00007 15.9963 4.00007C16.0263 4.00007 16.03 4.01007 16.04 4.03132L19.125 11.4826C19.1954 11.6529 19.3114 11.8004 19.4603 11.9089C19.6092 12.0175 19.7851 12.0827 19.9688 12.0976L27.9588 12.7426C27.9775 12.7426 27.9888 12.7426 28 12.7788C28.0113 12.8151 28 12.8288 27.98 12.8413Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
+    "star_fill": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M29.2862 14.3563L23.6612 19.21L25.375 26.4688C25.4695 26.8628 25.4452 27.2761 25.305 27.6563C25.1648 28.0365 24.9151 28.3666 24.5874 28.605C24.2597 28.8433 23.8687 28.9792 23.4638 28.9955C23.0589 29.0117 22.6582 28.9076 22.3125 28.6963L16 24.8113L9.68373 28.6963C9.33802 28.9064 8.93786 29.0095 8.53366 28.9927C8.12945 28.9758 7.73927 28.8398 7.41224 28.6016C7.08521 28.3634 6.83595 28.0339 6.69586 27.6543C6.55577 27.2748 6.53111 26.8623 6.62498 26.4688L8.34498 19.21L2.71998 14.3563C2.41411 14.0919 2.19289 13.7433 2.08396 13.354C1.97503 12.9646 1.98322 12.5518 2.1075 12.1671C2.23178 11.7824 2.46665 11.4428 2.78277 11.1908C3.09889 10.9388 3.48225 10.7855 3.88498 10.75L11.26 10.155L14.105 3.27004C14.259 2.89481 14.5211 2.57385 14.8579 2.34796C15.1948 2.12208 15.5913 2.00146 15.9969 2.00146C16.4025 2.00146 16.7989 2.12208 17.1358 2.34796C17.4726 2.57385 17.7347 2.89481 17.8887 3.27004L20.7325 10.155L28.1075 10.75C28.511 10.7842 28.8955 10.9366 29.2128 11.1883C29.53 11.44 29.766 11.7797 29.891 12.1649C30.0161 12.55 30.0247 12.9636 29.9158 13.3536C29.8069 13.7436 29.5853 14.0929 29.2787 14.3575L29.2862 14.3563Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "sun": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M15 5V2C15 1.73478 15.1054 1.48043 15.2929 1.29289C15.4804 1.10536 15.7348 1 16 1C16.2652 1 16.5196 1.10536 16.7071 1.29289C16.8946 1.48043 17 1.73478 17 2V5C17 5.26522 16.8946 5.51957 16.7071 5.70711C16.5196 5.89464 16.2652 6 16 6C15.7348 6 15.4804 5.89464 15.2929 5.70711C15.1054 5.51957 15 5.26522 15 5ZM24 16C24 17.5823 23.5308 19.129 22.6518 20.4446C21.7727 21.7602 20.5233 22.7855 19.0615 23.391C17.5997 23.9965 15.9911 24.155 14.4393 23.8463C12.8874 23.5376 11.462 22.7757 10.3431 21.6569C9.22433 20.538 8.4624 19.1126 8.15372 17.5607C7.84504 16.0089 8.00346 14.4003 8.60896 12.9385C9.21447 11.4767 10.2398 10.2273 11.5554 9.34824C12.871 8.46919 14.4177 8 16 8C18.121 8.00232 20.1545 8.84591 21.6543 10.3457C23.1541 11.8455 23.9977 13.879 24 16ZM22 16C22 14.8133 21.6481 13.6533 20.9888 12.6666C20.3295 11.6799 19.3925 10.9108 18.2961 10.4567C17.1997 10.0026 15.9933 9.88378 14.8295 10.1153C13.6656 10.3468 12.5965 10.9182 11.7574 11.7574C10.9182 12.5965 10.3468 13.6656 10.1153 14.8295C9.88378 15.9933 10.0026 17.1997 10.4567 18.2961C10.9108 19.3925 11.6799 20.3295 12.6666 20.9888C13.6533 21.6481 14.8133 22 16 22C17.5908 21.9983 19.116 21.3657 20.2408 20.2408C21.3657 19.116 21.9983 17.5908 22 16ZM7.2925 8.7075C7.48014 8.89514 7.73464 9.00056 8 9.00056C8.26536 9.00056 8.51986 8.89514 8.7075 8.7075C8.89514 8.51986 9.00056 8.26536 9.00056 8C9.00056 7.73464 8.89514 7.48014 8.7075 7.2925L6.7075 5.2925C6.51986 5.10486 6.26536 4.99944 6 4.99944C5.73464 4.99944 5.48014 5.10486 5.2925 5.2925C5.10486 5.48014 4.99944 5.73464 4.99944 6C4.99944 6.26536 5.10486 6.51986 5.2925 6.7075L7.2925 8.7075ZM7.2925 23.2925L5.2925 25.2925C5.10486 25.4801 4.99944 25.7346 4.99944 26C4.99944 26.2654 5.10486 26.5199 5.2925 26.7075C5.48014 26.8951 5.73464 27.0006 6 27.0006C6.26536 27.0006 6.51986 26.8951 6.7075 26.7075L8.7075 24.7075C8.80041 24.6146 8.87411 24.5043 8.92439 24.3829C8.97468 24.2615 9.00056 24.1314 9.00056 24C9.00056 23.8686 8.97468 23.7385 8.92439 23.6171C8.87411 23.4957 8.80041 23.3854 8.7075 23.2925C8.61459 23.1996 8.50429 23.1259 8.3829 23.0756C8.2615 23.0253 8.13139 22.9994 8 22.9994C7.86861 22.9994 7.7385 23.0253 7.6171 23.0756C7.49571 23.1259 7.38541 23.1996 7.2925 23.2925ZM24 9C24.1314 9.0001 24.2615 8.97432 24.3829 8.92414C24.5042 8.87395 24.6146 8.80033 24.7075 8.7075L26.7075 6.7075C26.8951 6.51986 27.0006 6.26536 27.0006 6C27.0006 5.73464 26.8951 5.48014 26.7075 5.2925C26.5199 5.10486 26.2654 4.99944 26 4.99944C25.7346 4.99944 25.4801 5.10486 25.2925 5.2925L23.2925 7.2925C23.1525 7.43236 23.0571 7.61061 23.0185 7.80469C22.9798 7.99878 22.9996 8.19997 23.0754 8.38279C23.1511 8.56561 23.2794 8.72185 23.444 8.83172C23.6086 8.94159 23.8021 9.00016 24 9ZM24.7075 23.2925C24.5199 23.1049 24.2654 22.9994 24 22.9994C23.7346 22.9994 23.4801 23.1049 23.2925 23.2925C23.1049 23.4801 22.9994 23.7346 22.9994 24C22.9994 24.2654 23.1049 24.5199 23.2925 24.7075L25.2925 26.7075C25.3854 26.8004 25.4957 26.8741 25.6171 26.9244C25.7385 26.9747 25.8686 27.0006 26 27.0006C26.1314 27.0006 26.2615 26.9747 26.3829 26.9244C26.5043 26.8741 26.6146 26.8004 26.7075 26.7075C26.8004 26.6146 26.8741 26.5043 26.9244 26.3829C26.9747 26.2615 27.0006 26.1314 27.0006 26C27.0006 25.8686 26.9747 25.7385 26.9244 25.6171C26.8741 25.4957 26.8004 25.3854 26.7075 25.2925L24.7075 23.2925ZM6 16C6 15.7348 5.89464 15.4804 5.70711 15.2929C5.51957 15.1054 5.26522 15 5 15H2C1.73478 15 1.48043 15.1054 1.29289 15.2929C1.10536 15.4804 1 15.7348 1 16C1 16.2652 1.10536 16.5196 1.29289 16.7071C1.48043 16.8946 1.73478 17 2 17H5C5.26522 17 5.51957 16.8946 5.70711 16.7071C5.89464 16.5196 6 16.2652 6 16ZM16 26C15.7348 26 15.4804 26.1054 15.2929 26.2929C15.1054 26.4804 15 26.7348 15 27V30C15 30.2652 15.1054 30.5196 15.2929 30.7071C15.4804 30.8946 15.7348 31 16 31C16.2652 31 16.5196 30.8946 16.7071 30.7071C16.8946 30.5196 17 30.2652 17 30V27C17 26.7348 16.8946 26.4804 16.7071 26.2929C16.5196 26.1054 16.2652 26 16 26ZM30 15H27C26.7348 15 26.4804 15.1054 26.2929 15.2929C26.1054 15.4804 26 15.7348 26 16C26 16.2652 26.1054 16.5196 26.2929 16.7071C26.4804 16.8946 26.7348 17 27 17H30C30.2652 17 30.5196 16.8946 30.7071 16.7071C30.8946 16.5196 31 16.2652 31 16C31 15.7348 30.8946 15.4804 30.7071 15.2929C30.5196 15.1054 30.2652 15 30 15Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2335,6 +4705,10 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M14.6563 19.7401C15.9966 18.8479 17.0141 17.548 17.5584 16.0327C18.1028 14.5174 18.145 12.8671 17.6789 11.326C17.2129 9.78483 16.2632 8.43458 14.9703 7.4749C13.6775 6.51522 12.1102 5.99707 10.5001 5.99707C8.88997 5.99707 7.32261 6.51522 6.02978 7.4749C4.73694 8.43458 3.78726 9.78483 3.32118 11.326C2.85509 12.8671 2.89734 14.5174 3.44168 16.0327C3.98603 17.548 5.00356 18.8479 6.34381 19.7401C3.91943 20.6337 1.84894 22.2872 0.441312 24.4539C0.367332 24.5638 0.315945 24.6874 0.290139 24.8174C0.264332 24.9474 0.264621 25.0812 0.290989 25.2111C0.317356 25.3409 0.369276 25.4643 0.44373 25.5739C0.518185 25.6835 0.613688 25.7773 0.72469 25.8497C0.835692 25.9221 0.959977 25.9717 1.09032 25.9956C1.22067 26.0196 1.35447 26.0174 1.48396 25.9892C1.61344 25.9609 1.73603 25.9073 1.84458 25.8312C1.95314 25.7552 2.04551 25.6584 2.11631 25.5464C3.0243 24.1498 4.26676 23.0023 5.73086 22.2078C7.19496 21.4134 8.83432 20.9973 10.5001 20.9973C12.1658 20.9973 13.8052 21.4134 15.2693 22.2078C16.7334 23.0023 17.9758 24.1498 18.8838 25.5464C19.0305 25.7644 19.257 25.9159 19.5145 25.9681C19.772 26.0204 20.0397 25.9692 20.2598 25.8257C20.4799 25.6822 20.6346 25.4578 20.6906 25.2011C20.7465 24.9444 20.6992 24.676 20.5588 24.4539C19.1512 22.2872 17.0807 20.6337 14.6563 19.7401ZM5.00006 13.5001C5.00006 12.4123 5.32263 11.3489 5.92698 10.4445C6.53133 9.54001 7.39031 8.83506 8.3953 8.41878C9.4003 8.00249 10.5062 7.89358 11.5731 8.10579C12.64 8.31801 13.62 8.84184 14.3891 9.61103C15.1583 10.3802 15.6822 11.3602 15.8944 12.4271C16.1066 13.494 15.9977 14.5999 15.5814 15.6049C15.1651 16.6099 14.4602 17.4688 13.5557 18.0732C12.6512 18.6775 11.5879 19.0001 10.5001 19.0001C9.04188 18.9985 7.64389 18.4185 6.6128 17.3874C5.58171 16.3563 5.00172 14.9583 5.00006 13.5001ZM31.2676 25.8376C31.0454 25.9825 30.7749 26.0331 30.5154 25.9785C30.2559 25.9239 30.0287 25.7685 29.8838 25.5464C28.9769 24.149 27.7346 23.0009 26.2702 22.2068C24.8058 21.4127 23.1659 20.9979 21.5001 21.0001C21.2348 21.0001 20.9805 20.8948 20.793 20.7072C20.6054 20.5197 20.5001 20.2653 20.5001 20.0001C20.5001 19.7349 20.6054 19.4805 20.793 19.293C20.9805 19.1055 21.2348 19.0001 21.5001 19.0001C22.31 18.9993 23.1098 18.8197 23.8423 18.474C24.5748 18.1283 25.2219 17.6251 25.7373 17.0003C26.2528 16.3756 26.6239 15.6447 26.8242 14.8598C27.0244 14.075 27.0488 13.2557 26.8957 12.4603C26.7426 11.6649 26.4157 10.9132 25.9383 10.2589C25.461 9.60449 24.845 9.06362 24.1344 8.6749C23.4239 8.28619 22.6362 8.05921 21.8277 8.0102C21.0192 7.96118 20.2099 8.09134 19.4576 8.39136C19.3349 8.44439 19.2028 8.47229 19.0692 8.47342C18.9356 8.47455 18.8031 8.44889 18.6795 8.39794C18.556 8.34699 18.4439 8.2718 18.3499 8.1768C18.2559 8.0818 18.1819 7.96893 18.1323 7.84485C18.0827 7.72077 18.0584 7.588 18.0609 7.45439C18.0635 7.32077 18.0928 7.18903 18.1471 7.06693C18.2015 6.94483 18.2797 6.83486 18.3772 6.74352C18.4748 6.65218 18.5897 6.58131 18.7151 6.53511C20.4369 5.84843 22.352 5.82372 24.091 6.46575C25.83 7.10778 27.2696 8.37106 28.1321 10.0119C28.9946 11.6527 29.2189 13.5548 28.7617 15.3513C28.3045 17.1477 27.1982 18.7112 25.6563 19.7401C28.0807 20.6337 30.1512 22.2872 31.5588 24.4539C31.7037 24.676 31.7543 24.9466 31.6997 25.2061C31.6451 25.4655 31.4897 25.6927 31.2676 25.8376Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "users_three": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path d=\"M30.5999 18.7999C30.4948 18.8787 30.3753 18.936 30.2481 18.9686C30.1209 19.0012 29.9885 19.0084 29.8585 18.9898C29.7285 18.9713 29.6034 18.9273 29.4904 18.8604C29.3774 18.7935 29.2787 18.705 29.1999 18.5999C28.5972 17.7897 27.8126 17.1324 26.9094 16.6808C26.0063 16.2292 25.0097 15.996 23.9999 15.9999C23.8032 15.9999 23.611 15.9419 23.4471 15.8332C23.2833 15.7244 23.1551 15.5698 23.0786 15.3886C23.0267 15.2656 23 15.1334 23 14.9999C23 14.8664 23.0267 14.7342 23.0786 14.6111C23.1551 14.43 23.2833 14.2754 23.4471 14.1666C23.611 14.0579 23.8032 13.9999 23.9999 13.9999C24.561 13.9998 25.1108 13.8424 25.5869 13.5456C26.063 13.2487 26.4464 12.8243 26.6934 12.3204C26.9403 11.8166 27.0411 11.2537 26.9841 10.6955C26.9272 10.1373 26.7149 9.60624 26.3713 9.16268C26.0276 8.71911 25.5665 8.3808 25.0403 8.18617C24.514 7.99154 23.9437 7.94839 23.3942 8.06163C22.8446 8.17486 22.3379 8.43994 21.9314 8.82676C21.525 9.21358 21.2352 9.70662 21.0949 10.2499C21.0621 10.3771 21.0045 10.4966 20.9255 10.6016C20.8465 10.7066 20.7475 10.7949 20.6344 10.8617C20.5212 10.9284 20.396 10.9722 20.2659 10.9906C20.1358 11.0089 20.0034 11.0015 19.8761 10.9686C19.7489 10.9358 19.6294 10.8783 19.5244 10.7992C19.4195 10.7202 19.3311 10.6213 19.2644 10.5081C19.1976 10.395 19.1538 10.2697 19.1355 10.1397C19.1171 10.0096 19.1246 9.87712 19.1574 9.7499C19.3521 8.99654 19.7199 8.29902 20.2316 7.71284C20.7433 7.12665 21.3848 6.66799 22.1049 6.37334C22.8251 6.07868 23.6041 5.95618 24.3799 6.01556C25.1558 6.07495 25.9071 6.31459 26.574 6.71541C27.2409 7.11624 27.8051 7.66719 28.2216 8.32442C28.6381 8.98165 28.8955 9.72703 28.9733 10.5012C29.0511 11.2755 28.9471 12.0571 28.6696 12.7841C28.3921 13.511 27.9488 14.1632 27.3749 14.6886C28.7347 15.2774 29.9167 16.2117 30.8036 17.3986C30.8824 17.504 30.9397 17.6238 30.9721 17.7513C31.0045 17.8788 31.0114 18.0114 30.9925 18.1415C30.9736 18.2717 30.9291 18.3969 30.8618 18.5098C30.7944 18.6228 30.7054 18.7214 30.5999 18.7999ZM23.8649 26.4999C23.9372 26.6137 23.9858 26.741 24.0077 26.8741C24.0296 27.0072 24.0243 27.1433 23.9923 27.2743C23.9602 27.4053 23.9019 27.5284 23.821 27.6363C23.7401 27.7442 23.6382 27.8346 23.5214 27.9021C23.4047 27.9696 23.2754 28.0128 23.1416 28.0291C23.0077 28.0453 22.8719 28.0343 22.7424 27.9968C22.6128 27.9592 22.4922 27.8958 22.3878 27.8104C22.2834 27.725 22.1974 27.6194 22.1349 27.4999C21.5049 26.4332 20.6078 25.5492 19.5319 24.9352C18.4561 24.3211 17.2387 23.9981 15.9999 23.9981C14.7611 23.9981 13.5437 24.3211 12.4679 24.9352C11.392 25.5492 10.4948 26.4332 9.86489 27.4999C9.80238 27.6194 9.71633 27.725 9.61194 27.8104C9.50755 27.8958 9.38696 27.9592 9.25743 27.9968C9.1279 28.0343 8.99211 28.0453 8.85822 28.0291C8.72434 28.0128 8.59513 27.9696 8.47836 27.9021C8.3616 27.8346 8.25969 27.7442 8.17878 27.6363C8.09786 27.5284 8.03961 27.4053 8.00752 27.2743C7.97543 27.1433 7.97018 27.0072 7.99206 26.8741C8.01395 26.741 8.06254 26.6137 8.13489 26.4999C9.10439 24.8341 10.5826 23.5232 12.3524 22.7599C11.3566 21.9974 10.6247 20.9421 10.2596 19.7422C9.89461 18.5423 9.91477 17.2581 10.3173 16.0703C10.7198 14.8824 11.4844 13.8506 12.5037 13.1197C13.523 12.3889 14.7457 11.9959 15.9999 11.9959C17.2541 11.9959 18.4768 12.3889 19.4961 13.1197C20.5153 13.8506 21.28 14.8824 21.6825 16.0703C22.085 17.2581 22.1052 18.5423 21.7401 19.7422C21.3751 20.9421 20.6432 21.9974 19.6474 22.7599C21.4171 23.5232 22.8954 24.8341 23.8649 26.4999ZM15.9999 21.9999C16.791 21.9999 17.5644 21.7653 18.2222 21.3258C18.88 20.8863 19.3927 20.2615 19.6954 19.5306C19.9982 18.7997 20.0774 17.9955 19.923 17.2195C19.7687 16.4436 19.3877 15.7309 18.8283 15.1715C18.2689 14.6121 17.5562 14.2311 16.7803 14.0768C16.0043 13.9224 15.2001 14.0016 14.4692 14.3044C13.7383 14.6071 13.1135 15.1198 12.674 15.7776C12.2345 16.4354 11.9999 17.2088 11.9999 17.9999C11.9999 19.0608 12.4213 20.0782 13.1715 20.8283C13.9216 21.5785 14.939 21.9999 15.9999 21.9999ZM8.99989 14.9999C8.99989 14.7347 8.89453 14.4803 8.707 14.2928C8.51946 14.1053 8.26511 13.9999 7.99989 13.9999C7.4388 13.9998 6.88897 13.8424 6.41285 13.5456C5.93673 13.2487 5.55341 12.8243 5.30643 12.3204C5.05945 11.8166 4.9587 11.2537 5.01564 10.6955C5.07258 10.1373 5.28491 9.60624 5.62853 9.16268C5.97214 8.71911 6.43326 8.3808 6.95952 8.18617C7.48577 7.99154 8.05605 7.94839 8.6056 8.06163C9.15514 8.17486 9.66192 8.43994 10.0684 8.82676C10.4748 9.21358 10.7646 9.70662 10.9049 10.2499C10.9712 10.5068 11.1368 10.7269 11.3654 10.8617C11.594 10.9965 11.8667 11.035 12.1236 10.9686C12.3806 10.9023 12.6006 10.7367 12.7354 10.5081C12.8702 10.2796 12.9087 10.0068 12.8424 9.7499C12.6477 8.99654 12.2799 8.29902 11.7682 7.71284C11.2564 7.12665 10.615 6.66799 9.89483 6.37334C9.17467 6.07868 8.39568 5.95618 7.61984 6.01556C6.844 6.07495 6.09273 6.31459 5.4258 6.71541C4.75887 7.11624 4.1947 7.66719 3.77817 8.32442C3.36164 8.98165 3.10425 9.72703 3.02648 10.5012C2.94871 11.2755 3.05271 12.0571 3.3302 12.7841C3.60769 13.511 4.05101 14.1632 4.62489 14.6886C3.26649 15.278 2.08578 16.2122 1.19989 17.3986C1.0406 17.6108 0.972109 17.8776 1.0095 18.1403C1.04689 18.4029 1.18709 18.64 1.39927 18.7993C1.61144 18.9586 1.8782 19.0271 2.14087 18.9897C2.40354 18.9523 2.6406 18.8121 2.79989 18.5999C3.40262 17.7897 4.18716 17.1324 5.09034 16.6808C5.99352 16.2292 6.99011 15.996 7.99989 15.9999C8.26511 15.9999 8.51946 15.8945 8.707 15.707C8.89453 15.5195 8.99989 15.2651 8.99989 14.9999Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "video_camera": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M31.4713 9.125C31.3118 9.03953 31.1321 8.99892 30.9514 9.0075C30.7707 9.01609 30.5956 9.07354 30.445 9.17375L26 12.1313V9C26 8.46957 25.7893 7.96086 25.4142 7.58579C25.0391 7.21071 24.5304 7 24 7H4C3.46957 7 2.96086 7.21071 2.58579 7.58579C2.21071 7.96086 2 8.46957 2 9V23C2 23.5304 2.21071 24.0391 2.58579 24.4142C2.96086 24.7893 3.46957 25 4 25H24C24.5304 25 25.0391 24.7893 25.4142 24.4142C25.7893 24.0391 26 23.5304 26 23V19.875L30.445 22.8388C30.6101 22.946 30.8032 23.002 31 23C31.2652 23 31.5196 22.8946 31.7071 22.7071C31.8946 22.5196 32 22.2652 32 22V10C31.9987 9.82007 31.949 9.64382 31.8559 9.48982C31.7628 9.33582 31.63 9.20979 31.4713 9.125ZM24 23H4V9H24V23ZM30 20.1313L26 17.465V14.535L30 11.875V20.1313Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
@@ -2359,6 +4733,10 @@ const BUILTIN_ICONS = Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M23 23C23 24.0609 22.5786 25.0783 21.8284 25.8284C21.0783 26.5786 20.0609 27 19 27C17.2875 27 15.6313 25.8837 15.0625 24.3475C14.976 24.1002 14.99 23.8288 15.1015 23.5916C15.213 23.3545 15.4131 23.1706 15.6588 23.0796C15.9045 22.9885 16.1762 22.9975 16.4153 23.1046C16.6544 23.2118 16.8419 23.4085 16.9375 23.6525C17.2175 24.4088 18.125 25 19 25C19.5304 25 20.0391 24.7893 20.4142 24.4142C20.7893 24.0391 21 23.5304 21 23C21 22.4696 20.7893 21.9609 20.4142 21.5858C20.0391 21.2107 19.5304 21 19 21H5C4.73478 21 4.48043 20.8946 4.29289 20.7071C4.10536 20.5196 4 20.2652 4 20C4 19.7348 4.10536 19.4804 4.29289 19.2929C4.48043 19.1054 4.73478 19 5 19H19C20.0609 19 21.0783 19.4214 21.8284 20.1716C22.5786 20.9217 23 21.9391 23 23ZM15 13C16.0609 13 17.0783 12.5786 17.8284 11.8284C18.5786 11.0783 19 10.0609 19 9C19 7.93913 18.5786 6.92172 17.8284 6.17157C17.0783 5.42143 16.0609 5 15 5C13.2875 5 11.6313 6.11625 11.0625 7.6525C10.976 7.89983 10.99 8.17125 11.1015 8.40837C11.213 8.64549 11.4131 8.82936 11.6588 8.92043C11.9045 9.0115 12.1762 9.0025 12.4153 8.89535C12.6544 8.78821 12.8419 8.59148 12.9375 8.3475C13.2175 7.59125 14.125 7 15 7C15.5304 7 16.0391 7.21071 16.4142 7.58579C16.7893 7.96086 17 8.46957 17 9C17 9.53043 16.7893 10.0391 16.4142 10.4142C16.0391 10.7893 15.5304 11 15 11H3C2.73478 11 2.48043 11.1054 2.29289 11.2929C2.10536 11.4804 2 11.7348 2 12C2 12.2652 2.10536 12.5196 2.29289 12.7071C2.48043 12.8946 2.73478 13 3 13H15ZM26 9C24.2875 9 22.6313 10.1163 22.0625 11.6525C21.976 11.8998 21.99 12.1712 22.1015 12.4084C22.213 12.6455 22.4131 12.8294 22.6588 12.9204C22.9045 13.0115 23.1762 13.0025 23.4153 12.8954C23.6544 12.7882 23.8419 12.5915 23.9375 12.3475C24.2175 11.5912 25.125 11 26 11C26.5304 11 27.0391 11.2107 27.4142 11.5858C27.7893 11.9609 28 12.4696 28 13C28 13.5304 27.7893 14.0391 27.4142 14.4142C27.0391 14.7893 26.5304 15 26 15H4C3.73478 15 3.48043 15.1054 3.29289 15.2929C3.10536 15.4804 3 15.7348 3 16C3 16.2652 3.10536 16.5196 3.29289 16.7071C3.48043 16.8946 3.73478 17 4 17H26C27.0609 17 28.0783 16.5786 28.8284 15.8284C29.5786 15.0783 30 14.0609 30 13C30 11.9391 29.5786 10.9217 28.8284 10.1716C28.0783 9.42143 27.0609 9 26 9Z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
     }),
+    "x_bold": Object.freeze({
+        viewBox: "0 0 32 32",
+        body: "<path transform=\"matrix(2 0 0 2 0 0)\" d=\"M13.045 2.999l-.096-.088-.08-.059-.09-.053a1.058 1.058 0 00-1.257.177L8 6.501 4.489 2.99l-.042-.04c-.438-.379-1.067-.378-1.449.002l-.075.08-.072.097-.052.088a1.06 1.06 0 00.176 1.258L6.501 8l-3.55 3.552c-.38.44-.38 1.069 0 1.451l.081.075.096.072.088.052c.42.225.925.157 1.258-.176l3.525-3.527 3.548 3.55c.447.388 1.076.374 1.474-.023l.07-.08.065-.087a1.06 1.06 0 00-.135-1.332L9.497 8.001l3.508-3.51.065-.069c.36-.417.35-1.046-.025-1.423z\" fill=\"currentColor\" fill-rule=\"evenodd\"></path>",
+    }),
     "x_circle": Object.freeze({
         viewBox: "0 0 32 32",
         body: "<path d=\"M20.7075 12.7075L17.4138 16L20.7075 19.2925C20.8004 19.3854 20.8741 19.4957 20.9244 19.6171C20.9747 19.7385 21.0006 19.8686 21.0006 20C21.0006 20.1314 20.9747 20.2615 20.9244 20.3829C20.8741 20.5043 20.8004 20.6146 20.7075 20.7075C20.6146 20.8004 20.5043 20.8741 20.3829 20.9244C20.2615 20.9747 20.1314 21.0006 20 21.0006C19.8686 21.0006 19.7385 20.9747 19.6171 20.9244C19.4957 20.8741 19.3854 20.8004 19.2925 20.7075L16 17.4137L12.7075 20.7075C12.6146 20.8004 12.5043 20.8741 12.3829 20.9244C12.2615 20.9747 12.1314 21.0006 12 21.0006C11.8686 21.0006 11.7385 20.9747 11.6171 20.9244C11.4957 20.8741 11.3854 20.8004 11.2925 20.7075C11.1996 20.6146 11.1259 20.5043 11.0756 20.3829C11.0253 20.2615 10.9994 20.1314 10.9994 20C10.9994 19.8686 11.0253 19.7385 11.0756 19.6171C11.1259 19.4957 11.1996 19.3854 11.2925 19.2925L14.5863 16L11.2925 12.7075C11.1049 12.5199 10.9994 12.2654 10.9994 12C10.9994 11.7346 11.1049 11.4801 11.2925 11.2925C11.4801 11.1049 11.7346 10.9994 12 10.9994C12.2654 10.9994 12.5199 11.1049 12.7075 11.2925L16 14.5863L19.2925 11.2925C19.3854 11.1996 19.4957 11.1259 19.6171 11.0756C19.7385 11.0253 19.8686 10.9994 20 10.9994C20.1314 10.9994 20.2615 11.0253 20.3829 11.0756C20.5043 11.1259 20.6146 11.1996 20.7075 11.2925C20.8004 11.3854 20.8741 11.4957 20.9244 11.6171C20.9747 11.7385 21.0006 11.8686 21.0006 12C21.0006 12.1314 20.9747 12.2615 20.9244 12.3829C20.8741 12.5043 20.8004 12.6146 20.7075 12.7075ZM29 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>",
@@ -2376,30 +4754,51 @@ function getBuiltinIcon(name) {
 exports.ActionRegistry = ActionRegistry;
 exports.BUILTIN_ICONS = BUILTIN_ICONS;
 exports.BUILTIN_ICON_NAMES = BUILTIN_ICON_NAMES;
+exports.JsonPointerPathError = JsonPointerPathError;
 exports.LifecycleManager = LifecycleManager;
 exports.StreamingEngine = StreamingEngine;
 exports.StreamingParser = StreamingParser;
 exports.a2uiComponentToElement = a2uiComponentToElement;
 exports.a2uiToCommand = a2uiToCommand;
+exports.bindingTopologyFingerprint = bindingTopologyFingerprint;
+exports.cloneJsonData = cloneJsonData;
 exports.convertLegacySchema = convertLegacySchema;
+exports.createA2UIParameterResolver = createA2UIParameterResolver;
+exports.createExpressionContext = createExpressionContext;
 exports.createLifecycleManager = createLifecycleManager;
+exports.decodeJsonPointerSegment = decodeJsonPointerSegment;
 exports.extractPartialSchema = extractPartialSchema;
+exports.findAffectedRepeatOwners = findAffectedRepeatOwners;
+exports.findTemplateRepeatOwners = findTemplateRepeatOwners;
 exports.getBuiltinIcon = getBuiltinIcon;
+exports.getByJsonPointer = getByJsonPointer;
 exports.getByPath = getByPath$1;
+exports.hasDynamicChildren = hasDynamicChildren;
 exports.hasExpression = hasExpression;
 exports.interpolate = interpolate;
+exports.isA2UIChildList = isA2UIChildList;
+exports.isA2UIDynamicChildList = isA2UIDynamicChildList;
 exports.isA2UIEnvelope = isA2UIEnvelope;
+exports.isA2UIPathBinding = isA2UIPathBinding;
+exports.isBoundRenderTreeNode = isBoundRenderTreeNode;
 exports.isLegacySchema = isLegacySchema;
+exports.materializeCard = materializeCard;
 exports.normalizeSchema = normalizeSchema;
+exports.parseJsonPointer = parseJsonPointer;
 exports.parseSchema = parseSchema;
 exports.registerActionHandler = registerActionHandler;
 exports.registry = registry;
+exports.replaceRootContents = replaceRootContents;
+exports.requiresBindingMaterialization = requiresBindingMaterialization;
 exports.resetIdCounter = resetIdCounter;
+exports.resolveA2UIDeep = resolveA2UIDeep;
+exports.resolveA2UIPath = resolveA2UIPath;
 exports.resolveActionRef = resolveActionRef;
 exports.resolveDeep = resolveDeep;
 exports.resolveExpression = resolveExpression;
 exports.resolveExpressionValue = resolveExpressionValue;
 exports.runActionStep = runActionStep;
 exports.runActionSteps = runActionSteps;
+exports.setByJsonPointer = setByJsonPointer;
 exports.setByPath = setByPath;
 exports.validateSchema = validateSchema;