@antglobal/copilot-cards-web 0.0.20260828032020-dev.9 → 0.0.20260915071159-dev.5

package/README.md

@@ -7,7 +7,7 @@ The package includes the core schema and action APIs, responsive rendering, Shad
 ## Installation
 
 ```bash
-npm install @antglobal/copilot-cards-web@1.0.8
+npm install @antglobal/copilot-cards-web@1.0.9
 ```
 
 `@antglobal/copilot-cards-core` is installed automatically.

package/dist/index.d.ts

@@ -107,6 +107,8 @@ declare function createResponsiveContext(isMobile: boolean, responsive?: Respons
  */
 
 interface RenderCardOptions extends WebActionContextOptions {
+    /** Block whole-card interaction and add a configurable overlay without restyling nodes. Default false. */
+    disabled?: boolean;
     /** Enable mobile component layout explicitly (default false). */
     isMobile?: boolean;
     /** Optional mobile sizing conversion; omitted values preserve px output. */
@@ -117,6 +119,8 @@ interface RenderCardOptions extends WebActionContextOptions {
     botId?: string;
 }
 interface CardInstance {
+    /** Toggle whole-card interaction without changing schema or component business rules. */
+    setDisabled: (disabled: boolean) => void;
     /** Dispose the card: unmount all lifecycles, remove DOM, detach listeners. */
     dispose: () => void;
     /** Update variables and re-render. */
@@ -509,6 +513,8 @@ declare abstract class BaseElement extends HTMLElement {
      * Subclasses must implement this to render their UI into `this.shadowRoot`.
      */
     protected abstract render(): void;
+    /** @internal Close temporary interaction UI without clearing component values. */
+    closeTransientUI(): void;
     /** Convert any content value to a safe display string. */
     protected resolveContent(content: any): string;
     /**
@@ -736,6 +742,7 @@ declare class CardImage extends BaseElement {
     private bindEvents;
     private openLightbox;
     private closeLightbox;
+    closeTransientUI(): void;
     disconnectedCallback(): void;
 }
 
@@ -899,6 +906,7 @@ declare class CardSelect extends BaseElement {
     private _onDocClick;
     static readonly is = "ai-card-select";
     protected render(): void;
+    closeTransientUI(): void;
     disconnectedCallback(): void;
     updateProps(props: Record<string, any>, isMobile?: boolean, responsive?: ResponsiveOptions): void;
     private _setOpen;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { getBuiltinIcon, cloneJsonData, createLifecycleManager, materializeCard, findAffectedRepeatOwners, createA2UIParameterResolver, createExpressionContext, replaceRootContents, getByJsonPointer, resolveA2UIDeep, resolveDeep, resolveExpressionValue, resolveActionRef, isBoundRenderTreeNode, hasExpression, resolveExpression, runActionSteps, normalizeSchema, validateSchema, requiresBindingMaterialization, parseSchema, StreamingParser, StreamingEngine, bindingTopologyFingerprint, findTemplateRepeatOwners, extractPartialSchema, runActionStep, registry } from '@antglobal/copilot-cards-core';
+import { getBuiltinIcon, cloneJsonData, createLifecycleManager, materializeCard, findAffectedRepeatOwners, createA2UIParameterResolver, createExpressionContext, replaceRootContents, getByJsonPointer, resolveA2UIDeep, resolveDeep, resolveExpressionValue, isBoundRenderTreeNode, resolveActionRef, hasExpression, resolveExpression, runActionSteps, normalizeSchema, validateSchema, requiresBindingMaterialization, parseSchema, StreamingParser, StreamingEngine, bindingTopologyFingerprint, findTemplateRepeatOwners, extractPartialSchema, runActionStep, registry } from '@antglobal/copilot-cards-core';
 export { ActionRegistry, a2uiComponentToElement, a2uiToCommand, convertLegacySchema, createLifecycleManager, hasExpression, isA2UIEnvelope, isLegacySchema, normalizeSchema, parseSchema, registerActionHandler, registry, resolveActionRef, resolveDeep, resolveExpression, resolveExpressionValue, runActionStep, runActionSteps, validateSchema } from '@antglobal/copilot-cards-core';
 import * as echarts from 'echarts/core';
 import { LineChart, BarChart, PieChart, ScatterChart, FunnelChart, HeatmapChart } from 'echarts/charts';
@@ -713,6 +713,269 @@ function buildHeatmapOption(config) {
     };
 }
 
+const controllers = new WeakMap();
+const interactionCleanups = new WeakMap();
+/** Cancel slot-owned gestures before covering the card. */
+function registerCardDisableCleanup(element, cleanup) {
+    let callbacks = interactionCleanups.get(element);
+    if (!callbacks) {
+        callbacks = new Set();
+        interactionCleanups.set(element, callbacks);
+    }
+    callbacks.add(cleanup);
+    return () => { callbacks.delete(cleanup); };
+}
+function composedParent(node) {
+    return node.parentNode ?? (node instanceof ShadowRoot ? node.host : null);
+}
+function isCardDisabled(node) {
+    for (let current = node; current; current = composedParent(current)) {
+        if (current instanceof HTMLElement && controllers.get(current)?.isDisabled)
+            return true;
+    }
+    return false;
+}
+const BLOCKED_EVENTS = [
+    'click', 'dblclick', 'auxclick', 'contextmenu',
+    'beforeinput', 'input', 'change', 'submit', 'keydown', 'keyup',
+    'compositionstart', 'compositionupdate', 'compositionend',
+    'choice-request-change', 'choice-navigate',
+];
+const TOUCH_EVENTS = ['pointerdown', 'pointerup', 'touchstart', 'touchend', 'mousedown', 'mouseup', 'wheel'];
+const TAB_TARGETS = [
+    'a[href]', 'area[href]', 'button', 'input', 'select', 'textarea', 'summary',
+    'iframe', 'object', 'embed', 'audio[controls]', 'video[controls]',
+    '[tabindex]', '[contenteditable]:not([contenteditable="false"])',
+].join(',');
+const CARD_DISABLED_ATTRIBUTE = 'data-card-disabled';
+function restoreAttribute(element, name, value) {
+    if (value === null)
+        element.removeAttribute(name);
+    else
+        element.setAttribute(name, value);
+}
+function createCardDisabledController(container, initiallyDisabled = false) {
+    let disabled = false;
+    let disposed = false;
+    let epoch = 0;
+    let updateDepth = 0;
+    let applyingPresentation = false;
+    let previousAriaDisabled = null;
+    let previousDisabledMarker = null;
+    let overlay;
+    let mountStyles = [];
+    let tabSnapshots = [];
+    let tabObserver;
+    const block = (event) => {
+        if (!disabled || disposed)
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    };
+    // Prevent component gesture handlers without cancelling the browser's scroll.
+    const stopGesture = (event) => {
+        if (disabled && !disposed)
+            event.stopImmediatePropagation();
+    };
+    const blockFocus = (event) => {
+        if (!disabled || disposed)
+            return;
+        const target = event.composedPath()[0] ?? event.target;
+        if (target instanceof HTMLElement)
+            target.blur();
+        event.stopImmediatePropagation();
+    };
+    function closeTransientUI(root) {
+        for (const element of root.querySelectorAll('*')) {
+            interactionCleanups.get(element)?.forEach(cleanup => cleanup());
+            const component = element;
+            component.closeTransientUI?.();
+            if (element.shadowRoot)
+                closeTransientUI(element.shadowRoot);
+        }
+    }
+    function blurCardInput() {
+        let active = container.ownerDocument.activeElement;
+        while (active?.shadowRoot?.activeElement)
+            active = active.shadowRoot.activeElement;
+        if (!(active instanceof HTMLElement))
+            return;
+        for (let node = active; node; node = composedParent(node)) {
+            if (node === container) {
+                active.blur();
+                return;
+            }
+        }
+    }
+    function excludeFromTabNavigation(root) {
+        const observer = tabObserver ?? (tabObserver = new MutationObserver(() => {
+            if (!disabled || disposed || updateDepth > 0)
+                return;
+            // Components such as streaming Markdown also update their own Shadow DOM.
+            restoreTabNavigation();
+            excludeFromTabNavigation(container);
+        }));
+        const targets = [];
+        const collect = (element) => {
+            if (element.matches(TAB_TARGETS)) {
+                targets.push(element);
+                return;
+            }
+            // Browsers can put scroll containers in the Tab order without tabindex.
+            const style = element.ownerDocument.defaultView?.getComputedStyle(element);
+            if (style && [style.overflowX, style.overflowY].some(value => value === 'auto' || value === 'scroll')) {
+                targets.push(element);
+            }
+        };
+        const walk = (parent) => {
+            observer.observe(parent, { childList: true, subtree: true });
+            if (parent instanceof HTMLElement)
+                collect(parent);
+            for (const element of parent.querySelectorAll('*')) {
+                collect(element);
+                if (element.shadowRoot)
+                    walk(element.shadowRoot);
+            }
+        };
+        // Collect before writing attributes so style reads stay in one batch.
+        walk(root);
+        for (const element of targets) {
+            tabSnapshots.push({ element, tabindex: element.getAttribute('tabindex') });
+            element.setAttribute('tabindex', '-1');
+        }
+    }
+    function restoreTabNavigation() {
+        tabObserver?.disconnect();
+        if (!disabled)
+            tabObserver = undefined;
+        for (const { element, tabindex } of tabSnapshots) {
+            restoreAttribute(element, 'tabindex', tabindex);
+        }
+        tabSnapshots = [];
+    }
+    function restorePresentation() {
+        restoreTabNavigation();
+        overlay?.remove();
+        for (const [name, value, priority] of mountStyles) {
+            if (value)
+                container.style.setProperty(name, value, priority);
+            else
+                container.style.removeProperty(name);
+        }
+        mountStyles = [];
+    }
+    function coverCard() {
+        const root = container.firstElementChild;
+        if (!root)
+            return;
+        const style = container.ownerDocument.defaultView?.getComputedStyle(container);
+        const ownStyle = (name, value) => {
+            mountStyles.push([name, container.style.getPropertyValue(name), container.style.getPropertyPriority(name)]);
+            container.style.setProperty(name, value, 'important');
+        };
+        if (!style?.position || style.position === 'static')
+            ownStyle('position', 'relative');
+        // Keep the mask above card content without covering neighboring messages.
+        ownStyle('isolation', 'isolate');
+        overlay ?? (overlay = container.ownerDocument.createElement('div'));
+        overlay.setAttribute('data-card-disabled-overlay', '');
+        overlay.setAttribute('aria-hidden', 'true');
+        overlay.style.cssText = 'position:absolute;inset:0;z-index:2147483647;pointer-events:auto;cursor:default;'
+            + 'background:var(--card-disabled-overlay-background, rgba(255, 255, 255, 0.6));';
+        // A dedicated mount normally shares the root card's bounds. Respect a mount
+        // radius when provided, otherwise match the rendered card's rounded corners.
+        const rootStyle = container.ownerDocument.defaultView?.getComputedStyle(root);
+        overlay.style.borderRadius = style?.borderRadius && style.borderRadius !== '0px'
+            ? style.borderRadius : rootStyle?.borderRadius ?? '';
+        container.appendChild(overlay);
+    }
+    function applyPresentation() {
+        if (!disabled || disposed || updateDepth > 0 || applyingPresentation)
+            return;
+        applyingPresentation = true;
+        try {
+            // Blur/popup callbacks can synchronously update or toggle the card.
+            // Reattach only after renderer updates and popup/gesture cleanup finish.
+            restorePresentation();
+            closeTransientUI(container);
+            blurCardInput();
+            if (!disabled || disposed)
+                return;
+            coverCard();
+            excludeFromTabNavigation(container);
+        }
+        finally {
+            applyingPresentation = false;
+        }
+    }
+    function listen(enabled) {
+        for (const name of BLOCKED_EVENTS) {
+            if (enabled)
+                container.addEventListener(name, block, true);
+            else
+                container.removeEventListener(name, block, true);
+        }
+        for (const name of TOUCH_EVENTS) {
+            if (enabled)
+                container.addEventListener(name, stopGesture, { capture: true, passive: true });
+            else
+                container.removeEventListener(name, stopGesture, true);
+        }
+        if (enabled)
+            container.addEventListener('focus', blockFocus, true);
+        else
+            container.removeEventListener('focus', blockFocus, true);
+    }
+    const controller = {
+        get isDisabled() { return disabled && !disposed; },
+        get epoch() { return epoch; },
+        setDisabled(value) {
+            if (disposed || disabled === value)
+                return;
+            disabled = value;
+            epoch += 1;
+            if (disabled) {
+                previousAriaDisabled = container.getAttribute('aria-disabled');
+                previousDisabledMarker = container.getAttribute(CARD_DISABLED_ATTRIBUTE);
+                container.setAttribute('aria-disabled', 'true');
+                container.setAttribute(CARD_DISABLED_ATTRIBUTE, 'true');
+                listen(true);
+                blurCardInput();
+                applyPresentation();
+            }
+            else {
+                restorePresentation();
+                restoreAttribute(container, 'aria-disabled', previousAriaDisabled);
+                restoreAttribute(container, CARD_DISABLED_ATTRIBUTE, previousDisabledMarker);
+                listen(false);
+            }
+        },
+        update(render) {
+            if (updateDepth === 0)
+                restorePresentation();
+            updateDepth += 1;
+            try {
+                return render();
+            }
+            finally {
+                updateDepth -= 1;
+                if (updateDepth === 0)
+                    applyPresentation();
+            }
+        },
+        dispose() {
+            if (disposed)
+                return;
+            controller.setDisabled(false);
+            disposed = true;
+            controllers.delete(container);
+        },
+    };
+    controllers.set(container, controller);
+    controller.setDisabled(initiallyDisabled);
+    return controller;
+}
+
 /**
  * Slot Layout Renderers — each slot key maps to a specific layout strategy.
  *
@@ -1033,6 +1296,15 @@ function mergePresentationOwnership(...ownership) {
         styleProperties: Array.from(new Set(ownership.flatMap(value => value.styleProperties))),
     };
 }
+const datePickerRowPaddingPatches = new WeakMap();
+/** Suspend an open date picker's row padding around renderer-owned style updates. */
+function registerDatePickerRowPaddingPatch(row, suspend) {
+    datePickerRowPaddingPatches.set(row, suspend);
+    return () => {
+        if (datePickerRowPaddingPatches.get(row) === suspend)
+            datePickerRowPaddingPatches.delete(row);
+    };
+}
 /** Patch renderer-owned shell presentation without overwriting layout state. */
 function patchElementShellPresentation(current, previous, desired, ...preservedOwnership) {
     const ownership = mergePresentationOwnership(...preservedOwnership);
@@ -1068,43 +1340,49 @@ function patchElementShellPresentation(current, previous, desired, ...preservedO
         else
             current.removeAttribute(name);
     }
-    const previousPropertyNames = stylePropertyNames(previous.style);
-    const desiredPropertyNames = stylePropertyNames(desired.style);
-    const propertyNames = new Set([
-        ...previousPropertyNames,
-        ...desiredPropertyNames,
-    ]);
-    const currentPropertyNames = stylePropertyNames(current.style);
-    for (const name of propertyNames) {
-        if (layoutStyleProperties.has(name))
-            continue;
-        const previousHas = previousPropertyNames.has(name);
-        const desiredHas = desiredPropertyNames.has(name);
-        const previousValue = previous.style.getPropertyValue(name);
-        const desiredValue = desired.style.getPropertyValue(name);
-        const previousPriority = previous.style.getPropertyPriority(name);
-        const desiredPriority = desired.style.getPropertyPriority(name);
-        if (previousHas === desiredHas
-            && previousValue === desiredValue
-            && previousPriority === desiredPriority) {
-            continue;
-        }
-        if (previousHas) {
-            if (!currentPropertyNames.has(name)
-                || current.style.getPropertyValue(name) !== previousValue
-                || current.style.getPropertyPriority(name) !== previousPriority) {
+    const resumeDatePickerPadding = datePickerRowPaddingPatches.get(current)?.();
+    try {
+        const previousPropertyNames = stylePropertyNames(previous.style);
+        const desiredPropertyNames = stylePropertyNames(desired.style);
+        const propertyNames = new Set([
+            ...previousPropertyNames,
+            ...desiredPropertyNames,
+        ]);
+        const currentPropertyNames = stylePropertyNames(current.style);
+        for (const name of propertyNames) {
+            if (layoutStyleProperties.has(name))
+                continue;
+            const previousHas = previousPropertyNames.has(name);
+            const desiredHas = desiredPropertyNames.has(name);
+            const previousValue = previous.style.getPropertyValue(name);
+            const desiredValue = desired.style.getPropertyValue(name);
+            const previousPriority = previous.style.getPropertyPriority(name);
+            const desiredPriority = desired.style.getPropertyPriority(name);
+            if (previousHas === desiredHas
+                && previousValue === desiredValue
+                && previousPriority === desiredPriority) {
                 continue;
             }
+            if (previousHas) {
+                if (!currentPropertyNames.has(name)
+                    || current.style.getPropertyValue(name) !== previousValue
+                    || current.style.getPropertyPriority(name) !== previousPriority) {
+                    continue;
+                }
+            }
+            else if (currentPropertyNames.has(name)) {
+                continue;
+            }
+            if (desiredHas) {
+                current.style.setProperty(name, desiredValue, desiredPriority);
+            }
+            else {
+                current.style.removeProperty(name);
+            }
         }
-        else if (currentPropertyNames.has(name)) {
-            continue;
-        }
-        if (desiredHas) {
-            current.style.setProperty(name, desiredValue, desiredPriority);
-        }
-        else {
-            current.style.removeProperty(name);
-        }
+    }
+    finally {
+        resumeDatePickerPadding?.();
     }
 }
 /** Release slot-owned item listeners within a disposed subtree. */
@@ -1391,15 +1669,29 @@ function renderHorizontalScrollSlot(container, children, slotContent, renderChil
         e.preventDefault();
         track.scrollLeft = scrollLeft - (e.pageX - startX);
     };
-    const stopDrag = () => {
+    const cancelDrag = () => {
         if (!isDragging)
             return;
         isDragging = false;
         track.style.cursor = 'grab';
         track.style.removeProperty('user-select');
+    };
+    const stopDrag = () => {
+        if (!isDragging)
+            return;
+        cancelDrag();
         if (snap)
             track.style.scrollSnapType = 'x mandatory';
     };
+    // Leave snap suspended on disable so the viewport does not jump. The next
+    // normal drag/wheel completion restores it.
+    ownerCleanup.add(registerCardDisableCleanup(track, () => {
+        cancelDrag();
+        if (wheelTimer) {
+            window.clearTimeout(wheelTimer);
+            wheelTimer = 0;
+        }
+    }));
     addSlotOwnerListener(ownerCleanup, track, 'mousedown', handleMouseDown);
     addSlotOwnerListener(ownerCleanup, track, 'mousemove', handleMouseMove);
     addSlotOwnerListener(ownerCleanup, track, 'mouseup', stopDrag);
@@ -1963,6 +2255,7 @@ function renderCarouselSlot(container, children, _slotContent, props, renderChil
     let isDragging = false;
     let startX = 0;
     let scrollStart = 0;
+    let wheelTimer = 0;
     const handleMouseDown = (event) => {
         if (ownerDisposed)
             return;
@@ -1993,12 +2286,46 @@ function renderCarouselSlot(container, children, _slotContent, props, renderChil
         if (!ownerDisposed)
             snapToNearest();
     };
+    ownerCleanup.add(registerCardDisableCleanup(container, () => {
+        if (isDragging) {
+            isDragging = false;
+            container.style.cursor = 'grab';
+        }
+        if (wheelTimer) {
+            window.clearTimeout(wheelTimer);
+            wheelTimer = 0;
+        }
+        const wasSnapping = pendingSnapScrollEnd !== null || pendingSnapTimer !== 0;
+        clearPendingSnap();
+        // Cancel the browser's in-flight animation as well as its completion callbacks.
+        // The next normal interaction restores snap through snapToNearest.
+        if (wasSnapping) {
+            const left = container.scrollLeft;
+            const overflowX = container.style.getPropertyValue('overflow-x');
+            const priority = container.style.getPropertyPriority('overflow-x');
+            // Safari can deliver a stale compositor frame after scrollTo('instant').
+            // Flush the scroll-container change synchronously so no delayed correction
+            // can overwrite a fresh gesture or API navigation after re-enabling.
+            container.style.setProperty('overflow-x', 'hidden', 'important');
+            try {
+                void container.offsetWidth;
+                container.scrollTo({ left, behavior: 'instant' });
+            }
+            finally {
+                if (overflowX)
+                    container.style.setProperty('overflow-x', overflowX, priority);
+                else
+                    container.style.removeProperty('overflow-x');
+            }
+            void container.offsetWidth;
+            container.scrollTo({ left, behavior: 'instant' });
+        }
+    }));
     addSlotOwnerListener(ownerCleanup, container, 'mousedown', handleMouseDown);
     addSlotOwnerListener(ownerCleanup, document, 'mousemove', handleMouseMove);
     addSlotOwnerListener(ownerCleanup, document, 'mouseup', handleMouseUp);
     addSlotOwnerListener(ownerCleanup, container, 'touchend', handleTouchEnd, { passive: true });
     // Wheel support
-    let wheelTimer = 0;
     const handleWheel = (event) => {
         if (ownerDisposed)
             return;
@@ -2396,6 +2723,8 @@ class BaseElement extends HTMLElement {
         this._responsive = createResponsiveContext(this._isMobile, this._responsiveOptions);
         this.render();
     }
+    /** @internal Close temporary interaction UI without clearing component values. */
+    closeTransientUI() { }
     // ─── Helpers ────────────────────────────────────────────────
     /** Convert any content value to a safe display string. */
     resolveContent(content) {
@@ -3856,7 +4185,8 @@ class CardInput extends BaseElement {
     requestAutoFocus() {
         if (!this.isConnected
             || !this._props.autoFocus
-            || this.hasAttribute('data-disabled')) {
+            || this.hasAttribute('data-disabled')
+            || isCardDisabled(this)) {
             return false;
         }
         const control = this.shadowRoot?.querySelector('.card-input');
@@ -4182,6 +4512,10 @@ class CardImage extends BaseElement {
         document.body.style.overflow = '';
         document.removeEventListener('keydown', this._handleEscape);
     }
+    closeTransientUI() {
+        if (this._lightbox?.classList.contains('open'))
+            this.closeLightbox(this._lightbox);
+    }
     disconnectedCallback() {
         // Ensure body overflow is restored when element is removed
         document.body.style.overflow = '';
@@ -5118,6 +5452,9 @@ class CardSelect extends BaseElement {
             });
         });
     }
+    closeTransientUI() {
+        this._setOpen(false);
+    }
     disconnectedCallback() {
         document.removeEventListener('click', this._onDocClick);
     }
@@ -7222,17 +7559,85 @@ const CHEVRON_ICON = `
   <svg viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
     <path d="M2.5 4.5L6 8l3.5-3.5" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"/>
   </svg>`;
+// Opening another picker starts before the document click closes the first one.
+// Share the row reservation so that this overlap cannot accumulate padding.
+const mobilePanelRows = new WeakMap();
+function updateRowSpace(row, space) {
+    // Preserve host style changes made while the calendar owns extra padding.
+    const padding = row.style.getPropertyValue('padding-bottom');
+    const priority = row.style.getPropertyPriority('padding-bottom');
+    if (padding !== space.appliedPaddingBottom || priority !== space.priority) {
+        space.paddingBottom = padding;
+        space.priority = priority;
+        space.basePaddingBottom = padding || getComputedStyle(row).paddingBottom;
+    }
+    if (space.panels.size) {
+        const height = Math.max(...space.panels.values());
+        row.style.setProperty('padding-bottom', `calc(${space.basePaddingBottom} + ${height}px)`, space.priority);
+    }
+    else {
+        if (space.paddingBottom)
+            row.style.setProperty('padding-bottom', space.paddingBottom, space.priority);
+        else
+            row.style.removeProperty('padding-bottom');
+        mobilePanelRows.delete(row);
+        space.releasePatch();
+    }
+    // CSSOM can simplify calc(); compare its serialized value on the next write.
+    space.appliedPaddingBottom = row.style.getPropertyValue('padding-bottom');
+}
 class CardDatePicker extends BaseElement {
     constructor() {
         super(...arguments);
         this._open = false;
         this._calendar = null;
+        this._panelResizeObserver = null;
+        this._mobilePanelRow = null;
         /** Dates picked in the panel; shown until props.value changes externally. */
         this._localValue = null;
         this._onDocClick = (e) => {
-            if (!this.contains(e.target))
+            if (!e.composedPath().includes(this))
                 this._setOpen(false);
         };
+        this._positionMobilePanel = () => {
+            if (!this._isMobile || !this._open)
+                return;
+            const panel = this.shadowRoot?.querySelector('.panel');
+            const calendar = panel?.querySelector('[data-vc="calendar"]');
+            if (!panel || !calendar)
+                return;
+            this._panelResizeObserver?.observe(calendar);
+            const row = this._mobilePanelRow;
+            if (row) {
+                const style = getComputedStyle(row);
+                const contentBottom = row.getBoundingClientRect().bottom
+                    - parseFloat(style.paddingBottom) - parseFloat(style.borderBottomWidth);
+                panel.style.top = `${contentBottom - this.getBoundingClientRect().top}px`;
+                const space = mobilePanelRows.get(row);
+                space.panels.set(this, calendar.getBoundingClientRect().bottom - contentBottom);
+                updateRowSpace(row, space);
+            }
+            panel.style.left = '0px';
+            const bounds = calendar.getBoundingClientRect();
+            let left = 0;
+            let right = document.documentElement.clientWidth;
+            // Intersect clipping ancestors, crossing shadow roots when cards are embedded.
+            let ancestor = this.shadowRoot.host;
+            while (ancestor) {
+                this._panelResizeObserver?.observe(ancestor);
+                if (/^(auto|scroll|hidden|clip)$/.test(getComputedStyle(ancestor).overflowX)) {
+                    const rect = ancestor.getBoundingClientRect();
+                    const innerLeft = rect.left + ancestor.clientLeft;
+                    left = Math.max(left, innerLeft);
+                    right = Math.min(right, innerLeft + ancestor.clientWidth);
+                }
+                const root = ancestor.getRootNode();
+                ancestor = ancestor.assignedSlot ?? ancestor.parentElement
+                    ?? (root instanceof ShadowRoot ? root.host : null);
+            }
+            // Shift the panel without changing the trigger's intrinsic width.
+            panel.style.left = `${Math.max(left, Math.min(bounds.left, right - bounds.width)) - bounds.left}px`;
+        };
     }
     render() {
         if (!this.shadowRoot || !this._node)
@@ -7333,8 +7738,11 @@ class CardDatePicker extends BaseElement {
         .trigger-arrow.open { transform: rotate(180deg); }
         .panel {
           display: none;
-          position: absolute;
-          top: calc(100% + 4px);
+          /* Column layouts include the calendar in flow. Horizontal flex rows
+             reserve space below the whole row when the panel is mounted. */
+          position: ${this._isMobile ? 'relative' : 'absolute'};
+          ${this._isMobile ? 'margin-top: 4px; contain: inline-size;' : ''}
+          top: ${this._isMobile ? '0' : 'calc(100% + 4px)'};
           left: 0;
           z-index: 1000;
         }
@@ -7386,6 +7794,9 @@ class CardDatePicker extends BaseElement {
         this._destroyCalendar();
     }
     // ─── Private ────────────────────────────────────────────────
+    closeTransientUI() {
+        this._setOpen(false);
+    }
     _setOpen(open) {
         if (this._open === open)
             return;
@@ -7467,8 +7878,59 @@ class CardDatePicker extends BaseElement {
             },
         });
         this._calendar.init();
+        if (this._isMobile) {
+            const row = this.parentElement;
+            if (row && /^(inline-)?flex$/.test(getComputedStyle(row).display)
+                && /^row/.test(getComputedStyle(row).flexDirection)) {
+                const panel = container.parentElement;
+                panel.style.position = 'absolute';
+                this._mobilePanelRow = row;
+                if (!mobilePanelRows.has(row)) {
+                    const space = {
+                        paddingBottom: row.style.getPropertyValue('padding-bottom'),
+                        priority: row.style.getPropertyPriority('padding-bottom'),
+                        basePaddingBottom: row.style.paddingBottom || getComputedStyle(row).paddingBottom,
+                        appliedPaddingBottom: row.style.getPropertyValue('padding-bottom'),
+                        panels: new Map(),
+                        releasePatch: () => { },
+                    };
+                    mobilePanelRows.set(row, space);
+                    space.releasePatch = registerDatePickerRowPaddingPatch(row, () => {
+                        // Make the schema's baseline visible to the incremental style diff.
+                        // If a host already replaced our value, leave that external style.
+                        if (row.style.getPropertyValue('padding-bottom') === space.appliedPaddingBottom
+                            && row.style.getPropertyPriority('padding-bottom') === space.priority) {
+                            if (space.paddingBottom)
+                                row.style.setProperty('padding-bottom', space.paddingBottom, space.priority);
+                            else
+                                row.style.removeProperty('padding-bottom');
+                            space.appliedPaddingBottom = row.style.getPropertyValue('padding-bottom');
+                        }
+                        return () => updateRowSpace(row, space);
+                    });
+                }
+            }
+            if (typeof ResizeObserver !== 'undefined') {
+                this._panelResizeObserver = new ResizeObserver(this._positionMobilePanel);
+            }
+            // Calendar navigation changes height synchronously, including browsers
+            // without ResizeObserver. Run after the calendar's own click handler.
+            container.parentElement.addEventListener('click', this._positionMobilePanel);
+            window.addEventListener('resize', this._positionMobilePanel);
+            this._positionMobilePanel();
+        }
     }
     _destroyCalendar() {
+        window.removeEventListener('resize', this._positionMobilePanel);
+        this.shadowRoot?.querySelector('.panel')?.removeEventListener('click', this._positionMobilePanel);
+        this._panelResizeObserver?.disconnect();
+        this._panelResizeObserver = null;
+        if (this._mobilePanelRow) {
+            const space = mobilePanelRows.get(this._mobilePanelRow);
+            space.panels.delete(this);
+            updateRowSpace(this._mobilePanelRow, space);
+            this._mobilePanelRow = null;
+        }
         if (this._calendar) {
             this._calendar.destroy();
             this._calendar = null;
@@ -8972,7 +9434,7 @@ function createCardNodeAccess(container) {
             },
             focus(options) {
                 const element = resolveElement(id);
-                if (!element || element.hasAttribute('data-disabled'))
+                if (!element || element.hasAttribute('data-disabled') || isCardDisabled(element))
                     return false;
                 const target = element.shadowRoot
                     ?.querySelector(FOCUS_TARGET_SELECTOR) ?? element;
@@ -9193,28 +9655,15 @@ function createCardNodeAccess(container) {
 }
 
 const DISABLED_MARKER = 'data-copilot-card-disabled';
-const DISABLED_STYLES_MARKER = 'data-copilot-card-disabled-styles';
-const DISABLED_PRESENTATION_CSS = `
-[${DISABLED_MARKER}="true"] {
-  background-color: var(--card-disabled-background, #F5F5F5) !important;
-  color: var(--card-disabled-foreground, #C0C0C0) !important;
-}
-`;
-function ensureDisabledPresentationStyles(ownerDocument) {
-    if (ownerDocument.head.querySelector(`style[${DISABLED_STYLES_MARKER}]`)) {
-        return;
-    }
-    const style = ownerDocument.createElement('style');
-    style.setAttribute(DISABLED_STYLES_MARKER, '');
-    style.textContent = DISABLED_PRESENTATION_CSS;
-    ownerDocument.head.appendChild(style);
-}
 function applyDisabledState(element, disabled) {
     if (!disabled)
         return;
-    ensureDisabledPresentationStyles(element.ownerDocument);
     element.setAttribute('data-disabled', 'true');
     element.setAttribute(DISABLED_MARKER, 'true');
+    // Inline declarations work inside host ShadowRoots too. Use the shorthand
+    // to mask background images/gradients, matching the historical disabled state.
+    element.style.background = 'var(--card-disabled-background, #F5F5F5)';
+    element.style.color = 'var(--card-disabled-foreground, #C0C0C0)';
     element.style.pointerEvents = 'none';
     element.style.cursor = 'default';
 }
@@ -9479,6 +9928,7 @@ function renderBoundCard(container, schema, options) {
             },
             events,
             isActive: () => (!disposed
+                && !cardDisabled.isDisabled
                 && !publishing
                 && container.contains(element)),
         });
@@ -9982,7 +10432,12 @@ function renderBoundCard(container, schema, options) {
         try {
             for (const [occurrenceKey, plan] of appendPlans) {
                 const prepared = findPreparedByOccurrenceKey(preparedRoot, occurrenceKey);
-                if (!prepared?.[REPEAT_APPEND]) {
+                // Hidden or force-replaced ancestors prune their descendants from the
+                // prepared tree. Their normal replacement commits the new variables;
+                // there is no live descendant append to prepare in this transaction.
+                if (!prepared)
+                    continue;
+                if (!prepared[REPEAT_APPEND]) {
                     throw new Error(`[renderCard] Missing prepared repeat append owner "${occurrenceKey}"`);
                 }
                 const nextOccurrenceKeys = occurrenceKeysForChildren(plan.current.occurrenceKey, plan.nextNode.children);
@@ -10463,7 +10918,7 @@ function renderBoundCard(container, schema, options) {
         error.failures = failures;
         return error;
     }
-    function commitIncrementalCandidate(candidate, renderVariables) {
+    function commitIncrementalCandidateContent(candidate, renderVariables) {
         const replacements = candidate.replacementRoots;
         try {
             if (!currentMountedTree) {
@@ -10655,6 +11110,9 @@ function renderBoundCard(container, schema, options) {
             disposeCandidate(candidate);
         }
     }
+    function commitIncrementalCandidate(candidate, renderVariables) {
+        return cardDisabled.update(() => commitIncrementalCandidateContent(candidate, renderVariables));
+    }
     function assertCurrentRevision(baseRevision) {
         if (disposed || publishing || revision !== baseRevision) {
             const error = new Error('[renderCard] BOUND_TRANSACTION_CONFLICT');
@@ -10662,7 +11120,7 @@ function renderBoundCard(container, schema, options) {
             throw error;
         }
     }
-    function commitDraft(before, draft, baseRevision) {
+    function commitDraftContent(before, draft, baseRevision) {
         assertCurrentRevision(baseRevision);
         const validationRoot = cloneJsonData(variables);
         replaceRootContents(validationRoot, draft);
@@ -10716,6 +11174,9 @@ function renderBoundCard(container, schema, options) {
         reconcileLifecycles(selectLifecycleNodes(currentMaterialized, collectMountedLifecycleIds(currentMountedTree)));
         applyAutoFocus(candidate);
     }
+    function commitDraft(before, draft, baseRevision) {
+        return cardDisabled.update(() => commitDraftContent(before, draft, baseRevision));
+    }
     function writeDraftVariable(draft, key, value) {
         Object.defineProperty(draft, String(key), {
             value,
@@ -10772,7 +11233,7 @@ function renderBoundCard(container, schema, options) {
         };
     }
     async function runBoundEvent(runtimeId, eventName, eventDetail, baseRevision, repeatTargetFingerprint) {
-        if (disposed)
+        if (disposed || cardDisabled.isDisabled)
             return;
         assertCurrentRevision(baseRevision);
         const transactionBefore = cloneJsonData(variables);
@@ -10808,13 +11269,14 @@ function renderBoundCard(container, schema, options) {
         commitDraft(cloneJsonData(lastPublishedVariables), draft, baseRevision);
     }
     function enqueueBoundEvent(runtimeId, eventName, eventDetail, repeatTargetFingerprint) {
-        if (disposed)
+        if (disposed || cardDisabled.isDisabled)
             return;
+        const interactionEpoch = cardDisabled.epoch;
         const enqueueRevision = revision;
         const queuedBehindAnotherAction = queuedActionCount > 0;
         queuedActionCount += 1;
         actionQueue = actionQueue
-            .then(() => runBoundEvent(runtimeId, eventName, eventDetail, queuedBehindAnotherAction ? revision : enqueueRevision, repeatTargetFingerprint))
+            .then(() => interactionEpoch === cardDisabled.epoch ? runBoundEvent(runtimeId, eventName, eventDetail, queuedBehindAnotherAction ? revision : enqueueRevision, repeatTargetFingerprint) : undefined)
             .catch((error) => {
             if (error
                 && typeof error === 'object'
@@ -10846,6 +11308,7 @@ function renderBoundCard(container, schema, options) {
         disposed = true;
         disposeRequested = false;
         nodeAccess.dispose();
+        cardDisabled.dispose();
         abortController.abort();
         if (currentMountedTree) {
             disposeBoundSubtree(currentMountedTree);
@@ -10883,17 +11346,26 @@ function renderBoundCard(container, schema, options) {
             console.error('[renderCard] Bound lifecycle dispose failed', error);
         });
     }
-    const initialCandidate = prepareIncrementalCandidate(variables, variables);
-    publishing = true;
+    const cardDisabled = createCardDisabledController(container, options.disabled);
     try {
-        currentMountedTree = commitIncrementalCandidate(initialCandidate, variables);
-        currentMaterialized = materializeCard(schema, variables);
+        const initialCandidate = prepareIncrementalCandidate(variables, variables);
+        publishing = true;
+        try {
+            currentMountedTree = commitIncrementalCandidate(initialCandidate, variables);
+            currentMaterialized = materializeCard(schema, variables);
+        }
+        finally {
+            publishing = false;
+        }
+        reconcileLifecycles(selectLifecycleNodes(currentMaterialized, collectMountedLifecycleIds(currentMountedTree)));
     }
-    finally {
-        publishing = false;
+    catch (error) {
+        nodeAccess.dispose();
+        cardDisabled.dispose();
+        throw error;
     }
-    reconcileLifecycles(selectLifecycleNodes(currentMaterialized, collectMountedLifecycleIds(currentMountedTree)));
     return {
+        setDisabled: cardDisabled.setDisabled,
         getNode: nodeAccess.getNode,
         onFocusChange: nodeAccess.onFocusChange,
         onScroll: nodeAccess.onScroll,
@@ -11261,7 +11733,7 @@ function renderStaticCard(container, schema, options) {
         };
     }
     function runStaticEventActions(steps, detail) {
-        if (disposed)
+        if (disposed || cardDisabled.isDisabled)
             return;
         if (detail != null)
             variables._event = detail;
@@ -11400,6 +11872,7 @@ function renderStaticCard(container, schema, options) {
             },
             events: resolvedEventBindings,
             isActive: () => (!disposed
+                && !cardDisabled.isDisabled
                 && !publishing
                 && container.contains(element)),
         });
@@ -11598,7 +12071,7 @@ function renderStaticCard(container, schema, options) {
             }
         }
     }
-    function render() {
+    function renderContent() {
         if (disposed)
             return;
         const generation = ++renderGeneration;
@@ -11692,6 +12165,9 @@ function renderStaticCard(container, schema, options) {
             startLifecycleMount(id, lifecycle);
         }
     }
+    function render() {
+        return cardDisabled.update(() => renderContent());
+    }
     function rerender() {
         if (disposed)
             return;
@@ -11705,6 +12181,7 @@ function renderStaticCard(container, schema, options) {
         disposeRequested = false;
         hostAuthorityEpoch += 1;
         nodeAccess.dispose();
+        cardDisabled.dispose();
         abortController.abort();
         if (mountedTree) {
             disposeStaticSubtree(mountedTree);
@@ -11718,9 +12195,18 @@ function renderStaticCard(container, schema, options) {
             destroyLifecycle(record);
     }
     // 7. Initial render
-    render();
+    const cardDisabled = createCardDisabledController(container, options.disabled);
+    try {
+        render();
+    }
+    catch (error) {
+        nodeAccess.dispose();
+        cardDisabled.dispose();
+        throw error;
+    }
     // 8. Return instance handle
     return {
+        setDisabled: cardDisabled.setDisabled,
         getNode: nodeAccess.getNode,
         onFocusChange: nodeAccess.onFocusChange,
         onScroll: nodeAccess.onScroll,
@@ -12101,6 +12587,8 @@ function renderStreamingCard(container, options = {}) {
         const variableKey = resolvedProps.variableKey;
         if (variableKey) {
             element.addEventListener('input', ((event) => {
+                if (disposed || cardDisabled.isDisabled || !container.contains(element))
+                    return;
                 if (event.target !== element || !currentMaterialized)
                     return;
                 const value = event.detail?.value
@@ -12116,6 +12604,8 @@ function renderStreamingCard(container, options = {}) {
                 }
                 const domEvent = eventMap[eventName] ?? eventName;
                 element.addEventListener(domEvent, ((event) => {
+                    if (disposed || cardDisabled.isDisabled || !container.contains(element))
+                        return;
                     const ownsValueEvent = ((domEvent === 'input' || domEvent === 'change')
                         && valueControlTypes.has(node.type));
                     if (ownsValueEvent && event.target !== element)
@@ -12184,6 +12674,8 @@ function renderStreamingCard(container, options = {}) {
         const variableKey = resolvedProps.variableKey;
         if (variableKey) {
             el.addEventListener('input', ((e) => {
+                if (disposed || cardDisabled.isDisabled || !container.contains(el))
+                    return;
                 const value = e.detail?.value
                     ?? e.target?.value;
                 if (value !== undefined) {
@@ -12202,6 +12694,8 @@ function renderStreamingCard(container, options = {}) {
                     continue;
                 const domEvent = eventMap[event] ?? event;
                 el.addEventListener(domEvent, ((e) => {
+                    if (disposed || cardDisabled.isDisabled || !container.contains(el))
+                        return;
                     if (e instanceof CustomEvent && e.detail != null) {
                         variables._event = e.detail;
                     }
@@ -12385,7 +12879,7 @@ function renderStreamingCard(container, options = {}) {
      * (visibility flips / container shape changes) re-render only their subtree.
      * Falls back to a full render solely when a subtree can't be rebuilt.
      */
-    function diffAllElements(previousVariables) {
+    function diffAllElementsContent(previousVariables) {
         actionContext = buildActionContext();
         const schema = (currentSurfaceId ? engine.getSchema(currentSurfaceId) : undefined) ?? currentSchema;
         if (!schema)
@@ -12425,6 +12919,8 @@ function renderStreamingCard(container, options = {}) {
                 continue;
             if ('updateProps' in el) {
                 el.updateProps(resolved, isMobile, options.responsive);
+                // Some components replace host cssText while updating their props.
+                applyDisabledState(el, wasDisabled);
                 propsCache.set(id, key);
             }
             else if (!replaceSubtree(schema, id, el)) {
@@ -12435,6 +12931,9 @@ function renderStreamingCard(container, options = {}) {
         }
         applyAutoFocusIds(autoFocusIds);
     }
+    function diffAllElements(previousVariables) {
+        return cardDisabled.update(() => diffAllElementsContent(previousVariables));
+    }
     function captureBoundScrollPositions(root) {
         const positions = new Map();
         root.querySelectorAll('[data-scroll-id]').forEach((element) => {
@@ -12785,7 +13284,7 @@ function renderStreamingCard(container, options = {}) {
             throw error;
         }
     }
-    function commitBoundFull(prepared, schema, draft, baseRevision, commitAuthoritativeVariables) {
+    function commitBoundFullContent(prepared, schema, draft, baseRevision, commitAuthoritativeVariables) {
         assertBoundRevision(baseRevision);
         commitAuthoritativeVariables?.();
         replaceRootContents(variables, draft);
@@ -12807,6 +13306,9 @@ function renderStreamingCard(container, options = {}) {
         restoreBoundScrollPositions(container, scrollPositions);
         restoreBoundMediaStates(container, mediaStates);
     }
+    function commitBoundFull(prepared, schema, draft, baseRevision, commitAuthoritativeVariables) {
+        return cardDisabled.update(() => commitBoundFullContent(prepared, schema, draft, baseRevision, commitAuthoritativeVariables));
+    }
     function ownerKeysWithoutNestedDuplicates(materialized, owners) {
         const selected = new Set(owners.map(owner => owner.key));
         return owners.filter((owner) => {
@@ -12926,7 +13428,7 @@ function renderStreamingCard(container, options = {}) {
             replacedLifecycleIds,
         };
     }
-    function commitBoundIncremental(prepared, schema, draft, baseRevision, commitAuthoritativeVariables) {
+    function commitBoundIncrementalContent(prepared, schema, draft, baseRevision, commitAuthoritativeVariables) {
         assertBoundRevision(baseRevision);
         commitAuthoritativeVariables?.();
         replaceRootContents(variables, draft);
@@ -12957,6 +13459,9 @@ function renderStreamingCard(container, options = {}) {
         restoreBoundScrollPositions(container, scrollPositions);
         restoreBoundMediaStates(container, mediaStates);
     }
+    function commitBoundIncremental(prepared, schema, draft, baseRevision, commitAuthoritativeVariables) {
+        return cardDisabled.update(() => commitBoundIncrementalContent(prepared, schema, draft, baseRevision, commitAuthoritativeVariables));
+    }
     function prepareAndCommitBoundUpdate(schema, draft, owners, baseRevision, commitAuthoritativeVariables, changedSourceIds = new Set()) {
         try {
             const prepared = prepareBoundIncremental(schema, draft, owners, changedSourceIds);
@@ -13136,6 +13641,8 @@ function renderStreamingCard(container, options = {}) {
         prepareAndCommitBoundUpdate(schema, draft, owners, baseRevision, commitAuthoritative);
     }
     async function runBoundEvent(runtimeId, eventName, eventDetail) {
+        if (disposed || cardDisabled.isDisabled)
+            return;
         if (!currentMaterialized || !currentSchema || !currentSurfaceId)
             return;
         const baseRevision = boundRevision;
@@ -13162,8 +13669,12 @@ function renderStreamingCard(container, options = {}) {
         applyAutoFocusIds(autoFocusIds);
     }
     function enqueueBoundEvent(runtimeId, eventName, eventDetail) {
+        if (disposed || cardDisabled.isDisabled)
+            return;
+        const interactionEpoch = cardDisabled.epoch;
         boundActionQueue = boundActionQueue
-            .then(() => runBoundEvent(runtimeId, eventName, eventDetail))
+            .then(() => interactionEpoch === cardDisabled.epoch
+            ? runBoundEvent(runtimeId, eventName, eventDetail) : undefined)
             .catch((error) => {
             if (error
                 && typeof error === 'object'
@@ -13338,7 +13849,7 @@ function renderStreamingCard(container, options = {}) {
      * assigned on createSurface — so newly added components would not render and text
      * appended via appendContent would be wiped on the next full re-render.
      */
-    function renderFull() {
+    function renderFullContent() {
         const engineSchema = currentSurfaceId ? engine.getSchema(currentSurfaceId) : undefined;
         const schema = engineSchema ?? currentSchema;
         if (!schema)
@@ -13365,6 +13876,9 @@ function renderStreamingCard(container, options = {}) {
         const dom = renderNode(tree);
         container.appendChild(dom);
     }
+    function renderFull() {
+        return cardDisabled.update(() => renderFullContent());
+    }
     /**
      * Full render that tolerates mid-stream schemas (e.g. children referencing
      * elements that have not arrived yet): keeps the previous DOM on failure so
@@ -13381,7 +13895,7 @@ function renderStreamingCard(container, options = {}) {
         }
     }
     // ─── Engine Event Handlers ──────────────────────────────────────
-    const engine = new StreamingEngine({
+    const engineEvents = {
         onSurfaceCreated(surfaceId, schemaInput) {
             if (schemaInput) {
                 const nextSchema = engine.getSchema(surfaceId)
@@ -13596,6 +14110,7 @@ function renderStreamingCard(container, options = {}) {
                     const typeChanged = el.getAttribute('data-card-type') !== element.type;
                     if (!typeChanged && 'updateProps' in el) {
                         el.updateProps(resolved, isMobile, options.responsive);
+                        applyDisabledState(el, wasDisabled);
                         propsCache.set(id, key);
                     }
                     else if (!typeChanged && isChildrenOnlyChange(propsCache.get(id), key, element)) {
@@ -13746,9 +14261,18 @@ function renderStreamingCard(container, options = {}) {
             boundRevision += 1;
             lifecycleManager.dispose(actionContext);
         },
+    };
+    const engine = new StreamingEngine({
+        onSurfaceCreated: (...args) => cardDisabled.update(() => engineEvents.onSurfaceCreated?.(...args)),
+        onComponentsUpdated: (...args) => cardDisabled.update(() => engineEvents.onComponentsUpdated?.(...args)),
+        onDataModelUpdated: (...args) => cardDisabled.update(() => engineEvents.onDataModelUpdated?.(...args)),
+        onContentAppended: (...args) => cardDisabled.update(() => engineEvents.onContentAppended?.(...args)),
+        onSurfaceDeleted: (...args) => cardDisabled.update(() => engineEvents.onSurfaceDeleted?.(...args)),
     });
     // ─── Public API ─────────────────────────────────────────────────
+    const cardDisabled = createCardDisabledController(container, options.disabled);
     return {
+        setDisabled: cardDisabled.setDisabled,
         getNode: nodeAccess.getNode,
         onFocusChange: nodeAccess.onFocusChange,
         onScroll: nodeAccess.onScroll,
@@ -13829,6 +14353,7 @@ function renderStreamingCard(container, options = {}) {
                 return;
             disposed = true;
             nodeAccess.dispose();
+            cardDisabled.dispose();
             boundRevision += 1;
             abortController.abort();
             teardownBoundLifecycles();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antglobal/copilot-cards-web",
-  "version": "0.0.20260828032020-dev.9",
+  "version": "0.0.20260915071159-dev.5",
   "description": "Web Component renderer for copilot bot card SDK — PC + Mobile + WebView unified rendering via Custom Elements",
   "type": "module",
   "module": "./dist/index.js",
@@ -28,7 +28,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@antglobal/copilot-cards-core": "0.0.20260828032020-dev.9",
+    "@antglobal/copilot-cards-core": "0.0.20260915071159-dev.5",
     "echarts": "^5.6.0",
     "marked": "^18.0.5",
     "tslib": "^2.8.1",