fix(animate): preserve static truth in frame writes

Animation frame writes now use the transient path, so appear starts, wait frames,

loop resets, and custom per-frame effects do not become static truth.

MotionPath keeps the public endpoint contract by committing only at end unless

commitOnEnd or saveOnEnd is explicitly false.

Constraint: D3 static truth remains baseAttributes + resolvedStatePatch -> attribute

Constraint: Do not restore normalAttrs snapshot/restore semantics

Rejected: Make MotionPath transient by default | examples expect path endpoint

Confidence: high

Scope-risk: moderate

Directive: Process frames must not call static setters without end commit semantics

Tested: packages/vrender-animate touched eslint

Tested: packages/vrender-animate rushx test --runInBand

Tested: vrender-core static truth/state unit subset

Tested: rush compile -t @visactor/vrender-animate

Tested: rush build --to @visactor/vrender-animate

Tested: VRender-only bar appear repro

Not-tested: Full repository test matrix

Author: xuefei1313

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

@@ -1,6 +1,7 @@
 import { createGroup, createRect } from '@visactor/vrender-core';
 import { registerAnimate } from '../../src/register';
 import { registerCustomAnimate } from '../../src/custom/register';
+import { AnimateExecutor } from '../../src/executor/animate-executor';
 import { DefaultTimeline } from '../../src/timeline';
 import { ManualTicker } from '../../src/ticker/manual-ticker';
 
@@ -159,6 +160,96 @@ describe('D3 pre-handoff animation runtime', () => {
     expect((rect as any).baseAttributes.x).toBe(80);
   });
 
+  test('wait step holds the previous frame without committing it to baseAttributes', () => {
+    const { group, ticker, graphicService } = createStageHarness('wait-step');
+    const rect = createAnimatedRect(graphicService);
+    group.appendChild(rect);
+
+    rect.animate().to({ x: 100 }, 100, 'linear').wait(50).to({ x: 200 }, 100, 'linear');
+
+    tick(ticker, 100);
+    expect(rect.attribute.x).toBeCloseTo(100, 5);
+    expect((rect as any).baseAttributes.x).toBe(0);
+
+    tick(ticker, 1);
+    expect(rect.attribute.x).toBeCloseTo(100, 5);
+    expect((rect as any).baseAttributes.x).toBe(0);
+  });
+
+  test('loop reset applies the start frame without overwriting current static truth', () => {
+    const { group, ticker, graphicService } = createStageHarness('loop-reset');
+    const rect = createAnimatedRect(graphicService);
+    group.appendChild(rect);
+
+    rect.animate().to({ x: 100 }, 100, 'linear').loop(1);
+
+    tick(ticker, 50);
+    expect(rect.attribute.x).toBeCloseTo(50, 5);
+    rect.setAttribute('x', 20);
+    expect((rect as any).baseAttributes.x).toBe(20);
+
+    tick(ticker, 50);
+    expect(rect.attribute.x).toBe(0);
+    expect((rect as any).baseAttributes.x).toBe(20);
+  });
+
+  test('stop with an explicit target is a static commit API', () => {
+    const { group, ticker, graphicService } = createStageHarness('stop-commit');
+    const endRect = createAnimatedRect(graphicService);
+    const startRect = createAnimatedRect(graphicService);
+    const customRect = createAnimatedRect(graphicService);
+    group.appendChild(endRect);
+    group.appendChild(startRect);
+    group.appendChild(customRect);
+
+    const endAnimate = endRect.animate().to({ x: 100 }, 100, 'linear');
+    tick(ticker, 50);
+    endAnimate.stop('end');
+    expect(endRect.attribute.x).toBe(100);
+    expect((endRect as any).baseAttributes.x).toBe(100);
+
+    const startAnimate = startRect.animate().to({ x: 100 }, 100, 'linear');
+    tick(ticker, 50);
+    startAnimate.stop('start');
+    expect(startRect.attribute.x).toBe(0);
+    expect((startRect as any).baseAttributes.x).toBe(0);
+
+    const customAnimate = customRect.animate().to({ x: 100 }, 100, 'linear');
+    tick(ticker, 50);
+    customAnimate.stop({ x: 12 });
+    expect(customRect.attribute.x).toBe(12);
+    expect((customRect as any).baseAttributes.x).toBe(12);
+  });
+
+  test('executor attrOutChannel commits non-animated diff attrs as static truth', () => {
+    const { group, ticker, graphicService } = createStageHarness('executor-attr-out-channel');
+    const rect = createAnimatedRect(graphicService);
+    (rect as any).context = {
+      diffAttrs: {
+        x: 80,
+        fill: 'red'
+      }
+    };
+    group.appendChild(rect);
+
+    new AnimateExecutor(rect).execute({
+      channel: {
+        x: { to: 80 }
+      },
+      duration: 100,
+      easing: 'linear'
+    });
+
+    expect((rect as any).baseAttributes.fill).toBe('red');
+    expect((rect as any).baseAttributes.x).toBe(0);
+
+    tick(ticker, 50);
+    expect(rect.attribute.x).toBeCloseTo(40, 5);
+    expect(rect.attribute.fill).toBe('red');
+    expect((rect as any).baseAttributes.fill).toBe('red');
+    expect((rect as any).baseAttributes.x).toBe(0);
+  });
+
   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);
@@ -189,7 +280,7 @@ describe('D3 pre-handoff animation runtime', () => {
     expect(rect.attribute.opacity).toBeCloseTo(0.8, 5);
   });
 
-  test('state switch wins over an in-flight self-driven animation on the same attribute and restores current truth', () => {
+  test('state switch wins over an in-flight self-driven animation on the same attribute', () => {
     const { group, ticker, graphicService } = createStageHarness('self-vs-state');
     const rect = createAnimatedRect(graphicService);
     group.appendChild(rect);