@omote/core 0.5.2 → 0.5.3

package/dist/index.mjs

@@ -761,80 +761,6 @@ var A2EProcessor = 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;
-  }
-  /**
-   * 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/telemetry/exporters/console.ts
 var ConsoleExporter = class {
   constructor(options = {}) {
@@ -2891,16 +2817,11 @@ var FullFacePipeline = class extends EventEmitter {
     this.lastNewFrameTime = 0;
     this.lastKnownLamFrame = null;
     this.staleWarningEmitted = false;
-    // Frame loop timing (for dt calculation)
-    this.lastFrameLoopTime = 0;
     // Diagnostic logging counter
     this.frameLoopCount = 0;
     const sampleRate = options.sampleRate ?? 16e3;
     this.profile = options.profile ?? {};
     this.staleThresholdMs = options.staleThresholdMs ?? 2e3;
-    this.smoother = new BlendshapeSmoother({
-      halflife: options.smoothingHalflife ?? 0.06
-    });
     const isCpuModel = options.lam.modelId === "wav2arkit_cpu";
     const chunkSize = options.chunkSize ?? options.lam.chunkSize ?? 16e3;
     const chunkAccumulationMs = chunkSize / sampleRate * 1e3;
@@ -2983,9 +2904,7 @@ var FullFacePipeline = class extends EventEmitter {
     this.lastNewFrameTime = 0;
     this.lastKnownLamFrame = null;
     this.staleWarningEmitted = false;
-    this.lastFrameLoopTime = 0;
     this.frameLoopCount = 0;
-    this.smoother.reset();
     this.scheduler.warmup();
     this.startFrameLoop();
     this.startMonitoring();
@@ -3020,22 +2939,16 @@ var FullFacePipeline = class extends EventEmitter {
   /**
    * Start frame animation loop
    *
-   * Uses critically damped spring smoother to produce continuous output
-   * at render rate (60fps), even between inference batches (~30fps bursts).
-   * Springs interpolate toward the latest inference target, and decay
-   * to neutral when inference stalls.
+   * Polls A2EProcessor at render rate (60fps) for the latest inference frame
+   * matching the current AudioContext time. Between inference batches (~30fps
+   * bursts), getFrameForTime() holds the last frame.
    */
   startFrameLoop() {
-    this.lastFrameLoopTime = 0;
     const updateFrame = () => {
-      const now = performance.now() / 1e3;
-      const dt = this.lastFrameLoopTime > 0 ? now - this.lastFrameLoopTime : 1 / 60;
-      this.lastFrameLoopTime = now;
       this.frameLoopCount++;
       const currentTime = this.scheduler.getCurrentTime();
       const lamFrame = this.processor.getFrameForTime(currentTime);
       if (lamFrame && lamFrame !== this.lastKnownLamFrame) {
-        this.smoother.setTarget(lamFrame);
         this.lastNewFrameTime = performance.now();
         this.lastKnownLamFrame = lamFrame;
         this.staleWarningEmitted = false;
@@ -3055,17 +2968,15 @@ var FullFacePipeline = class extends EventEmitter {
           currentTime: currentTime.toFixed(3),
           playbackEndTime: this.scheduler.getPlaybackEndTime().toFixed(3),
           queuedFrames: this.processor.queuedFrameCount,
-          hasTarget: this.smoother.hasTarget,
           playbackStarted: this.playbackStarted,
           msSinceNewFrame: this.lastNewFrameTime > 0 ? Math.round(performance.now() - this.lastNewFrameTime) : -1,
           processorFill: this.processor.fillLevel.toFixed(2)
         });
       }
       if (this.playbackStarted && this.lastNewFrameTime > 0 && performance.now() - this.lastNewFrameTime > this.staleThresholdMs) {
-        this.smoother.decayToNeutral();
         if (!this.staleWarningEmitted) {
           this.staleWarningEmitted = true;
-          logger4.warn("A2E stalled \u2014 decaying to neutral", {
+          logger4.warn("A2E stalled \u2014 no new inference frames", {
             staleDurationMs: Math.round(performance.now() - this.lastNewFrameTime),
             queuedFrames: this.processor.queuedFrameCount
           });
@@ -3104,12 +3015,10 @@ var FullFacePipeline = class extends EventEmitter {
     await this.scheduler.cancelAll(fadeOutMs);
     this.coalescer.reset();
     this.processor.reset();
-    this.smoother.reset();
     this.playbackStarted = false;
     this.lastNewFrameTime = 0;
     this.lastKnownLamFrame = null;
     this.staleWarningEmitted = false;
-    this.lastFrameLoopTime = 0;
     this.emit("playback_complete", void 0);
   }
   /**
@@ -6995,6 +6904,80 @@ var A2EWithFallback = 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;
+  }
+  /**
+   * 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/animation/audioEnergy.ts
 function calculateRMS(samples) {
   if (samples.length === 0) return 0;