@omote/core 0.9.5 → 0.9.7

package/dist/index.mjs

@@ -806,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();
   }
   /**
@@ -975,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,
@@ -1235,7 +1237,7 @@ function applyProfile(raw, profile, out) {
 
 // src/audio/PlaybackPipeline.ts
 var logger5 = createLogger("PlaybackPipeline");
-var PlaybackPipeline = class extends EventEmitter {
+var _PlaybackPipeline = class _PlaybackPipeline extends EventEmitter {
   constructor(config) {
     super();
     this.config = config;
@@ -1254,6 +1256,10 @@ var PlaybackPipeline = class extends EventEmitter {
     this.neutralTransitionFrame = null;
     this.neutralTransitionStart = 0;
     this.neutralAnimationId = null;
+    this.rampInActive = false;
+    this.rampInLastTime = 0;
+    this.rampInStartTime = 0;
+    this._rampInBuffer = new Float32Array(52);
     // Current frame refs
     this._currentFrame = null;
     this._currentRawFrame = null;
@@ -1280,6 +1286,7 @@ var PlaybackPipeline = class extends EventEmitter {
       modelId: config.lam.modelId,
       neutralTransitionEnabled: this.neutralTransitionEnabled
     });
+    this.rampInSmoother = new BlendshapeSmoother({ halflife: _PlaybackPipeline.RAMP_IN_HALFLIFE });
     this.scheduler = new AudioScheduler({
       sampleRate: this.sampleRate,
       initialLookaheadSec: audioDelayMs / 1e3
@@ -1347,6 +1354,10 @@ var PlaybackPipeline = class extends EventEmitter {
     this.frameLoopCount = 0;
     this._currentFrame = null;
     this._currentRawFrame = null;
+    this.rampInSmoother.reset();
+    this.rampInActive = true;
+    this.rampInLastTime = 0;
+    this.rampInStartTime = 0;
     this.cancelNeutralTransition();
     this.scheduler.warmup();
     this.sessionStartTime = getClock().now();
@@ -1483,17 +1494,36 @@ var PlaybackPipeline = class extends EventEmitter {
         }
       }
       if (lamFrame) {
-        const scaled = applyProfile(lamFrame, this.profile, this._profileBuffer);
+        let effectiveFrame = lamFrame;
+        if (this.rampInActive) {
+          const now = getClock().now();
+          if (this.rampInLastTime === 0) {
+            this.rampInStartTime = now;
+            this.rampInLastTime = now;
+          }
+          this.rampInSmoother.setTarget(lamFrame);
+          const dt = (now - this.rampInLastTime) / 1e3;
+          this.rampInLastTime = now;
+          if (dt > 0) {
+            const smoothed = this.rampInSmoother.update(dt);
+            this._rampInBuffer.set(smoothed);
+            effectiveFrame = this._rampInBuffer;
+          }
+          if (now - this.rampInStartTime > _PlaybackPipeline.RAMP_IN_DURATION_MS) {
+            this.rampInActive = false;
+          }
+        }
+        const scaled = applyProfile(effectiveFrame, this.profile, this._profileBuffer);
         this._currentFrame = scaled;
-        this._currentRawFrame = lamFrame;
+        this._currentRawFrame = effectiveFrame;
         const fullFrame = {
           blendshapes: scaled,
-          rawBlendshapes: lamFrame,
+          rawBlendshapes: effectiveFrame,
           timestamp: currentTime,
           emotion: this._emotion ?? void 0
         };
         this.emit("frame", fullFrame);
-        this.emit("frame:raw", lamFrame);
+        this.emit("frame:raw", effectiveFrame);
       }
       this.frameAnimationId = requestAnimationFrame(updateFrame);
     };
@@ -1593,6 +1623,11 @@ var PlaybackPipeline = class extends EventEmitter {
     this.emit("state", state);
   }
 };
+// Ramp-in smoother: smooths neutral → first inference frame at start-of-speech
+_PlaybackPipeline.RAMP_IN_HALFLIFE = 0.05;
+// 50ms — snappy but smooth
+_PlaybackPipeline.RAMP_IN_DURATION_MS = 150;
+var PlaybackPipeline = _PlaybackPipeline;
 
 // src/audio/TTSPlayback.ts
 var logger6 = createLogger("TTSPlayback");