@omote/core 0.9.3 → 0.9.5

package/dist/index.d.mts

@@ -2541,6 +2541,9 @@ declare class A2EProcessor {
     private lastPulledFrame;
     private lastDequeuedTime;
     private decayBuffer;
+    private smoother;
+    private gapDecayStarted;
+    private lastSmootherUpdate;
     private inferenceRunning;
     private pendingChunks;
     private getFrameCallCount;
@@ -2660,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

@@ -2541,6 +2541,9 @@ declare class A2EProcessor {
     private lastPulledFrame;
     private lastDequeuedTime;
     private decayBuffer;
+    private smoother;
+    private gapDecayStarted;
+    private lastSmootherUpdate;
     private inferenceRunning;
     private pendingChunks;
     private getFrameCallCount;
@@ -2660,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

@@ -1687,12 +1687,99 @@ var AudioChunkCoalescer = class {
   }
 };
 
+// src/inference/BlendshapeSmoother.ts
+var NUM_BLENDSHAPES = 52;
+var BlendshapeSmoother = class {
+  constructor(config) {
+    /** Whether any target has been set */
+    this._hasTarget = false;
+    this.halflife = config?.halflife ?? 0.06;
+    this.values = new Float32Array(NUM_BLENDSHAPES);
+    this.velocities = new Float32Array(NUM_BLENDSHAPES);
+    this.targets = new Float32Array(NUM_BLENDSHAPES);
+  }
+  /** Whether a target frame has been set (false until first setTarget call) */
+  get hasTarget() {
+    return this._hasTarget;
+  }
+  /**
+   * Set new target frame from inference output.
+   * Springs will converge toward these values on subsequent update() calls.
+   */
+  setTarget(frame) {
+    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.
+   *
+   * Call this every render frame (e.g., inside requestAnimationFrame).
+   * Returns the internal values buffer — do NOT mutate the returned array.
+   *
+   * @param dt - Time step in seconds (e.g., 1/60 for 60fps)
+   * @returns Smoothed blendshape values (Float32Array of 52)
+   */
+  update(dt) {
+    if (!this._hasTarget) {
+      return this.values;
+    }
+    if (this.halflife <= 0) {
+      this.values.set(this.targets);
+      this.velocities.fill(0);
+      return this.values;
+    }
+    const damping = Math.LN2 / this.halflife;
+    const eydt = Math.exp(-damping * dt);
+    for (let i = 0; i < NUM_BLENDSHAPES; i++) {
+      const j0 = this.values[i] - this.targets[i];
+      const j1 = this.velocities[i] + j0 * damping;
+      this.values[i] = eydt * (j0 + j1 * dt) + this.targets[i];
+      this.velocities[i] = eydt * (this.velocities[i] - j1 * damping * dt);
+      this.values[i] = Math.max(0, Math.min(1, this.values[i]));
+    }
+    return this.values;
+  }
+  /**
+   * Decay all spring targets to neutral (0).
+   *
+   * Call when inference stalls (no new frames for threshold duration).
+   * The springs will smoothly close the mouth / relax the face over
+   * the halflife period rather than freezing.
+   */
+  decayToNeutral() {
+    this.targets.fill(0);
+  }
+  /**
+   * Reset all state (values, velocities, targets).
+   * Call when starting a new playback session.
+   */
+  reset() {
+    this.values.fill(0);
+    this.velocities.fill(0);
+    this.targets.fill(0);
+    this._hasTarget = false;
+  }
+};
+
 // src/inference/A2EProcessor.ts
 var logger4 = createLogger("A2EProcessor");
 var FRAME_RATE = 30;
 var DRIP_INTERVAL_MS = 33;
 var HOLD_DURATION_MS = 400;
-var DECAY_DURATION_MS = 300;
+var GAP_DECAY_HALFLIFE_S = 0.08;
 var _A2EProcessor = class _A2EProcessor {
   constructor(config) {
     this.writeOffset = 0;
@@ -1707,6 +1794,8 @@ var _A2EProcessor = class _A2EProcessor {
     this.lastPulledFrame = null;
     this.lastDequeuedTime = 0;
     this.decayBuffer = null;
+    this.gapDecayStarted = false;
+    this.lastSmootherUpdate = 0;
     // Inference serialization
     this.inferenceRunning = false;
     this.pendingChunks = [];
@@ -1721,6 +1810,7 @@ var _A2EProcessor = class _A2EProcessor {
     this.onError = config.onError;
     this.bufferCapacity = this.chunkSize * 2;
     this.buffer = new Float32Array(this.bufferCapacity);
+    this.smoother = new BlendshapeSmoother({ halflife: GAP_DECAY_HALFLIFE_S });
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Audio Input
@@ -1823,6 +1913,9 @@ var _A2EProcessor = class _A2EProcessor {
     this.pendingChunks = [];
     this.inferenceRunning = false;
     this.getFrameCallCount = 0;
+    this.smoother.reset();
+    this.gapDecayStarted = false;
+    this.lastSmootherUpdate = 0;
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Frame Output — Pull Mode (TTS playback)
@@ -1857,6 +1950,7 @@ var _A2EProcessor = class _A2EProcessor {
       const { frame } = this.timestampedQueue.shift();
       this.lastPulledFrame = frame;
       this.lastDequeuedTime = getClock().now();
+      this.gapDecayStarted = false;
       return frame;
     }
     if (this.timestampedQueue.length > 0 && this.getFrameCallCount % 60 === 0) {
@@ -1868,21 +1962,30 @@ var _A2EProcessor = class _A2EProcessor {
       });
     }
     if (this.lastPulledFrame) {
-      const elapsed = getClock().now() - this.lastDequeuedTime;
+      const now = getClock().now();
+      const elapsed = now - this.lastDequeuedTime;
       if (elapsed < HOLD_DURATION_MS) {
         return this.lastPulledFrame;
       }
-      const decayElapsed = elapsed - HOLD_DURATION_MS;
-      if (decayElapsed >= DECAY_DURATION_MS) {
+      if (!this.gapDecayStarted) {
+        this.smoother.setPosition(this.lastPulledFrame);
+        this.smoother.decayToNeutral();
+        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;
       }
-      const t = decayElapsed / DECAY_DURATION_MS;
-      const factor = (1 - t) * (1 - t);
       if (!this.decayBuffer) this.decayBuffer = new Float32Array(52);
-      for (let i = 0; i < 52; i++) {
-        this.decayBuffer[i] = this.lastPulledFrame[i] * factor;
-      }
+      this.decayBuffer.set(smoothed);
       return this.decayBuffer;
     }
     return null;
@@ -11216,80 +11319,6 @@ var InterruptionHandler = class extends EventEmitter {
   }
 };
 
-// src/inference/BlendshapeSmoother.ts
-var NUM_BLENDSHAPES = 52;
-var BlendshapeSmoother = class {
-  constructor(config) {
-    /** Whether any target has been set */
-    this._hasTarget = false;
-    this.halflife = config?.halflife ?? 0.06;
-    this.values = new Float32Array(NUM_BLENDSHAPES);
-    this.velocities = new Float32Array(NUM_BLENDSHAPES);
-    this.targets = new Float32Array(NUM_BLENDSHAPES);
-  }
-  /** Whether a target frame has been set (false until first setTarget call) */
-  get hasTarget() {
-    return this._hasTarget;
-  }
-  /**
-   * Set new target frame from inference output.
-   * Springs will converge toward these values on subsequent update() calls.
-   */
-  setTarget(frame) {
-    this.targets.set(frame);
-    this._hasTarget = true;
-  }
-  /**
-   * Advance all 52 springs by `dt` seconds and return the smoothed frame.
-   *
-   * Call this every render frame (e.g., inside requestAnimationFrame).
-   * Returns the internal values buffer — do NOT mutate the returned array.
-   *
-   * @param dt - Time step in seconds (e.g., 1/60 for 60fps)
-   * @returns Smoothed blendshape values (Float32Array of 52)
-   */
-  update(dt) {
-    if (!this._hasTarget) {
-      return this.values;
-    }
-    if (this.halflife <= 0) {
-      this.values.set(this.targets);
-      this.velocities.fill(0);
-      return this.values;
-    }
-    const damping = Math.LN2 / this.halflife;
-    const eydt = Math.exp(-damping * dt);
-    for (let i = 0; i < NUM_BLENDSHAPES; i++) {
-      const j0 = this.values[i] - this.targets[i];
-      const j1 = this.velocities[i] + j0 * damping;
-      this.values[i] = eydt * (j0 + j1 * dt) + this.targets[i];
-      this.velocities[i] = eydt * (this.velocities[i] - j1 * damping * dt);
-      this.values[i] = Math.max(0, Math.min(1, this.values[i]));
-    }
-    return this.values;
-  }
-  /**
-   * Decay all spring targets to neutral (0).
-   *
-   * Call when inference stalls (no new frames for threshold duration).
-   * The springs will smoothly close the mouth / relax the face over
-   * the halflife period rather than freezing.
-   */
-  decayToNeutral() {
-    this.targets.fill(0);
-  }
-  /**
-   * Reset all state (values, velocities, targets).
-   * Call when starting a new playback session.
-   */
-  reset() {
-    this.values.fill(0);
-    this.velocities.fill(0);
-    this.targets.fill(0);
-    this._hasTarget = false;
-  }
-};
-
 // src/inference/SafariSpeechRecognition.ts
 var logger33 = createLogger("SafariSpeech");
 var SafariSpeechRecognition = class _SafariSpeechRecognition {