@vortexm/vjt 0.1.14 → 0.1.16

package/dist/index.js

@@ -3865,7 +3865,7 @@ var NetworkRuntime = class {
     this.rerenderRoot = options.rerenderRoot;
   }
   connectSseStreams() {
-    if (typeof window === "undefined" || typeof EventSource === "undefined" || this.eventSources.length > 0) {
+    if (typeof window === "undefined" || this.eventSources.length > 0) {
       return;
     }
     for (const config of this.sseConfigs) {
@@ -3877,26 +3877,10 @@ var NetworkRuntime = class {
         logRuntimeError("sseConfig", new Error("Blocked unsafe SSE url"), { url: config.url });
         continue;
       }
-      const source = new EventSource(safeUrl);
-      this.eventSources.push(source);
-      for (const eventDefinition of config.events ?? []) {
-        if (!eventDefinition?.name) {
-          continue;
-        }
-        source.addEventListener(eventDefinition.name, (event) => {
-          void this.handleSseEvent(eventDefinition, event).catch((error) => {
-            logRuntimeError("handleSseEvent", error, {
-              eventName: eventDefinition.name,
-              url: safeUrl
-            });
-          });
-        });
+      const connection = this.createSseConnection(config, safeUrl);
+      if (connection) {
+        this.eventSources.push(connection);
       }
-      source.onerror = (event) => {
-        logRuntimeError("sseConnection", event, {
-          url: config.url
-        });
-      };
     }
   }
   async executeRequest(requestName, currentValue) {
@@ -4099,21 +4083,297 @@ var NetworkRuntime = class {
         return this.stringifyPrimitive(value);
     }
   }
-  async handleSseEvent(eventDefinition, event) {
+  createSseConnection(config, safeUrl) {
+    if (typeof fetch === "function" && typeof AbortController !== "undefined" && typeof TextDecoder !== "undefined" && typeof ReadableStream !== "undefined") {
+      return this.createFetchSseConnection(config, safeUrl);
+    }
+    if (typeof EventSource !== "undefined") {
+      return this.createNativeSseConnection(config, safeUrl);
+    }
+    logRuntimeError("sseConnection", new Error("SSE is not supported in this browser"), {
+      url: safeUrl
+    });
+    return null;
+  }
+  createNativeSseConnection(config, safeUrl) {
+    const source = new EventSource(safeUrl);
+    source.onopen = () => {
+      logRuntimeDebug(this.debugLogging, "sse-open", {
+        url: safeUrl,
+        transport: "event-source"
+      });
+    };
+    source.onmessage = (event) => {
+      const payload = typeof event.data === "string" ? event.data : "";
+      logRuntimeDebug(this.debugLogging, "sse-message", {
+        url: safeUrl,
+        transport: "event-source",
+        eventName: "message",
+        payloadLength: payload.length
+      });
+    };
+    for (const eventDefinition of config.events ?? []) {
+      if (!eventDefinition?.name) {
+        continue;
+      }
+      source.addEventListener(eventDefinition.name, (event) => {
+        void this.handleSseEvent(eventDefinition, event.data ?? "", safeUrl).catch((error) => {
+          logRuntimeError("handleSseEvent", error, {
+            eventName: eventDefinition.name,
+            url: safeUrl
+          });
+        });
+      });
+    }
+    source.onerror = (event) => {
+      logRuntimeError("sseConnection", event, {
+        url: config.url,
+        transport: "event-source"
+      });
+    };
+    logRuntimeDebug(this.debugLogging, "sse-connect", {
+      url: safeUrl,
+      transport: "event-source"
+    });
+    return {
+      close: () => {
+        source.close();
+      }
+    };
+  }
+  createFetchSseConnection(config, safeUrl) {
+    let closed = false;
+    let reconnectDelayMs = 2e3;
+    let reconnectTimeoutId = null;
+    let activeAbortController = null;
+    let lastEventId = "";
+    let connectionAttempt = 0;
+    const clearReconnectTimeout = () => {
+      if (reconnectTimeoutId !== null && typeof window !== "undefined") {
+        window.clearTimeout(reconnectTimeoutId);
+      }
+      reconnectTimeoutId = null;
+    };
+    const scheduleReconnect = (reason) => {
+      if (closed || typeof window === "undefined") {
+        return;
+      }
+      logRuntimeDebug(this.debugLogging, "sse-reconnect-scheduled", {
+        url: safeUrl,
+        transport: "fetch",
+        delayMs: reconnectDelayMs,
+        reason,
+        lastEventId
+      });
+      clearReconnectTimeout();
+      reconnectTimeoutId = window.setTimeout(() => {
+        reconnectTimeoutId = null;
+        void connectLoop().catch((error) => {
+          logRuntimeError("sseConnection", error, {
+            url: safeUrl,
+            transport: "fetch"
+          });
+        });
+      }, reconnectDelayMs);
+    };
+    const flushSseChunk = (eventName, dataLines) => {
+      if (!dataLines.length) {
+        return;
+      }
+      const payload = dataLines.join("\n");
+      const matchingDefinitions = (config.events ?? []).filter((definition) => definition?.name === eventName);
+      logRuntimeDebug(this.debugLogging, "sse-dispatch", {
+        url: safeUrl,
+        transport: "fetch",
+        eventName,
+        payloadLength: payload.length,
+        matchedHandlers: matchingDefinitions.length,
+        lastEventId
+      });
+      if (!matchingDefinitions.length) {
+        return;
+      }
+      for (const eventDefinition of matchingDefinitions) {
+        void this.handleSseEvent(eventDefinition, payload, safeUrl).catch((error) => {
+          logRuntimeError("handleSseEvent", error, {
+            eventName,
+            url: safeUrl
+          });
+        });
+      }
+    };
+    const processSseText = (chunk) => {
+      let eventName = "message";
+      let dataLines = [];
+      const normalized = chunk.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+      const lines = normalized.split("\n");
+      for (const line of lines) {
+        if (!line) {
+          flushSseChunk(eventName, dataLines);
+          eventName = "message";
+          dataLines = [];
+          continue;
+        }
+        if (line.startsWith(":")) {
+          continue;
+        }
+        const separatorIndex = line.indexOf(":");
+        const field = separatorIndex >= 0 ? line.slice(0, separatorIndex) : line;
+        let value = separatorIndex >= 0 ? line.slice(separatorIndex + 1) : "";
+        if (value.startsWith(" ")) {
+          value = value.slice(1);
+        }
+        switch (field) {
+          case "event":
+            eventName = value || "message";
+            break;
+          case "data":
+            dataLines.push(value);
+            break;
+          case "id":
+            if (!value.includes("\0")) {
+              lastEventId = value;
+            }
+            break;
+          case "retry": {
+            const parsedDelay = Number.parseInt(value, 10);
+            if (Number.isFinite(parsedDelay) && parsedDelay >= 0) {
+              reconnectDelayMs = parsedDelay;
+            }
+            break;
+          }
+          default:
+            break;
+        }
+      }
+      flushSseChunk(eventName, dataLines);
+    };
+    const findEventBoundary = (value) => value.search(/\r?\n\r?\n/);
+    const connectLoop = async () => {
+      if (closed) {
+        return;
+      }
+      connectionAttempt += 1;
+      activeAbortController = new AbortController();
+      let reconnectReason = "stream-ended";
+      try {
+        logRuntimeDebug(this.debugLogging, "sse-connect-attempt", {
+          url: safeUrl,
+          transport: "fetch",
+          attempt: connectionAttempt,
+          lastEventId
+        });
+        const headers = {
+          Accept: "text/event-stream"
+        };
+        if (lastEventId) {
+          headers["Last-Event-ID"] = lastEventId;
+        }
+        const response = await fetch(safeUrl, {
+          method: "GET",
+          headers,
+          cache: "no-store",
+          credentials: "same-origin",
+          signal: activeAbortController.signal
+        });
+        if (!response.ok) {
+          throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (!contentType.toLowerCase().includes("text/event-stream")) {
+          throw new Error(`SSE response has unexpected content-type: ${contentType || "<empty>"}`);
+        }
+        logRuntimeDebug(this.debugLogging, "sse-open", {
+          url: safeUrl,
+          transport: "fetch",
+          status: response.status,
+          contentType,
+          attempt: connectionAttempt,
+          lastEventId,
+          requestUsesLastEventIdHeader: Boolean(lastEventId)
+        });
+        if (!response.body || typeof response.body.getReader !== "function") {
+          throw new Error("SSE streaming is not available in fetch response body");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let receivedChunkCount = 0;
+        let receivedByteCount = 0;
+        while (!closed) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          receivedChunkCount += 1;
+          receivedByteCount += value?.byteLength ?? 0;
+          buffer += decoder.decode(value, { stream: true });
+          logRuntimeDebug(this.debugLogging, "sse-chunk", {
+            url: safeUrl,
+            transport: "fetch",
+            chunkIndex: receivedChunkCount,
+            chunkBytes: value?.byteLength ?? 0,
+            totalBytes: receivedByteCount,
+            bufferedChars: buffer.length
+          });
+          let boundaryIndex = findEventBoundary(buffer);
+          while (boundaryIndex >= 0) {
+            const rawChunk = buffer.slice(0, boundaryIndex);
+            processSseText(rawChunk);
+            buffer = buffer.slice(boundaryIndex).replace(/^\r?\n\r?\n/, "");
+            boundaryIndex = findEventBoundary(buffer);
+          }
+        }
+        buffer += decoder.decode();
+        if (buffer.trim()) {
+          processSseText(buffer);
+        }
+      } catch (error) {
+        if (closed || error instanceof DOMException && error.name === "AbortError") {
+          return;
+        }
+        reconnectReason = error instanceof Error ? error.message : "stream-error";
+        logRuntimeError("sseConnection", error, {
+          url: safeUrl,
+          transport: "fetch"
+        });
+      } finally {
+        activeAbortController = null;
+      }
+      scheduleReconnect(reconnectReason);
+    };
+    const connection = {
+      close: () => {
+        closed = true;
+        clearReconnectTimeout();
+        activeAbortController?.abort();
+        activeAbortController = null;
+      }
+    };
+    void connectLoop().catch((error) => {
+      logRuntimeError("sseConnection", error, {
+        url: safeUrl,
+        transport: "fetch"
+      });
+    });
+    return connection;
+  }
+  async handleSseEvent(eventDefinition, rawData, url) {
     let parsedMessage = {};
     try {
-      parsedMessage = event.data ? JSON.parse(event.data) : {};
+      parsedMessage = rawData ? JSON.parse(rawData) : {};
     } catch {
-      parsedMessage = { value: event.data ?? "" };
+      parsedMessage = { value: rawData ?? "" };
     }
     const message = eventDefinition.message ? sanitizeSchemaValue(eventDefinition.message, parsedMessage, `sse.${eventDefinition.name}`) : (() => {
       throw new Error(`SSE event ${eventDefinition.name} must define message schema`);
     })();
     logRuntimeDebug(this.debugLogging, "sse", {
       eventName: eventDefinition.name,
-      raw: event.data,
+      raw: rawData,
       parsedMessage,
-      message
+      message,
+      url
     });
     if (!eventDefinition.onEvent?.length) {
       return;
@@ -4479,6 +4739,10 @@ var ReferenceRuntime = class {
         return readPath(state, ["value"]);
       case "isHidden":
         return state.isHidden ?? true;
+      case "isScrolledToTop":
+        return state.isScrolledToTop ?? true;
+      case "isScrolledToBottom":
+        return state.isScrolledToBottom ?? true;
       case "url":
         return resolveInlineI18nValue(this.host, state.url ?? "");
       case "base64":
@@ -5869,8 +6133,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 +6216,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 +6341,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 +6414,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 +6497,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 +6542,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 +6742,6 @@ var VoiceRuntime = class {
     if (this.listening) {
       return;
     }
-    if (this.listeningRecorder && this.listeningRecorder.state !== "inactive") {
-      return;
-    }
     if (this.mediaRecorder && this.mediaRecorder.state !== "inactive") {
       return;
     }
@@ -7617,6 +7984,19 @@ function isGeneratedElementId(value) {
 function isStepperEdit(node) {
   return node.type === "number" || node.type === "float";
 }
+function isScrollableWidgetNode(node) {
+  switch (node.widget) {
+    case "list":
+    case "grid-view":
+    case "listbox":
+    case "combobox":
+      return true;
+    case "container-layout":
+      return normalizeBoolean(node.verticallyScrollable, false);
+    default:
+      return false;
+  }
+}
 function getDateFormat(node) {
   return node.format === "yyyy-MM-dd" ? "yyyy-MM-dd" : DEFAULT_DATE_FORMAT;
 }
@@ -7953,6 +8333,7 @@ var RuntimeRenderer = class {
     this.attachInputBehavior(this.root);
     this.attachWidgetEvents(this.root);
     restoreElementState(this.root, preservedState, this.stateByKey);
+    this.syncAllScrollStateFlags();
     this.applyPendingScrollAction();
     this.applyPendingCursorAction();
     this.activeContextMenu = adjustContextMenuPosition(this.root, this.activeContextMenu);
@@ -8571,7 +8952,9 @@ var RuntimeRenderer = class {
           enabled: normalizeBoolean(node.enabled, true),
           definitionSignature: buildDefinitionSignature(node.elements ?? []),
           elements: deepClone(node.elements ?? []),
-          selected: toFiniteNumber3(node.item) ?? toFiniteNumber3(node.selected) ?? -1
+          selected: toFiniteNumber3(node.item) ?? toFiniteNumber3(node.selected) ?? -1,
+          isScrolledToTop: true,
+          isScrolledToBottom: true
         };
         break;
       case "listbox":
@@ -8583,7 +8966,9 @@ var RuntimeRenderer = class {
           enabled: normalizeBoolean(node.enabled, true),
           definitionSignature: buildDefinitionSignature(node.elements ?? []),
           listboxElements: deepClone(node.elements ?? []),
-          selected: toFiniteNumber3(node.selected) ?? 0
+          selected: toFiniteNumber3(node.selected) ?? 0,
+          isScrolledToTop: true,
+          isScrolledToBottom: true
         };
         break;
       case "combobox":
@@ -8595,7 +8980,9 @@ var RuntimeRenderer = class {
           enabled: normalizeBoolean(node.enabled, true),
           definitionSignature: buildDefinitionSignature(node.elements ?? []),
           comboboxElements: deepClone(node.elements ?? []),
-          selected: toFiniteNumber3(node.selected) ?? 0
+          selected: toFiniteNumber3(node.selected) ?? 0,
+          isScrolledToTop: true,
+          isScrolledToBottom: true
         };
         break;
       case "radio-group":
@@ -8647,7 +9034,9 @@ var RuntimeRenderer = class {
           widget: node.widget,
           id: stateId,
           name: node.name,
-          enabled: normalizeBoolean(node.enabled, true)
+          enabled: normalizeBoolean(node.enabled, true),
+          isScrolledToTop: isScrollableWidgetNode(node) ? true : void 0,
+          isScrolledToBottom: isScrollableWidgetNode(node) ? true : void 0
         };
         break;
     }
@@ -9104,6 +9493,19 @@ var RuntimeRenderer = class {
       redispatchUnderlyingClick: (x, y) => this.redispatchUnderlyingClick(x, y),
       runActions: (actions, inputValue, context) => this.actionRuntime.runActions(actions, inputValue, context)
     });
+    for (const element of Array.from(root.querySelectorAll("[data-widget-key]"))) {
+      const key = element.dataset.widgetKey;
+      if (!key) {
+        continue;
+      }
+      const node = this.nodeByKey.get(key);
+      if (!node || !isScrollableWidgetNode(node)) {
+        continue;
+      }
+      element.addEventListener("scroll", () => {
+        this.syncScrollStateForElement(element, key);
+      }, { passive: true });
+    }
   }
   updateOwningListElementDescriptor(element, mutate) {
     const listElement = element.closest(".vjt-list-element");
@@ -9422,6 +9824,7 @@ var RuntimeRenderer = class {
     }
     if (typeof window === "undefined") {
       initialElement.scrollTop = Math.max(0, Math.min(targetTop, getMaxScrollTop(initialElement)));
+      this.syncScrollStateForReference(reference, initialElement);
       return;
     }
     if (this.activeScrollAnimationFrameId !== null) {
@@ -9433,6 +9836,7 @@ var RuntimeRenderer = class {
     const delta = clampedTargetTop - startTop;
     if (Math.abs(delta) < 1) {
       initialElement.scrollTop = clampedTargetTop;
+      this.syncScrollStateForReference(reference, initialElement);
       return;
     }
     const durationMs = 300;
@@ -9448,10 +9852,12 @@ var RuntimeRenderer = class {
       const progress = Math.min(1, elapsed / durationMs);
       const liveTargetTop = Math.max(0, Math.min(clampedTargetTop, getMaxScrollTop(liveElement)));
       liveElement.scrollTop = startTop + (liveTargetTop - startTop) * easeInOutCubic(progress);
+      this.syncScrollStateForReference(reference, liveElement);
       if (progress < 1) {
         this.activeScrollAnimationFrameId = window.requestAnimationFrame(tick);
       } else {
         liveElement.scrollTop = liveTargetTop;
+        this.syncScrollStateForReference(reference, liveElement);
         this.activeScrollAnimationFrameId = null;
       }
     };
@@ -9505,6 +9911,48 @@ var RuntimeRenderer = class {
     }
     return null;
   }
+  syncAllScrollStateFlags() {
+    if (!(this.root instanceof HTMLElement)) {
+      return;
+    }
+    for (const element of Array.from(this.root.querySelectorAll("[data-widget-key]"))) {
+      const key = element.dataset.widgetKey;
+      if (!key) {
+        continue;
+      }
+      const node = this.nodeByKey.get(key);
+      if (!node || !isScrollableWidgetNode(node)) {
+        continue;
+      }
+      this.syncScrollStateForElement(element, key);
+    }
+  }
+  syncScrollStateForReference(reference, element) {
+    const widgetId = reference.split(".")[0]?.trim();
+    if (!widgetId) {
+      return;
+    }
+    const targetElement = element ?? this.findScrollableWidgetElement(reference);
+    if (!(targetElement instanceof HTMLElement)) {
+      return;
+    }
+    const key = targetElement.dataset.widgetKey ?? widgetId;
+    this.syncScrollStateForElement(targetElement, key);
+  }
+  syncScrollStateForElement(element, key) {
+    const state = this.stateByKey.get(key) ?? this.stateById.get(key);
+    if (!state) {
+      return;
+    }
+    const maxScrollTop = Math.max(0, element.scrollHeight - element.clientHeight);
+    if (maxScrollTop <= 1) {
+      state.isScrolledToTop = true;
+      state.isScrolledToBottom = true;
+      return;
+    }
+    state.isScrolledToTop = element.scrollTop <= 1;
+    state.isScrolledToBottom = element.scrollTop >= maxScrollTop - 1;
+  }
   toScrollableIndex(value) {
     if (typeof value === "number" && Number.isFinite(value)) {
       return Math.max(0, Math.trunc(value));

package/dist/lib/network.d.ts

@@ -1,4 +1,4 @@
-import type { ActionDefinition, PrimitiveRequestType, RequestMapInput, RequestSchema, SseConfig } from './types.js';
+import type { ActionDefinition, ClosableRuntimeResource, PrimitiveRequestType, RequestMapInput, RequestSchema, SseConfig } from './types.js';
 type ActionRunner = (actions: ActionDefinition[], inputValue: unknown, context: {
     currentValue: unknown;
     responseValue?: unknown;
@@ -8,7 +8,7 @@ type NetworkRuntimeOptions = {
     requestsMap: RequestMapInput;
     sseConfigs: SseConfig[];
     backendUrl?: string;
-    eventSources: EventSource[];
+    eventSources: ClosableRuntimeResource[];
     runActions: ActionRunner;
     rerenderRoot: () => Promise<void>;
 };
@@ -28,6 +28,9 @@ export declare class NetworkRuntime {
     private createRequestError;
     private toRequestErrorPayload;
     coercePrimitiveSchemaValue(type: PrimitiveRequestType, value: unknown): unknown;
+    private createSseConnection;
+    private createNativeSseConnection;
+    private createFetchSseConnection;
     private handleSseEvent;
 }
 export {};

package/dist/lib/types.d.ts

@@ -6,6 +6,9 @@ export type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
 export type WidgetEventName = 'onClick' | 'onUserValueChange' | 'onRefresh' | 'onEnter' | 'onShiftEnter' | 'onControlEnter' | 'onPaste';
 export type SystemEventName = 'onBeforeRender' | 'onAfterRender' | 'onBeforeNavigate' | 'onAfterNavigate' | 'onLayoutSwitchToMobile' | 'onLayoutSwitchToDesktop' | 'onSpeechDetected' | 'onRecordingStarted' | 'onRecordingStopped' | 'onRecordingError' | 'onListeningError' | 'onListeringError' | 'onPlayFinished' | 'onPlayingStopped';
 export type PrimitiveRequestType = 'int' | 'float' | 'boolean' | 'string';
+export type ClosableRuntimeResource = {
+    close: () => void;
+};
 export type RouteDefinition = {
     path: string;
     ui: string;
@@ -128,6 +131,8 @@ export type WidgetState = {
     modalHeight?: number;
     activeTab?: number;
     isHidden?: boolean;
+    isScrolledToTop?: boolean;
+    isScrolledToBottom?: boolean;
 };
 export type RuntimeSnapshot = {
     stateByKey: Array<[string, WidgetState]>;

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.16",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",