@olares/lares-core 0.15.33 → 0.15.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.33",
+  "version": "0.15.34",
   "description": "Lares 共享业务核心：Router、workspace、文件/媒体、Olares 身份（无 UI、无平台壳）",
   "type": "module",
   "repository": {

package/voice/pcm-player.js

@@ -1,6 +1,9 @@
 import { PCM_PLAYER_WORKLET } from "./pcm-worklet.js";
 import { pcmSamples } from "./realtime-audio.js";
 
+/** Unread audio the speaker may be holding. A longer reply waits here; it is not a failed call. */
+export const PLAYBACK_QUEUE_SECONDS = 4;
+
 let primed = null;
 const worklets = new WeakMap();
 let watchingVisibility = false;
@@ -43,7 +46,10 @@ export function primePlaybackContext(Context = globalThis.AudioContext || global
 }
 
 export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () => {}, context: Context = globalThis.AudioContext || globalThis.webkitAudioContext } = {}) {
-  let context, node, resolve, reject, played = 0, generation = 0, pendingByte = null, failed = null, paused = false, owned = false;
+  let context, node, resolve, reject, played = 0, accepted = 0, rate = 0, generation = 0, pendingByte = null, paused = false, owned = false;
+  let tail = Promise.resolve();
+  const waiters = new Set();
+  const wake = () => { for (const listen of [...waiters]) listen(); };
   /**
    * The page shares one primed context. iOS interrupts it (a call, the lock
    * screen) and it never resumes on its own, so a reply that starts after that
@@ -85,11 +91,14 @@ export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () =>
     owned = false;
     if (closing && closing.state !== "closed") void closing.close().catch(() => {});
     context = null; resolve?.(); resolve = reject = null; pendingByte = null;
+    wake();
+    tail = Promise.resolve();
   };
   return {
     async start({ sampleRate, channels, encoding }) {
-      stop(); failed = null; played = 0;
+      stop(); played = 0; accepted = 0;
       if (!Context || channels !== 1 || encoding !== "pcm_s16le" || !Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) throw new Error("voice_audio_format");
+      rate = sampleRate;
       const epoch = generation;
       const shared = primed && primed.state !== "closed" ? primed : null;
       let opened;
@@ -109,27 +118,61 @@ export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () =>
       });
       node.port.onmessage = ({ data }) => {
         if (epoch !== generation) return;
-        if (data.type === "progress") { played = data.frames; onProgress(played); }
+        if (data.type === "progress") { played = data.frames; onProgress(played); wake(); }
         if (data.type === "started" || data.type === "underrun") onMetric({ stage: `playback_${data.type}` });
         if (data.type === "done") { resolve?.(); resolve = reject = null; }
-        if (data.type === "error") { failed = new Error("voice_audio_backpressure"); reject?.(failed); }
       };
       node.connect(opened.destination);
     },
     write(bytes) {
-      if (!node) throw new Error("voice_cancelled");
-      let chunk = bytes;
-      if (pendingByte !== null) { chunk = new Uint8Array(bytes.length + 1); chunk[0] = pendingByte; chunk.set(bytes, 1); pendingByte = null; }
-      if (chunk.length % 2) { pendingByte = chunk[chunk.length - 1]; chunk = chunk.subarray(0, -1); }
-      if (!chunk.length) return;
-      const samples = pcmSamples(chunk);
-      node.port.postMessage({ type: "audio", samples }, [samples.buffer]);
+      const epoch = generation;
+      const run = () => {
+        if (epoch !== generation || !node) throw new Error("voice_cancelled");
+        let chunk = bytes;
+        if (pendingByte !== null) { chunk = new Uint8Array(bytes.length + 1); chunk[0] = pendingByte; chunk.set(bytes, 1); pendingByte = null; }
+        if (chunk.length % 2) { pendingByte = chunk[chunk.length - 1]; chunk = chunk.subarray(0, -1); }
+        if (!chunk.length) return;
+        const source = pcmSamples(chunk);
+        const budget = rate * PLAYBACK_QUEUE_SECONDS;
+        let offset = 0;
+        const post = (from, count) => {
+          const samples = count === source.length && from === 0 ? source : source.slice(from, from + count);
+          accepted += samples.length;
+          node.port.postMessage({ type: "audio", samples }, [samples.buffer]);
+        };
+        const pump = () => {
+          while (offset < source.length) {
+            const room = budget - (accepted - played);
+            if (room <= 0) return false;
+            const count = Math.min(source.length - offset, room);
+            post(offset, count);
+            offset += count;
+          }
+          return true;
+        };
+        if (pump()) return;
+        // The rest of a long reply plays as the speaker catches up.
+        return new Promise((done, fail) => {
+          const listen = () => {
+            if (epoch !== generation || !node) { waiters.delete(listen); fail(new Error("voice_cancelled")); return; }
+            if (!pump()) return;
+            waiters.delete(listen);
+            done();
+          };
+          waiters.add(listen);
+        });
+      };
+      const pending = tail.then(run, run);
+      tail = pending.catch(() => {});
+      return pending;
     },
     finish() {
-      if (failed) return Promise.reject(failed);
-      if (!node) return Promise.resolve();
-      if (pendingByte !== null) return Promise.reject(new Error("voice_audio_format"));
-      return new Promise((done, fail) => { resolve = done; reject = fail; node.port.postMessage({ type: "finish" }); });
+      const epoch = generation;
+      return tail.catch(() => {}).then(() => {
+        if (epoch !== generation || !node) return;
+        if (pendingByte !== null) throw new Error("voice_audio_format");
+        return new Promise((done, fail) => { resolve = done; reject = fail; node.port.postMessage({ type: "finish" }); });
+      });
     },
     canPause: true,
     pause() { paused = true; node?.port.postMessage({ type: "pause" }); },

package/voice/pcm-worklet.js

@@ -10,7 +10,6 @@ class LaresPcmPlayer extends AudioWorkletProcessor {
     this.paused = false; this.queued = 0; this.finished = false; this.started = false; this.starved = false;
     this.port.onmessage = ({ data }) => {
       if (data.type === 'audio') {
-        if (this.queued + data.samples.length > this.rate * 4) { this.port.postMessage({ type: 'error' }); return; }
         this.queue.push(data.samples); this.queued += data.samples.length;
       } else if (data.type === 'finish') this.finished = true;
       else if (data.type === 'pause') this.paused = true;

package/voice/playout-clock.js

@@ -3,8 +3,10 @@
  * means the client has stopped reading. Both gates share this so a dropped
  * progress tick cannot freeze one path while the other keeps going.
  *
- * The client's queue holds about four seconds. This lead stays inside that
- * queue: a chunk past the lead is still under the cap.
+ * The player holds about four seconds. While reports are still arriving, the
+ * wall clock may lead the speaker by one send-ahead and no further: a long
+ * reply is not already played just because time passed. A report that stops
+ * falls back to the wall clock, so one missed tick does not end the reply.
  */
 export const PLAYOUT_LEAD_MS = 2_000;
 export const SOCKET_FUSE_BYTES = 1024 * 1024;
@@ -12,12 +14,10 @@ export const SOCKET_FUSE_BYTES = 1024 * 1024;
 /**
  * Credit for one reply. The playhead moves at 1x and stops when it catches
  * the audio already handed to the client. A gap while the next sentence is
- * synthesized does not pre-pay a burst, and a missing progress tick does not
- * hold the rest: time keeps the playhead moving up to what was sent. Pause
- * freezes it.
+ * synthesized does not pre-pay a burst. Pause freezes the clock.
  */
 export function createPlayoutClock({ leadMs = PLAYOUT_LEAD_MS, now = Date.now } = {}) {
-  let heard = 0, heldAt = 0, playhead = 0, markedAt = 0, sent = 0;
+  let heard = 0, heardAt = 0, heldAt = 0, playhead = 0, markedAt = 0, sent = 0;
   const stamp = () => heldAt || now();
   const advance = (sentMs) => {
     if (Number.isFinite(sentMs) && sentMs > sent) sent = sentMs;
@@ -27,7 +27,7 @@ export function createPlayoutClock({ leadMs = PLAYOUT_LEAD_MS, now = Date.now }
     markedAt = t;
   };
   return {
-    heard(ms) { if (Number.isFinite(ms) && ms > heard) heard = ms; },
+    heard(ms) { if (Number.isFinite(ms) && ms > heard) { heard = ms; heardAt = stamp(); } },
     pause() {
       if (heldAt) return;
       advance(sent);
@@ -42,7 +42,9 @@ export function createPlayoutClock({ leadMs = PLAYOUT_LEAD_MS, now = Date.now }
     start() { if (!markedAt) markedAt = now(); },
     credit(sentMs) {
       advance(sentMs);
-      return Math.max(heard, playhead);
+      const wall = Math.max(heard, playhead);
+      if (heardAt && stamp() - heardAt <= leadMs) return Math.min(wall, heard + leadMs);
+      return wall;
     },
     blocked(sentMs) { return sentMs - this.credit(sentMs) > leadMs; },
     wait(sentMs) {

package/voice/stream-client.js

@@ -126,7 +126,7 @@ export async function playAudioStream(options) {
       }
       if (!progressNoted) { progressNoted = true; streamMetric(options, { stage: "playback_progress_sent", frames }); }
     };
-    const writeAudio = (bytes) => {
+    const writeAudio = async (bytes) => {
       let chunk = bytes;
       if (skipBytes > 0) {
         const drop = Math.min(skipBytes, chunk.length);
@@ -136,7 +136,7 @@ export async function playAudioStream(options) {
         chunk = chunk.subarray(drop);
         if (!chunk.length) return;
       }
-      player.write(chunk);
+      await player.write(chunk);
     };
     const gapWatch = setInterval(() => {
       if (!ready || paused || complete || gapReported || Date.now() - lastProgressAt < 4000) return;
@@ -168,7 +168,7 @@ export async function playAudioStream(options) {
           }
           chain = chain.then(async () => {
             if (options.signal?.aborted) throw new Error("voice_cancelled");
-            if (typeof data !== "string") { writeAudio(new Uint8Array(data)); return; }
+            if (typeof data !== "string") { await writeAudio(new Uint8Array(data)); return; }
             if (event.type === "segment") {
               if (event.index !== segmentIndex + 1) throw new Error("voice_reply_sequence");
               segmentIndex = event.index;

package/voice/unified-conversation.js

@@ -64,7 +64,7 @@ export function createUnifiedConversation({ request, socket: openSocket = browse
         return;
       }
       if (!current.audio) { current.audio = true; current.chain = current.chain.then(() => player.start({ sampleRate: RATE, channels: 1, encoding: "pcm_s16le" })); controller.observePlayback(true); }
-      current.chain = current.chain.then(() => { if (reply === current) player.write(decodeBase64(delta)); });
+      current.chain = current.chain.then(() => { if (reply === current) return player.write(decodeBase64(delta)); });
       current.chain.catch(() => {});
     },
     async done() {