@omote/core 0.9.4 → 0.9.6

package/dist/index.d.mts

@@ -2517,12 +2517,6 @@ interface A2EProcessorConfig {
      * different expression intensity across face regions (brows, eyes, cheeks).
      */
     identityIndex?: number;
-    /**
-     * Spring halflife for blendshape smoothing (seconds).
-     * - 0.06 (default): Sweet spot for lip sync
-     * - 0: Bypass (raw frames, no smoothing)
-     */
-    smoothingHalflife?: number;
     /** Callback fired with each blendshape frame (push mode) */
     onFrame?: (frame: Float32Array) => void;
     /** Error callback */
@@ -2544,11 +2538,12 @@ declare class A2EProcessor {
     private plainQueue;
     private _latestFrame;
     private dripInterval;
-    private smoother;
+    private lastPulledFrame;
     private lastDequeuedTime;
-    private lastUpdateTime;
-    private neutralTriggered;
-    private outputBuffer;
+    private decayBuffer;
+    private smoother;
+    private gapDecayStarted;
+    private lastSmootherUpdate;
     private inferenceRunning;
     private pendingChunks;
     private getFrameCallCount;
@@ -2668,6 +2663,15 @@ declare class BlendshapeSmoother {
      * Springs will converge toward these values on subsequent update() calls.
      */
     setTarget(frame: Float32Array): void;
+    /**
+     * Snap current position to a frame without triggering spring physics.
+     * Zeroes velocities so the spring starts from rest at this position.
+     *
+     * Used by A2EProcessor to seed the smoother when entering gap decay —
+     * positions the spring at the last real inference frame before decaying
+     * toward neutral.
+     */
+    setPosition(frame: Float32Array): void;
     /**
      * Advance all 52 springs by `dt` seconds and return the smoothed frame.
      *

package/dist/index.d.ts

@@ -2517,12 +2517,6 @@ interface A2EProcessorConfig {
      * different expression intensity across face regions (brows, eyes, cheeks).
      */
     identityIndex?: number;
-    /**
-     * Spring halflife for blendshape smoothing (seconds).
-     * - 0.06 (default): Sweet spot for lip sync
-     * - 0: Bypass (raw frames, no smoothing)
-     */
-    smoothingHalflife?: number;
     /** Callback fired with each blendshape frame (push mode) */
     onFrame?: (frame: Float32Array) => void;
     /** Error callback */
@@ -2544,11 +2538,12 @@ declare class A2EProcessor {
     private plainQueue;
     private _latestFrame;
     private dripInterval;
-    private smoother;
+    private lastPulledFrame;
     private lastDequeuedTime;
-    private lastUpdateTime;
-    private neutralTriggered;
-    private outputBuffer;
+    private decayBuffer;
+    private smoother;
+    private gapDecayStarted;
+    private lastSmootherUpdate;
     private inferenceRunning;
     private pendingChunks;
     private getFrameCallCount;
@@ -2668,6 +2663,15 @@ declare class BlendshapeSmoother {
      * Springs will converge toward these values on subsequent update() calls.
      */
     setTarget(frame: Float32Array): void;
+    /**
+     * Snap current position to a frame without triggering spring physics.
+     * Zeroes velocities so the spring starts from rest at this position.
+     *
+     * Used by A2EProcessor to seed the smoother when entering gap decay —
+     * positions the spring at the last real inference frame before decaying
+     * toward neutral.
+     */
+    setPosition(frame: Float32Array): void;
     /**
      * Advance all 52 springs by `dt` seconds and return the smoothed frame.
      *

package/dist/index.js

@@ -1710,6 +1710,19 @@ var BlendshapeSmoother = class {
     this.targets.set(frame);
     this._hasTarget = true;
   }
+  /**
+   * Snap current position to a frame without triggering spring physics.
+   * Zeroes velocities so the spring starts from rest at this position.
+   *
+   * Used by A2EProcessor to seed the smoother when entering gap decay —
+   * positions the spring at the last real inference frame before decaying
+   * toward neutral.
+   */
+  setPosition(frame) {
+    this.values.set(frame);
+    this.velocities.fill(0);
+    this._hasTarget = true;
+  }
   /**
    * Advance all 52 springs by `dt` seconds and return the smoothed frame.
    *
@@ -1765,7 +1778,8 @@ var BlendshapeSmoother = class {
 var logger4 = createLogger("A2EProcessor");
 var FRAME_RATE = 30;
 var DRIP_INTERVAL_MS = 33;
-var NEUTRAL_THRESHOLD_MS = 1500;
+var HOLD_DURATION_MS = 400;
+var GAP_DECAY_HALFLIFE_S = 0.08;
 var _A2EProcessor = class _A2EProcessor {
   constructor(config) {
     this.writeOffset = 0;
@@ -1776,10 +1790,12 @@ var _A2EProcessor = class _A2EProcessor {
     // Push mode state
     this._latestFrame = null;
     this.dripInterval = null;
+    // Last-frame-hold for pull mode (prevents avatar freezing between frames)
+    this.lastPulledFrame = null;
     this.lastDequeuedTime = 0;
-    this.lastUpdateTime = 0;
-    this.neutralTriggered = false;
-    this.outputBuffer = null;
+    this.decayBuffer = null;
+    this.gapDecayStarted = false;
+    this.lastSmootherUpdate = 0;
     // Inference serialization
     this.inferenceRunning = false;
     this.pendingChunks = [];
@@ -1792,9 +1808,9 @@ var _A2EProcessor = class _A2EProcessor {
     this.identityIndex = config.identityIndex ?? 0;
     this.onFrame = config.onFrame;
     this.onError = config.onError;
-    this.smoother = new BlendshapeSmoother({ halflife: config.smoothingHalflife ?? 0.06 });
     this.bufferCapacity = this.chunkSize * 2;
     this.buffer = new Float32Array(this.bufferCapacity);
+    this.smoother = new BlendshapeSmoother({ halflife: GAP_DECAY_HALFLIFE_S });
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Audio Input
@@ -1869,18 +1885,19 @@ var _A2EProcessor = class _A2EProcessor {
    */
   async flush() {
     if (this.disposed || this.writeOffset === 0) return;
+    const actualSamples = this.writeOffset;
     const padded = new Float32Array(this.chunkSize);
-    padded.set(this.buffer.subarray(0, this.writeOffset), 0);
+    padded.set(this.buffer.subarray(0, actualSamples), 0);
     const chunkTimestamp = this.bufferStartTime > 0 ? this.bufferStartTime : void 0;
     logger4.info("flush: routing through drain pipeline", {
-      actualSamples: this.writeOffset,
+      actualSamples,
       chunkTimestamp: chunkTimestamp?.toFixed(3),
       pendingChunks: this.pendingChunks.length,
       inferenceRunning: this.inferenceRunning
     });
     this.writeOffset = 0;
     this.bufferStartTime = 0;
-    this.pendingChunks.push({ chunk: padded, timestamp: chunkTimestamp });
+    this.pendingChunks.push({ chunk: padded, timestamp: chunkTimestamp, actualSamples });
     this.drainPendingChunks();
   }
   /**
@@ -1892,14 +1909,14 @@ var _A2EProcessor = class _A2EProcessor {
     this.timestampedQueue = [];
     this.plainQueue = [];
     this._latestFrame = null;
-    this.smoother.reset();
+    this.lastPulledFrame = null;
     this.lastDequeuedTime = 0;
-    this.lastUpdateTime = 0;
-    this.neutralTriggered = false;
-    this.outputBuffer = null;
     this.pendingChunks = [];
     this.inferenceRunning = false;
     this.getFrameCallCount = 0;
+    this.smoother.reset();
+    this.gapDecayStarted = false;
+    this.lastSmootherUpdate = 0;
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Frame Output — Pull Mode (TTS playback)
@@ -1915,7 +1932,6 @@ var _A2EProcessor = class _A2EProcessor {
    */
   getFrameForTime(currentTime) {
     this.getFrameCallCount++;
-    const now = getClock().now();
     const discardWindow = this.backend.backend === "wasm" ? 1.5 : 0.5;
     let discardCount = 0;
     while (this.timestampedQueue.length > 0 && this.timestampedQueue[0].timestamp < currentTime - discardWindow) {
@@ -1931,20 +1947,14 @@ var _A2EProcessor = class _A2EProcessor {
         nextFrameTs: this.timestampedQueue.length > 0 ? this.timestampedQueue[0].timestamp.toFixed(3) : "none"
       });
     }
-    let newDequeue = false;
     if (this.timestampedQueue.length > 0 && this.timestampedQueue[0].timestamp <= currentTime) {
       const { frame } = this.timestampedQueue.shift();
-      const firstTarget = !this.smoother.hasTarget;
-      this.smoother.setTarget(frame);
-      if (firstTarget) {
-        this.smoother.update(1);
-        this.lastUpdateTime = now;
-      }
-      newDequeue = true;
-      this.neutralTriggered = false;
-      this.lastDequeuedTime = now;
+      this.lastPulledFrame = frame;
+      this.lastDequeuedTime = getClock().now();
+      this.gapDecayStarted = false;
+      return frame;
     }
-    if (!newDequeue && this.timestampedQueue.length > 0 && this.getFrameCallCount % 60 === 0) {
+    if (this.timestampedQueue.length > 0 && this.getFrameCallCount % 60 === 0) {
       logger4.debug("getFrameForTime: waiting for playback time to reach queued frames", {
         queueLen: this.timestampedQueue.length,
         frontTimestamp: this.timestampedQueue[0].timestamp.toFixed(4),
@@ -1952,24 +1962,34 @@ var _A2EProcessor = class _A2EProcessor {
         delta: (this.timestampedQueue[0].timestamp - currentTime).toFixed(4)
       });
     }
-    if (!newDequeue && this.smoother.hasTarget && !this.neutralTriggered) {
+    if (this.lastPulledFrame) {
+      const now = getClock().now();
       const elapsed = now - this.lastDequeuedTime;
-      if (elapsed >= NEUTRAL_THRESHOLD_MS) {
+      if (elapsed < HOLD_DURATION_MS) {
+        return this.lastPulledFrame;
+      }
+      if (!this.gapDecayStarted) {
+        this.smoother.setPosition(this.lastPulledFrame);
         this.smoother.decayToNeutral();
-        this.neutralTriggered = true;
+        this.gapDecayStarted = true;
+        this.lastSmootherUpdate = now;
       }
+      const dt = Math.min((now - this.lastSmootherUpdate) / 1e3, 0.1);
+      this.lastSmootherUpdate = now;
+      const smoothed = this.smoother.update(dt);
+      let maxVal = 0;
+      for (let i = 0; i < 52; i++) {
+        if (smoothed[i] > maxVal) maxVal = smoothed[i];
+      }
+      if (maxVal < 1e-3) {
+        this.lastPulledFrame = null;
+        return null;
+      }
+      if (!this.decayBuffer) this.decayBuffer = new Float32Array(52);
+      this.decayBuffer.set(smoothed);
+      return this.decayBuffer;
     }
-    if (!this.smoother.hasTarget) {
-      return null;
-    }
-    const dt = Math.min((now - this.lastUpdateTime) / 1e3, 0.1);
-    const smoothed = this.smoother.update(dt);
-    this.lastUpdateTime = now;
-    if (newDequeue || !this.outputBuffer) {
-      this.outputBuffer = new Float32Array(52);
-    }
-    this.outputBuffer.set(smoothed);
-    return this.outputBuffer;
+    return null;
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Frame Output — Push Mode (live mic, game loop)
@@ -2035,14 +2055,15 @@ var _A2EProcessor = class _A2EProcessor {
     logger4.info("drainPendingChunks starting", { pendingChunks: this.pendingChunks.length });
     const processNext = async () => {
       while (this.pendingChunks.length > 0 && !this.disposed) {
-        const { chunk, timestamp } = this.pendingChunks.shift();
+        const { chunk, timestamp, actualSamples } = this.pendingChunks.shift();
         try {
           const t0 = getClock().now();
           const result = await this.backend.infer(chunk, this.identityIndex);
           const inferMs = Math.round(getClock().now() - t0);
-          const actualDuration = chunk.length / this.sampleRate;
+          const effectiveSamples = actualSamples ?? chunk.length;
+          const actualDuration = effectiveSamples / this.sampleRate;
           const actualFrameCount = Math.ceil(actualDuration * FRAME_RATE);
-          const framesToQueue = Math.min(actualFrameCount, result.blendshapes.length);
+          const framesToQueue = Math.min(Math.max(1, actualFrameCount), result.blendshapes.length);
           logger4.info("Inference complete", {
             inferMs,
             modelFrames: result.blendshapes.length,