@visactor/vrender-core 1.1.0-alpha.24 → 1.1.0-alpha.25

package/dist/index.es.js

@@ -698,6 +698,9 @@ class Node extends EventEmitter {
         this.parent = null;
         this._count = 1;
     }
+    onParentSharedStateTreeChanged(_stage, _layer) {
+        return;
+    }
     forEachChildren(cb, reverse = false) {
         if (reverse) {
             let child = this._lastChild;
@@ -9024,7 +9027,7 @@ function createConicalGradient(context, stops, x, y, deltaAngle, startAngle, end
     return pattern;
 }
 
-const FULL_DEFINITION_KEYS$1 = new Set([
+const FULL_DEFINITION_KEYS = new Set([
     'name',
     'patch',
     'priority',
@@ -9033,7 +9036,7 @@ const FULL_DEFINITION_KEYS$1 = new Set([
     'resolver',
     'declaredAffectedKeys'
 ]);
-function isPlainObject$2(value) {
+function isPlainObject$1(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 function normalizePatch(value) {
@@ -9095,14 +9098,13 @@ class StateDefinitionCompiler {
                 patch: undefined
             };
         }
-        const keys = isPlainObject$2(value) ? Object.keys(value) : [];
-        const hasFullKey = keys.some(key => FULL_DEFINITION_KEYS$1.has(key));
+        const keys = isPlainObject$1(value) ? Object.keys(value) : [];
+        const hasFullKey = keys.some(key => FULL_DEFINITION_KEYS.has(key));
         if (hasFullKey) {
             const definition = value;
             return {
                 name: (_a = definition.name) !== null && _a !== void 0 ? _a : name,
                 priority: (_b = definition.priority) !== null && _b !== void 0 ? _b : 0,
-                rank: definition.rank,
                 patch: normalizePatch(definition.patch),
                 resolver: definition.resolver,
                 declaredAffectedKeys: definition.declaredAffectedKeys,
@@ -9123,425 +9125,54 @@ class StateDefinitionCompiler {
         });
         compiled.forEach((definition, origin) => {
             const closure = new Set();
-            const walk = (stateName, stack) => {
+            const walk = (stateName, visiting) => {
                 const nextStates = rawRelationMap.get(stateName);
                 if (!nextStates || !nextStates.size) {
                     return;
                 }
                 nextStates.forEach(nextState => {
-                    if (nextState === origin) {
-                        console.warn(`[StateDefinitionCompiler] circular ${relation} relation detected: ${stack.join(' -> ')} -> ${origin}`);
-                        return;
-                    }
-                    if (stack.includes(nextState)) {
-                        console.warn(`[StateDefinitionCompiler] circular ${relation} relation detected: ${stack.join(' -> ')} -> ${nextState}`);
-                        return;
-                    }
-                    if (closure.has(nextState)) {
+                    if (nextState === origin || visiting.has(nextState) || closure.has(nextState)) {
                         return;
                     }
                     closure.add(nextState);
-                    walk(nextState, stack.concat(nextState));
+                    visiting.add(nextState);
+                    walk(nextState, visiting);
+                    visiting.delete(nextState);
                 });
             };
-            walk(origin, [origin]);
+            walk(origin, new Set([origin]));
             definition[relation] = closure;
         });
     }
 }
 
-var UpdateCategory;
-(function (UpdateCategory) {
-    UpdateCategory[UpdateCategory["NONE"] = 0] = "NONE";
-    UpdateCategory[UpdateCategory["PAINT"] = 1] = "PAINT";
-    UpdateCategory[UpdateCategory["SHAPE"] = 2] = "SHAPE";
-    UpdateCategory[UpdateCategory["BOUNDS"] = 4] = "BOUNDS";
-    UpdateCategory[UpdateCategory["TRANSFORM"] = 8] = "TRANSFORM";
-    UpdateCategory[UpdateCategory["LAYOUT"] = 16] = "LAYOUT";
-    UpdateCategory[UpdateCategory["PICK"] = 32] = "PICK";
-})(UpdateCategory || (UpdateCategory = {}));
-const ATTRIBUTE_CATEGORY = {
-    fill: UpdateCategory.PAINT,
-    opacity: UpdateCategory.PAINT,
-    fillOpacity: UpdateCategory.PAINT,
-    strokeOpacity: UpdateCategory.PAINT,
-    lineDash: UpdateCategory.PAINT,
-    lineDashOffset: UpdateCategory.PAINT,
-    lineCap: UpdateCategory.PAINT,
-    lineJoin: UpdateCategory.PAINT,
-    miterLimit: UpdateCategory.PAINT,
-    shadowColor: UpdateCategory.PAINT,
-    x: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    y: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    scaleX: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    scaleY: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    angle: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    anchor: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    anchor3d: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    postMatrix: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    layout: UpdateCategory.LAYOUT,
-    zIndex: UpdateCategory.PAINT,
-    visible: UpdateCategory.PAINT | UpdateCategory.PICK,
-    lineWidth: UpdateCategory.SHAPE | UpdateCategory.BOUNDS | UpdateCategory.PICK,
-    width: UpdateCategory.SHAPE | UpdateCategory.BOUNDS,
-    height: UpdateCategory.SHAPE | UpdateCategory.BOUNDS
-};
-const ATTRIBUTE_DELTA_CLASSIFIER = {
-    stroke: (prev, next) => {
-        const prevEnabled = prev != null && prev !== false;
-        const nextEnabled = next != null && next !== false;
-        if (prevEnabled !== nextEnabled) {
-            return UpdateCategory.PAINT | UpdateCategory.BOUNDS | UpdateCategory.PICK;
-        }
-        return UpdateCategory.PAINT;
-    },
-    shadowBlur: (prev, next) => {
-        const prevBlur = Number(prev !== null && prev !== void 0 ? prev : 0);
-        const nextBlur = Number(next !== null && next !== void 0 ? next : 0);
-        if (prevBlur !== nextBlur && (prevBlur > 0 || nextBlur > 0)) {
-            return UpdateCategory.PAINT | UpdateCategory.BOUNDS;
-        }
-        return UpdateCategory.PAINT;
-    }
-};
-function classifyAttributeDelta(key, prev, next) {
-    var _a;
-    const dynamicClassifier = ATTRIBUTE_DELTA_CLASSIFIER[key];
-    if (dynamicClassifier) {
-        return dynamicClassifier(prev, next);
-    }
-    return (_a = ATTRIBUTE_CATEGORY[key]) !== null && _a !== void 0 ? _a : UpdateCategory.PAINT;
-}
-function classifyAffectedKeyConservatively(key) {
-    var _a;
-    if (key === 'stroke') {
-        return UpdateCategory.PAINT | UpdateCategory.BOUNDS | UpdateCategory.PICK;
-    }
-    if (key === 'shadowBlur') {
-        return UpdateCategory.PAINT | UpdateCategory.BOUNDS;
-    }
-    return (_a = ATTRIBUTE_CATEGORY[key]) !== null && _a !== void 0 ? _a : UpdateCategory.PAINT;
-}
-function classifyAffectedKeys(keys) {
-    let category = UpdateCategory.NONE;
-    for (const key of keys) {
-        category |= classifyAffectedKeyConservatively(key);
-    }
-    return category;
-}
-
-const DEFAULT_MAX_EVENT_RECORDS = 100;
-const STAGE_PERF_MONITOR = Symbol('vrender.statePerfMonitor');
-function createReasonBreakdown() {
-    return {
-        config_disabled: 0,
-        context_disabled: 0,
-        non_batch_operation: 0,
-        mixed_update_category: 0,
-        resolver_unstable_keys: 0,
-        graphic_unavailable: 0
-    };
-}
-function createEmptyStatePerfSnapshot() {
-    return {
-        counters: {
-            stateCommits: 0,
-            sharedRefreshCommits: 0,
-            deferredJobsCreated: 0,
-            deferredJobsCompleted: 0,
-            deferredJobsCancelled: 0,
-            deferredJobsCoalesced: 0,
-            deferredGraphicsCommitted: 0,
-            deferredBudgetYields: 0,
-            deferredIneligibleGraphics: 0
-        },
-        deferredIneligibleByReason: createReasonBreakdown(),
-        categoryBreakdown: {
-            paint: 0,
-            transform: 0,
-            shape: 0,
-            bounds: 0,
-            layout: 0,
-            pick: 0
-        },
-        refresh: {
-            queuedGraphics: 0,
-            flushedGraphics: 0,
-            ensureFreshCalls: 0,
-            renderScheduled: 0
-        },
-        resolver: {
-            cacheHits: 0,
-            cacheMisses: 0,
-            invalidations: 0
-        },
-        cost: {
-            resolverTotalMs: 0,
-            resolverMaxMs: 0,
-            patchTotalMs: 0,
-            patchMaxMs: 0,
-            sharedRefreshTotalMs: 0,
-            sharedRefreshMaxMs: 0,
-            batchSliceTotalMs: 0,
-            batchSliceMaxMs: 0
-        },
-        allocationHints: {
-            patchObjectsCreated: 0,
-            batchEntriesCreated: 0,
-            refreshQueuePushes: 0
-        },
-        batch: {
-            pendingJobs: 0,
-            maxPendingJobs: 0,
-            maxGraphicsInJob: 0,
-            maxFrameSliceCost: 0
-        },
-        events: []
-    };
-}
-function cloneSnapshot(snapshot) {
-    return {
-        counters: Object.assign({}, snapshot.counters),
-        deferredIneligibleByReason: Object.assign({}, snapshot.deferredIneligibleByReason),
-        categoryBreakdown: Object.assign({}, snapshot.categoryBreakdown),
-        refresh: Object.assign({}, snapshot.refresh),
-        resolver: Object.assign({}, snapshot.resolver),
-        cost: Object.assign({}, snapshot.cost),
-        allocationHints: Object.assign({}, snapshot.allocationHints),
-        batch: Object.assign({}, snapshot.batch),
-        events: snapshot.events ? snapshot.events.slice() : []
-    };
-}
-function isDeferredStateContextConfig(value) {
-    return (!!value &&
-        (Object.prototype.hasOwnProperty.call(value, 'deferred') ||
-            Object.prototype.hasOwnProperty.call(value, 'localEnabled')));
-}
-function normalizeDeferredStateOwnerConfig(value) {
-    if (!value) {
-        return undefined;
-    }
-    if (isDeferredStateContextConfig(value)) {
-        return value;
-    }
-    return {
-        deferred: value
-    };
-}
-function normalizeDeferredStateConfig(config) {
-    var _a, _b, _c;
-    return {
-        enabled: (_a = config === null || config === void 0 ? void 0 : config.enabled) !== null && _a !== void 0 ? _a : false,
-        frameBudget: (_b = config === null || config === void 0 ? void 0 : config.frameBudget) !== null && _b !== void 0 ? _b : 8,
-        maxGraphicsPerFrame: (_c = config === null || config === void 0 ? void 0 : config.maxGraphicsPerFrame) !== null && _c !== void 0 ? _c : 100
-    };
-}
-function fingerprintDeferredStateConfig(config) {
-    return `${config.enabled ? 1 : 0}:${config.frameBudget}:${config.maxGraphicsPerFrame}`;
-}
-class StatePerfMonitor {
-    constructor(configSource) {
-        this.configSource = configSource;
-        this.snapshot = createEmptyStatePerfSnapshot();
-    }
-    setConfig(config) {
-        this.configSource = config;
-    }
-    getSnapshot() {
-        return cloneSnapshot(this.snapshot);
-    }
-    reset() {
-        const next = createEmptyStatePerfSnapshot();
-        Object.assign(this.snapshot.counters, next.counters);
-        Object.assign(this.snapshot.deferredIneligibleByReason, next.deferredIneligibleByReason);
-        Object.assign(this.snapshot.categoryBreakdown, next.categoryBreakdown);
-        Object.assign(this.snapshot.refresh, next.refresh);
-        Object.assign(this.snapshot.resolver, next.resolver);
-        Object.assign(this.snapshot.cost, next.cost);
-        Object.assign(this.snapshot.allocationHints, next.allocationHints);
-        Object.assign(this.snapshot.batch, next.batch);
-        this.snapshot.events = [];
-    }
-    incrementCounter(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.counters[key] += delta;
-    }
-    recordDeferredIneligible(reason, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.deferredIneligibleByReason[reason] += delta;
-        this.snapshot.counters.deferredIneligibleGraphics += delta;
-        this.recordEvent('deferred-ineligible', { reason, count: delta });
-    }
-    recordCategory(category) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        if (category & UpdateCategory.PAINT) {
-            this.snapshot.categoryBreakdown.paint += 1;
-        }
-        if (category & UpdateCategory.TRANSFORM) {
-            this.snapshot.categoryBreakdown.transform += 1;
-        }
-        if (category & UpdateCategory.SHAPE) {
-            this.snapshot.categoryBreakdown.shape += 1;
-        }
-        if (category & UpdateCategory.BOUNDS) {
-            this.snapshot.categoryBreakdown.bounds += 1;
-        }
-        if (category & UpdateCategory.LAYOUT) {
-            this.snapshot.categoryBreakdown.layout += 1;
-        }
-        if (category & UpdateCategory.PICK) {
-            this.snapshot.categoryBreakdown.pick += 1;
-        }
-    }
-    recordRefresh(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.refresh[key] += delta;
-    }
-    recordResolver(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.resolver[key] += delta;
-    }
-    recordCost(kind, durationMs) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        if (kind === 'resolver') {
-            this.snapshot.cost.resolverTotalMs += durationMs;
-            this.snapshot.cost.resolverMaxMs = Math.max(this.snapshot.cost.resolverMaxMs, durationMs);
-            return;
-        }
-        if (kind === 'patch') {
-            this.snapshot.cost.patchTotalMs += durationMs;
-            this.snapshot.cost.patchMaxMs = Math.max(this.snapshot.cost.patchMaxMs, durationMs);
-            return;
-        }
-        if (kind === 'sharedRefresh') {
-            this.snapshot.cost.sharedRefreshTotalMs += durationMs;
-            this.snapshot.cost.sharedRefreshMaxMs = Math.max(this.snapshot.cost.sharedRefreshMaxMs, durationMs);
-            return;
-        }
-        this.snapshot.cost.batchSliceTotalMs += durationMs;
-        this.snapshot.cost.batchSliceMaxMs = Math.max(this.snapshot.cost.batchSliceMaxMs, durationMs);
-        this.snapshot.batch.maxFrameSliceCost = Math.max(this.snapshot.batch.maxFrameSliceCost, durationMs);
-    }
-    recordAllocation(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.allocationHints[key] += delta;
-    }
-    updateBatchPending(pendingJobs) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.batch.pendingJobs = pendingJobs;
-        this.snapshot.batch.maxPendingJobs = Math.max(this.snapshot.batch.maxPendingJobs, pendingJobs);
-    }
-    updateMaxGraphicsInJob(count) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.batch.maxGraphicsInJob = Math.max(this.snapshot.batch.maxGraphicsInJob, count);
-    }
-    recordEvent(type, detail) {
-        var _a, _b, _c;
-        if (!this.shouldRecordEvents()) {
-            return;
-        }
-        const events = (_a = this.snapshot.events) !== null && _a !== void 0 ? _a : (this.snapshot.events = []);
-        events.push({
-            type,
-            at: Date.now(),
-            detail
-        });
-        const max = (_c = (_b = this.getConfig()) === null || _b === void 0 ? void 0 : _b.maxEventRecords) !== null && _c !== void 0 ? _c : DEFAULT_MAX_EVENT_RECORDS;
-        if (events.length > max) {
-            events.splice(0, events.length - max);
-        }
-    }
-    isEnabled() {
-        var _a;
-        return ((_a = this.getConfig()) === null || _a === void 0 ? void 0 : _a.enabled) === true;
-    }
-    shouldRecordEvents() {
-        const config = this.getConfig();
-        return !!(config === null || config === void 0 ? void 0 : config.enabled) && !!config.recordEvents;
-    }
-    getConfig() {
-        return typeof this.configSource === 'function' ? this.configSource() : this.configSource;
-    }
-}
-function ensureStageStatePerfMonitor(stage) {
-    const stageAny = stage;
-    if (!stageAny[STAGE_PERF_MONITOR]) {
-        stageAny[STAGE_PERF_MONITOR] = new StatePerfMonitor(() => stage.statePerfConfig);
-    }
-    return stageAny[STAGE_PERF_MONITOR];
-}
-function getStageStatePerfMonitor(stage) {
-    if (!stage) {
-        return undefined;
-    }
-    return stage[STAGE_PERF_MONITOR];
-}
-function getActiveStageStatePerfMonitor(stage) {
-    var _a;
-    if (!stage) {
-        return undefined;
-    }
-    const current = getStageStatePerfMonitor(stage);
-    if (current) {
-        return current;
-    }
-    return ((_a = stage.statePerfConfig) === null || _a === void 0 ? void 0 : _a.enabled) === true ? ensureStageStatePerfMonitor(stage) : undefined;
-}
-
-function isPlainObject$1(value) {
+function isPlainObject(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);
 }
-function cloneValue$1(value) {
-    if (!isPlainObject$1(value)) {
+function cloneValue(value) {
+    if (!isPlainObject(value)) {
         return value;
     }
     const clone = {};
     Object.keys(value).forEach(key => {
-        clone[key] = cloneValue$1(value[key]);
+        clone[key] = cloneValue(value[key]);
     });
     return clone;
 }
-function deepMerge$1(base, value) {
+function deepMerge(base, value) {
     var _a;
-    const result = (_a = cloneValue$1(base)) !== null && _a !== void 0 ? _a : {};
+    const result = (_a = cloneValue(base)) !== null && _a !== void 0 ? _a : {};
     Object.keys(value).forEach(key => {
         const nextValue = value[key];
         const previousValue = result[key];
-        if (isPlainObject$1(previousValue) && isPlainObject$1(nextValue)) {
-            result[key] = deepMerge$1(previousValue, nextValue);
+        if (isPlainObject(previousValue) && isPlainObject(nextValue)) {
+            result[key] = deepMerge(previousValue, nextValue);
             return;
         }
-        result[key] = cloneValue$1(nextValue);
+        result[key] = cloneValue(nextValue);
     });
     return result;
 }
-const FULL_DEFINITION_KEYS = new Set([
-    'name',
-    'patch',
-    'priority',
-    'exclude',
-    'suppress',
-    'resolver',
-    'declaredAffectedKeys'
-]);
 class StateEngine {
     constructor(options) {
         var _a;
@@ -9555,9 +9186,6 @@ class StateEngine {
         this.baseAttributes = {};
         this.compiledDefinitions = options.compiledDefinitions;
         this.stateSort = options.stateSort;
-        this.stateProxy = options.stateProxy;
-        this.stateProxyEligibility = options.stateProxyEligibility;
-        this.states = options.states;
         this.mergeMode = (_a = options.mergeMode) !== null && _a !== void 0 ? _a : 'shallow';
     }
     get activeStates() {
@@ -9656,11 +9284,9 @@ class StateEngine {
         };
     }
     invalidateResolverCache() {
-        var _a, _b;
         this.resolverPatchCache.clear();
         this.resolverCacheKey = '';
         this.resolverCacheValid = false;
-        (_b = getActiveStageStatePerfMonitor((_a = this.graphic) === null || _a === void 0 ? void 0 : _a.stage)) === null || _b === void 0 ? void 0 : _b.recordResolver('invalidations');
     }
     hasState(stateName) {
         if (!this._activeStates.length) {
@@ -9671,28 +9297,6 @@ class StateEngine {
         }
         return this._activeStates.includes(stateName);
     }
-    getCompatPatch(stateName) {
-        var _a, _b, _c;
-        const targetStates = this._activeStates.length ? this._activeStates : this._effectiveStates;
-        const canUseStateProxy = this.canUseStateProxy(stateName);
-        const proxyPatch = canUseStateProxy ? (_a = this.stateProxy) === null || _a === void 0 ? void 0 : _a.call(this, stateName, targetStates) : undefined;
-        if (this.stateProxy && canUseStateProxy) {
-            return proxyPatch !== null && proxyPatch !== void 0 ? proxyPatch : undefined;
-        }
-        const value = (_b = this.states) === null || _b === void 0 ? void 0 : _b[stateName];
-        if (value == null) {
-            return undefined;
-        }
-        if (!isPlainObject$1(value)) {
-            return value;
-        }
-        const keys = Object.keys(value);
-        const hasFullKey = keys.some(key => FULL_DEFINITION_KEYS.has(key));
-        if (!hasFullKey) {
-            return value;
-        }
-        return cloneValue$1(((_c = value.patch) !== null && _c !== void 0 ? _c : undefined));
-    }
     sortStates(states) {
         const withDefinition = [];
         const withoutDefinition = [];
@@ -9749,96 +9353,44 @@ class StateEngine {
         };
     }
     recomputePatch(effectiveStates) {
-        var _a;
-        const perfMonitor = getActiveStageStatePerfMonitor((_a = this.graphic) === null || _a === void 0 ? void 0 : _a.stage);
-        const patchStart = perfMonitor ? performance.now() : 0;
-        let resolverCost = 0;
         const cacheKey = effectiveStates.join(',');
         const nextPatch = {};
-        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordAllocation('patchObjectsCreated');
-        if (this.resolverCacheValid && this.resolverCacheKey === cacheKey) {
-            effectiveStates.forEach(stateName => {
-                var _a;
-                const canUseStateProxy = this.canUseStateProxy(stateName);
-                const proxyPatch = canUseStateProxy ? (_a = this.stateProxy) === null || _a === void 0 ? void 0 : _a.call(this, stateName, effectiveStates) : undefined;
-                if (this.stateProxy && canUseStateProxy) {
-                    if (proxyPatch != null) {
-                        this.mergeInto(nextPatch, proxyPatch);
-                    }
-                    return;
-                }
-                const definition = this.compiledDefinitions.get(stateName);
-                if (!definition) {
-                    const compatPatch = this.getCompatPatch(stateName);
-                    if (compatPatch) {
-                        this.mergeInto(nextPatch, compatPatch);
-                    }
-                    return;
-                }
-                if (definition.patch) {
-                    this.mergeInto(nextPatch, definition.patch);
-                }
-                if (definition.hasResolver) {
-                    const cachedPatch = this.resolverPatchCache.get(stateName);
-                    if (cachedPatch) {
-                        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordResolver('cacheHits');
-                        this.mergeInto(nextPatch, cachedPatch);
-                    }
-                }
-            });
-        }
-        else {
+        const useResolverCache = this.resolverCacheValid && this.resolverCacheKey === cacheKey;
+        if (!useResolverCache) {
             this.resolverPatchCache.clear();
             this.resolverCacheKey = cacheKey;
-            effectiveStates.forEach(stateName => {
-                var _a;
-                const canUseStateProxy = this.canUseStateProxy(stateName);
-                const proxyPatch = canUseStateProxy ? (_a = this.stateProxy) === null || _a === void 0 ? void 0 : _a.call(this, stateName, effectiveStates) : undefined;
-                if (this.stateProxy && canUseStateProxy) {
-                    if (proxyPatch != null) {
-                        this.mergeInto(nextPatch, proxyPatch);
-                    }
-                    return;
-                }
-                const definition = this.compiledDefinitions.get(stateName);
-                if (!definition) {
-                    const compatPatch = this.getCompatPatch(stateName);
-                    if (compatPatch) {
-                        this.mergeInto(nextPatch, compatPatch);
-                    }
-                    return;
-                }
-                if (definition.patch) {
-                    this.mergeInto(nextPatch, definition.patch);
-                }
-                if (definition.hasResolver && definition.resolver) {
-                    perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordResolver('cacheMisses');
-                    const resolverStart = perfMonitor ? performance.now() : 0;
-                    const resolverPatch = definition.resolver({
+        }
+        effectiveStates.forEach(stateName => {
+            var _a;
+            const definition = this.compiledDefinitions.get(stateName);
+            if (!definition) {
+                return;
+            }
+            if (definition.patch) {
+                this.mergeInto(nextPatch, definition.patch);
+            }
+            if (definition.hasResolver) {
+                const resolverPatch = useResolverCache
+                    ? this.resolverPatchCache.get(stateName)
+                    : (_a = definition.resolver) === null || _a === void 0 ? void 0 : _a.call(definition, {
                         graphic: this.graphic,
                         activeStates: this._activeStates,
                         effectiveStates: this._effectiveStates,
                         baseAttributes: this.baseAttributes,
                         resolvedPatch: nextPatch
                     });
-                    if (perfMonitor) {
-                        const duration = performance.now() - resolverStart;
-                        resolverCost += duration;
-                        perfMonitor.recordCost('resolver', duration);
-                    }
-                    if (resolverPatch) {
+                if (resolverPatch) {
+                    if (!useResolverCache) {
                         this.resolverPatchCache.set(stateName, resolverPatch);
-                        this.mergeInto(nextPatch, resolverPatch);
                     }
+                    this.mergeInto(nextPatch, resolverPatch);
                 }
-            });
+            }
+        });
+        if (!useResolverCache) {
             this.resolverCacheValid = true;
         }
         this._resolvedPatch = nextPatch;
-        if (perfMonitor) {
-            const totalCost = performance.now() - patchStart;
-            perfMonitor.recordCost('patch', Math.max(0, totalCost - resolverCost));
-        }
     }
     mergeInto(target, patch) {
         if (this.mergeMode === 'deep') {
@@ -9847,20 +9399,20 @@ class StateEngine {
                 const nextValue = patch[key];
                 const previousValue = target[key];
                 const baseValue = (_a = this.baseAttributes) === null || _a === void 0 ? void 0 : _a[key];
-                if (isPlainObject$1(previousValue) && isPlainObject$1(nextValue)) {
-                    target[key] = deepMerge$1(previousValue, nextValue);
+                if (isPlainObject(previousValue) && isPlainObject(nextValue)) {
+                    target[key] = deepMerge(previousValue, nextValue);
                     return;
                 }
-                if (!isPlainObject$1(previousValue) && isPlainObject$1(baseValue) && isPlainObject$1(nextValue)) {
-                    target[key] = deepMerge$1(baseValue, nextValue);
+                if (!isPlainObject(previousValue) && isPlainObject(baseValue) && isPlainObject(nextValue)) {
+                    target[key] = deepMerge(baseValue, nextValue);
                     return;
                 }
-                target[key] = cloneValue$1(nextValue);
+                target[key] = cloneValue(nextValue);
             });
             return;
         }
         Object.keys(patch).forEach(key => {
-            target[key] = cloneValue$1(patch[key]);
+            target[key] = cloneValue(patch[key]);
         });
     }
     sameArray(left, right) {
@@ -9874,285 +9426,69 @@ class StateEngine {
         }
         return true;
     }
-    canUseStateProxy(stateName) {
-        if (!this.stateProxy) {
-            return false;
-        }
-        return this.stateProxyEligibility ? this.stateProxyEligibility(stateName) : true;
-    }
 }
 
-class StateModel {
-    constructor(options = {}) {
-        var _a;
-        this.exclusiveGroupMap = new Map();
-        this.exclusiveGroups = new Map();
-        this.states = options.states;
-        this.currentStates = options.currentStates ? [...options.currentStates] : undefined;
-        this.stateSort = options.stateSort;
-        this.stateProxy = options.stateProxy;
-        this.stateEngine = options.stateEngine;
-        if (this.stateEngine &&
-            options.currentStates &&
-            !this.sameStates(this.stateEngine.activeStates, options.currentStates)) {
-            this.stateEngine.applyStates(options.currentStates);
-        }
-        const exclusiveGroups = (_a = options.exclusiveGroups) !== null && _a !== void 0 ? _a : {};
-        for (const groupName in exclusiveGroups) {
-            if (!Object.prototype.hasOwnProperty.call(exclusiveGroups, groupName)) {
-                continue;
-            }
-            this.registerExclusiveGroup(groupName, exclusiveGroups[groupName]);
-        }
-    }
-    getCurrentStates() {
-        return this.currentStates ? [...this.currentStates] : [];
-    }
-    hasState(stateName) {
-        if (this.stateEngine) {
-            return this.stateEngine.hasState(stateName);
-        }
-        if (!this.currentStates || !this.currentStates.length) {
-            return false;
-        }
-        if (stateName == null) {
-            return true;
-        }
-        return this.currentStates.includes(stateName);
-    }
-    getState(stateName) {
-        var _a;
-        return (_a = this.states) === null || _a === void 0 ? void 0 : _a[stateName];
-    }
-    useStates(states) {
-        var _a;
-        if (this.stateEngine) {
-            const result = this.stateEngine.applyStates(states);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (!states.length) {
-            return this.clearStates();
-        }
-        const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : [];
-        const changed = previousStates.length !== states.length || states.some((stateName, index) => previousStates[index] !== stateName);
-        const nextStates = this.sortStates(states);
-        if (changed) {
-            this.currentStates = nextStates;
-        }
-        return {
-            changed,
-            states: changed ? [...nextStates] : [...previousStates]
-        };
-    }
-    clearStates() {
-        if (this.stateEngine) {
-            const result = this.stateEngine.clearStates();
-            this.currentStates = [];
-            return {
-                changed: result.changed,
-                states: [],
-                effectiveStates: []
-            };
-        }
-        const changed = this.hasState();
-        this.currentStates = [];
-        return {
-            changed,
-            states: []
-        };
-    }
-    addState(stateName, keepCurrentStates) {
-        var _a;
-        if (this.stateEngine) {
-            const result = this.stateEngine.addState(stateName, keepCurrentStates);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (this.currentStates &&
-            this.currentStates.includes(stateName) &&
-            (keepCurrentStates || this.currentStates.length === 1)) {
-            return {
-                changed: false,
-                states: this.getCurrentStates()
-            };
-        }
-        const nextStates = keepCurrentStates && ((_a = this.currentStates) === null || _a === void 0 ? void 0 : _a.length) ? this.currentStates.concat([stateName]) : [stateName];
-        return this.useStates(nextStates);
-    }
-    removeState(stateName) {
-        if (this.stateEngine) {
-            const result = this.stateEngine.removeState(stateName);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (!this.currentStates) {
-            return {
-                changed: false,
-                states: []
-            };
-        }
-        const filter = Array.isArray(stateName) ? (s) => !stateName.includes(s) : (s) => s !== stateName;
-        const nextStates = this.currentStates.filter(filter);
-        if (nextStates.length === this.currentStates.length) {
-            return {
-                changed: false,
-                states: this.getCurrentStates()
-            };
-        }
-        return this.useStates(nextStates);
-    }
-    toggleState(stateName) {
-        if (this.stateEngine) {
-            const result = this.stateEngine.toggleState(stateName);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (this.hasState(stateName)) {
-            return this.removeState(stateName);
-        }
-        const nextStates = this.currentStates ? this.currentStates.slice() : [];
-        if (!nextStates.includes(stateName)) {
-            nextStates.push(stateName);
-        }
-        return this.useStates(nextStates);
-    }
-    sortStates(states) {
-        if (this.stateEngine) {
-            return [...this.stateEngine.activeStates];
-        }
-        if (!this.stateSort) {
-            return [...states];
-        }
-        return [...states].sort(this.stateSort);
-    }
-    registerExclusiveGroup(groupName, states) {
-        const uniqueStates = Array.from(new Set(states));
-        this.exclusiveGroups.set(groupName, uniqueStates);
-        uniqueStates.forEach(stateName => this.exclusiveGroupMap.set(stateName, groupName));
-    }
-    getExclusiveGroup(stateName) {
-        return this.exclusiveGroupMap.get(stateName);
-    }
-    getMutuallyExclusiveStates(stateName) {
-        var _a;
-        const groupName = this.getExclusiveGroup(stateName);
-        if (!groupName) {
-            return [];
-        }
-        return ((_a = this.exclusiveGroups.get(groupName)) !== null && _a !== void 0 ? _a : []).filter(name => name !== stateName);
-    }
-    isMutuallyExclusive(stateA, stateB) {
-        const groupName = this.getExclusiveGroup(stateA);
-        return !!groupName && groupName === this.getExclusiveGroup(stateB) && stateA !== stateB;
-    }
-    get effectiveStates() {
-        var _a, _b, _c;
-        return (_c = (_b = (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.effectiveStates) !== null && _b !== void 0 ? _b : this.currentStates) !== null && _c !== void 0 ? _c : [];
-    }
-    get resolvedPatch() {
-        var _a;
-        return (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.resolvedPatch;
-    }
-    sameStates(left, right) {
-        if (left.length !== right.length) {
-            return false;
-        }
-        for (let index = 0; index < left.length; index++) {
-            if (left[index] !== right[index]) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-
-function isPlainObject(value) {
-    return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-function cloneValue(value) {
-    if (!isPlainObject(value)) {
-        return value;
-    }
-    const clone = {};
-    for (const key in value) {
-        if (!Object.prototype.hasOwnProperty.call(value, key)) {
-            continue;
-        }
-        clone[key] = cloneValue(value[key]);
-    }
-    return clone;
-}
-function deepMerge(base, value) {
-    const result = cloneValue(base) || {};
-    for (const key in value) {
-        if (!Object.prototype.hasOwnProperty.call(value, key)) {
-            continue;
-        }
-        const nextValue = value[key];
-        const previousValue = result[key];
-        if (isPlainObject(previousValue) && isPlainObject(nextValue)) {
-            result[key] = deepMerge(previousValue, nextValue);
+var UpdateCategory;
+(function (UpdateCategory) {
+    UpdateCategory[UpdateCategory["NONE"] = 0] = "NONE";
+    UpdateCategory[UpdateCategory["PAINT"] = 1] = "PAINT";
+    UpdateCategory[UpdateCategory["SHAPE"] = 2] = "SHAPE";
+    UpdateCategory[UpdateCategory["BOUNDS"] = 4] = "BOUNDS";
+    UpdateCategory[UpdateCategory["TRANSFORM"] = 8] = "TRANSFORM";
+    UpdateCategory[UpdateCategory["LAYOUT"] = 16] = "LAYOUT";
+    UpdateCategory[UpdateCategory["PICK"] = 32] = "PICK";
+})(UpdateCategory || (UpdateCategory = {}));
+const ATTRIBUTE_CATEGORY = {
+    fill: UpdateCategory.PAINT,
+    opacity: UpdateCategory.PAINT,
+    fillOpacity: UpdateCategory.PAINT,
+    strokeOpacity: UpdateCategory.PAINT,
+    lineDash: UpdateCategory.PAINT,
+    lineDashOffset: UpdateCategory.PAINT,
+    lineCap: UpdateCategory.PAINT,
+    lineJoin: UpdateCategory.PAINT,
+    miterLimit: UpdateCategory.PAINT,
+    shadowColor: UpdateCategory.PAINT,
+    x: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    y: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    scaleX: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    scaleY: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    angle: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    anchor: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    anchor3d: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    postMatrix: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    layout: UpdateCategory.LAYOUT,
+    zIndex: UpdateCategory.PAINT,
+    visible: UpdateCategory.PAINT | UpdateCategory.PICK,
+    lineWidth: UpdateCategory.SHAPE | UpdateCategory.BOUNDS | UpdateCategory.PICK,
+    width: UpdateCategory.SHAPE | UpdateCategory.BOUNDS,
+    height: UpdateCategory.SHAPE | UpdateCategory.BOUNDS
+};
+const ATTRIBUTE_DELTA_CLASSIFIER = {
+    stroke: (prev, next) => {
+        const prevEnabled = prev != null && prev !== false;
+        const nextEnabled = next != null && next !== false;
+        if (prevEnabled !== nextEnabled) {
+            return UpdateCategory.PAINT | UpdateCategory.BOUNDS | UpdateCategory.PICK;
         }
-        else {
-            result[key] = cloneValue(nextValue);
+        return UpdateCategory.PAINT;
+    },
+    shadowBlur: (prev, next) => {
+        const prevBlur = Number(prev !== null && prev !== void 0 ? prev : 0);
+        const nextBlur = Number(next !== null && next !== void 0 ? next : 0);
+        if (prevBlur !== nextBlur && (prevBlur > 0 || nextBlur > 0)) {
+            return UpdateCategory.PAINT | UpdateCategory.BOUNDS;
         }
+        return UpdateCategory.PAINT;
     }
-    return result;
-}
-class StateStyleResolver {
-    constructor(options = {}) {
-        this.options = options;
-    }
-    resolve(normalAttrs, states, stateProxy, currentStates, stateSort) {
-        var _a;
-        const mergeMode = (_a = this.options.mergeMode) !== null && _a !== void 0 ? _a : 'shallow';
-        const sortedStates = stateSort ? currentStates.slice().sort(stateSort) : currentStates.slice();
-        const resolvedAttrs = {};
-        sortedStates.forEach(stateName => {
-            const attrs = stateProxy ? stateProxy(stateName, sortedStates) : states === null || states === void 0 ? void 0 : states[stateName];
-            if (attrs == null) {
-                return;
-            }
-            for (const key in attrs) {
-                if (!Object.prototype.hasOwnProperty.call(attrs, key)) {
-                    continue;
-                }
-                const nextValue = attrs[key];
-                if (mergeMode === 'deep' &&
-                    isPlainObject(nextValue) &&
-                    (isPlainObject(resolvedAttrs[key]) ||
-                        isPlainObject(normalAttrs[key]))) {
-                    const baseValue = isPlainObject(resolvedAttrs[key])
-                        ? resolvedAttrs[key]
-                        : isPlainObject(normalAttrs[key])
-                            ? normalAttrs[key]
-                            : {};
-                    resolvedAttrs[key] = deepMerge(baseValue, nextValue);
-                }
-                else {
-                    resolvedAttrs[key] = cloneValue(nextValue);
-                }
-            }
-        });
-        return resolvedAttrs;
+};
+function classifyAttributeDelta(key, prev, next) {
+    var _a;
+    const dynamicClassifier = ATTRIBUTE_DELTA_CLASSIFIER[key];
+    if (dynamicClassifier) {
+        return dynamicClassifier(prev, next);
     }
+    return (_a = ATTRIBUTE_CATEGORY[key]) !== null && _a !== void 0 ? _a : UpdateCategory.PAINT;
 }
 
 function hasOwnKeys(value) {
@@ -10176,13 +9512,11 @@ function normalizeNoAnimateAttrConfig(config) {
     }, {});
 }
 class StateTransitionOrchestrator {
-    analyzeTransition(_currentAttrs, targetAttrs, stateNames, hasAnimation, options = {}) {
+    analyzeTransition(targetAttrs, hasAnimation, options = {}) {
         var _a, _b;
         const plan = {
-            stateNames,
             targetAttrs: Object.assign({}, targetAttrs),
             animateAttrs: {},
-            jumpAttrs: {},
             noAnimateAttrs: {}
         };
         if (!hasAnimation) {
@@ -10191,10 +9525,10 @@ class StateTransitionOrchestrator {
         const noWorkAnimateAttr = Object.assign(Object.assign({}, ((_a = options.noWorkAnimateAttr) !== null && _a !== void 0 ? _a : {})), normalizeNoAnimateAttrConfig((_b = options.animateConfig) === null || _b === void 0 ? void 0 : _b.noAnimateAttrs));
         const isClear = options.isClear === true;
         const getDefaultAttribute = options.getDefaultAttribute;
+        const readDefaultAttribute = getDefaultAttribute;
         const shouldSkipDefaultAttribute = options.shouldSkipDefaultAttribute;
         const assignTransitionAttr = (key, value) => {
             if (noWorkAnimateAttr[key]) {
-                plan.jumpAttrs[key] = value;
                 plan.noAnimateAttrs[key] = value;
                 return;
             }
@@ -10202,7 +9536,7 @@ class StateTransitionOrchestrator {
                 if (shouldSkipDefaultAttribute === null || shouldSkipDefaultAttribute === void 0 ? void 0 : shouldSkipDefaultAttribute(key, targetAttrs)) {
                     return;
                 }
-                plan.animateAttrs[key] = getDefaultAttribute ? getDefaultAttribute(key) : value;
+                plan.animateAttrs[key] = readDefaultAttribute(key);
                 return;
             }
             plan.animateAttrs[key] = value;
@@ -10256,13 +9590,13 @@ class StateTransitionOrchestrator {
         graphic._emitCustomEvent('afterStateUpdate', { type: AttributeUpdateType.STATE });
         return plan;
     }
-    applyClearTransition(graphic, targetAttrs, hasAnimation, stateNames, options = {}) {
-        var _a, _b, _c, _d;
-        const plan = this.analyzeTransition({}, targetAttrs, stateNames, hasAnimation, {
-            noWorkAnimateAttr: (_a = graphic.getNoWorkAnimateAttr) === null || _a === void 0 ? void 0 : _a.call(graphic),
+    applyClearTransition(graphic, targetAttrs, hasAnimation, options = {}) {
+        var _a;
+        const plan = this.analyzeTransition(targetAttrs, hasAnimation, {
+            noWorkAnimateAttr: graphic.getNoWorkAnimateAttr(),
             isClear: true,
-            getDefaultAttribute: (_b = graphic.getDefaultAttribute) === null || _b === void 0 ? void 0 : _b.bind(graphic),
-            shouldSkipDefaultAttribute: (_c = options.shouldSkipDefaultAttribute) !== null && _c !== void 0 ? _c : (_d = graphic.shouldSkipStateTransitionDefaultAttribute) === null || _d === void 0 ? void 0 : _d.bind(graphic),
+            getDefaultAttribute: graphic.getDefaultAttribute.bind(graphic),
+            shouldSkipDefaultAttribute: (_a = options.shouldSkipDefaultAttribute) !== null && _a !== void 0 ? _a : graphic.shouldSkipStateTransitionDefaultAttribute.bind(graphic),
             animateConfig: options.animateConfig,
             extraAnimateAttrs: options.extraAnimateAttrs
         });
@@ -10271,33 +9605,11 @@ class StateTransitionOrchestrator {
 }
 
 const compiler = new StateDefinitionCompiler();
-function copyDefinitions(definitions) {
-    return definitions ? Object.assign({}, definitions) : {};
-}
 function buildEffectiveSourceDefinitions(parentScope, localStateDefinitions, themeStateDefinitions) {
-    const merged = parentScope
-        ? copyDefinitions(parentScope.effectiveSourceDefinitions)
-        : copyDefinitions(themeStateDefinitions);
-    if (localStateDefinitions) {
-        Object.keys(localStateDefinitions).forEach(stateName => {
-            merged[stateName] = localStateDefinitions[stateName];
-        });
-    }
-    return merged;
-}
-function initializeScope(scope, revision = 0) {
-    var _a;
-    const effectiveSourceDefinitions = buildEffectiveSourceDefinitions(scope.parentScope, scope.localStateDefinitions, scope.themeStateDefinitions);
-    scope.effectiveSourceDefinitions = effectiveSourceDefinitions;
-    scope.effectiveCompiledDefinitions = compiler.compile(effectiveSourceDefinitions);
-    scope.parentRevisionAtBuild = (_a = scope.parentScope) === null || _a === void 0 ? void 0 : _a.revision;
-    scope.revision = revision;
-    scope.dirty = false;
-    return scope;
+    return Object.assign({}, parentScope ? parentScope.effectiveSourceDefinitions : themeStateDefinitions, localStateDefinitions);
 }
 function createRootSharedStateScope(stage, themeStateDefinitions) {
-    return initializeScope({
-        ownerKind: 'root',
+    return rebuildSharedStateScope({
         ownerStage: stage,
         themeStateDefinitions,
         effectiveSourceDefinitions: {},
@@ -10308,9 +9620,7 @@ function createRootSharedStateScope(stage, themeStateDefinitions) {
     }, 0);
 }
 function createGroupSharedStateScope(group, parentScope, localStateDefinitions) {
-    return initializeScope({
-        ownerKind: 'group',
-        ownerGroup: group,
+    return rebuildSharedStateScope({
         ownerStage: group.stage,
         parentScope,
         localStateDefinitions,
@@ -10345,22 +9655,20 @@ function setRootSharedStateScopeThemeDefinitions(scope, themeStateDefinitions) {
     rebuildSharedStateScope(scope);
     return true;
 }
-function rebuildSharedStateScope(scope) {
+function rebuildSharedStateScope(scope, revision = scope.revision + 1) {
     var _a;
     const effectiveSourceDefinitions = buildEffectiveSourceDefinitions(scope.parentScope, scope.localStateDefinitions, scope.themeStateDefinitions);
     scope.effectiveSourceDefinitions = effectiveSourceDefinitions;
     scope.effectiveCompiledDefinitions = compiler.compile(effectiveSourceDefinitions);
     scope.parentRevisionAtBuild = (_a = scope.parentScope) === null || _a === void 0 ? void 0 : _a.revision;
-    scope.revision += 1;
+    scope.revision = revision;
     scope.dirty = false;
     return scope;
 }
 function ensureSharedStateScopeFresh(scope) {
-    var _a;
     if (!scope) {
         return undefined;
     }
-    (_a = getActiveStageStatePerfMonitor(scope.ownerStage)) === null || _a === void 0 ? void 0 : _a.recordRefresh('ensureFreshCalls');
     if (scope.parentScope) {
         ensureSharedStateScopeFresh(scope.parentScope);
     }
@@ -10380,11 +9688,9 @@ function collectSharedStateScopeChain(scope) {
 }
 
 function scheduleStageSharedStateRefresh(stage) {
-    var _a;
     if (!stage || stage.releaseStatus === 'released') {
         return;
     }
-    (_a = getActiveStageStatePerfMonitor(stage)) === null || _a === void 0 ? void 0 : _a.recordRefresh('renderScheduled');
     stage.renderNextFrame();
 }
 function enqueueGraphicSharedStateRefresh(stage, graphic) {
@@ -10393,36 +9699,27 @@ function enqueueGraphicSharedStateRefresh(stage, graphic) {
         return;
     }
     const pending = (_a = stage._pendingSharedStateRefreshGraphics) !== null && _a !== void 0 ? _a : (stage._pendingSharedStateRefreshGraphics = new Set());
-    if (!pending.has(graphic)) {
-        pending.add(graphic);
-        const perfMonitor = getActiveStageStatePerfMonitor(stage);
-        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordRefresh('queuedGraphics');
-        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordAllocation('refreshQueuePushes');
-    }
+    pending.add(graphic);
 }
 function markScopeActiveDescendantsDirty(scope, stage) {
-    let marked = false;
+    if (!scope.subtreeActiveDescendants.size) {
+        return;
+    }
     scope.subtreeActiveDescendants.forEach(graphic => {
         var _a;
         graphic.sharedStateDirty = true;
         const ownerStage = (_a = stage !== null && stage !== void 0 ? stage : graphic.stage) !== null && _a !== void 0 ? _a : scope.ownerStage;
         enqueueGraphicSharedStateRefresh(ownerStage, graphic);
-        marked = true;
     });
-    if (marked) {
-        scheduleStageSharedStateRefresh(stage !== null && stage !== void 0 ? stage : scope.ownerStage);
-    }
+    scheduleStageSharedStateRefresh(stage !== null && stage !== void 0 ? stage : scope.ownerStage);
 }
 function flushStageSharedStateRefresh(stage) {
     const pending = stage._pendingSharedStateRefreshGraphics;
     if (!pending || !pending.size) {
         return;
     }
-    const perfMonitor = getActiveStageStatePerfMonitor(stage);
-    const start = perfMonitor ? performance.now() : 0;
     const graphics = Array.from(pending.values());
     pending.clear();
-    perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordRefresh('flushedGraphics', graphics.length);
     graphics.forEach(graphic => {
         if (graphic.releaseStatus === 'released') {
             return;
@@ -10433,19 +9730,8 @@ function flushStageSharedStateRefresh(stage) {
         if (!graphic.sharedStateDirty) {
             return;
         }
-        const refresh = graphic.refreshSharedStateBeforeRender;
-        if (typeof refresh === 'function') {
-            refresh.call(graphic);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('sharedRefreshCommits');
-        }
+        graphic.refreshSharedStateBeforeRender();
     });
-    if (perfMonitor) {
-        perfMonitor.recordCost('sharedRefresh', performance.now() - start);
-        perfMonitor.recordEvent('shared-refresh-flush', {
-            stageId: stage._uid,
-            flushedGraphics: graphics.length
-        });
-    }
 }
 
 const _tempBounds$1 = new AABBBounds();
@@ -10485,18 +9771,8 @@ const builtinTextureTypes = new Set([
     'grid',
     'wave'
 ]);
-const FULL_STATE_DEFINITION_KEYS = new Set([
-    'name',
-    'patch',
-    'priority',
-    'exclude',
-    'suppress',
-    'resolver',
-    'declaredAffectedKeys'
-]);
 const point = new Point();
 const EMPTY_STATE_NAMES = [];
-const deprecatedLocalStateFallbackWarningStateNames = new Set();
 const BROAD_UPDATE_CATEGORY = UpdateCategory.PAINT |
     UpdateCategory.SHAPE |
     UpdateCategory.BOUNDS |
@@ -10650,18 +9926,6 @@ class Graphic extends Node {
     getAttributes() {
         return this.attribute;
     }
-    getStateStyleResolver(mergeMode) {
-        if (mergeMode === 'deep') {
-            if (!this.deepStateStyleResolver) {
-                this.deepStateStyleResolver = new StateStyleResolver({ mergeMode: 'deep' });
-            }
-            return this.deepStateStyleResolver;
-        }
-        if (!this.stateStyleResolver) {
-            this.stateStyleResolver = new StateStyleResolver();
-        }
-        return this.stateStyleResolver;
-    }
     getStateTransitionOrchestrator() {
         if (!this.stateTransitionOrchestrator) {
             this.stateTransitionOrchestrator = new StateTransitionOrchestrator();
@@ -10688,12 +9952,10 @@ class Graphic extends Node {
         }
         this.boundSharedStateScope = nextScope;
         this.boundSharedStateRevision = undefined;
-        this.localFallbackCompiledDefinitions = undefined;
         this.compiledStateDefinitions = undefined;
         this.compiledStateDefinitionsCacheKey = undefined;
         this.stateEngine = undefined;
         this.stateEngineCompiledDefinitions = undefined;
-        this.stateEngineStateProxyModeKey = undefined;
         this.syncSharedStateActiveRegistrations();
         if (markDirty && ((_a = this.currentStates) === null || _a === void 0 ? void 0 : _a.length)) {
             this.markSharedStateDirty();
@@ -10776,20 +10038,9 @@ class Graphic extends Node {
         var _a, _b;
         if (this.localStateDefinitionsSource !== this.states) {
             this.localStateDefinitionsSource = this.states;
-            this.localFallbackVersion = ((_a = this.localFallbackVersion) !== null && _a !== void 0 ? _a : 0) + 1;
-        }
-        return (_b = this.localFallbackVersion) !== null && _b !== void 0 ? _b : 0;
-    }
-    warnDeprecatedLocalStatesFallback(stateNames) {
-        for (let index = 0; index < stateNames.length; index++) {
-            const stateName = stateNames[index];
-            if (deprecatedLocalStateFallbackWarningStateNames.has(stateName)) {
-                continue;
-            }
-            deprecatedLocalStateFallbackWarningStateNames.add(stateName);
-            console.warn(`[VRender] graphic.states fallback for missing shared state definition "${stateName}" is deprecated. ` +
-                'Move the state definition to sharedStateDefinitions or use stateProxy for dynamic per-graphic styles.');
+            this.localStateDefinitionsVersion = ((_a = this.localStateDefinitionsVersion) !== null && _a !== void 0 ? _a : 0) + 1;
         }
+        return (_b = this.localStateDefinitionsVersion) !== null && _b !== void 0 ? _b : 0;
     }
     resolveEffectiveCompiledDefinitions() {
         this.syncSharedStateScopeBindingFromTree(false);
@@ -10802,8 +10053,7 @@ class Graphic extends Node {
         if (!boundScope) {
             if (!hasStates) {
                 return {
-                    compiledDefinitions: undefined,
-                    stateProxyModeKey: 'none'
+                    compiledDefinitions: undefined
                 };
             }
             const localStatesVersion = this.getLocalStatesVersion();
@@ -10813,53 +10063,12 @@ class Graphic extends Node {
                 this.compiledStateDefinitionsCacheKey = cacheKey;
             }
             return {
-                compiledDefinitions: this.compiledStateDefinitions,
-                stateProxyModeKey: this.stateProxy ? 'legacy-all' : 'none'
-            };
-        }
-        const sharedCompiledDefinitions = boundScope.effectiveCompiledDefinitions;
-        const sharedStateProxyModeKey = this.stateProxy ? 'shared-missing-only' : 'none';
-        const sharedStateProxyEligibility = this.stateProxy
-            ? (stateName) => !sharedCompiledDefinitions.has(stateName)
-            : undefined;
-        if (!hasStates) {
-            this.localFallbackCompiledDefinitions = undefined;
-            return {
-                compiledDefinitions: sharedCompiledDefinitions,
-                stateProxyModeKey: sharedStateProxyModeKey,
-                stateProxyEligibility: sharedStateProxyEligibility
-            };
-        }
-        const localStates = this.states;
-        const missingLocalStateDefinitions = {};
-        const missingStateNames = [];
-        Object.keys(localStates).forEach(stateName => {
-            if (sharedCompiledDefinitions.has(stateName)) {
-                return;
-            }
-            missingLocalStateDefinitions[stateName] = localStates[stateName];
-            missingStateNames.push(stateName);
-        });
-        if (!missingStateNames.length) {
-            this.localFallbackCompiledDefinitions = undefined;
-            return {
-                compiledDefinitions: sharedCompiledDefinitions,
-                stateProxyModeKey: sharedStateProxyModeKey,
-                stateProxyEligibility: sharedStateProxyEligibility
+                compiledDefinitions: this.compiledStateDefinitions
             };
         }
-        this.warnDeprecatedLocalStatesFallback(missingStateNames);
-        const localStatesVersion = this.getLocalStatesVersion();
-        const stateProxyModeKey = this.stateProxy ? `missing:${missingStateNames.sort().join('|')}` : 'none';
-        const cacheKey = `shared:${boundScope.revision}:fallback:${localStatesVersion}:${stateProxyModeKey}`;
-        if (!this.localFallbackCompiledDefinitions || this.compiledStateDefinitionsCacheKey !== cacheKey) {
-            this.localFallbackCompiledDefinitions = new StateDefinitionCompiler().compile(Object.assign(Object.assign({}, boundScope.effectiveSourceDefinitions), missingLocalStateDefinitions));
-            this.compiledStateDefinitionsCacheKey = cacheKey;
-        }
+        const sharedCompiledDefinitions = boundScope.effectiveCompiledDefinitions;
         return {
-            compiledDefinitions: this.localFallbackCompiledDefinitions,
-            stateProxyModeKey,
-            stateProxyEligibility: sharedStateProxyEligibility
+            compiledDefinitions: sharedCompiledDefinitions
         };
     }
     recomputeCurrentStatePatch() {
@@ -10871,11 +10080,9 @@ class Graphic extends Node {
             return;
         }
         const stateResolveBaseAttrs = this.getStateResolveBaseAttrs();
-        const stateModel = this.createStateModel(stateResolveBaseAttrs);
-        const transition = stateModel.useStates(this.currentStates);
+        const transition = this.resolveUseStatesTransition(this.currentStates, stateResolveBaseAttrs);
         const effectiveStates = (_b = transition.effectiveStates) !== null && _b !== void 0 ? _b : transition.states;
-        const resolvedStateAttrs = this.stateEngine && this.compiledStateDefinitions
-            ? Object.assign({}, this.stateEngine.resolvedPatch) : this.getStateStyleResolver(this.stateMergeMode).resolve(stateResolveBaseAttrs, this.states, this.stateProxy, transition.states, this.stateSort);
+        const resolvedStateAttrs = this.stateEngine && this.compiledStateDefinitions ? Object.assign({}, this.stateEngine.resolvedPatch) : {};
         this.currentStates = transition.states;
         this.effectiveStates = [...effectiveStates];
         this.resolvedStatePatch = resolvedStateAttrs;
@@ -10984,19 +10191,12 @@ class Graphic extends Node {
         return category | nextCategory;
     }
     submitUpdateByCategory(category, forceUpdateTag = false) {
-        var _a;
         if (forceUpdateTag) {
             this.addUpdateShapeAndBoundsTag();
             this.addUpdatePositionTag();
             this.addUpdateLayoutTag();
             return;
         }
-        if (category !== UpdateCategory.NONE) {
-            const stage = this.stage;
-            if (stage) {
-                (_a = getActiveStageStatePerfMonitor(stage)) === null || _a === void 0 ? void 0 : _a.recordCategory(category);
-            }
-        }
         if ((category & BROAD_UPDATE_CATEGORY) === BROAD_UPDATE_CATEGORY) {
             this.addBroadUpdateTag();
             return;
@@ -11949,159 +11149,141 @@ class Graphic extends Node {
         (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.setResolveContext(this, stateResolveBaseAttrs);
         return stateResolveBaseAttrs;
     }
-    createStateModel(stateResolveBaseAttrs = this.getStateResolveBaseAttrs()) {
-        const { compiledDefinitions, stateProxyEligibility, stateProxyModeKey } = this.resolveEffectiveCompiledDefinitions();
+    ensureStateEngine(stateResolveBaseAttrs = this.getStateResolveBaseAttrs()) {
+        const { compiledDefinitions } = this.resolveEffectiveCompiledDefinitions();
         this.compiledStateDefinitions = compiledDefinitions;
         if (!compiledDefinitions) {
             this.stateEngine = undefined;
             this.stateEngineCompiledDefinitions = undefined;
-            this.stateEngineStateProxyModeKey = undefined;
         }
         else if (!this.stateEngine ||
             this.stateEngineCompiledDefinitions !== compiledDefinitions ||
-            this.stateEngineStateProxy !== this.stateProxy ||
             this.stateEngineStateSort !== this.stateSort ||
-            this.stateEngineMergeMode !== this.stateMergeMode ||
-            this.stateEngineStateProxyModeKey !== stateProxyModeKey) {
+            this.stateEngineMergeMode !== this.stateMergeMode) {
             this.stateEngine = new StateEngine({
                 compiledDefinitions,
                 stateSort: this.stateSort,
-                stateProxy: this.stateProxy,
-                stateProxyEligibility,
-                states: this.states,
                 mergeMode: this.stateMergeMode
             });
             this.stateEngineCompiledDefinitions = compiledDefinitions;
-            this.stateEngineStateProxy = this.stateProxy;
             this.stateEngineStateSort = this.stateSort;
             this.stateEngineMergeMode = this.stateMergeMode;
-            this.stateEngineStateProxyModeKey = stateProxyModeKey;
         }
         this.syncStateResolveContext(stateResolveBaseAttrs);
-        return new StateModel({
-            states: this.states,
-            currentStates: this.currentStates,
-            stateSort: this.stateSort,
-            stateProxy: this.stateProxy,
-            stateEngine: this.stateEngine
-        });
+        if (this.stateEngine &&
+            this.currentStates &&
+            !this.sameStateNames(this.stateEngine.activeStates, this.currentStates)) {
+            this.stateEngine.applyStates(this.currentStates);
+        }
+        return this.stateEngine;
+    }
+    toGraphicStateTransition(result) {
+        return {
+            changed: result.changed,
+            states: [...result.activeStates],
+            effectiveStates: [...result.effectiveStates]
+        };
     }
-    resolveSimpleLocalStateTransition(states, previousStates) {
+    sortLocalStates(states) {
+        return this.stateSort ? [...states].sort(this.stateSort) : [...states];
+    }
+    resolveLocalUseStatesTransition(states) {
         var _a;
-        if (!this.states ||
-            this.stateProxy ||
-            this.stateSort ||
-            this.stateMergeMode === 'deep' ||
-            this.parent ||
-            ((_a = this.stage) === null || _a === void 0 ? void 0 : _a.rootSharedStateScope) ||
-            this.boundSharedStateScope) {
-            return null;
+        if (!states.length) {
+            return this.resolveLocalClearStatesTransition();
         }
-        if (states.length === 1) {
-            const stateName = states[0];
-            const hasDefinition = Object.prototype.hasOwnProperty.call(this.states, stateName);
-            const nextStates = [stateName];
-            const changed = !this.sameStateNames(previousStates, nextStates);
-            const resolvedStateAttrs = {};
-            if (hasDefinition) {
-                const attrs = this.states[stateName];
-                if (attrs != null) {
-                    if (!isPlainObjectValue(attrs)) {
-                        return null;
-                    }
-                    const keys = Object.keys(attrs);
-                    for (let keyIndex = 0; keyIndex < keys.length; keyIndex++) {
-                        const key = keys[keyIndex];
-                        if (FULL_STATE_DEFINITION_KEYS.has(key)) {
-                            return null;
-                        }
-                        const attrValue = attrs[key];
-                        resolvedStateAttrs[key] = isPlainObjectValue(attrValue)
-                            ? cloneAttributeValue(attrValue)
-                            : attrValue;
-                    }
-                }
-            }
+        const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
+        const changed = previousStates.length !== states.length || states.some((stateName, index) => previousStates[index] !== stateName);
+        const nextStates = this.sortLocalStates(states);
+        return {
+            changed,
+            states: changed ? nextStates : [...previousStates]
+        };
+    }
+    resolveLocalClearStatesTransition() {
+        return {
+            changed: this.hasState(),
+            states: []
+        };
+    }
+    resolveUseStatesTransition(states, stateResolveBaseAttrs = this.getStateResolveBaseAttrs()) {
+        const stateEngine = this.ensureStateEngine(stateResolveBaseAttrs);
+        return stateEngine
+            ? this.toGraphicStateTransition(stateEngine.applyStates(states))
+            : this.resolveLocalUseStatesTransition(states);
+    }
+    resolveClearStatesTransition() {
+        const stateEngine = this.ensureStateEngine();
+        return stateEngine
+            ? this.toGraphicStateTransition(stateEngine.clearStates())
+            : this.resolveLocalClearStatesTransition();
+    }
+    resolveAddStateTransition(stateName, keepCurrentStates) {
+        var _a;
+        const stateEngine = this.ensureStateEngine();
+        if (stateEngine) {
+            return this.toGraphicStateTransition(stateEngine.addState(stateName, keepCurrentStates));
+        }
+        if (this.currentStates &&
+            this.currentStates.includes(stateName) &&
+            (keepCurrentStates || this.currentStates.length === 1)) {
             return {
-                changed,
-                states: nextStates,
-                effectiveStates: nextStates,
-                resolvedStateAttrs
+                changed: false,
+                states: [...this.currentStates]
             };
         }
-        const uniqueStates = Array.from(new Set(states));
-        const withDefinition = [];
-        const withoutDefinition = [];
-        for (let i = 0; i < uniqueStates.length; i++) {
-            const stateName = uniqueStates[i];
-            if (Object.prototype.hasOwnProperty.call(this.states, stateName)) {
-                withDefinition.push(stateName);
-            }
-            else {
-                withoutDefinition.push(stateName);
-            }
+        const nextStates = keepCurrentStates && ((_a = this.currentStates) === null || _a === void 0 ? void 0 : _a.length) ? this.currentStates.concat([stateName]) : [stateName];
+        return this.resolveLocalUseStatesTransition(nextStates);
+    }
+    resolveRemoveStateTransition(stateName) {
+        const stateEngine = this.ensureStateEngine();
+        if (stateEngine) {
+            return this.toGraphicStateTransition(stateEngine.removeState(stateName));
         }
-        withDefinition.sort((left, right) => left.localeCompare(right));
-        const nextStates = withDefinition.concat(withoutDefinition);
-        const changed = !this.sameStateNames(previousStates, nextStates);
-        const resolvedStateAttrs = {};
-        for (let i = 0; i < nextStates.length; i++) {
-            const stateName = nextStates[i];
-            const hasDefinition = Object.prototype.hasOwnProperty.call(this.states, stateName);
-            if (!hasDefinition) {
-                continue;
-            }
-            const attrs = this.states[stateName];
-            if (attrs == null) {
-                continue;
-            }
-            if (!isPlainObjectValue(attrs)) {
-                return null;
-            }
-            const keys = Object.keys(attrs);
-            for (let keyIndex = 0; keyIndex < keys.length; keyIndex++) {
-                const key = keys[keyIndex];
-                if (FULL_STATE_DEFINITION_KEYS.has(key)) {
-                    return null;
-                }
-                const attrValue = attrs[key];
-                resolvedStateAttrs[key] = isPlainObjectValue(attrValue)
-                    ? cloneAttributeValue(attrValue)
-                    : attrValue;
-            }
+        if (!this.currentStates) {
+            return {
+                changed: false,
+                states: []
+            };
         }
-        return {
-            changed,
-            states: nextStates,
-            effectiveStates: nextStates,
-            resolvedStateAttrs
-        };
+        const filter = Array.isArray(stateName) ? (s) => !stateName.includes(s) : (s) => s !== stateName;
+        const nextStates = this.currentStates.filter(filter);
+        if (nextStates.length === this.currentStates.length) {
+            return {
+                changed: false,
+                states: [...this.currentStates]
+            };
+        }
+        return this.resolveLocalUseStatesTransition(nextStates);
     }
-    resolveGraphicStateTransition(states, previousStates, forceResolverRefresh = false) {
-        var _a, _b;
-        let transition = this.resolveSimpleLocalStateTransition(states, previousStates);
-        const isSimpleLocalTransition = !!transition;
-        let resolvedStateAttrs;
-        if (transition) {
-            resolvedStateAttrs = transition.resolvedStateAttrs;
+    resolveToggleStateTransition(stateName) {
+        const stateEngine = this.ensureStateEngine();
+        if (stateEngine) {
+            return this.toGraphicStateTransition(stateEngine.toggleState(stateName));
         }
-        else {
-            const stateResolveBaseAttrs = this.getStateResolveBaseAttrs();
-            const stateModel = this.createStateModel(stateResolveBaseAttrs);
-            if (forceResolverRefresh) {
-                (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.invalidateResolverCache();
-            }
-            transition = stateModel.useStates(states);
-            resolvedStateAttrs =
-                this.stateEngine && this.compiledStateDefinitions
-                    ? Object.assign({}, this.stateEngine.resolvedPatch) : this.getStateStyleResolver(this.stateMergeMode).resolve(stateResolveBaseAttrs, this.states, this.stateProxy, transition.states, this.stateSort);
+        if (this.hasState(stateName)) {
+            return this.resolveRemoveStateTransition(stateName);
         }
-        const effectiveStates = (_b = transition.effectiveStates) !== null && _b !== void 0 ? _b : transition.states;
+        const nextStates = this.currentStates ? this.currentStates.slice() : [];
+        nextStates.push(stateName);
+        return this.resolveLocalUseStatesTransition(nextStates);
+    }
+    resolveGraphicStateTransition(states, forceResolverRefresh = false) {
+        var _a;
+        const stateResolveBaseAttrs = this.getStateResolveBaseAttrs();
+        const stateEngine = this.ensureStateEngine(stateResolveBaseAttrs);
+        if (forceResolverRefresh) {
+            stateEngine === null || stateEngine === void 0 ? void 0 : stateEngine.invalidateResolverCache();
+        }
+        const transition = stateEngine
+            ? this.toGraphicStateTransition(stateEngine.applyStates(states))
+            : this.resolveLocalUseStatesTransition(states);
+        const resolvedStateAttrs = this.stateEngine && this.compiledStateDefinitions ? Object.assign({}, this.stateEngine.resolvedPatch) : {};
+        const effectiveStates = (_a = transition.effectiveStates) !== null && _a !== void 0 ? _a : transition.states;
         return {
             transition,
             effectiveStates: effectiveStates,
-            resolvedStateAttrs,
-            isSimpleLocalTransition
+            resolvedStateAttrs
         };
     }
     normalizeSetStatesOptions(options) {
@@ -12138,28 +11320,20 @@ class Graphic extends Node {
         var _a;
         const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
         const previousResolvedStatePatch = this.resolvedStatePatch;
-        const { transition, effectiveStates, resolvedStateAttrs, isSimpleLocalTransition } = this.resolveGraphicStateTransition(states, previousStates, true);
+        const { transition, effectiveStates, resolvedStateAttrs } = this.resolveGraphicStateTransition(states, true);
         const patchChanged = !this.sameStatePatches(previousResolvedStatePatch, resolvedStateAttrs);
         if (patchChanged &&
             !this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, false)) {
             return;
         }
         this.currentStates = transition.states;
-        this.effectiveStates = isSimpleLocalTransition ? effectiveStates : [...effectiveStates];
+        this.effectiveStates = [...effectiveStates];
         this.resolvedStatePatch = resolvedStateAttrs;
         this.sharedStateDirty = false;
         this.syncSharedStateActiveRegistrations();
         if (!patchChanged) {
             return;
         }
-        if (this.stage) {
-            const perfMonitor = getActiveStageStatePerfMonitor(this.stage);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('stateCommits');
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordEvent('state-commit', {
-                graphicId: this._uid,
-                targetStates: [...transition.states]
-            });
-        }
         if (hasAnimation && animateSameStatePatchChange) {
             this._syncFinalAttributeFromStaticTruth();
             this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
@@ -12191,10 +11365,10 @@ class Graphic extends Node {
             }
             : undefined;
         if (isClear) {
-            this.getStateTransitionOrchestrator().applyClearTransition(this, attrs, hasAnimation, stateNames, transitionOptions);
+            this.getStateTransitionOrchestrator().applyClearTransition(this, attrs, hasAnimation, transitionOptions);
             return;
         }
-        const plan = this.getStateTransitionOrchestrator().analyzeTransition({}, attrs, stateNames, hasAnimation, {
+        const plan = this.getStateTransitionOrchestrator().analyzeTransition(attrs, hasAnimation, {
             noWorkAnimateAttr: this.getNoWorkAnimateAttr(),
             animateConfig: resolvedAnimateConfig,
             extraAnimateAttrs: extraAnimateAttrs,
@@ -12227,19 +11401,11 @@ class Graphic extends Node {
         });
         stateAnimates.forEach(animate => animate.stop(type));
     }
-    getNormalAttribute(key) {
-        var _a, _b;
-        const value = this.attribute[key];
-        if (this.hasAnyTrackedAnimate()) {
-            return (_a = this.finalAttribute) === null || _a === void 0 ? void 0 : _a[key];
-        }
-        return value !== null && value !== void 0 ? value : (_b = this.finalAttribute) === null || _b === void 0 ? void 0 : _b[key];
-    }
     clearStates(hasAnimation) {
         var _a, _b, _c;
         const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
         const previousResolvedStatePatch = this.resolvedStatePatch;
-        const transition = this.createStateModel().clearStates();
+        const transition = this.resolveClearStatesTransition();
         if (!transition.changed && previousStates.length === 0) {
             this.currentStates = [];
             this.effectiveStates = [];
@@ -12260,14 +11426,6 @@ class Graphic extends Node {
         this.resolvedStatePatch = undefined;
         this.sharedStateDirty = false;
         this.clearSharedStateActiveRegistrations();
-        if (this.stage) {
-            const perfMonitor = getActiveStageStatePerfMonitor(this.stage);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('stateCommits');
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordEvent('state-commit', {
-                graphicId: this._uid,
-                targetStates: []
-            });
-        }
         if (hasAnimation) {
             this._syncFinalAttributeFromStaticTruth();
             this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, true, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
@@ -12286,19 +11444,19 @@ class Graphic extends Node {
         }
     }
     removeState(stateName, hasAnimation) {
-        const transition = this.createStateModel().removeState(stateName);
+        const transition = this.resolveRemoveStateTransition(stateName);
         if (transition.changed) {
             this.useStates(transition.states, hasAnimation);
         }
     }
     toggleState(stateName, hasAnimation) {
-        const transition = this.createStateModel().toggleState(stateName);
+        const transition = this.resolveToggleStateTransition(stateName);
         if (transition.changed) {
             this.useStates(transition.states, hasAnimation);
         }
     }
     addState(stateName, keepCurrentStates, hasAnimation) {
-        const transition = this.createStateModel().addState(stateName, keepCurrentStates);
+        const transition = this.resolveAddStateTransition(stateName, keepCurrentStates);
         if (!transition.changed) {
             return;
         }
@@ -12339,7 +11497,7 @@ class Graphic extends Node {
         }
         const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
         const previousResolvedStatePatch = this.resolvedStatePatch;
-        const { transition, effectiveStates, resolvedStateAttrs, isSimpleLocalTransition } = this.resolveGraphicStateTransition(states, previousStates);
+        const { transition, effectiveStates, resolvedStateAttrs } = this.resolveGraphicStateTransition(states);
         if (!transition.changed && this.sameStateNames(previousStates, transition.states)) {
             return;
         }
@@ -12347,18 +11505,10 @@ class Graphic extends Node {
             return;
         }
         this.currentStates = transition.states;
-        this.effectiveStates = isSimpleLocalTransition ? effectiveStates : [...effectiveStates];
+        this.effectiveStates = [...effectiveStates];
         this.resolvedStatePatch = resolvedStateAttrs;
         this.sharedStateDirty = false;
         this.syncSharedStateActiveRegistrations();
-        if (this.stage) {
-            const perfMonitor = getActiveStageStatePerfMonitor(this.stage);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('stateCommits');
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordEvent('state-commit', {
-                graphicId: this._uid,
-                targetStates: [...transition.states]
-            });
-        }
         if (hasAnimation) {
             this._syncFinalAttributeFromStaticTruth();
             this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
@@ -12622,12 +11772,10 @@ class Graphic extends Node {
         }
         this.boundSharedStateScope = undefined;
         this.boundSharedStateRevision = undefined;
-        this.localFallbackCompiledDefinitions = undefined;
         this.compiledStateDefinitions = undefined;
         this.compiledStateDefinitionsCacheKey = undefined;
         this.stateEngine = undefined;
         this.stateEngineCompiledDefinitions = undefined;
-        this.stateEngineStateProxyModeKey = undefined;
         this.sharedStateDirty = false;
         this.stage = null;
         this.layer = null;
@@ -14616,23 +13764,15 @@ class Glyph extends Graphic {
             states = states.sort(this.stateSort);
         }
         const stateAttrs = {};
-        const subAttrs = this.subGraphic.map(() => ({}));
         states.forEach(stateName => {
-            var _a;
             const attrs = this.glyphStateProxy ? this.glyphStateProxy(stateName, states) : this.glyphStates[stateName];
             if (attrs) {
                 Object.assign(stateAttrs, attrs.attributes);
-                if ((_a = attrs.subAttributes) === null || _a === void 0 ? void 0 : _a.length) {
-                    subAttrs.forEach((subAttrs, index) => {
-                        Object.assign(subAttrs, attrs.subAttributes[index]);
-                    });
-                }
             }
         });
         if (!this.beforeStateUpdate(stateAttrs, previousStates, states, hasAnimation, false)) {
             return;
         }
-        this.updateNormalAttrs(stateAttrs);
         this.currentStates = states;
         this.applyStateAttrs(stateAttrs, states, hasAnimation);
     }
@@ -14649,7 +13789,6 @@ class Glyph extends Graphic {
         else {
             this.currentStates = [];
         }
-        this.normalAttrs = null;
     }
     clone() {
         const glyph = new Glyph(Object.assign({}, this.attribute));
@@ -17091,7 +16230,6 @@ class Group extends Graphic {
         this.type = 'group';
         this.parent = null;
         this.isContainer = true;
-        this._hasSharedStateDefinitions = false;
         this.numberType = GROUP_NUMBER_TYPE;
         this._childUpdateTag = UpdateTag.UPDATE_BOUNDS;
     }
@@ -17104,7 +16242,6 @@ class Group extends Graphic {
         }
         const previousScope = this.sharedStateScope;
         this._sharedStateDefinitions = value;
-        this._hasSharedStateDefinitions = !!value && Object.keys(value).length > 0;
         this.ensureSharedStateScopeBound();
         if (this.sharedStateScope) {
             setSharedStateScopeLocalDefinitions(this.sharedStateScope, value);
@@ -17249,13 +16386,7 @@ class Group extends Graphic {
     incrementalAppendChild(node) {
         const data = super.appendChild(node);
         if (data) {
-            if (this.stage &&
-                (data.stage !== this.stage || data.layer !== this.layer)) {
-                data.setStage(this.stage, this.layer);
-            }
-            else if (data.onParentSharedStateTreeChanged) {
-                data.onParentSharedStateTreeChanged(this.stage, this.layer);
-            }
+            this.syncChildSharedStateTreeBinding(data);
         }
         this.addUpdateBoundTag();
         this.getGraphicService().onAddIncremental(node, this, this.stage);
@@ -17269,12 +16400,7 @@ class Group extends Graphic {
     }
     _updateChildToStage(child) {
         if (child) {
-            if (this.stage && (child.stage !== this.stage || child.layer !== this.layer)) {
-                child.setStage(this.stage, this.layer);
-            }
-            else if (child.onParentSharedStateTreeChanged) {
-                child.onParentSharedStateTreeChanged(this.stage, this.layer);
-            }
+            this.syncChildSharedStateTreeBinding(child);
         }
         this.addUpdateBoundTag();
         return child;
@@ -17282,13 +16408,8 @@ class Group extends Graphic {
     appendChild(node, addStage = true) {
         const data = super.appendChild(node);
         if (data) {
-            if (addStage &&
-                this.stage &&
-                (data.stage !== this.stage || data.layer !== this.layer)) {
-                data.setStage(this.stage, this.layer);
-            }
-            else if (data.onParentSharedStateTreeChanged) {
-                data.onParentSharedStateTreeChanged(this.stage, this.layer);
+            if (addStage) {
+                this.syncChildSharedStateTreeBinding(data);
             }
         }
         this.addUpdateBoundTag();
@@ -17304,13 +16425,12 @@ class Group extends Graphic {
         return this._updateChildToStage(super.insertInto(newNode, idx));
     }
     removeChild(child, highPerformance = false) {
-        var _a;
         const data = super.removeChild(child);
         if (!data) {
             return data;
         }
         if (highPerformance) {
-            (_a = child.detachStageForRelease) === null || _a === void 0 ? void 0 : _a.call(child);
+            child.detachStageForRelease();
             return data;
         }
         this.getGraphicService().onRemove(child);
@@ -17335,7 +16455,7 @@ class Group extends Graphic {
     setStage(stage, layer) {
         var _a, _b, _c, _d, _e, _f;
         const graphicService = (_c = (_a = stage === null || stage === void 0 ? void 0 : stage.graphicService) !== null && _a !== void 0 ? _a : (_b = this.stage) === null || _b === void 0 ? void 0 : _b.graphicService) !== null && _c !== void 0 ? _c : application.graphicService;
-        const needsSharedStateTreeSync = this._hasSharedStateDefinitions ||
+        const needsSharedStateTreeSync = this.hasSharedStateDefinitions() ||
             this.sharedStateScope ||
             ((_d = this.currentStates) === null || _d === void 0 ? void 0 : _d.length) ||
             this.boundSharedStateScope ||
@@ -17351,9 +16471,7 @@ class Group extends Graphic {
             this.setStageToShadowRoot(stage, layer);
             this._onSetStage && this._onSetStage(this, stage, layer);
             (_f = graphicService === null || graphicService === void 0 ? void 0 : graphicService.onSetStage) === null || _f === void 0 ? void 0 : _f.call(graphicService, this, stage);
-            this.forEachChildren(item => {
-                item.setStage(stage, this.layer);
-            });
+            this.notifyChildrenSharedStateTreeChanged();
             return;
         }
         const layerChanged = this.layer !== layer;
@@ -17366,11 +16484,7 @@ class Group extends Graphic {
             this.notifyChildrenSharedStateTreeChanged();
         }
         else if (layerChanged) {
-            this.forEachChildren(item => {
-                if (item.onParentSharedStateTreeChanged) {
-                    item.onParentSharedStateTreeChanged(stage, this.layer);
-                }
-            });
+            this.notifyChildrenSharedStateTreeChanged();
         }
     }
     addUpdatePositionTag() {
@@ -17442,8 +16556,7 @@ class Group extends Graphic {
         super.detachStageForRelease();
         this.sharedStateScope = undefined;
         this.forEachChildren((item) => {
-            var _a;
-            (_a = item.detachStageForRelease) === null || _a === void 0 ? void 0 : _a.call(item);
+            item.detachStageForRelease();
         });
     }
     ensureSharedStateScopeBound() {
@@ -17457,7 +16570,6 @@ class Group extends Graphic {
             this.sharedStateScope = createGroupSharedStateScope(this, parentScope, this._sharedStateDefinitions);
             return;
         }
-        this.sharedStateScope.ownerGroup = this;
         this.sharedStateScope.ownerStage = this.stage;
         setSharedStateScopeParent(this.sharedStateScope, parentScope);
         if (this.sharedStateScope.localStateDefinitions !== this._sharedStateDefinitions) {
@@ -17465,15 +16577,16 @@ class Group extends Graphic {
         }
     }
     hasSharedStateDefinitions() {
-        return this._hasSharedStateDefinitions;
+        return !!this._sharedStateDefinitions && Object.keys(this._sharedStateDefinitions).length > 0;
     }
     notifyChildrenSharedStateTreeChanged() {
         this.forEachChildren(item => {
-            if (item.onParentSharedStateTreeChanged) {
-                item.onParentSharedStateTreeChanged(this.stage, this.layer);
-            }
+            this.syncChildSharedStateTreeBinding(item);
         });
     }
+    syncChildSharedStateTreeBinding(child) {
+        child.onParentSharedStateTreeChanged(this.stage, this.layer);
+    }
     onParentSharedStateTreeChanged(stage, layer) {
         var _a;
         if (this.stage !== stage || this.layer !== layer) {
@@ -19574,11 +18687,6 @@ class RendererRegistry {
         this.entries.set(key, renderer);
         this.cache.delete(key);
     }
-    registerMany(entries) {
-        for (const [key, renderer] of entries) {
-            this.register(key, renderer);
-        }
-    }
     get(key) {
         if (this.cache.has(key)) {
             return this.cache.get(key);
@@ -19609,11 +18717,6 @@ class PickerRegistry {
     register(key, picker) {
         this.entries.set(key, picker);
     }
-    registerMany(entries) {
-        for (const [key, picker] of entries) {
-            this.register(key, picker);
-        }
-    }
     get(key) {
         return this.entries.get(key);
     }
@@ -19656,11 +18759,6 @@ class ContributionRegistry {
         current.push(contribution);
         this.entries.set(key, current);
     }
-    registerMany(entries) {
-        for (const [key, contribution] of entries) {
-            this.register(key, contribution);
-        }
-    }
     get(key) {
         var _a;
         return [...((_a = this.entries.get(key)) !== null && _a !== void 0 ? _a : [])];
@@ -19685,13 +18783,12 @@ const EMPTY_AUTO_ENABLE_PROVIDER = {
 };
 class DefaultPluginService {
     constructor(autoEnablePlugins = EMPTY_AUTO_ENABLE_PROVIDER, deps = {}) {
-        var _a, _b, _c;
+        var _a;
         this.autoEnablePlugins = autoEnablePlugins;
         this.onStartupFinishedPlugin = [];
         this.onRegisterPlugin = [];
         this.actived = false;
         this.pluginRegistry = (_a = deps.pluginRegistry) !== null && _a !== void 0 ? _a : new PluginRegistry();
-        this.autoEnablePlugins = (_c = (_b = deps.autoEnablePlugins) !== null && _b !== void 0 ? _b : this.autoEnablePlugins) !== null && _c !== void 0 ? _c : EMPTY_AUTO_ENABLE_PROVIDER;
     }
     active(stage, params) {
         this.stage = stage;
@@ -19963,7 +19060,7 @@ class DirtyBoundsPlugin {
         this.key = this.name + this._uid;
         this.dirtyBoundsHooksRegistered = false;
         this.handlePaintOnlyUpdate = (graphic) => {
-            var _a, _b, _c, _d;
+            var _a;
             const stage = this.pluginService.stage;
             if (!(stage && stage === graphic.stage && stage.renderCount)) {
                 return;
@@ -19976,7 +19073,7 @@ class DirtyBoundsPlugin {
             if (ownerBounds && !ownerBounds.empty()) {
                 stage.dirty(ownerBounds);
             }
-            (_b = owner.clearUpdatePaintTag) === null || _b === void 0 ? void 0 : _b.call(owner);
+            owner.clearUpdatePaintTag();
             const shadowRoot = owner.shadowRoot;
             if (!shadowRoot) {
                 return;
@@ -19985,29 +19082,25 @@ class DirtyBoundsPlugin {
             if (shadowBounds && !shadowBounds.empty()) {
                 stage.dirty(shadowBounds);
             }
-            (_d = (_c = shadowRoot).clearUpdatePaintTag) === null || _d === void 0 ? void 0 : _d.call(_c);
+            shadowRoot.clearUpdatePaintTag();
         };
     }
     ensurePaintDirtyBoundsCache(graphic) {
-        var _a, _b;
+        var _a;
         const owner = graphic;
-        const hasLocalBounds = owner._AABBBounds && typeof owner._AABBBounds.empty === 'function' && !owner._AABBBounds.empty();
-        if (!hasLocalBounds && typeof owner.doUpdateAABBBounds === 'function') {
+        if (owner._AABBBounds.empty()) {
             owner.doUpdateAABBBounds(((_a = owner.attribute) === null || _a === void 0 ? void 0 : _a.boundsMode) === 'imprecise');
         }
-        const hasGlobalBounds = owner._globalAABBBounds &&
-            typeof owner._globalAABBBounds.empty === 'function' &&
-            !owner._globalAABBBounds.empty();
-        if (!hasGlobalBounds && typeof owner.tryUpdateGlobalAABBBounds === 'function') {
+        if (!owner._globalAABBBounds || owner._globalAABBBounds.empty()) {
             owner.tryUpdateGlobalAABBBounds();
         }
-        return (_b = owner._globalAABBBounds) !== null && _b !== void 0 ? _b : owner.globalAABBBounds;
+        return owner._globalAABBBounds;
     }
     getRemoveDirtyBounds(graphic) {
         var _a;
         const owner = ((_a = graphic.glyphHost) !== null && _a !== void 0 ? _a : graphic);
         const cachedBounds = owner._globalAABBBounds;
-        if (cachedBounds && typeof cachedBounds.empty === 'function' && !cachedBounds.empty()) {
+        if (cachedBounds && !cachedBounds.empty()) {
             return cachedBounds;
         }
     }
@@ -20143,387 +19236,6 @@ function getCurrentEnv() {
     return isBrowserEnv() ? 'browser' : 'node';
 }
 
-function isRenderableGraphic(graphic) {
-    return !!graphic.stage && graphic.releaseStatus !== 'released';
-}
-function createTargetStatesKey(targetStates) {
-    return targetStates.length ? targetStates.join('|') : '__clear__';
-}
-function createIntentKey(contextOwnerId, configFingerprint, targetStatesKey) {
-    return `${contextOwnerId}:${configFingerprint}:${targetStatesKey}`;
-}
-function hasMeaningfulDeferredConfig(config) {
-    const normalized = normalizeDeferredStateOwnerConfig(config);
-    return !!normalized && (normalized.localEnabled != null || normalized.deferred != null);
-}
-function getGraphicCompiledDefinitions(graphic) {
-    const graphicAny = graphic;
-    if (typeof graphicAny.resolveEffectiveCompiledDefinitions === 'function') {
-        const result = graphicAny.resolveEffectiveCompiledDefinitions();
-        return {
-            compiledDefinitions: result.compiledDefinitions,
-            stateProxyEligibility: result.stateProxyEligibility
-        };
-    }
-    return {};
-}
-function getCurrentStateNames(graphic) {
-    var _a, _b;
-    return (_b = (_a = graphic.currentStates) === null || _a === void 0 ? void 0 : _a.slice()) !== null && _b !== void 0 ? _b : [];
-}
-class StateBatchScheduler {
-    constructor(stage, perfMonitor) {
-        this.stage = stage;
-        this.perfMonitor = perfMonitor;
-        this.jobsByIntentKey = new Map();
-        this.pendingIntentByGraphic = new Map();
-        this.nextJobId = 1;
-        this.runningJobs = new Map();
-    }
-    schedule(graphics, targetStates) {
-        const batchOperation = graphics.length > 1;
-        graphics.forEach(graphic => {
-            const eligibility = this.resolveEligibility(graphic, targetStates, batchOperation, true);
-            if ('reason' in eligibility) {
-                this.removeGraphicFromPending(graphic);
-                if (eligibility.reason !== 'graphic_unavailable') {
-                    this.commitSynchronously(graphic, targetStates);
-                }
-                return;
-            }
-            this.enqueueDeferredIntent(graphic, targetStates, eligibility.context, eligibility.targetStatesKey);
-        });
-    }
-    release() {
-        var _a;
-        this.jobsByIntentKey.forEach(job => {
-            job.status = 'cancelled';
-        });
-        this.jobsByIntentKey.clear();
-        this.pendingIntentByGraphic.clear();
-        this.runningJobs.clear();
-        (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.updateBatchPending(0);
-    }
-    resolveEligibility(graphic, targetStates, batchOperation, recordObservability) {
-        var _a, _b, _c, _d, _e, _f;
-        if (!isRenderableGraphic(graphic)) {
-            if (recordObservability) {
-                (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.recordDeferredIneligible('graphic_unavailable');
-            }
-            return { eligible: false, reason: 'graphic_unavailable' };
-        }
-        if (!batchOperation) {
-            if (recordObservability) {
-                (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.recordDeferredIneligible('non_batch_operation');
-            }
-            return { eligible: false, reason: 'non_batch_operation' };
-        }
-        const context = this.resolveDeferredContext(graphic);
-        if (!context) {
-            if (recordObservability) {
-                (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.recordDeferredIneligible('graphic_unavailable');
-            }
-            return { eligible: false, reason: 'graphic_unavailable' };
-        }
-        if (!context.config.enabled) {
-            const normalizedOwnerConfig = normalizeDeferredStateOwnerConfig(context.contextOwner.deferredStateConfig);
-            const reason = (normalizedOwnerConfig === null || normalizedOwnerConfig === void 0 ? void 0 : normalizedOwnerConfig.localEnabled) === false ? 'context_disabled' : 'config_disabled';
-            if (recordObservability) {
-                (_d = this.perfMonitor) === null || _d === void 0 ? void 0 : _d.recordDeferredIneligible(reason);
-            }
-            return { eligible: false, reason };
-        }
-        const classification = this.classifyGraphicTargetStates(graphic, targetStates);
-        if (classification.reason) {
-            if (recordObservability) {
-                (_e = this.perfMonitor) === null || _e === void 0 ? void 0 : _e.recordDeferredIneligible(classification.reason);
-            }
-            return { eligible: false, reason: classification.reason };
-        }
-        if (classification.category !== UpdateCategory.PAINT) {
-            if (recordObservability) {
-                (_f = this.perfMonitor) === null || _f === void 0 ? void 0 : _f.recordDeferredIneligible('mixed_update_category');
-            }
-            return { eligible: false, reason: 'mixed_update_category' };
-        }
-        return {
-            eligible: true,
-            context,
-            targetStatesKey: createTargetStatesKey(targetStates)
-        };
-    }
-    resolveDeferredContext(graphic) {
-        var _a;
-        const stage = graphic.stage;
-        if (!stage) {
-            return undefined;
-        }
-        let owner = stage;
-        let config = normalizeDeferredStateConfig(undefined);
-        const ownerConfigs = [stage];
-        const parents = [];
-        let parent = graphic.parent;
-        while (parent && parent !== stage) {
-            parents.push(parent);
-            parent = parent.parent;
-        }
-        parents.reverse().forEach(current => ownerConfigs.push(current));
-        ownerConfigs.forEach(current => {
-            const deferredStateConfig = normalizeDeferredStateOwnerConfig(current.deferredStateConfig);
-            if (!deferredStateConfig) {
-                return;
-            }
-            if (deferredStateConfig.deferred) {
-                config = Object.assign(Object.assign({}, config), deferredStateConfig.deferred);
-            }
-            if (deferredStateConfig.localEnabled != null) {
-                config.enabled = deferredStateConfig.localEnabled;
-            }
-            if (hasMeaningfulDeferredConfig(current.deferredStateConfig)) {
-                owner = current;
-            }
-        });
-        const normalized = normalizeDeferredStateConfig(config);
-        return {
-            contextOwner: owner,
-            contextOwnerId: (_a = owner._uid) !== null && _a !== void 0 ? _a : 0,
-            config: normalized,
-            configFingerprint: fingerprintDeferredStateConfig(normalized)
-        };
-    }
-    classifyGraphicTargetStates(graphic, targetStates) {
-        const { compiledDefinitions, stateProxyEligibility } = getGraphicCompiledDefinitions(graphic);
-        const candidateStates = Array.from(new Set([...getCurrentStateNames(graphic), ...targetStates]));
-        let category = UpdateCategory.NONE;
-        candidateStates.forEach(stateName => {
-            if (stateProxyEligibility === null || stateProxyEligibility === void 0 ? void 0 : stateProxyEligibility(stateName)) {
-                category = UpdateCategory.NONE;
-                return;
-            }
-            const definition = compiledDefinitions === null || compiledDefinitions === void 0 ? void 0 : compiledDefinitions.get(stateName);
-            if (!definition) {
-                return;
-            }
-            if (definition.hasResolver && definition.affectedKeys.size === 0) {
-                category = UpdateCategory.NONE;
-                return;
-            }
-            category |= classifyAffectedKeys(definition.affectedKeys);
-        });
-        if (candidateStates.some(stateName => stateProxyEligibility === null || stateProxyEligibility === void 0 ? void 0 : stateProxyEligibility(stateName)) ||
-            candidateStates.some(stateName => {
-                const definition = compiledDefinitions === null || compiledDefinitions === void 0 ? void 0 : compiledDefinitions.get(stateName);
-                return !!(definition === null || definition === void 0 ? void 0 : definition.hasResolver) && definition.affectedKeys.size === 0;
-            })) {
-            return {
-                category: UpdateCategory.NONE,
-                reason: 'resolver_unstable_keys'
-            };
-        }
-        return {
-            category: category === UpdateCategory.NONE ? UpdateCategory.PAINT : category
-        };
-    }
-    enqueueDeferredIntent(graphic, targetStates, context, targetStatesKey) {
-        var _a, _b, _c, _d, _e, _f;
-        const nextIntentKey = createIntentKey(context.contextOwnerId, context.configFingerprint, targetStatesKey);
-        const prevIntentKey = this.pendingIntentByGraphic.get(graphic);
-        if (prevIntentKey === nextIntentKey) {
-            (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.incrementCounter('deferredJobsCoalesced');
-            return;
-        }
-        if (prevIntentKey) {
-            this.removeGraphicFromIntentJob(graphic, prevIntentKey);
-        }
-        let job = this.jobsByIntentKey.get(nextIntentKey);
-        if (!job) {
-            job = {
-                id: this.nextJobId++,
-                kind: 'apply_states',
-                intentKey: nextIntentKey,
-                status: 'pending',
-                targetStates: [...targetStates],
-                targetStatesKey,
-                pendingGraphics: new Set(),
-                orderedGraphics: [],
-                config: context.config,
-                contextOwner: context.contextOwner,
-                contextOwnerId: context.contextOwnerId,
-                configFingerprint: context.configFingerprint,
-                createdAt: Date.now(),
-                processedCount: 0
-            };
-            this.jobsByIntentKey.set(nextIntentKey, job);
-            (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.incrementCounter('deferredJobsCreated');
-            (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.updateBatchPending(this.jobsByIntentKey.size);
-        }
-        else {
-            (_d = this.perfMonitor) === null || _d === void 0 ? void 0 : _d.incrementCounter('deferredJobsCoalesced');
-        }
-        if (!job.pendingGraphics.has(graphic)) {
-            job.pendingGraphics.add(graphic);
-            job.orderedGraphics.push(graphic);
-            this.pendingIntentByGraphic.set(graphic, nextIntentKey);
-            (_e = this.perfMonitor) === null || _e === void 0 ? void 0 : _e.recordAllocation('batchEntriesCreated');
-            (_f = this.perfMonitor) === null || _f === void 0 ? void 0 : _f.updateMaxGraphicsInJob(job.pendingGraphics.size);
-        }
-        this.ensureJobRunning(job);
-    }
-    removeGraphicFromPending(graphic) {
-        const prevIntentKey = this.pendingIntentByGraphic.get(graphic);
-        if (!prevIntentKey) {
-            return;
-        }
-        this.removeGraphicFromIntentJob(graphic, prevIntentKey);
-    }
-    removeGraphicFromIntentJob(graphic, intentKey) {
-        var _a, _b, _c;
-        const job = this.jobsByIntentKey.get(intentKey);
-        if (!job) {
-            this.pendingIntentByGraphic.delete(graphic);
-            return;
-        }
-        job.pendingGraphics.delete(graphic);
-        if (this.pendingIntentByGraphic.get(graphic) === intentKey) {
-            this.pendingIntentByGraphic.delete(graphic);
-        }
-        if (job.pendingGraphics.size === 0 && job.status !== 'completed') {
-            job.status = 'cancelled';
-            this.jobsByIntentKey.delete(intentKey);
-            (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.incrementCounter('deferredJobsCancelled');
-            (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.recordEvent('deferred-job-cancel', {
-                intentKey,
-                jobId: job.id
-            });
-            (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.updateBatchPending(this.jobsByIntentKey.size);
-        }
-    }
-    ensureJobRunning(job) {
-        if (this.runningJobs.has(job.intentKey)) {
-            return;
-        }
-        const runner = this.runJob(job).then(() => {
-            this.runningJobs.delete(job.intentKey);
-        }, () => {
-            this.runningJobs.delete(job.intentKey);
-        });
-        this.runningJobs.set(job.intentKey, runner);
-    }
-    runJob(job) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (job.status === 'cancelled') {
-                return;
-            }
-            yield this.waitForNextFrame();
-            if (job.status === 'cancelled') {
-                return;
-            }
-            job.status = 'running';
-            (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.recordEvent('deferred-job-start', {
-                intentKey: job.intentKey,
-                jobId: job.id
-            });
-            let index = 0;
-            let frameStart = performance.now();
-            let processedInFrame = 0;
-            let committedInSlice = 0;
-            while (index < job.orderedGraphics.length) {
-                if (job.status === 'cancelled') {
-                    return;
-                }
-                if (processedInFrame > 0 &&
-                    (processedInFrame >= job.config.maxGraphicsPerFrame || performance.now() - frameStart >= job.config.frameBudget)) {
-                    (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.incrementCounter('deferredBudgetYields');
-                    (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.recordCost('batchSlice', performance.now() - frameStart);
-                    (_d = this.perfMonitor) === null || _d === void 0 ? void 0 : _d.recordEvent('deferred-job-yield', {
-                        intentKey: job.intentKey,
-                        jobId: job.id,
-                        processedInFrame
-                    });
-                    if (committedInSlice > 0) {
-                        this.stage.renderNextFrame();
-                    }
-                    yield this.waitForNextFrame();
-                    frameStart = performance.now();
-                    processedInFrame = 0;
-                    committedInSlice = 0;
-                }
-                const graphic = job.orderedGraphics[index++];
-                if (!job.pendingGraphics.has(graphic)) {
-                    continue;
-                }
-                if (!isRenderableGraphic(graphic)) {
-                    job.pendingGraphics.delete(graphic);
-                    if (this.pendingIntentByGraphic.get(graphic) === job.intentKey) {
-                        this.pendingIntentByGraphic.delete(graphic);
-                    }
-                    continue;
-                }
-                if (this.pendingIntentByGraphic.get(graphic) !== job.intentKey) {
-                    job.pendingGraphics.delete(graphic);
-                    continue;
-                }
-                const nextEligibility = this.resolveEligibility(graphic, job.targetStates, true, false);
-                if (!nextEligibility.eligible) {
-                    job.pendingGraphics.delete(graphic);
-                    this.pendingIntentByGraphic.delete(graphic);
-                    this.commitSynchronously(graphic, job.targetStates);
-                    continue;
-                }
-                const nextIntentKey = createIntentKey(nextEligibility.context.contextOwnerId, nextEligibility.context.configFingerprint, nextEligibility.targetStatesKey);
-                if (nextIntentKey !== job.intentKey) {
-                    job.pendingGraphics.delete(graphic);
-                    this.pendingIntentByGraphic.delete(graphic);
-                    this.enqueueDeferredIntent(graphic, job.targetStates, nextEligibility.context, nextEligibility.targetStatesKey);
-                    continue;
-                }
-                this.commitSynchronously(graphic, job.targetStates);
-                job.pendingGraphics.delete(graphic);
-                this.pendingIntentByGraphic.delete(graphic);
-                job.processedCount += 1;
-                processedInFrame += 1;
-                committedInSlice += 1;
-                (_e = this.perfMonitor) === null || _e === void 0 ? void 0 : _e.incrementCounter('deferredGraphicsCommitted');
-            }
-            if (processedInFrame > 0) {
-                (_f = this.perfMonitor) === null || _f === void 0 ? void 0 : _f.recordCost('batchSlice', performance.now() - frameStart);
-                this.stage.renderNextFrame();
-            }
-            if (job.pendingGraphics.size === 0 && this.jobsByIntentKey.get(job.intentKey) === job) {
-                job.status = 'completed';
-                this.jobsByIntentKey.delete(job.intentKey);
-                (_g = this.perfMonitor) === null || _g === void 0 ? void 0 : _g.incrementCounter('deferredJobsCompleted');
-                (_h = this.perfMonitor) === null || _h === void 0 ? void 0 : _h.recordEvent('deferred-job-complete', {
-                    intentKey: job.intentKey,
-                    jobId: job.id,
-                    processedCount: job.processedCount
-                });
-                (_j = this.perfMonitor) === null || _j === void 0 ? void 0 : _j.updateBatchPending(this.jobsByIntentKey.size);
-            }
-        });
-    }
-    waitForNextFrame() {
-        const stageGlobal = this.stage.global;
-        if (stageGlobal === null || stageGlobal === void 0 ? void 0 : stageGlobal.getSpecifiedPerformanceRAF) {
-            return stageGlobal.getSpecifiedPerformanceRAF(this.stage.rafId).wait();
-        }
-        return new Promise(resolve => {
-            stageGlobal === null || stageGlobal === void 0 ? void 0 : stageGlobal.getSpecifiedRequestAnimationFrame(this.stage.rafId)(() => resolve());
-        });
-    }
-    commitSynchronously(graphic, targetStates) {
-        if (!isRenderableGraphic(graphic)) {
-            return;
-        }
-        if (!targetStates.length) {
-            graphic.clearStates(false);
-            return;
-        }
-        graphic.useStates(targetStates, false);
-    }
-}
-
 const DefaultConfig = {
     WIDTH: 500,
     HEIGHT: 500,
@@ -20704,14 +19416,12 @@ class Stage extends Group {
         this.theme.onStateDefinitionsChange = () => {
             var _a;
             const definitions = (_a = this.theme) === null || _a === void 0 ? void 0 : _a.stateDefinitions;
-            if (!definitions || !Object.keys(definitions).length) {
-                if (this.rootSharedStateScope) {
-                    setRootSharedStateScopeThemeDefinitions(this.rootSharedStateScope, definitions);
-                    markScopeActiveDescendantsDirty(this.rootSharedStateScope, this);
-                }
+            const rootScope = definitions && Object.keys(definitions).length
+                ? this.ensureRootSharedStateScope(definitions)
+                : this.rootSharedStateScope;
+            if (!rootScope) {
                 return;
             }
-            const rootScope = this.ensureRootSharedStateScope(definitions);
             setRootSharedStateScopeThemeDefinitions(rootScope, definitions);
             markScopeActiveDescendantsDirty(rootScope, this);
         };
@@ -21143,21 +19853,6 @@ class Stage extends Group {
         this.rootSharedStateScope.ownerStage = this;
         return this.rootSharedStateScope;
     }
-    getStateBatchScheduler() {
-        if (!this._stateBatchScheduler) {
-            this._stateBatchScheduler = new StateBatchScheduler(this, ensureStageStatePerfMonitor(this));
-        }
-        return this._stateBatchScheduler;
-    }
-    scheduleStateBatch(graphics, targetStates) {
-        this.getStateBatchScheduler().schedule(graphics, targetStates);
-    }
-    getStatePerfSnapshot() {
-        return ensureStageStatePerfMonitor(this).getSnapshot();
-    }
-    resetStatePerfSnapshot() {
-        ensureStageStatePerfMonitor(this).reset();
-    }
     _doRenderInThisFrame() {
         if (this.releaseStatus === 'released') {
             return;
@@ -21291,8 +19986,7 @@ class Stage extends Group {
         throw new Error('暂不支持');
     }
     release() {
-        var _a, _b, _d, _e;
-        (_a = this._stateBatchScheduler) === null || _a === void 0 ? void 0 : _a.release();
+        var _a, _b, _d;
         super.release();
         this.hooks.beforeRender.unTap('constructor', this.beforeRender);
         this.hooks.afterRender.unTap('constructor', this.afterRender);
@@ -21310,10 +20004,10 @@ class Stage extends Group {
             this.interactiveLayer.release();
         }
         this.window.release();
-        (_b = this._ticker) === null || _b === void 0 ? void 0 : _b.remTimeline(this === null || this === void 0 ? void 0 : this.timeline);
-        (_d = this._ticker) === null || _d === void 0 ? void 0 : _d.removeListener('tick', this.afterTickCb);
+        (_a = this._ticker) === null || _a === void 0 ? void 0 : _a.remTimeline(this === null || this === void 0 ? void 0 : this.timeline);
+        (_b = this._ticker) === null || _b === void 0 ? void 0 : _b.removeListener('tick', this.afterTickCb);
         if (!this.params.ticker) {
-            (_e = this._ticker) === null || _e === void 0 ? void 0 : _e.release();
+            (_d = this._ticker) === null || _d === void 0 ? void 0 : _d.release();
         }
         this.renderService.renderTreeRoots = [];
     }
@@ -27609,18 +26303,12 @@ function createBrowserApp(options = {}) {
 }
 
 class NodeEntry extends BrowserEntry {
-    constructor(options = {}) {
-        super(options);
-    }
 }
 function createNodeApp(options = {}) {
     return new NodeEntry(options);
 }
 
 class MiniappEntry extends BrowserEntry {
-    constructor(options = {}) {
-        super(options);
-    }
 }
 function createMiniappApp(options = {}) {
     return new MiniappEntry(options);