fix(animate): commit update layout at animation end

VChart resize updates write the new layout into finalAttribute and pass the
layout delta through context.diffAttrs for the built-in update animation. The
animation frames interpolate correctly, but automatic close-out restores from
baseAttributes. Before this change, baseAttributes still held the pre-resize
layout, so restoreStaticAttribute pulled attribute and finalAttribute back to the
old bar size after the update animation ended.

The built-in update animation now treats its diffAttrs as an explicit end commit
for upper-layer layout changes. It commits those attrs to static truth only when
the update animation naturally ends, leaving in-flight frames transient and
preserving ordinary self-driven animations that should restore to the old base.

Constraint: D3 static truth remains baseAttributes + resolvedStatePatch -> attribute
Constraint: Animation frames stay transient until an explicit end commit
Rejected: Sync all setFinalAttributes calls to base | breaks custom target caches
Rejected: Restore from finalAttribute directly | reintroduces finalAttribute as truth
Confidence: high
Scope-risk: narrow
Directive: Keep update layout commits in Update.onEnd, not generic restore paths
Tested: packages/vrender-animate rushx test --runInBand
Tested: packages/vrender-core targeted static truth/state suites under Node 22.18.0
Tested: rush compile -t @visactor/vrender-animate
Tested: rush build -t @visactor/vrender-animate
Tested: rush build -t @visactor/vrender
Tested: built aggregate CJS resize-update repro keeps resized y/y1/width after end
Not-tested: Full VChart browser smoke against local packages

Author: xuefei1313

packages/vrender-animate/__tests__/unit/animation-runtime-attribute.test.ts

@@ -305,6 +305,80 @@ describe('D3 pre-handoff animation runtime', () => {
     expect(rect.getFinalAttribute().y1).toBe(260);
   });
 
+  test('executor update animation restores to resized final layout after completion', () => {
+    const { group, ticker, graphicService } = createStageHarness('executor-update-resize-static-truth');
+    const initial = {
+      x: 78.75,
+      y: 31.2,
+      y1: 260,
+      width: 202.5,
+      visible: true
+    };
+    const resized = {
+      x: 105,
+      y: 38.4,
+      y1: 320,
+      width: 270,
+      visible: true
+    };
+    const rect = createRect(initial);
+    bindGraphicService(rect as any, graphicService);
+    rect.setFinalAttributes(initial);
+    group.appendChild(rect);
+
+    (rect as any).context = {
+      animationState: 'update',
+      data: [{ value: 10 }],
+      diffAttrs: {
+        x: resized.x,
+        y: resized.y,
+        y1: resized.y1,
+        width: resized.width
+      },
+      finalAttrs: resized
+    };
+    rect.setFinalAttributes(resized);
+
+    new AnimateExecutor(rect).execute({
+      type: 'update',
+      duration: 100,
+      easing: 'linear'
+    });
+
+    expect((rect as any).baseAttributes.x).toBe(initial.x);
+    expect((rect as any).baseAttributes.y).toBe(initial.y);
+    expect((rect as any).baseAttributes.y1).toBe(initial.y1);
+    expect((rect as any).baseAttributes.width).toBe(initial.width);
+    expect(rect.getFinalAttribute().x).toBe(resized.x);
+    expect(rect.getFinalAttribute().y).toBe(resized.y);
+    expect(rect.getFinalAttribute().y1).toBe(resized.y1);
+    expect(rect.getFinalAttribute().width).toBe(resized.width);
+
+    tick(ticker, 50);
+    expect(rect.attribute.x).toBeCloseTo(91.875, 5);
+    expect(rect.attribute.y).toBeCloseTo(34.8, 5);
+    expect(rect.attribute.y1).toBeCloseTo(290, 5);
+    expect(rect.attribute.width).toBeCloseTo(236.25, 5);
+    expect((rect as any).baseAttributes.x).toBe(initial.x);
+    expect((rect as any).baseAttributes.y).toBe(initial.y);
+    expect((rect as any).baseAttributes.y1).toBe(initial.y1);
+    expect((rect as any).baseAttributes.width).toBe(initial.width);
+
+    tick(ticker, 50);
+    expect((rect as any).baseAttributes.x).toBe(resized.x);
+    expect((rect as any).baseAttributes.y).toBe(resized.y);
+    expect((rect as any).baseAttributes.y1).toBe(resized.y1);
+    expect((rect as any).baseAttributes.width).toBe(resized.width);
+    expect(rect.attribute.x).toBe(resized.x);
+    expect(rect.attribute.y).toBe(resized.y);
+    expect(rect.attribute.y1).toBe(resized.y1);
+    expect(rect.attribute.width).toBe(resized.width);
+    expect(rect.getFinalAttribute().x).toBe(resized.x);
+    expect(rect.getFinalAttribute().y).toBe(resized.y);
+    expect(rect.getFinalAttribute().y1).toBe(resized.y1);
+    expect(rect.getFinalAttribute().width).toBe(resized.width);
+  });
+
   test('switching states mid-animation restores to the new static truth and blocks late writes', () => {
     const { group, ticker, graphicService } = createStageHarness('state-conflict');
     const rect = createAnimatedRect(graphicService);

packages/vrender-animate/src/custom/update.ts

@@ -1,4 +1,4 @@
-import type { EasingType } from '@visactor/vrender-core';
+import { AttributeUpdateType, type EasingType, type IAnimate, type IStep } from '@visactor/vrender-core';
 import { ACustomAnimate } from './custom-animate';
 
 export interface IUpdateAnimationOptions {
@@ -37,6 +37,18 @@ export class Update extends ACustomAnimate<Record<string, number>> {
     this.props = diffAttrs;
   }
 
+  onEnd(cb?: (animate: IAnimate, step: IStep) => void): void {
+    if (cb) {
+      super.onEnd(cb);
+      return;
+    }
+
+    if (this.props && Object.keys(this.props).length) {
+      this.target.setAttributes(this.props, false, { type: AttributeUpdateType.ANIMATE_END });
+    }
+    super.onEnd();
+  }
+
   update(end: boolean, ratio: number, out: Record<string, any>): void {
     this.onStart();
     if (!this.props || !this.propKeys) {