@omote/core 0.9.4 → 0.9.6

package/dist/index.mjs

@@ -631,6 +631,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.
    *
@@ -686,7 +699,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;
@@ -697,10 +711,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 = [];
@@ -713,9 +729,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
@@ -790,18 +806,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();
   }
   /**
@@ -813,14 +830,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)
@@ -836,7 +853,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) {
@@ -852,20 +868,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),
@@ -873,24 +883,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)
@@ -956,14 +976,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,