@antglobal/copilot-cards-mini-program 1.0.1 → 1.0.3

package/dist/action-context/index.js

@@ -7,6 +7,32 @@
  * Mirrors the web-side `createWebActionContext` but routes calls
  * through the adapter instead of browser globals.
  */
+function abortedRequestError() {
+    return new DOMException('The request was aborted', 'AbortError');
+}
+function awaitMiniProgramRequest(request, signal) {
+    if (!signal)
+        return request;
+    if (signal.aborted) {
+        // Observe a request implementation that has already started so a later
+        // rejection cannot become unhandled.
+        void request.catch(() => undefined);
+        return Promise.reject(abortedRequestError());
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            reject(abortedRequestError());
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        request.then(response => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(response);
+        }, error => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
 // ─── Factory ─────────────────────────────────────────────────────
 /**
  * Create an ActionRunnerContext wired to mini-program platform APIs.
@@ -24,13 +50,18 @@
 function createMiniProgramActionContext(adapter, options = {}) {
     return {
         fetch: async (url, init) => {
+            if (init?.signal?.aborted) {
+                throw abortedRequestError();
+            }
             // Convert standard fetch interface to mini-program adapter request
-            const response = await adapter.request({
+            const requestOptions = {
                 url,
                 method: init?.method ?? 'GET',
                 headers: init?.headers,
                 data: init?.body ? JSON.parse(init.body) : undefined,
-            });
+                ...(init?.signal ? { signal: init.signal } : {}),
+            };
+            const response = await awaitMiniProgramRequest(adapter.request(requestOptions), init?.signal);
             // Wrap as a fetch-compatible Response
             return {
                 ok: response.statusCode >= 200 && response.statusCode < 300,

package/dist/renderer/index.d.ts

@@ -1,4 +1,4 @@
-import { ExpressionContext, CardSchemaInput } from '@antglobal/copilot-cards-core';
+import { ExpressionContext, CardSchemaInput, MaterializedCard } from '@antglobal/copilot-cards-core';
 import { MiniProgramAdapter } from '../adapter/index.js';
 export { transformNode, transformTree } from './transform.js';
 
@@ -46,6 +46,11 @@ interface MiniProgramCardInstance {
     /** Dispose the card instance and clean up resources */
     dispose(): void;
 }
+interface MiniProgramRendererSnapshot {
+    tree: MiniProgramRenderNode;
+    materialized: MaterializedCard | null;
+    variables: Record<string, any>;
+}
 /**
  * Create a mini-program card instance from a schema.
  *
@@ -62,6 +67,8 @@ interface MiniProgramCardInstance {
  * ```
  */
 declare function renderForMiniProgram(schemaInput: CardSchemaInput, options: MiniProgramRendererOptions): MiniProgramCardInstance;
+declare function getMiniProgramRendererSnapshot(instance: MiniProgramCardInstance): MiniProgramRendererSnapshot;
+declare function syncMiniProgramAuthoritativeVariables(instance: MiniProgramCardInstance, nextRoot: Record<string, any>): MiniProgramRendererSnapshot;
 
-export { renderForMiniProgram };
-export type { MiniProgramCardInstance, MiniProgramRenderNode, MiniProgramRendererOptions };
+export { getMiniProgramRendererSnapshot, renderForMiniProgram, syncMiniProgramAuthoritativeVariables };
+export type { MiniProgramCardInstance, MiniProgramRenderNode, MiniProgramRendererOptions, MiniProgramRendererSnapshot };

package/dist/renderer/index.js

@@ -1,6 +1,6 @@
-import { normalizeSchema, validateSchema, parseSchema, createLifecycleManager, runActionSteps, resolveActionRef } from '@antglobal/copilot-cards-core';
+import { normalizeSchema, validateSchema, requiresBindingMaterialization, parseSchema, createLifecycleManager, cloneJsonData, runActionSteps, materializeCard, resolveActionRef, createA2UIParameterResolver, createExpressionContext, findAffectedRepeatOwners } from '@antglobal/copilot-cards-core';
 import { createMiniProgramActionContext } from '../action-context/index.js';
-import { transformTree } from './transform.js';
+import { transformTree, transformBoundTree } from './transform.js';
 export { transformNode } from './transform.js';
 
 /**
@@ -11,6 +11,8 @@ export { transformNode } from './transform.js';
  * this renderer doesn't produce DOM. Instead, it produces a normalised
  * data tree that can be consumed by mini-program templates.
  */
+const rendererSnapshots = new WeakMap();
+const boundRendererControllers = new WeakMap();
 // ─── Main API ────────────────────────────────────────────────────
 /**
  * Create a mini-program card instance from a schema.
@@ -35,6 +37,12 @@ function renderForMiniProgram(schemaInput, options) {
     if (errors.length > 0) {
         throw new Error(`[renderForMiniProgram] Invalid schema:\n${errors.join('\n')}`);
     }
+    if (!requiresBindingMaterialization(schema)) {
+        return renderStaticForMiniProgram(schema, options);
+    }
+    return renderBoundForMiniProgram(schema, options);
+}
+function renderStaticForMiniProgram(schema, options) {
     // 2. Parse into render tree
     const tree = parseSchema(schema);
     // 3. Reactive variables store
@@ -72,7 +80,7 @@ function renderForMiniProgram(schemaInput, options) {
     // 9. Compute initial data
     let currentTree = transformTree(tree, variables);
     // ── Instance API ───────────────────────────────────────────────
-    return {
+    const instance = {
         getData() {
             return { tree: currentTree };
         },
@@ -80,6 +88,11 @@ function renderForMiniProgram(schemaInput, options) {
             variables = { ...variables, ...newVars };
             rebuildActionContext();
             currentTree = transformTree(tree, variables);
+            rendererSnapshots.set(instance, {
+                tree: currentTree,
+                materialized: null,
+                variables,
+            });
             return { tree: currentTree };
         },
         async handleEvent(nodeId, eventName, eventDetail) {
@@ -104,12 +117,327 @@ function renderForMiniProgram(schemaInput, options) {
             // Re-compute tree after action execution (variables may have changed)
             rebuildActionContext();
             currentTree = transformTree(tree, variables);
+            rendererSnapshots.set(instance, {
+                tree: currentTree,
+                materialized: null,
+                variables,
+            });
         },
         dispose() {
             abortController.abort();
             lifecycleManager.dispose(actionContext);
         },
     };
+    rendererSnapshots.set(instance, {
+        tree: currentTree,
+        materialized: null,
+        variables,
+    });
+    return instance;
+}
+function renderBoundForMiniProgram(schema, options) {
+    const schemaActions = schema.actions ?? {};
+    const variables = {};
+    const lifecycleManager = createLifecycleManager();
+    const abortController = new AbortController();
+    const inflightRequests = new Map();
+    let revision = 0;
+    let currentTree;
+    let currentMaterialized;
+    let nodeEventsMap = new Map();
+    let instance;
+    let actionQueue = Promise.resolve();
+    let disposed = false;
+    const lifecycleMounts = new Map();
+    function transactionConflict() {
+        return new Error('[MiniProgramRenderer] BOUND_TRANSACTION_CONFLICT: '
+            + (disposed
+                ? 'renderer instance is disposed'
+                : 'renderer state changed before the candidate could commit'));
+    }
+    function assertCurrentRevision(baseRevision) {
+        if (disposed || baseRevision !== revision) {
+            throw transactionConflict();
+        }
+    }
+    function installDraftRoot(draft) {
+        for (const key of Object.keys(variables)) {
+            if (!Reflect.deleteProperty(variables, key)) {
+                throw new Error(`[MiniProgramRenderer] Cannot remove bound variable "${key}"`);
+            }
+        }
+        for (const key of Object.keys(draft)) {
+            Object.defineProperty(variables, key, {
+                value: draft[key],
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+    function rebindMaterializedRoot(root) {
+        const visitedScopes = new WeakSet();
+        function walk(node) {
+            if (!visitedScopes.has(node.scope)) {
+                node.scope.root = variables;
+                visitedScopes.add(node.scope);
+            }
+            node.children.forEach(walk);
+        }
+        walk(root);
+    }
+    function publishSnapshot() {
+        const snapshot = {
+            tree: currentTree,
+            materialized: currentMaterialized,
+            variables,
+        };
+        if (instance) {
+            rendererSnapshots.set(instance, snapshot);
+        }
+        return snapshot;
+    }
+    function prepareState(draft, changedPaths, baseRevision) {
+        assertCurrentRevision(baseRevision);
+        // Dependency selection is intentionally computed from the last committed
+        // metadata. Mini's public API still publishes a complete transformed tree.
+        if (currentMaterialized) {
+            for (const changedPath of changedPaths) {
+                findAffectedRepeatOwners(currentMaterialized, changedPath);
+            }
+        }
+        const nextMaterialized = materializeCard(schema, draft);
+        const nextTree = transformBoundTree(nextMaterialized.root);
+        // Committed event contexts must terminate at the stable variables object.
+        // The nested local objects are values from `draft`; those same references
+        // become reachable from the stable root in the final synchronous commit.
+        rebindMaterializedRoot(nextMaterialized.root);
+        const nextNodeEventsMap = buildBoundNodeEventsMap(nextMaterialized.root, schemaActions);
+        assertCurrentRevision(baseRevision);
+        installDraftRoot(draft);
+        currentTree = nextTree;
+        currentMaterialized = nextMaterialized;
+        nodeEventsMap = nextNodeEventsMap;
+        revision += 1;
+        return publishSnapshot();
+    }
+    function cloneCommittedVariables() {
+        return cloneJsonData(variables);
+    }
+    function defineDraftValues(draft, values) {
+        const clonedValues = cloneJsonData(values);
+        const changedPaths = [];
+        for (const key of Object.keys(clonedValues)) {
+            Object.defineProperty(draft, key, {
+                value: clonedValues[key],
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+            changedPaths.push(`/${escapeJsonPointerSegment(key)}`);
+        }
+        return changedPaths;
+    }
+    function createLifecycleActionContext(node, allowAfterDispose = false) {
+        const platformContext = createMiniProgramActionContext(options.adapter, {
+            setVariable: (key, value) => {
+                if (allowAfterDispose || !disposed)
+                    variables[key] = value;
+            },
+            emit: (eventName, payload) => {
+                if (allowAfterDispose || !disposed) {
+                    options.onEmit?.(eventName, payload);
+                }
+            },
+            variables,
+            botId: options.botId,
+            abortSignal: abortController.signal,
+        });
+        return {
+            ...platformContext,
+            showToast: (...args) => {
+                if (allowAfterDispose || !disposed) {
+                    platformContext.showToast?.(...args);
+                }
+            },
+            navigate: (...args) => {
+                if (allowAfterDispose || !disposed) {
+                    platformContext.navigate?.(...args);
+                }
+            },
+            copyText: (...args) => {
+                if (allowAfterDispose || !disposed) {
+                    platformContext.copyText?.(...args);
+                }
+            },
+            variables,
+            ...(node.bindingDialect === 'a2ui'
+                ? {
+                    parameterResolver: createA2UIParameterResolver(variables, node.dataPath),
+                }
+                : {
+                    expressionContext: createExpressionContext(node.scope),
+                }),
+            inflightRequests,
+        };
+    }
+    function registerBoundLifecycles(root) {
+        function walk(node) {
+            if (node.lifecycle) {
+                const context = createLifecycleActionContext(node);
+                lifecycleManager.register(node.id, node.lifecycle);
+                lifecycleMounts.set(node.id, lifecycleManager.mount(node.id, context));
+            }
+            node.children.forEach(walk);
+        }
+        walk(root);
+    }
+    function disposeBoundLifecycles(root) {
+        function walk(node) {
+            if (node.lifecycle) {
+                const mount = lifecycleMounts.get(node.id) ?? Promise.resolve();
+                const destroyContext = createLifecycleActionContext(node, true);
+                void mount.then(() => lifecycleManager.destroy(node.id, destroyContext), () => undefined).finally(() => {
+                    lifecycleManager.unregister(node.id);
+                    lifecycleMounts.delete(node.id);
+                });
+            }
+            node.children.forEach(walk);
+        }
+        walk(root);
+    }
+    const initialVariables = cloneJsonData({
+        ...schema.variables,
+        ...options.data,
+    });
+    prepareState(initialVariables, [''], revision);
+    registerBoundLifecycles(currentMaterialized.root);
+    async function runBoundEvent(nodeId, eventName, eventDetail) {
+        assertCurrentRevision(revision);
+        if (!nodeEventsMap.has(nodeId)) {
+            throw new Error(`[MiniProgramRenderer] Unknown or stale runtime node "${nodeId}"`);
+        }
+        const baseRevision = revision;
+        const draft = cloneCommittedVariables();
+        const freshMaterialized = materializeCard(schema, draft);
+        const freshNodeEventsMap = buildBoundNodeEventsMap(freshMaterialized.root, schemaActions);
+        const nodeInfo = freshNodeEventsMap.get(nodeId);
+        if (!nodeInfo) {
+            throw new Error(`[MiniProgramRenderer] Unknown or stale runtime node "${nodeId}"`);
+        }
+        const changedPaths = new Set();
+        const writeVariable = (key, value) => {
+            Object.defineProperty(draft, key, {
+                value,
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+            changedPaths.add(`/${escapeJsonPointerSegment(key)}`);
+        };
+        if (eventDetail != null) {
+            writeVariable('_event', cloneJsonData(eventDetail));
+        }
+        if ((eventName === 'onInput' || eventName === 'onChange')
+            && nodeInfo.variableKey
+            && eventDetail?.value !== undefined) {
+            writeVariable(nodeInfo.variableKey, cloneJsonData(eventDetail.value));
+        }
+        const steps = nodeInfo.events[eventName];
+        if (steps) {
+            const platformContext = createMiniProgramActionContext(options.adapter, {
+                setVariable: writeVariable,
+                emit: (eventName, payload) => {
+                    if (!disposed)
+                        options.onEmit?.(eventName, payload);
+                },
+                variables: draft,
+                botId: options.botId,
+                abortSignal: abortController.signal,
+            });
+            const actionContext = {
+                ...platformContext,
+                showToast: (...args) => {
+                    if (!disposed)
+                        platformContext.showToast?.(...args);
+                },
+                navigate: (...args) => {
+                    if (!disposed)
+                        platformContext.navigate?.(...args);
+                },
+                copyText: (...args) => {
+                    if (!disposed)
+                        platformContext.copyText?.(...args);
+                },
+                variables: draft,
+                expressionContext: nodeInfo.expressionContext,
+                parameterResolver: nodeInfo.parameterResolver,
+                variableWriter: (key, value) => {
+                    writeVariable(key, value);
+                },
+                inflightRequests,
+            };
+            await runActionSteps(steps, actionContext);
+        }
+        prepareState(draft, [...changedPaths], baseRevision);
+    }
+    instance = {
+        getData() {
+            return { tree: currentTree };
+        },
+        updateVariables(newVars) {
+            assertCurrentRevision(revision);
+            const baseRevision = revision;
+            const draft = cloneCommittedVariables();
+            const changedPaths = defineDraftValues(draft, newVars);
+            const snapshot = prepareState(draft, changedPaths, baseRevision);
+            return { tree: snapshot.tree };
+        },
+        handleEvent(nodeId, eventName, eventDetail) {
+            if (disposed) {
+                return Promise.reject(transactionConflict());
+            }
+            const result = actionQueue.then(() => runBoundEvent(nodeId, eventName, eventDetail));
+            actionQueue = result.then(() => undefined, () => undefined);
+            return result;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            revision += 1;
+            abortController.abort();
+            disposeBoundLifecycles(currentMaterialized.root);
+        },
+    };
+    boundRendererControllers.set(instance, {
+        syncAuthoritativeVariables(nextRoot) {
+            assertCurrentRevision(revision);
+            const baseRevision = revision;
+            const draft = cloneJsonData(nextRoot);
+            return prepareState(draft, [''], baseRevision);
+        },
+    });
+    publishSnapshot();
+    return instance;
+}
+function escapeJsonPointerSegment(value) {
+    return value.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function getMiniProgramRendererSnapshot(instance) {
+    const snapshot = rendererSnapshots.get(instance);
+    if (!snapshot) {
+        throw new Error('[MiniProgramRenderer] Unknown renderer instance');
+    }
+    return snapshot;
+}
+function syncMiniProgramAuthoritativeVariables(instance, nextRoot) {
+    const controller = boundRendererControllers.get(instance);
+    if (controller) {
+        return controller.syncAuthoritativeVariables(nextRoot);
+    }
+    instance.updateVariables(nextRoot);
+    return getMiniProgramRendererSnapshot(instance);
 }
 /**
  * Build a map of nodeId → { events, variableKey } for fast event lookup.
@@ -139,6 +467,39 @@ function buildNodeEventsMap(tree, schemaActions) {
     walk(tree);
     return map;
 }
+function buildBoundNodeEventsMap(tree, schemaActions) {
+    const map = new Map();
+    function walk(node) {
+        const events = {};
+        if (node.events) {
+            for (const [eventName, eventValue] of Object.entries(node.events)) {
+                if (!eventValue)
+                    continue;
+                const resolvedSteps = resolveActionRef(eventValue, schemaActions);
+                if (resolvedSteps) {
+                    events[eventName] = resolvedSteps;
+                }
+            }
+        }
+        const variableKey = node.props?.variableKey;
+        if (Object.keys(events).length > 0 || variableKey) {
+            map.set(node.id, {
+                events,
+                variableKey,
+                ...(node.bindingDialect === 'a2ui'
+                    ? {
+                        parameterResolver: createA2UIParameterResolver(node.scope.root, node.dataPath),
+                    }
+                    : {
+                        expressionContext: createExpressionContext(node.scope),
+                    }),
+            });
+        }
+        node.children.forEach(walk);
+    }
+    walk(tree);
+    return map;
+}
 /**
  * Register lifecycle hooks for all nodes in the tree.
  */
@@ -155,4 +516,4 @@ function registerLifecycles(tree, lifecycleManager, actionContext) {
     walk(tree);
 }
 
-export { renderForMiniProgram, transformTree };
+export { getMiniProgramRendererSnapshot, renderForMiniProgram, syncMiniProgramAuthoritativeVariables, transformTree };

package/dist/renderer/transform.d.ts

@@ -1,4 +1,4 @@
-import { RenderTreeNode } from '@antglobal/copilot-cards-core';
+import { RenderTreeNode, BoundRenderTreeNode } from '@antglobal/copilot-cards-core';
 import { MiniProgramRenderNode } from './index.js';
 
 /**
@@ -20,5 +20,14 @@ declare function transformNode(node: RenderTreeNode, variables: Record<string, a
  * Transform an entire render tree into a mini-program data tree.
  */
 declare function transformTree(tree: RenderTreeNode, variables: Record<string, any>): MiniProgramRenderNode;
+/**
+ * Transform a materialized node against its captured repeat/A2UI scope.
+ *
+ * The legacy transform above deliberately remains untouched so literal cards
+ * retain their exact output and expression behavior.
+ */
+declare function transformBoundNode(node: BoundRenderTreeNode): MiniProgramRenderNode;
+/** Transform a fully materialized bound render tree. */
+declare function transformBoundTree(tree: BoundRenderTreeNode): MiniProgramRenderNode;
 
-export { transformNode, transformTree };
+export { transformBoundNode, transformBoundTree, transformNode, transformTree };

package/dist/renderer/transform.js

@@ -1,4 +1,4 @@
-import { hasExpression, resolveExpression, resolveDeep, resolveExpressionValue } from '@antglobal/copilot-cards-core';
+import { hasExpression, resolveExpression, resolveDeep, resolveExpressionValue, createExpressionContext, resolveA2UIDeep } from '@antglobal/copilot-cards-core';
 import { decorateMiniIconProps } from '../icons.js';
 
 /**
@@ -87,5 +87,81 @@ function transformNode(node, variables) {
 function transformTree(tree, variables) {
     return transformNode(tree, variables);
 }
+// ─── Bound Transform ─────────────────────────────────────────────
+function isHidden(value) {
+    return value === false || value === 'false' || value === '' || value === 0;
+}
+function isDisabled(value) {
+    return value === true || value === 'true' || value === 1;
+}
+function resolveBoundDirective(node, value, expressionContext) {
+    if (node.bindingDialect === 'a2ui') {
+        return resolveA2UIDeep(value, node.scope.root, node.dataPath);
+    }
+    return typeof value === 'string' && hasExpression(value)
+        ? resolveExpression(value, expressionContext)
+        : value;
+}
+/**
+ * Transform a materialized node against its captured repeat/A2UI scope.
+ *
+ * The legacy transform above deliberately remains untouched so literal cards
+ * retain their exact output and expression behavior.
+ */
+function transformBoundNode(node) {
+    const expressionContext = createExpressionContext(node.scope);
+    let visible = true;
+    if (node.directives?.visible) {
+        visible = !isHidden(resolveBoundDirective(node, node.directives.visible, expressionContext));
+    }
+    if (!visible) {
+        return {
+            id: node.id,
+            type: node.type,
+            props: {},
+            children: [],
+            visible: false,
+            disabled: false,
+            events: [],
+        };
+    }
+    let resolvedProps = (node.bindingDialect === 'a2ui'
+        ? resolveA2UIDeep(node.props, node.scope.root, node.dataPath)
+        : resolveDeep(node.props, expressionContext));
+    if (resolvedProps.content
+        && typeof resolvedProps.content === 'object'
+        && resolvedProps.content !== null
+        && 'type' in resolvedProps.content) {
+        resolvedProps.content = resolveExpressionValue(resolvedProps.content, expressionContext);
+    }
+    if (node.type === 'Icon') {
+        resolvedProps = decorateMiniIconProps(resolvedProps);
+    }
+    let disabled = false;
+    if (node.directives?.disabled) {
+        disabled = isDisabled(resolveBoundDirective(node, node.directives.disabled, expressionContext));
+    }
+    const events = [];
+    if (node.events && !disabled) {
+        for (const eventName of Object.keys(node.events)) {
+            if (node.events[eventName]) {
+                events.push(eventName);
+            }
+        }
+    }
+    return {
+        id: node.id,
+        type: node.type,
+        props: resolvedProps,
+        children: node.children.map(transformBoundNode),
+        visible,
+        disabled,
+        events,
+    };
+}
+/** Transform a fully materialized bound render tree. */
+function transformBoundTree(tree) {
+    return transformBoundNode(tree);
+}
 
-export { transformNode, transformTree };
+export { transformBoundNode, transformBoundTree, transformNode, transformTree };

package/dist/streaming/index.js

@@ -1,5 +1,5 @@
-import { StreamingParser, StreamingEngine, normalizeSchema } from '@antglobal/copilot-cards-core';
-import { renderForMiniProgram } from '../renderer/index.js';
+import { StreamingParser, StreamingEngine, normalizeSchema, cloneJsonData, replaceRootContents, findAffectedRepeatOwners, bindingTopologyFingerprint, validateSchema } from '@antglobal/copilot-cards-core';
+import { getMiniProgramRendererSnapshot, syncMiniProgramAuthoritativeVariables, renderForMiniProgram } from '../renderer/index.js';
 
 /**
  * Streaming Adapter for Mini-Program — enables progressive card rendering
@@ -39,139 +39,384 @@ import { renderForMiniProgram } from '../renderer/index.js';
 function createStreamingCardInstance(options) {
     const parser = new StreamingParser(options.parserOptions);
     let currentInstance = null;
+    let currentSurfaceId = null;
     let currentTree = null;
-    let variables = { ...options.data };
-    // Track node paths for efficient patching
-    const nodePathMap = new Map(); // elementId → setData path
-    /**
-     * Build the node path map by traversing the tree.
-     */
-    function buildNodePaths(node, basePath) {
-        nodePathMap.set(node.id, basePath);
-        node.children.forEach((child, index) => {
-            buildNodePaths(child, `${basePath}.children[${index}]`);
+    let currentTopologyFingerprint = null;
+    let nodePathMap = new Map();
+    let nodeMap = new Map();
+    let duplicateNodeIds = new Set();
+    const incompleteSurfaces = new Set();
+    function indexTree(tree) {
+        const paths = new Map();
+        const nodes = new Map();
+        const duplicates = new Set();
+        function visit(node, path) {
+            if (nodes.has(node.id))
+                duplicates.add(node.id);
+            paths.set(node.id, path);
+            nodes.set(node.id, node);
+            node.children.forEach((child, index) => {
+                visit(child, `${path}.children[${index}]`);
+            });
+        }
+        visit(tree, 'tree');
+        return { paths, nodes, duplicates };
+    }
+    function createFullPatch(tree = currentTree) {
+        return { data: { tree } };
+    }
+    function pathsOverlap(left, right) {
+        return (left === right
+            || left.startsWith(`${right}.`)
+            || left.startsWith(`${right}[`)
+            || right.startsWith(`${left}.`)
+            || right.startsWith(`${left}[`));
+    }
+    function nodeShell(node) {
+        return JSON.stringify({
+            id: node.id,
+            type: node.type,
+            props: node.props,
+            visible: node.visible,
+            disabled: node.disabled,
+            events: node.events,
         });
     }
-    /**
-     * Create a full tree patch (for initial render or full re-render).
-     */
-    function createFullPatch() {
-        return { data: { tree: currentTree } };
+    function isStaticPublishedNode(materialized, id) {
+        for (const instance of materialized.instances.values()) {
+            if (instance.id === id && instance.node.instancePath === '') {
+                return true;
+            }
+        }
+        return false;
+    }
+    function buildTargetedDataPatch(oldSnapshot, nextSnapshot, updatePath, oldPaths, oldNodes, oldDuplicates, nextIndex) {
+        const oldMaterialized = oldSnapshot.materialized;
+        const nextMaterialized = nextSnapshot.materialized;
+        const fullPatch = () => createFullPatch(nextSnapshot.tree);
+        if (!oldMaterialized
+            || !nextMaterialized
+            || oldMaterialized.unresolvedRepeatOwners.size > 0
+            || nextMaterialized.unresolvedRepeatOwners.size > 0) {
+            return fullPatch();
+        }
+        const owners = findAffectedRepeatOwners(oldMaterialized, updatePath);
+        if (owners.length === 0)
+            return fullPatch();
+        const data = {};
+        const patchPaths = [];
+        for (const owner of owners) {
+            const nextOwner = nextMaterialized.repeatOwners.get(owner.key);
+            const runtimeId = owner.runtimeOwnerId;
+            const oldPath = oldPaths.get(runtimeId);
+            const nextPath = nextIndex.paths.get(runtimeId);
+            const nextNode = nextIndex.nodes.get(runtimeId);
+            if (!nextOwner
+                || nextOwner.runtimeOwnerId !== runtimeId
+                || !oldPath
+                || nextPath !== oldPath
+                || !nextNode
+                || oldDuplicates.has(runtimeId)
+                || nextIndex.duplicates.has(runtimeId)
+                || patchPaths.some(path => pathsOverlap(path, oldPath))) {
+                return fullPatch();
+            }
+            data[oldPath] = nextNode;
+            patchPaths.push(oldPath);
+        }
+        // A repeat dependency can also affect static nodes outside every repeat
+        // closure (for example, a global currency heading). Publish those nodes in
+        // the same patch or fall back before exposing an incomplete host tree.
+        for (const [id, oldNode] of oldNodes) {
+            if (!isStaticPublishedNode(oldMaterialized, id))
+                continue;
+            if (oldDuplicates.has(id) || nextIndex.duplicates.has(id)) {
+                return fullPatch();
+            }
+            const oldPath = oldPaths.get(id);
+            const nextPath = nextIndex.paths.get(id);
+            const nextNode = nextIndex.nodes.get(id);
+            if (!oldPath || nextPath !== oldPath || !nextNode) {
+                return fullPatch();
+            }
+            if (nodeShell(oldNode) === nodeShell(nextNode))
+                continue;
+            if (Object.prototype.hasOwnProperty.call(data, oldPath))
+                continue;
+            if (patchPaths.some(path => pathsOverlap(path, oldPath))) {
+                return fullPatch();
+            }
+            data[oldPath] = nextNode;
+            patchPaths.push(oldPath);
+        }
+        return patchPaths.length > 0 ? { data } : fullPatch();
+    }
+    function buildRendererCandidate(schema, authoritativeVariables) {
+        const instance = renderForMiniProgram(schema, {
+            adapter: options.adapter,
+            data: authoritativeVariables,
+            botId: options.botId,
+            onEmit: options.onEmit,
+        });
+        const snapshot = getMiniProgramRendererSnapshot(instance);
+        return {
+            instance,
+            snapshot,
+            index: indexTree(snapshot.tree),
+            topologyFingerprint: bindingTopologyFingerprint(schema),
+        };
+    }
+    function hasOnlyExplicitIncompleteReferences(schema) {
+        if (!hasWellFormedReferenceIds(schema))
+            return false;
+        const errors = validateSchema(schema);
+        return errors.length > 0 && errors.every(error => ((error.startsWith('Root element "')
+            && error.endsWith('not found in elements'))
+            || error.includes(' references unknown child "')
+            || error.includes(' group references unknown child "')
+            || error.includes(' repeat references unknown template "')
+            || error.includes(' dynamic children reference unknown template "')));
+    }
+    function hasWellFormedReferenceIds(schema) {
+        const isReferenceId = (value) => typeof value === 'string' && value.length > 0;
+        const ownValue = (target, key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(target, key);
+            if (!descriptor)
+                return { found: false };
+            if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+                return null;
+            }
+            return { found: true, value: descriptor.value };
+        };
+        try {
+            if (!isReferenceId(schema.rootID))
+                return false;
+            if (!schema.elements
+                || typeof schema.elements !== 'object'
+                || Array.isArray(schema.elements))
+                return false;
+            for (const elementId of Object.keys(schema.elements)) {
+                const elementEntry = ownValue(schema.elements, elementId);
+                if (!elementEntry?.found
+                    || !elementEntry.value
+                    || typeof elementEntry.value !== 'object')
+                    return false;
+                const propsEntry = ownValue(elementEntry.value, 'props');
+                if (!propsEntry?.found
+                    || !propsEntry.value
+                    || typeof propsEntry.value !== 'object')
+                    return false;
+                const slotsEntry = ownValue(propsEntry.value, 'slots');
+                if (!slotsEntry)
+                    return false;
+                if (!slotsEntry.found || slotsEntry.value === undefined)
+                    continue;
+                if (!slotsEntry.value
+                    || typeof slotsEntry.value !== 'object'
+                    || Array.isArray(slotsEntry.value))
+                    return false;
+                for (const slotName of Reflect.ownKeys(slotsEntry.value)) {
+                    const slotEntry = ownValue(slotsEntry.value, slotName);
+                    if (!slotEntry?.found
+                        || !slotEntry.value
+                        || typeof slotEntry.value !== 'object')
+                        return false;
+                    const slot = slotEntry.value;
+                    const childrenEntry = ownValue(slot, 'children');
+                    if (!childrenEntry)
+                        return false;
+                    if (childrenEntry.found && childrenEntry.value !== undefined) {
+                        if (!Array.isArray(childrenEntry.value)
+                            || !childrenEntry.value.every(isReferenceId))
+                            return false;
+                    }
+                    const groupsEntry = ownValue(slot, 'groups');
+                    if (!groupsEntry)
+                        return false;
+                    if (groupsEntry.found && groupsEntry.value !== undefined) {
+                        if (!Array.isArray(groupsEntry.value)
+                            || !groupsEntry.value.every(group => Array.isArray(group) && group.every(isReferenceId)))
+                            return false;
+                    }
+                    const repeatEntry = ownValue(slot, 'repeat');
+                    if (!repeatEntry)
+                        return false;
+                    if (repeatEntry.found) {
+                        if (!repeatEntry.value
+                            || typeof repeatEntry.value !== 'object'
+                            || Array.isArray(repeatEntry.value))
+                            return false;
+                        const templateEntry = ownValue(repeatEntry.value, 'template');
+                        if (!templateEntry?.found
+                            || !isReferenceId(templateEntry.value))
+                            return false;
+                    }
+                    for (const key of Reflect.ownKeys(slot)) {
+                        if (typeof key !== 'symbol')
+                            continue;
+                        const sidecarEntry = ownValue(slot, key);
+                        if (!sidecarEntry?.found
+                            || !sidecarEntry.value
+                            || typeof sidecarEntry.value !== 'object')
+                            continue;
+                        const dialectEntry = ownValue(sidecarEntry.value, 'dialect');
+                        const templateEntry = ownValue(sidecarEntry.value, 'templateId');
+                        if (dialectEntry?.found
+                            && dialectEntry.value === 'a2ui'
+                            && (!templateEntry?.found
+                                || !isReferenceId(templateEntry.value)))
+                            return false;
+                    }
+                }
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function publishCandidate(surfaceId, candidate, patch) {
+        const previousInstance = currentInstance;
+        currentInstance = candidate.instance;
+        currentSurfaceId = surfaceId;
+        currentTree = candidate.snapshot.tree;
+        currentTopologyFingerprint = candidate.topologyFingerprint;
+        nodePathMap = candidate.index.paths;
+        nodeMap = candidate.index.nodes;
+        duplicateNodeIds = candidate.index.duplicates;
+        pendingPatches.push(patch);
+        previousInstance?.dispose();
+    }
+    function publishSnapshot(snapshot, index, patch) {
+        currentTree = snapshot.tree;
+        nodePathMap = index.paths;
+        nodeMap = index.nodes;
+        duplicateNodeIds = index.duplicates;
+        pendingPatches.push(patch);
     }
     // ─── Engine Setup ───────────────────────────────────────────────
     const pendingPatches = [];
     const engine = new StreamingEngine({
         onSurfaceCreated(surfaceId, schemaInput) {
-            if (schemaInput) {
-                const schema = normalizeSchema(schemaInput);
-                variables = { ...schema.variables, ...options.data };
-                currentInstance = renderForMiniProgram(schema, {
-                    adapter: options.adapter,
-                    data: variables,
-                    botId: options.botId,
-                    onEmit: options.onEmit,
+            if (!schemaInput) {
+                incompleteSurfaces.add(surfaceId);
+                return;
+            }
+            const schema = engine.getSchema(surfaceId)
+                ?? normalizeSchema(schemaInput);
+            const authoritativeVariables = engine.getVariables(surfaceId);
+            if (!authoritativeVariables)
+                return;
+            const initialData = options.data ?? {};
+            for (const key of Object.keys(initialData)) {
+                Object.defineProperty(authoritativeVariables, key, {
+                    value: initialData[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
                 });
-                currentTree = currentInstance.getData().tree;
-                if (currentTree) {
-                    nodePathMap.clear();
-                    buildNodePaths(currentTree, 'tree');
+            }
+            let candidate;
+            try {
+                candidate = buildRendererCandidate(schema, authoritativeVariables);
+            }
+            catch (error) {
+                if (hasOnlyExplicitIncompleteReferences(schema)) {
+                    incompleteSurfaces.add(surfaceId);
+                    return;
                 }
-                pendingPatches.push(createFullPatch());
+                throw error;
             }
+            incompleteSurfaces.delete(surfaceId);
+            publishCandidate(surfaceId, candidate, createFullPatch(candidate.snapshot.tree));
         },
-        onComponentsUpdated(surfaceId, changes) {
-            // For mini-program, component tree changes require full re-render
-            // because we can't insert DOM nodes — we need to regenerate the data tree
+        onComponentsUpdated(surfaceId) {
             const schema = engine.getSchema(surfaceId);
-            if (!schema)
+            const authoritativeVariables = engine.getVariables(surfaceId);
+            if (!schema || !authoritativeVariables)
                 return;
-            currentInstance = renderForMiniProgram(schema, {
-                adapter: options.adapter,
-                data: variables,
-                botId: options.botId,
-                onEmit: options.onEmit,
-            });
-            currentTree = currentInstance.getData().tree;
-            if (currentTree) {
-                nodePathMap.clear();
-                buildNodePaths(currentTree, 'tree');
+            let candidate;
+            try {
+                candidate = buildRendererCandidate(schema, authoritativeVariables);
             }
-            pendingPatches.push(createFullPatch());
-        },
-        onDataModelUpdated(surfaceId, path, value) {
-            if (!currentInstance)
-                return;
-            // Update variables and regenerate tree
-            const pathParts = path.replace(/^\//, '').split('/').filter(Boolean);
-            if (pathParts.length === 0) {
-                if (typeof value === 'object' && value !== null) {
-                    variables = { ...variables, ...value };
+            catch (error) {
+                if (hasOnlyExplicitIncompleteReferences(schema)) {
+                    incompleteSurfaces.add(surfaceId);
+                    return;
                 }
+                throw error;
             }
-            else {
-                let current = variables;
-                for (let i = 0; i < pathParts.length - 1; i++) {
-                    if (current[pathParts[i]] === undefined)
-                        current[pathParts[i]] = {};
-                    current = current[pathParts[i]];
-                }
-                current[pathParts[pathParts.length - 1]] = value;
+            incompleteSurfaces.delete(surfaceId);
+            // Component topology/mode changes must be full patches. Unchanged
+            // topology is also conservatively full until every static/repeat target
+            // can be proven safe from one candidate.
+            if (currentTopologyFingerprint !== null
+                && currentTopologyFingerprint
+                    !== candidate.topologyFingerprint) {
+                publishCandidate(surfaceId, candidate, createFullPatch(candidate.snapshot.tree));
+                return;
             }
-            const result = currentInstance.updateVariables(variables);
-            currentTree = result.tree;
-            if (currentTree) {
-                nodePathMap.clear();
-                buildNodePaths(currentTree, 'tree');
+            publishCandidate(surfaceId, candidate, createFullPatch(candidate.snapshot.tree));
+        },
+        onDataModelUpdated(surfaceId, path) {
+            if (incompleteSurfaces.has(surfaceId)
+                || !currentInstance
+                || currentSurfaceId !== surfaceId)
+                return;
+            const authoritativeVariables = engine.getVariables(surfaceId);
+            if (!authoritativeVariables)
+                return;
+            const oldSnapshot = getMiniProgramRendererSnapshot(currentInstance);
+            const oldPaths = nodePathMap;
+            const oldNodes = nodeMap;
+            const oldDuplicates = duplicateNodeIds;
+            const nextSnapshot = syncMiniProgramAuthoritativeVariables(currentInstance, authoritativeVariables);
+            const nextIndex = indexTree(nextSnapshot.tree);
+            let patch;
+            try {
+                patch = buildTargetedDataPatch(oldSnapshot, nextSnapshot, path, oldPaths, oldNodes, oldDuplicates, nextIndex);
+            }
+            catch {
+                patch = createFullPatch(nextSnapshot.tree);
             }
-            pendingPatches.push(createFullPatch());
+            publishSnapshot(nextSnapshot, nextIndex, patch);
         },
         onContentAppended(surfaceId, elementId, content) {
-            // Try to do a targeted patch for text content
+            if (currentSurfaceId !== surfaceId)
+                return;
             const nodePath = nodePathMap.get(elementId);
-            if (nodePath && currentTree) {
-                // Find the node and update its content in-place
-                const node = findNodeById(currentTree, elementId);
-                if (node) {
-                    const currentContent = typeof node.props.content === 'string'
-                        ? node.props.content : '';
-                    node.props.content = currentContent + content;
-                    // Generate a path-based setData patch for efficiency
-                    pendingPatches.push({
-                        data: { [`${nodePath}.props.content`]: node.props.content },
-                    });
-                    return;
-                }
-            }
-            // Fallback: full re-render
-            if (currentInstance) {
-                const schema = engine.getSchema(surfaceId);
-                if (schema) {
-                    variables = { ...schema.variables, ...variables };
-                    const result = currentInstance.updateVariables(variables);
-                    currentTree = result.tree;
-                    pendingPatches.push(createFullPatch());
-                }
+            const node = nodeMap.get(elementId);
+            if (nodePath
+                && node
+                && currentTree
+                && !duplicateNodeIds.has(elementId)) {
+                const currentContent = typeof node.props.content === 'string'
+                    ? node.props.content : '';
+                node.props.content = currentContent + content;
+                pendingPatches.push({
+                    data: { [`${nodePath}.props.content`]: node.props.content },
+                });
+                return;
             }
+            if (currentInstance)
+                pendingPatches.push(createFullPatch());
         },
         onSurfaceDeleted(surfaceId) {
+            incompleteSurfaces.delete(surfaceId);
+            if (currentSurfaceId !== surfaceId)
+                return;
             currentInstance?.dispose();
             currentInstance = null;
+            currentSurfaceId = null;
             currentTree = null;
-            nodePathMap.clear();
+            currentTopologyFingerprint = null;
+            nodePathMap = new Map();
+            nodeMap = new Map();
+            duplicateNodeIds = new Set();
             pendingPatches.push({ data: { tree: null } });
         },
     });
     // ─── Helpers ────────────────────────────────────────────────────
-    function findNodeById(node, id) {
-        if (node.id === id)
-            return node;
-        for (const child of node.children) {
-            const found = findNodeById(child, id);
-            if (found)
-                return found;
-        }
-        return null;
-    }
     function drainPatches() {
         const patches = [...pendingPatches];
         pendingPatches.length = 0;
@@ -208,19 +453,51 @@ function createStreamingCardInstance(options) {
         async handleEvent(nodeId, eventName, eventDetail) {
             if (!currentInstance)
                 return null;
-            await currentInstance.handleEvent(nodeId, eventName, eventDetail);
-            currentTree = currentInstance.getData().tree;
-            if (currentTree) {
-                nodePathMap.clear();
-                buildNodePaths(currentTree, 'tree');
+            const handledInstance = currentInstance;
+            const handledSurfaceId = currentSurfaceId;
+            if (!handledSurfaceId)
+                return null;
+            const previousEngineVariables = engine.getVariables(handledSurfaceId);
+            if (!previousEngineVariables)
+                return null;
+            const engineRollback = cloneJsonData(previousEngineVariables);
+            await handledInstance.handleEvent(nodeId, eventName, eventDetail);
+            if (currentInstance !== handledInstance
+                || currentSurfaceId !== handledSurfaceId)
+                return null;
+            const snapshot = getMiniProgramRendererSnapshot(handledInstance);
+            const index = indexTree(snapshot.tree);
+            const authoritativeVariables = engine.getVariables(handledSurfaceId);
+            if (!authoritativeVariables)
+                return null;
+            try {
+                replaceRootContents(authoritativeVariables, snapshot.variables);
+            }
+            catch (error) {
+                const rollbackSnapshot = syncMiniProgramAuthoritativeVariables(handledInstance, engineRollback);
+                const rollbackIndex = indexTree(rollbackSnapshot.tree);
+                currentTree = rollbackSnapshot.tree;
+                nodePathMap = rollbackIndex.paths;
+                nodeMap = rollbackIndex.nodes;
+                duplicateNodeIds = rollbackIndex.duplicates;
+                throw error;
             }
-            return createFullPatch();
+            currentTree = snapshot.tree;
+            nodePathMap = index.paths;
+            nodeMap = index.nodes;
+            duplicateNodeIds = index.duplicates;
+            return createFullPatch(snapshot.tree);
         },
         dispose() {
             currentInstance?.dispose();
             currentInstance = null;
+            currentSurfaceId = null;
             currentTree = null;
-            nodePathMap.clear();
+            currentTopologyFingerprint = null;
+            nodePathMap = new Map();
+            nodeMap = new Map();
+            duplicateNodeIds = new Set();
+            incompleteSurfaces.clear();
             engine.dispose();
             parser.reset();
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antglobal/copilot-cards-mini-program",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Mini-program native renderer for copilot bot card SDK — adapts to WeChat / Alipay / DingTalk mini-program templates",
   "type": "module",
   "module": "./dist/index.js",
@@ -30,7 +30,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@antglobal/copilot-cards-core": "^1.0.1",
+    "@antglobal/copilot-cards-core": "^1.0.3",
     "tslib": "^2.8.1"
   },
   "devDependencies": {