@laplace.live/pixijs-live2d 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -3240,6 +3240,14 @@ export declare enum MotionPreloadStrategy {
   /** No preload. */
   NONE = "NONE"
 }
+/**
+ * What plays when nothing else does: a motion to loop, `'idle-group'` for a random motion of
+ * the idle group (the default), or `null` to hold still.
+ */
+export type IdleMotion = {
+  group: string;
+  index: number;
+} | 'idle-group' | null;
 /**
  * Handles the motion playback for Live2D models.
  * Responsible for loading, playing, and managing motion states and audio.
@@ -3322,6 +3330,22 @@ export declare abstract class MotionManager<Motion = unknown, MotionSpec = unkno
    * @type {boolean}
    */
   destroyed: boolean;
+  /** The idle selection; see {@link setIdleMotion}. */
+  idleMotion: IdleMotion;
+  /**
+   * Choose what plays when nothing else does. A running idle gives way at once and a loading one
+   * is dropped; a higher-priority motion in flight hands over to the new selection when it ends.
+   */
+  setIdleMotion(motion: IdleMotion): void;
+  /**
+   * List a motion file after load, under `group`, so a file written beside the model plays
+   * without a reload. A new group is created; an existing one grows by one index.
+   */
+  addMotion(group: string, definition: MotionSpec): void;
+  /** Stop the idle so the next update starts the selection. Cubism eases its parameters home too. */
+  protected releaseIdle(): void;
+  /** Start the idle selection at IDLE priority; a chosen motion loops regardless of its own flag. */
+  protected startIdleMotion(): Promise<boolean>;
   /**
    * Reference to the parent InternalModel.
    * @type {InternalModel}
@@ -3541,7 +3565,9 @@ export declare abstract class ExpressionManager<Expression = unknown, Expression
    */
   tag: string;
   /**
-   * Expression definitions copied from ModelSettings.
+   * Expression definitions copied from ModelSettings. An index is not stable across an `await`:
+   * {@link removeDefinition} shifts the ones above it, so a load or activation in flight
+   * re-resolves its definition afterwards rather than trusting the index it started with.
    */
   abstract readonly definitions: ExpressionSpec[];
   /**
@@ -3574,6 +3600,14 @@ export declare abstract class ExpressionManager<Expression = unknown, Expression
    * Active set remembered by {@link resetExpression} for {@link restoreExpression}.
    */
   protected suppressedIndices: number[] | null;
+  /**
+   * Indices whose parameters are skipped while they stay active — an editor previewing an
+   * expression's own edit needs the real one silent without touching the active set anyone
+   * persists or observes.
+   */
+  protected muted: Set<number>;
+  /** Every entry silenced at once (the editor's Solo), on top of {@link muted}. */
+  protected muteAll: boolean;
   /**
    * Flags the instance has been destroyed.
    */
@@ -3593,6 +3627,40 @@ export declare abstract class ExpressionManager<Expression = unknown, Expression
    * @ignore
    */
   private _loadExpression;
+  /**
+   * Lists a definition after load, so a file written beside the model activates without a reload.
+   * @return The new index.
+   */
+  addDefinition(definition: ExpressionSpec): number;
+  /**
+   * Replaces the loaded Expression at `index` — a file the editor just rewrote — keeping an active one
+   * active at its current weight.
+   */
+  replaceExpression(index: number, expression: Expression): void;
+  /**
+   * Forgets a definition (its file was deleted or renamed away): deactivates it, then shifts every
+   * index above it so the remaining expressions keep their state. An activation of it still loading
+   * settles as a no-op.
+   */
+  removeDefinition(index: number): void;
+  /**
+   * Mutes or unmutes an Expression: an active one keeps its state and fade but contributes nothing
+   * until unmuted. Unknown indices are ignored.
+   */
+  setExpressionMuted(index: number | string, muted: boolean): void;
+  /**
+   * Mutes or unmutes every Expression at once, active state untouched; the per-entry mutes stay
+   * as they are underneath.
+   */
+  setAllMuted(muted: boolean): void;
+  /**
+   * A loaded Expression was swapped for another at `index`; a subclass holding it live re-points.
+   */
+  protected onExpressionReplaced(_index: number, _expression: Expression): void;
+  /**
+   * The definition at `index` is gone and every index above it moved down by one.
+   */
+  protected onDefinitionRemoved(_index: number): void;
   /**
    * Activates a random inactive Expression.
    * @return Promise that resolves with true if succeeded, with false otherwise.
@@ -4656,7 +4724,8 @@ export declare class Live2DFactory {
   /**
    * Load tasks of each expression.
    */
-  static expressionTasksMap: WeakMap<ExpressionManager<unknown, unknown>, (Promise<any> | undefined)[]>;
+  /** Keyed by the definition object: a removal shifts indices, never the object. */
+  static expressionTasksMap: WeakMap<ExpressionManager<unknown, unknown>, Map<unknown, Promise<any>>>;
   /**
    * Registers a Live2DRuntime.
    */
@@ -5742,9 +5811,15 @@ export declare class CubismModelSettings extends ModelSettings {
 export declare class CubismExpressionManager extends ExpressionManager<CubismExpressionMotion, Expression> {
   readonly expressionDataType: "arraybuffer";
   readonly definitions: Expression[];
+  /** The settings the listings read; `definitions` was filtered out of them, so both are kept in step. */
+  private readonly cubismSettings;
   /** Active fade entries in activation order; deactivated ones stay until fully faded out. */
   private entries;
   constructor(settings: CubismModelSettings, options?: MotionManagerOptions);
+  addDefinition(definition: Expression): number;
+  removeDefinition(index: number): void;
+  protected onExpressionReplaced(index: number, expression: CubismExpressionMotion): void;
+  protected onDefinitionRemoved(index: number): void;
   isFinished(): boolean;
   getExpressionIndex(name: string): number;
   getExpressionFile(definition: Expression): string;
@@ -6917,15 +6992,41 @@ export declare class CubismMotionManager extends MotionManager<CubismMotion, Mot
   expressionManager?: CubismExpressionManager;
   eyeBlinkIds: string[];
   lipSyncIds: string[];
+  /** What each motion's curves write, read once when it is created. */
+  private readonly meta;
+  /** Eases the parameters a released idle animated back to rest; see {@link releaseIdle}. */
+  private release;
   constructor(parent: CubismInternalModel);
   protected init(options?: MotionManagerOptions): void;
   isFinished(): boolean;
   protected _startMotion(motion: CubismMotion, onFinish?: (motion: CubismMotion) => void, ignoreParamIds?: string[], loop?: boolean): number;
   protected _stopAllMotions(): void;
+  /**
+   * Fade the queue's motions out over their own fade-out time instead of cutting them; each
+   * ends like a natural finish (idle restart, `motionFinish`), which is how a looping one stops.
+   * The motion's sound stops at once, as it does on {@link stopAllMotions}.
+   */
+  fadeOutMotions(): void;
   createMotion(data: ArrayBuffer, group: string, definition: Motion): CubismMotion;
   getMotionFile(definition: Motion): string;
   protected getMotionName(definition: Motion): string;
   protected getSoundFile(definition: Motion): string | undefined;
+  /** Whether the playing motion animates the eyes itself, so the engine's auto-blink must yield to it. */
+  currentMotionBlinks(): boolean;
+  /** The parameters the playing motion writes, for a host driver handing them over to it; null when none plays. */
+  currentMotionParameters(): ReadonlySet<string> | null;
+  /**
+   * The parameters a playing one-shot (anything above IDLE) writes — what a host's tracking
+   * yields to while it plays, as VTS ranks an animation above tracking. Null under the idle.
+   */
+  oneShotParameters(): ReadonlySet<string> | null;
+  /** A motion above idle priority is current — one the player started, never the idle. */
+  oneShotPlaying(): boolean;
+  private currentMotion;
+  private currentMeta;
+  protected releaseIdle(): void;
+  /** One frame of the ease-to-rest, ahead of the motions so a new idle's fade-in blends from it. */
+  private updateRelease;
   protected updateParameters(model: CubismModel, now: DOMHighResTimeStamp): boolean;
   destroy(): void;
   motionLastFrame(group: string, index: number, { expression }?: {

package/dist/index.js

@@ -2734,6 +2734,14 @@ var ExpressionManager = class extends EventEmitter {
 	*/
 	suppressedIndices = null;
 	/**
+	* Indices whose parameters are skipped while they stay active — an editor previewing an
+	* expression's own edit needs the real one silent without touching the active set anyone
+	* persists or observes.
+	*/
+	muted = /* @__PURE__ */ new Set();
+	/** Every entry silenced at once (the editor's Solo), on top of {@link muted}. */
+	muteAll = false;
+	/**
 	* Flags the instance has been destroyed.
 	*/
 	destroyed = false;
@@ -2751,7 +2759,8 @@ var ExpressionManager = class extends EventEmitter {
 	* @emits {@link ExpressionManagerEvents.expressionLoadError}
 	*/
 	async loadExpression(index) {
-		if (!this.definitions[index]) {
+		const definition = this.definitions[index];
+		if (!definition) {
 			logger.warn(this.tag, `Undefined expression at [${index}]`);
 			return;
 		}
@@ -2762,7 +2771,11 @@ var ExpressionManager = class extends EventEmitter {
 		if (this.expressions[index]) return this.expressions[index];
 		const expression = await this._loadExpression(index);
 		if (this.destroyed) return;
-		this.expressions[index] = expression;
+		const slot = this.definitions.indexOf(definition);
+		if (slot < 0) return;
+		const replaced = this.expressions[slot];
+		if (replaced) return replaced;
+		this.expressions[slot] = expression;
 		return expression;
 	}
 	/**
@@ -2773,6 +2786,66 @@ var ExpressionManager = class extends EventEmitter {
 		throw new Error("Not implemented.");
 	}
 	/**
+	* Lists a definition after load, so a file written beside the model activates without a reload.
+	* @return The new index.
+	*/
+	addDefinition(definition) {
+		this.definitions.push(definition);
+		return this.definitions.length - 1;
+	}
+	/**
+	* Replaces the loaded Expression at `index` — a file the editor just rewrote — keeping an active one
+	* active at its current weight.
+	*/
+	replaceExpression(index, expression) {
+		if (!this.definitions[index]) return;
+		this.expressions[index] = expression;
+		this.onExpressionReplaced(index, expression);
+	}
+	/**
+	* Forgets a definition (its file was deleted or renamed away): deactivates it, then shifts every
+	* index above it so the remaining expressions keep their state. An activation of it still loading
+	* settles as a no-op.
+	*/
+	removeDefinition(index) {
+		if (!(index >= 0 && index < this.definitions.length)) return;
+		this.unsetExpression(index);
+		this.definitions.splice(index, 1);
+		this.expressions.splice(index, 1);
+		const shift = (i) => i > index ? i - 1 : i;
+		this.activeIndices = this.activeIndices.map(shift);
+		this.pendingIndices = new Set([...this.pendingIndices].map(shift));
+		this.requestSeqs = new Map([...this.requestSeqs].map(([i, seq]) => [shift(i), seq]));
+		if (this.suppressedIndices) this.suppressedIndices = this.suppressedIndices.filter((i) => i !== index).map(shift);
+		this.muted = new Set([...this.muted].filter((i) => i !== index).map(shift));
+		this.onDefinitionRemoved(index);
+	}
+	/**
+	* Mutes or unmutes an Expression: an active one keeps its state and fade but contributes nothing
+	* until unmuted. Unknown indices are ignored.
+	*/
+	setExpressionMuted(index, muted) {
+		if (typeof index !== "number") index = this.getExpressionIndex(index);
+		if (!this.definitions[index]) return;
+		if (muted) this.muted.add(index);
+		else this.muted.delete(index);
+	}
+	/**
+	* Mutes or unmutes every Expression at once, active state untouched; the per-entry mutes stay
+	* as they are underneath.
+	*/
+	setAllMuted(muted) {
+		this.muteAll = muted;
+	}
+	/**
+	* A loaded Expression was swapped for another at `index`; a subclass holding it live re-points.
+	*/
+	onExpressionReplaced(_index, _expression) {}
+	/**
+	* The definition at `index` is gone and every index above it moved down by one.
+	*/
+	onDefinitionRemoved(_index) {}
+	/**
 	* Activates a random inactive Expression.
 	* @return Promise that resolves with true if succeeded, with false otherwise.
 	*/
@@ -2837,14 +2910,17 @@ var ExpressionManager = class extends EventEmitter {
 	*/
 	async setExpression(index, options) {
 		if (typeof index !== "number") index = this.getExpressionIndex(index);
-		if (!(index > -1 && index < this.definitions.length)) return false;
+		const definition = this.definitions[index];
+		if (!definition) return false;
 		if (this.activeIndices.includes(index) || this.pendingIndices.has(index)) return false;
 		this.pendingIndices.add(index);
 		const seq = this.nextRequestSeq++;
 		this.requestSeqs.set(index, seq);
 		this.emit("expressionsChanged");
 		const expression = await this.loadExpression(index);
-		if (this.destroyed || this.requestSeqs.get(index) !== seq || !this.pendingIndices.has(index)) return false;
+		if (this.destroyed) return false;
+		index = this.definitions.indexOf(definition);
+		if (index < 0 || this.requestSeqs.get(index) !== seq || !this.pendingIndices.has(index)) return false;
 		if (!expression) {
 			this.pendingIndices.delete(index);
 			this.requestSeqs.delete(index);
@@ -2911,6 +2987,8 @@ var ExpressionManager = class extends EventEmitter {
 		this.requestSeqs.clear();
 		this.activeIndices = [];
 		this.suppressedIndices = null;
+		this.muted.clear();
+		this.muteAll = false;
 		this.stopAllExpressions();
 		const self = this;
 		self.definitions = void 0;
@@ -3567,6 +3645,10 @@ var MotionState = class {
 	*/
 	start(motion, group, index, priority) {
 		if (priority === 1) {
+			if (group !== this.reservedIdleGroup || index !== this.reservedIdleIndex) {
+				logger.log(this.tag, "Cannot start idle motion because it is no longer reserved.", this.dump(group, index));
+				return false;
+			}
 			this.setReservedIdle(void 0, void 0);
 			if (this.currentPriority !== 0) {
 				logger.log(this.tag, "Cannot start idle motion because another motion is playing.", this.dump(group, index));
@@ -3912,6 +3994,10 @@ let MotionPreloadStrategy = /* @__PURE__ */ function(MotionPreloadStrategy) {
 	MotionPreloadStrategy["NONE"] = "NONE";
 	return MotionPreloadStrategy;
 }({});
+function sameIdleMotion(a, b) {
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return a === b;
+	return a.group === b.group && a.index === b.index;
+}
 /**
 * Handles the motion playback for Live2D models.
 * Responsible for loading, playing, and managing motion states and audio.
@@ -3966,6 +4052,39 @@ var MotionManager = class extends EventEmitter {
 	* @type {boolean}
 	*/
 	destroyed = false;
+	/** The idle selection; see {@link setIdleMotion}. */
+	idleMotion = "idle-group";
+	/**
+	* Choose what plays when nothing else does. A running idle gives way at once and a loading one
+	* is dropped; a higher-priority motion in flight hands over to the new selection when it ends.
+	*/
+	setIdleMotion(motion) {
+		if (sameIdleMotion(this.idleMotion, motion)) return;
+		this.idleMotion = motion;
+		this.state.setReservedIdle(void 0, void 0);
+		if (this.state.currentPriority === 1) this.releaseIdle();
+	}
+	/**
+	* List a motion file after load, under `group`, so a file written beside the model plays
+	* without a reload. A new group is created; an existing one grows by one index.
+	*/
+	addMotion(group, definition) {
+		const definitions = this.definitions[group] ?? [];
+		definitions.push(definition);
+		this.definitions[group] = definitions;
+		this.motionGroups[group] ??= [];
+	}
+	/** Stop the idle so the next update starts the selection. Cubism eases its parameters home too. */
+	releaseIdle() {
+		this.stopAllMotions();
+	}
+	/** Start the idle selection at IDLE priority; a chosen motion loops regardless of its own flag. */
+	startIdleMotion() {
+		const idle = this.idleMotion;
+		if (idle === null) return Promise.resolve(false);
+		if (idle === "idle-group") return this.startRandomMotion(this.groups.idle, 1);
+		return this.startMotion(idle.group, idle.index, 1, { loop: true });
+	}
 	/**
 	* Reference to the parent InternalModel.
 	* @type {InternalModel}
@@ -4264,7 +4383,7 @@ var MotionManager = class extends EventEmitter {
 			}
 			if (this.state.shouldOverrideExpression()) this.expressionManager?.restoreExpression();
 			this.state.complete();
-			if (this.state.shouldRequestIdleMotion()) this.startRandomMotion(this.groups.idle, 1);
+			if (this.idleMotion !== null && this.state.shouldRequestIdleMotion()) this.startIdleMotion();
 		}
 		return this.updateParameters(model, now);
 	}
@@ -4840,6 +4959,7 @@ var Live2DFactory = class Live2DFactory {
 	/**
 	* Load tasks of each expression.
 	*/
+	/** Keyed by the definition object: a removal shifts indices, never the object. */
 	static expressionTasksMap = /* @__PURE__ */ new WeakMap();
 	/**
 	* Registers a Live2DRuntime.
@@ -4938,28 +5058,33 @@ var Live2DFactory = class Live2DFactory {
 			expressionManager.once("destroy", () => Live2DFactory.releaseExpressionTasks(expressionManager));
 			let tasks = Live2DFactory.expressionTasksMap.get(expressionManager);
 			if (!tasks) {
-				tasks = [];
+				tasks = /* @__PURE__ */ new Map();
 				Live2DFactory.expressionTasksMap.set(expressionManager, tasks);
 			}
 			const path = expressionManager.getExpressionFile(definition);
 			const responseType = expressionManager.expressionDataType ?? "json";
-			tasks[index] ??= Live2DLoader.load({
-				url: path,
-				settings: expressionManager.settings,
-				type: responseType,
-				target: expressionManager
-			}).then((data) => {
-				const tasks = Live2DFactory.expressionTasksMap.get(expressionManager);
-				if (tasks) tasks[index] = void 0;
-				const expressionData = data;
-				const expression = expressionManager.createExpression(expressionData, definition);
-				expressionManager.emit("expressionLoaded", index, expression);
-				return expression;
-			}).catch((e) => {
-				logger.warn(expressionManager.tag, `Failed to load expression: ${path}\n`, e);
-				handleError(e);
-			});
-			return tasks[index];
+			let task = tasks.get(definition);
+			if (!task) {
+				task = Live2DLoader.load({
+					url: path,
+					settings: expressionManager.settings,
+					type: responseType,
+					target: expressionManager
+				}).then((data) => {
+					const expressionData = data;
+					const expression = expressionManager.createExpression(expressionData, definition);
+					const current = expressionManager.definitions.indexOf(definition);
+					if (current >= 0) expressionManager.emit("expressionLoaded", current, expression);
+					return expression;
+				}).catch((e) => {
+					logger.warn(expressionManager.tag, `Failed to load expression: ${path}\n`, e);
+					handleError(e);
+				}).finally(() => {
+					Live2DFactory.expressionTasksMap.get(expressionManager)?.delete(definition);
+				});
+				tasks.set(definition, task);
+			}
+			return task;
 		} catch (e) {
 			logger.warn(expressionManager.tag, `Failed to load expression at [${index}]\n`, e);
 			handleError(e);
@@ -14569,12 +14694,39 @@ let Live2DCubismFramework$2;
 var CubismExpressionManager = class extends ExpressionManager {
 	expressionDataType = "arraybuffer";
 	definitions;
+	/** The settings the listings read; `definitions` was filtered out of them, so both are kept in step. */
+	cubismSettings;
 	/** Active fade entries in activation order; deactivated ones stay until fully faded out. */
 	entries = [];
 	constructor(settings, options) {
 		super(settings, options);
+		this.cubismSettings = settings;
 		this.definitions = settings.expressions?.filter((expression) => !!expression && typeof expression.File === "string" && typeof expression.Name === "string") ?? [];
 	}
+	addDefinition(definition) {
+		const index = super.addDefinition(definition);
+		this.cubismSettings.expressions ??= [];
+		this.cubismSettings.expressions.push(definition);
+		return index;
+	}
+	removeDefinition(index) {
+		const definition = this.definitions[index];
+		super.removeDefinition(index);
+		const listed = this.cubismSettings.expressions;
+		const at = definition && listed ? listed.indexOf(definition) : -1;
+		if (listed && at >= 0) listed.splice(at, 1);
+	}
+	onExpressionReplaced(index, expression) {
+		for (const entry of this.entries) if (entry.index === index) {
+			entry.motion = expression;
+			entry.fadeStartWeight = entry.weight;
+			entry.fadeStartTime = -1;
+		}
+	}
+	onDefinitionRemoved(index) {
+		this.entries = this.entries.filter((entry) => entry.index !== index);
+		for (const entry of this.entries) if (entry.index > index) entry.index -= 1;
+	}
 	isFinished() {
 		return this.entries.length === 0;
 	}
@@ -14631,6 +14783,7 @@ var CubismExpressionManager = class extends ExpressionManager {
 		if (!this.entries.length) return false;
 		const states = /* @__PURE__ */ new Map();
 		for (const entry of this.entries) {
+			if (this.muteAll || this.muted.has(entry.index)) continue;
 			const weight = entry.weight;
 			for (const parameter of entry.motion.getExpressionParameters()) {
 				if (parameter.parameterId == null) continue;
@@ -14693,9 +14846,14 @@ var CubismMotionManager = class extends MotionManager {
 	expressionManager;
 	eyeBlinkIds;
 	lipSyncIds = ["ParamMouthOpenY"];
+	/** What each motion's curves write, read once when it is created. */
+	meta = /* @__PURE__ */ new WeakMap();
+	/** Eases the parameters a released idle animated back to rest; see {@link releaseIdle}. */
+	release = null;
 	constructor(parent) {
 		super(parent);
-		this.definitions = parent.settings.motions ?? {};
+		parent.settings.motions ??= {};
+		this.definitions = parent.settings.motions;
 		this.eyeBlinkIds = parent.settings.getEyeBlinkParameters() || [];
 		const lipSyncIds = parent.settings.getLipSyncParameters();
 		if (lipSyncIds?.length) this.lipSyncIds = lipSyncIds;
@@ -14703,7 +14861,7 @@ var CubismMotionManager = class extends MotionManager {
 	}
 	init(options) {
 		super.init(options);
-		if (this.settings.expressions) this.expressionManager = new CubismExpressionManager(this.settings, options);
+		this.expressionManager = new CubismExpressionManager(this.settings, options);
 		this.queueManager.setEventCallback((_caller, eventValue) => {
 			const value = eventValue == null ? "undefined" : String(eventValue);
 			this.emit(`motion:${value}`);
@@ -14722,6 +14880,7 @@ var CubismMotionManager = class extends MotionManager {
 			});
 			motion._motionData.curves = filtered;
 			motion._motionData.curveCount = filtered.length;
+			this.meta.set(motion, motionMeta(motion, this.eyeBlinkIds));
 		}
 		this.queueManager.stopAllMotions();
 		return this.queueManager.startMotion(motion, false);
@@ -14729,14 +14888,24 @@ var CubismMotionManager = class extends MotionManager {
 	_stopAllMotions() {
 		this.queueManager.stopAllMotions();
 	}
+	/**
+	* Fade the queue's motions out over their own fade-out time instead of cutting them; each
+	* ends like a natural finish (idle restart, `motionFinish`), which is how a looping one stops.
+	* The motion's sound stops at once, as it does on {@link stopAllMotions}.
+	*/
+	fadeOutMotions() {
+		for (const entry of this.queueManager.getCubismMotionQueueEntries()) entry.setFadeOut(entry._motion.getFadeOutTime());
+		this.stopSpeaking();
+	}
 	createMotion(data, group, definition) {
 		const shouldCheckMotionConsistency = !!this.parent.options.checkMotionConsistency;
 		const motion = CubismMotion.create(data, data.byteLength, void 0, void 0, shouldCheckMotionConsistency);
 		const json = new CubismMotionJson(data, data.byteLength);
 		motion.setLoop(json.isMotionLoop());
+		this.meta.set(motion, motionMeta(motion, this.eyeBlinkIds));
 		const defaultFadingDuration = (group === this.groups.idle ? config.idleMotionFadingDuration : config.motionFadingDuration) / 1e3;
-		if (json.getMotionFadeInTime() === void 0) motion.setFadeInTime(definition.FadeInTime > 0 ? definition.FadeInTime : defaultFadingDuration);
-		if (json.getMotionFadeOutTime() === void 0) motion.setFadeOutTime(definition.FadeOutTime > 0 ? definition.FadeOutTime : defaultFadingDuration);
+		if (!json.isExistMotionFadeInTime()) motion.setFadeInTime(definition.FadeInTime > 0 ? definition.FadeInTime : defaultFadingDuration);
+		if (!json.isExistMotionFadeOutTime()) motion.setFadeOutTime(definition.FadeOutTime > 0 ? definition.FadeOutTime : defaultFadingDuration);
 		motion.setEffectIds(this.createIdList(this.eyeBlinkIds), this.createIdList(this.lipSyncIds));
 		return motion;
 	}
@@ -14749,7 +14918,68 @@ var CubismMotionManager = class extends MotionManager {
 	getSoundFile(definition) {
 		return definition.Sound;
 	}
+	/** Whether the playing motion animates the eyes itself, so the engine's auto-blink must yield to it. */
+	currentMotionBlinks() {
+		return this.currentMeta()?.blinks ?? false;
+	}
+	/** The parameters the playing motion writes, for a host driver handing them over to it; null when none plays. */
+	currentMotionParameters() {
+		return this.currentMeta()?.animated ?? null;
+	}
+	/**
+	* The parameters a playing one-shot (anything above IDLE) writes — what a host's tracking
+	* yields to while it plays, as VTS ranks an animation above tracking. Null under the idle.
+	*/
+	oneShotParameters() {
+		return this.oneShotPlaying() ? this.currentMotionParameters() : null;
+	}
+	/** A motion above idle priority is current — one the player started, never the idle. */
+	oneShotPlaying() {
+		return this.state.currentPriority > 1;
+	}
+	currentMotion() {
+		const { currentGroup, currentIndex } = this.state;
+		if (currentGroup === void 0 || currentIndex === void 0) return null;
+		return this.motionGroups[currentGroup]?.[currentIndex] ?? null;
+	}
+	currentMeta() {
+		const motion = this.currentMotion();
+		return motion ? this.meta.get(motion) ?? null : null;
+	}
+	releaseIdle() {
+		const motion = this.currentMotion();
+		super.releaseIdle();
+		if (motion) this.release = {
+			ids: this.meta.get(motion)?.parameterIds ?? [],
+			seconds: motion.getFadeOutTime(),
+			ramp: null
+		};
+	}
+	/** One frame of the ease-to-rest, ahead of the motions so a new idle's fade-in blends from it. */
+	updateRelease(model, now) {
+		const r = this.release;
+		if (!r) return;
+		if (r.ramp === null) {
+			const count = model.getParameterCount();
+			const indices = r.ids.map((id) => model.getParameterIndex(id)).filter((index) => index < count);
+			r.ramp = {
+				indices,
+				from: indices.map((index) => model.getParameterValueByIndex(index)),
+				startedAt: now
+			};
+		}
+		const { indices, from, startedAt } = r.ramp;
+		const t = r.seconds > 0 ? Math.min(1, (now - startedAt) / r.seconds) : 1;
+		const w = CubismMath.getEasingSine(t);
+		for (let i = 0; i < indices.length; i++) {
+			const index = indices[i];
+			const start = from[i];
+			model.setParameterValueByIndex(index, start + (model.getParameterDefaultValue(index) - start) * w);
+		}
+		if (t >= 1) this.release = null;
+	}
 	updateParameters(model, now) {
+		this.updateRelease(model, now);
 		return this.queueManager.doUpdateMotion(model, now);
 	}
 	destroy() {
@@ -14770,6 +15000,23 @@ var CubismMotionManager = class extends MotionManager {
 		return ids.map((id) => idManager.getId(id));
 	}
 };
+function motionMeta(motion, eyeBlinkIds) {
+	const parameterIds = [];
+	const animated = /* @__PURE__ */ new Set();
+	let blinks = false;
+	for (const curve of motion._motionData.curves) {
+		const id = getCurveId$1(curve);
+		if (curve.type === 1) {
+			parameterIds.push(curve.id);
+			if (id !== void 0) animated.add(id);
+		} else if (curve.type === 0 && id === "EyeBlink") blinks = true;
+	}
+	return {
+		parameterIds,
+		animated,
+		blinks: blinks || eyeBlinkIds.some((id) => animated.has(id))
+	};
+}
 function getCurveId$1(curve) {
 	if (!curve || typeof curve !== "object") return;
 	const id = curve.id;
@@ -15322,10 +15569,10 @@ var CubismInternalModel = class extends InternalModel {
 		dt /= 1e3;
 		now /= 1e3;
 		const model = this.coreModel;
-		const motionUpdated = this.updateMotions(model, now);
+		this.updateMotions(model, now);
 		model.saveParameters();
 		this.motionManager.expressionManager?.update(model, now);
-		if (!motionUpdated) this.eyeBlink?.updateParameters?.(model, dt);
+		if (!this.motionManager.currentMotionBlinks()) this.eyeBlink?.updateParameters?.(model, dt);
 		this.updateFocus();
 		this.updateNaturalMovements(dt * 1e3, now * 1e3);
 		if (this.lipSync && this.motionManager.currentAudio) {