@vortexm/vjt 0.1.14 → 0.1.15

package/dist/index.js

@@ -5869,8 +5869,9 @@ var MAX_RECORDING_MS = 10 * 60 * 1e3;
 var MAX_LISTENING_SILENCE_MS = 60 * 60 * 1e3;
 var SILENCE_STOP_MS = 2e3;
 var DEFAULT_SPEECH_THRESHOLD = 0.035;
-var LISTENING_PRE_ROLL_MS = 300;
-var LISTENING_RECORDER_TIMESLICE_MS = 100;
+var LISTENING_TARGET_PRE_ROLL_MS = 300;
+var LISTENING_SEGMENT_MS = 1e3;
+var LISTENING_SEGMENT_STEP_MS = 500;
 var RECORDING_MIME_CANDIDATES = [
   "audio/webm;codecs=opus",
   "audio/webm",
@@ -5951,10 +5952,10 @@ var VoiceRuntime = class {
   listenAnalyser = null;
   listenSource = null;
   listenFrameId = null;
-  listeningRecorder = null;
-  listeningRecorderMimeType = "audio/webm";
-  listeningPreRollChunks = [];
-  listeningCaptureChunks = [];
+  listeningIdleSessions = [];
+  listeningLaneTimeoutIds = [];
+  listeningLaneIntervalIds = [];
+  listeningPromotedSession = null;
   listeningCaptureActive = false;
   lastSpeechAt = 0;
   listeningStartedAt = 0;
@@ -6076,14 +6077,16 @@ var VoiceRuntime = class {
       analyser.fftSize = 2048;
       const source = context.createMediaStreamSource(stream);
       source.connect(analyser);
-      this.startListeningRecorder(stream);
       this.listening = true;
       this.listenContext = context;
       this.listenAnalyser = analyser;
       this.listenSource = source;
+      this.listeningIdleSessions = [];
+      this.listeningPromotedSession = null;
       this.lastSpeechAt = 0;
       this.listeningStartedAt = performance.now();
       this.speechEventTriggered = false;
+      this.startListeningRecorderSchedule(stream);
       const sampleBuffer = new Uint8Array(analyser.fftSize);
       const step = async () => {
         if (!this.listening || !this.listenAnalyser) {
@@ -6147,9 +6150,8 @@ var VoiceRuntime = class {
     if (this.listeningCaptureActive) {
       await this.stopListeningCapture();
     }
-    this.stopListeningRecorder();
-    this.listeningPreRollChunks = [];
-    this.listeningCaptureChunks = [];
+    this.clearListeningRecorderSchedule();
+    await this.discardListeningIdleSessions();
     this.listeningCaptureActive = false;
     this.recordingStartedFromListening = false;
     this.releaseInputStreamIfIdle();
@@ -6231,7 +6233,6 @@ var VoiceRuntime = class {
   async handleRecordingError(error) {
     logRuntimeError("voice.recording", error);
     this.listeningCaptureActive = false;
-    this.listeningCaptureChunks = [];
     this.recordingStartedFromListening = false;
     await this.triggerSystemEvent("onRecordingError", this.normalizeErrorMessage(error));
   }
@@ -6277,89 +6278,194 @@ var VoiceRuntime = class {
     this.mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
     return this.mediaStream;
   }
-  startListeningRecorder(stream) {
-    if (this.listeningRecorder && this.listeningRecorder.state !== "inactive") {
-      return;
+  startListeningRecorderSchedule(stream) {
+    this.clearListeningRecorderSchedule();
+    this.launchListeningRecorder(stream);
+    const delayedStart = window.setTimeout(() => {
+      if (!this.listening || this.listeningCaptureActive) {
+        return;
+      }
+      this.launchListeningRecorder(stream);
+      const laneB = window.setInterval(() => {
+        if (!this.listening || this.listeningCaptureActive) {
+          return;
+        }
+        this.launchListeningRecorder(stream);
+      }, LISTENING_SEGMENT_MS);
+      this.listeningLaneIntervalIds.push(laneB);
+    }, LISTENING_SEGMENT_STEP_MS);
+    this.listeningLaneTimeoutIds.push(delayedStart);
+    const laneA = window.setInterval(() => {
+      if (!this.listening || this.listeningCaptureActive) {
+        return;
+      }
+      this.launchListeningRecorder(stream);
+    }, LISTENING_SEGMENT_MS);
+    this.listeningLaneIntervalIds.push(laneA);
+  }
+  clearListeningRecorderSchedule() {
+    for (const timeoutId of this.listeningLaneTimeoutIds) {
+      window.clearTimeout(timeoutId);
+    }
+    this.listeningLaneTimeoutIds = [];
+    for (const intervalId of this.listeningLaneIntervalIds) {
+      window.clearInterval(intervalId);
     }
+    this.listeningLaneIntervalIds = [];
+  }
+  launchListeningRecorder(stream) {
+    const session = this.createListeningRecorderSession(stream);
+    this.listeningIdleSessions.push(session);
+    session.recorder.start();
+    session.stopTimeoutId = window.setTimeout(() => {
+      if (!session.promoted && session.recorder.state !== "inactive") {
+        session.recorder.stop();
+      }
+    }, LISTENING_SEGMENT_MS);
+  }
+  createListeningRecorderSession(stream) {
     if (typeof MediaRecorder === "undefined") {
       throw new Error("MediaRecorder is not supported in this browser");
     }
     const preferredMimeType = this.getPreferredRecordingMimeType();
     const options = preferredMimeType ? { mimeType: preferredMimeType } : void 0;
     const recorder = options ? new MediaRecorder(stream, options) : new MediaRecorder(stream);
-    this.listeningRecorder = recorder;
-    this.listeningRecorderMimeType = recorder.mimeType || preferredMimeType || "audio/webm";
-    this.listeningPreRollChunks = [];
-    this.listeningCaptureChunks = [];
+    let resolveStopped = () => {
+    };
+    const stopped = new Promise((resolve) => {
+      resolveStopped = resolve;
+    });
+    const session = {
+      recorder,
+      mimeType: recorder.mimeType || preferredMimeType || "audio/webm",
+      startedAt: performance.now(),
+      chunks: [],
+      stopTimeoutId: null,
+      promoted: false,
+      discard: false,
+      stopped,
+      resolveStopped
+    };
     recorder.ondataavailable = (event) => {
-      if (!event.data || event.data.size === 0) {
-        return;
-      }
-      const timestamp = performance.now();
-      if (this.listeningCaptureActive) {
-        this.listeningCaptureChunks.push(event.data);
-        return;
-      }
-      this.listeningPreRollChunks.push({ data: event.data, timestamp });
-      const cutoff = timestamp - LISTENING_PRE_ROLL_MS;
-      while (this.listeningPreRollChunks.length > 0 && this.listeningPreRollChunks[0].timestamp < cutoff) {
-        this.listeningPreRollChunks.shift();
+      if (event.data && event.data.size > 0) {
+        session.chunks.push(event.data);
       }
     };
     recorder.onerror = (event) => {
-      void this.handleRecordingError(event.error ?? new Error("Unknown listening recorder error"));
+      void this.handleRecordingError(event.error ?? new Error("Unknown listening recording error"));
     };
-    recorder.start(LISTENING_RECORDER_TIMESLICE_MS);
+    recorder.onstop = () => {
+      void this.handleListeningRecorderStop(session);
+    };
+    return session;
   }
-  stopListeningRecorder() {
-    if (!this.listeningRecorder) {
+  beginListeningCapture() {
+    const winner = this.selectListeningRecorderWinner();
+    if (!winner) {
       return;
     }
-    const recorder = this.listeningRecorder;
-    this.listeningRecorder = null;
-    recorder.ondataavailable = null;
-    recorder.onerror = null;
-    if (recorder.state !== "inactive") {
-      recorder.stop();
-    }
-  }
-  beginListeningCapture() {
     this.listeningCaptureActive = true;
     this.recordingStartedFromListening = true;
-    this.listeningCaptureChunks = this.listeningPreRollChunks.map((chunk) => chunk.data);
-    this.listeningPreRollChunks = [];
+    this.listeningPromotedSession = winner;
+    winner.promoted = true;
+    winner.discard = false;
+    if (winner.stopTimeoutId !== null) {
+      window.clearTimeout(winner.stopTimeoutId);
+      winner.stopTimeoutId = null;
+    }
+    this.clearListeningRecorderSchedule();
+    for (const session of this.listeningIdleSessions) {
+      if (session === winner) {
+        continue;
+      }
+      void this.discardListeningSession(session);
+    }
+    const preRollMs = Math.max(0, Math.round(performance.now() - winner.startedAt));
     logRuntimeDebug(this.debugLogging, "voice-recording-started", {
-      mimeType: this.listeningRecorderMimeType,
+      mimeType: winner.mimeType,
       fromListening: true,
-      preRollMs: LISTENING_PRE_ROLL_MS,
-      preRollChunks: this.listeningCaptureChunks.length
+      preRollMs
     });
     void this.triggerSystemEvent("onRecordingStarted", null);
   }
+  selectListeningRecorderWinner() {
+    const activeSessions = this.listeningIdleSessions.filter((session) => session.recorder.state !== "inactive");
+    if (activeSessions.length === 0) {
+      return null;
+    }
+    const targetStartedAt = performance.now() - LISTENING_TARGET_PRE_ROLL_MS;
+    const suitable = activeSessions.filter((session) => session.startedAt <= targetStartedAt).sort((left, right) => right.startedAt - left.startedAt);
+    if (suitable.length > 0) {
+      return suitable[0];
+    }
+    return activeSessions.sort((left, right) => left.startedAt - right.startedAt)[0] ?? null;
+  }
   async stopListeningCapture() {
-    if (!this.listeningCaptureActive) {
+    if (!this.listeningCaptureActive || !this.listeningPromotedSession) {
       return;
     }
+    const session = this.listeningPromotedSession;
     this.listeningCaptureActive = false;
-    const chunks = [...this.listeningCaptureChunks];
-    this.listeningCaptureChunks = [];
+    this.listeningPromotedSession = null;
+    if (session.recorder.state !== "inactive") {
+      session.recorder.stop();
+    }
+    await session.stopped;
+  }
+  async discardListeningSession(session) {
+    session.discard = true;
+    if (session.stopTimeoutId !== null) {
+      window.clearTimeout(session.stopTimeoutId);
+      session.stopTimeoutId = null;
+    }
+    if (session.recorder.state !== "inactive") {
+      session.recorder.stop();
+    }
+    await session.stopped;
+  }
+  async discardListeningIdleSessions() {
+    const sessions = [...this.listeningIdleSessions];
+    for (const session of sessions) {
+      if (session === this.listeningPromotedSession) {
+        continue;
+      }
+      await this.discardListeningSession(session);
+    }
+    this.listeningIdleSessions = this.listeningPromotedSession ? [this.listeningPromotedSession] : [];
+  }
+  async handleListeningRecorderStop(session) {
+    if (session.stopTimeoutId !== null) {
+      window.clearTimeout(session.stopTimeoutId);
+      session.stopTimeoutId = null;
+    }
+    this.listeningIdleSessions = this.listeningIdleSessions.filter((entry) => entry !== session);
     try {
-      const blob = new Blob(chunks, { type: this.listeningRecorderMimeType });
+      if (session.discard || !session.promoted) {
+        return;
+      }
+      const blob = new Blob(session.chunks, { type: session.mimeType });
       const audioData = await blobToBase64(blob);
       logRuntimeDebug(this.debugLogging, "voice-recording-stopped", {
-        mimeType: this.listeningRecorderMimeType,
+        mimeType: session.mimeType,
         size: blob.size,
-        fromListening: true,
-        preRollMs: LISTENING_PRE_ROLL_MS
+        fromListening: true
       });
       await this.triggerSystemEvent("onRecordingStopped", {
         audioData,
-        mimeType: this.listeningRecorderMimeType
+        mimeType: session.mimeType
       });
     } catch (error) {
       await this.handleRecordingError(error);
     } finally {
-      this.recordingStartedFromListening = false;
+      session.resolveStopped();
+      if (session.promoted) {
+        this.recordingStartedFromListening = false;
+        if (this.listening && this.mediaStream?.active) {
+          this.listeningStartedAt = performance.now();
+          this.speechEventTriggered = false;
+          this.startListeningRecorderSchedule(this.mediaStream);
+        }
+      }
     }
   }
   clearRecordingTimeout() {
@@ -6372,9 +6478,6 @@ var VoiceRuntime = class {
     if (this.listening) {
       return;
     }
-    if (this.listeningRecorder && this.listeningRecorder.state !== "inactive") {
-      return;
-    }
     if (this.mediaRecorder && this.mediaRecorder.state !== "inactive") {
       return;
     }

package/dist/lib/voice-runtime.d.ts

@@ -16,10 +16,10 @@ export declare class VoiceRuntime {
     private listenAnalyser;
     private listenSource;
     private listenFrameId;
-    private listeningRecorder;
-    private listeningRecorderMimeType;
-    private listeningPreRollChunks;
-    private listeningCaptureChunks;
+    private listeningIdleSessions;
+    private listeningLaneTimeoutIds;
+    private listeningLaneIntervalIds;
+    private listeningPromotedSession;
     private listeningCaptureActive;
     private lastSpeechAt;
     private listeningStartedAt;
@@ -44,10 +44,16 @@ export declare class VoiceRuntime {
     private normalizePlayablePayload;
     private getPreferredRecordingMimeType;
     private ensureInputStream;
-    private startListeningRecorder;
-    private stopListeningRecorder;
+    private startListeningRecorderSchedule;
+    private clearListeningRecorderSchedule;
+    private launchListeningRecorder;
+    private createListeningRecorderSession;
     private beginListeningCapture;
+    private selectListeningRecorderWinner;
     private stopListeningCapture;
+    private discardListeningSession;
+    private discardListeningIdleSessions;
+    private handleListeningRecorderStop;
     private clearRecordingTimeout;
     private releaseInputStreamIfIdle;
     private stopStreamTracks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vortexm/vjt",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",