@vortexm/vjt 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { renderApp, renderJson } from './lib/render.js';
 export { ResourceManager } from './lib/resource-manager.js';
 export { DEFAULT_STYLE_MAP } from './lib/default-styles.js';
-export type { ActionDefinition, ActionMap, AdaptiveLayoutNode, BaseNode, ButtonNode, CheckboxNode, ComboboxNode, ConditionExpression, ConditionalContainerNode, ContextMenuNode, ContainerCell, ContainerLayoutNode, CellConstraints, DescriptionNode, GridViewNode, HeadingTag, I18nMap, ImageNode, LayoutType, LinkNode, ListElementContext, ListNode, ListboxNode, MdTextNode, ModalWindowNode, MountJsonOptions, OverlayContainerNode, OverlayLayer, PanelNode, PrimitiveRequestType, RadioGroupNode, RequestDefinition, RequestMap, RequestSchema, RenderJsonOptions, RuntimeSnapshot, SseConfig, SseConfigInput, SseEventDefinition, SpoilerNode, SplitterNode, StaticTextNode, StyleMap, TabsNode, TextAlign, TextareaNode, UiReferenceNode, Theme, VerticalAlign, WidgetEventName, WidgetState } from './lib/types.js';
+export type { ActionDefinition, ActionMap, AdaptiveLayoutNode, BaseNode, ButtonNode, CheckboxNode, ComboboxNode, ConditionExpression, ConditionalContainerNode, ContextMenuNode, ContainerCell, ContainerLayoutNode, CellConstraints, DescriptionNode, GridViewNode, HeadingTag, I18nMap, ImageNode, LayoutType, LinkNode, ListElementContext, ListNode, ListboxNode, MdTextNode, ModalWindowNode, MountJsonOptions, OverlayContainerNode, OverlayLayer, PanelNode, PrimitiveRequestType, RadioGroupNode, RequestDefinition, RequestMap, RequestSchema, RenderJsonOptions, RuntimeSnapshot, SseConfig, SseConfigInput, SseEventDefinition, SpoilerNode, SplitterNode, StaticTextNode, StyleMap, SystemEventName, TabsNode, TextAlign, TextareaNode, UiReferenceNode, Theme, VerticalAlign, WidgetEventName, WidgetState } from './lib/types.js';

package/dist/index.js

@@ -3904,69 +3904,111 @@ var NetworkRuntime = class {
     if (!definition) {
       return null;
     }
-    const payload = await this.buildSchemaValue(definition.request, currentValue, void 0);
-    const requestEnvelope = {
-      jsonrpc: "2.0",
-      id: Date.now(),
-      method: requestName,
-      params: payload
-    };
-    const requestUrl = definition.url ?? this.backendUrl;
-    if (!requestUrl) {
-      throw new Error(`Request ${requestName} has no url in config`);
-    }
-    const safeRequestUrl = sanitizeUrl(requestUrl, { allowRelative: true });
-    if (!safeRequestUrl) {
-      throw new Error(`Request ${requestName} has unsafe url`);
-    }
-    const requestBody = JSON.stringify(requestEnvelope);
-    logRuntimeDebug(this.debugLogging, "request", {
-      requestName,
-      url: safeRequestUrl,
-      envelope: requestEnvelope,
-      body: requestBody
-    });
-    const response = await fetch(safeRequestUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: requestBody
-    });
-    const responseText = await response.text();
-    if (!response.ok) {
-      throw new Error(`Request ${requestName} failed: ${response.status} ${response.statusText || responseText}`);
-    }
-    if (!responseText.trim()) {
-      throw new Error(`Request ${requestName} returned empty response body`);
-    }
-    let json;
     try {
-      json = JSON.parse(responseText);
-    } catch {
-      throw new Error(`Request ${requestName} returned non-JSON response: ${responseText.slice(0, 120)}`);
-    }
-    if (json.error) {
-      throw new Error(`Request ${requestName} returned JSON-RPC error: ${this.stringifyPrimitive(json.error.message ?? "unknown error")}`);
-    }
-    if (!definition.response) {
-      throw new Error(`Request ${requestName} must define response schema`);
-    }
-    const result = sanitizeSchemaValue(definition.response, json.result, `response.${requestName}`);
-    logRuntimeDebug(this.debugLogging, "response", {
-      requestName,
-      url: safeRequestUrl,
-      status: response.status,
-      json,
-      result
-    });
-    if (definition.onResponse?.length) {
-      await this.runActions(definition.onResponse, null, {
-        currentValue: null,
-        responseValue: result
+      const payload = await this.buildSchemaValue(definition.request, currentValue, void 0);
+      const requestEnvelope = {
+        jsonrpc: "2.0",
+        id: Date.now(),
+        method: requestName,
+        params: payload
+      };
+      const requestUrl = definition.url ?? this.backendUrl;
+      if (!requestUrl) {
+        throw new Error(`Request ${requestName} has no url in config`);
+      }
+      const safeRequestUrl = sanitizeUrl(requestUrl, { allowRelative: true });
+      if (!safeRequestUrl) {
+        throw new Error(`Request ${requestName} has unsafe url`);
+      }
+      const requestBody = JSON.stringify(requestEnvelope);
+      logRuntimeDebug(this.debugLogging, "request", {
+        requestName,
+        url: safeRequestUrl,
+        envelope: requestEnvelope,
+        body: requestBody
+      });
+      const response = await fetch(safeRequestUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: requestBody
+      });
+      const responseText = await response.text();
+      if (!response.ok) {
+        throw this.createRequestError(requestName, {
+          message: `Request ${requestName} failed: ${response.status} ${response.statusText || responseText}`,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseText,
+          url: safeRequestUrl
+        });
+      }
+      if (!responseText.trim()) {
+        throw this.createRequestError(requestName, {
+          message: `Request ${requestName} returned empty response body`,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseText,
+          url: safeRequestUrl
+        });
+      }
+      let json;
+      try {
+        json = JSON.parse(responseText);
+      } catch {
+        throw this.createRequestError(requestName, {
+          message: `Request ${requestName} returned non-JSON response: ${responseText.slice(0, 120)}`,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseText,
+          url: safeRequestUrl
+        });
+      }
+      if (json.error) {
+        throw this.createRequestError(requestName, {
+          message: `Request ${requestName} returned JSON-RPC error: ${this.stringifyPrimitive(json.error.message ?? "unknown error")}`,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseText,
+          url: safeRequestUrl,
+          error: json.error
+        });
+      }
+      if (!definition.response) {
+        throw this.createRequestError(requestName, {
+          message: `Request ${requestName} must define response schema`,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseText,
+          url: safeRequestUrl
+        });
+      }
+      const result = sanitizeSchemaValue(definition.response, json.result, `response.${requestName}`);
+      logRuntimeDebug(this.debugLogging, "response", {
+        requestName,
+        url: safeRequestUrl,
+        status: response.status,
+        json,
+        result
       });
+      if (definition.onResponse?.length) {
+        await this.runActions(definition.onResponse, null, {
+          currentValue: null,
+          responseValue: result
+        });
+      }
+      return result;
+    } catch (error) {
+      if (definition.onError?.length) {
+        const errorPayload = this.toRequestErrorPayload(requestName, error);
+        await this.runActions(definition.onError, null, {
+          currentValue: null,
+          responseValue: errorPayload
+        });
+      }
+      throw error;
     }
-    return result;
   }
   async buildSchemaValue(schema, currentValue, responseValue) {
     if (schema.type === "object") {
@@ -4004,6 +4046,36 @@ var NetworkRuntime = class {
     }
     return JSON.stringify(value);
   }
+  createRequestError(requestName, payload) {
+    const error = new Error(payload.message);
+    error.requestPayload = {
+      requestName,
+      message: payload.message,
+      status: payload.status ?? null,
+      statusText: payload.statusText ?? "",
+      body: payload.body ?? "",
+      url: payload.url ?? "",
+      error: payload.error ?? null
+    };
+    return error;
+  }
+  toRequestErrorPayload(requestName, error) {
+    if (typeof error === "object" && error !== null && "requestPayload" in error) {
+      const payload = error.requestPayload;
+      if (typeof payload === "object" && payload !== null && !Array.isArray(payload)) {
+        return payload;
+      }
+    }
+    return {
+      requestName,
+      message: error instanceof Error ? error.message : this.stringifyPrimitive(error),
+      status: null,
+      statusText: "",
+      body: "",
+      url: "",
+      error: null
+    };
+  }
   coercePrimitiveSchemaValue(type, value) {
     switch (type) {
       case "int": {
@@ -4186,6 +4258,9 @@ var ReferenceRuntime = class {
     if (reference.startsWith("url.")) {
       return getUrlParamValue(reference.slice(4));
     }
+    if (reference.startsWith("vars.")) {
+      return this.host.getVarValue(reference.slice(5));
+    }
     const [widgetId, ...rest] = reference.split(".");
     const state = this.host.stateById.get(widgetId);
     if (!state) {
@@ -4311,6 +4386,10 @@ var ReferenceRuntime = class {
       this.host.setAppValue(reference.slice(4), inputValue);
       return;
     }
+    if (reference.startsWith("vars.")) {
+      this.host.setVarValue(reference.slice(5), inputValue);
+      return;
+    }
     const [widgetId, ...rest] = reference.split(".");
     const field = rest.join(".");
     const state = this.host.stateById.get(widgetId);
@@ -4489,6 +4568,7 @@ var ActionRuntime = class {
   actionFunctions;
   nodeById;
   stateById;
+  stateByKey;
   rerenderRoot;
   dispatchWidgetEventImpl;
   executeRequest;
@@ -4498,6 +4578,14 @@ var ActionRuntime = class {
   resolveMappedValue;
   setWidgetEnabled;
   clearWidget;
+  clearListElementState;
+  focusWidget;
+  playAudio;
+  stopPlaying;
+  startRecording;
+  stopRecording;
+  startListening;
+  stopListening;
   setUiReference;
   refreshWidgetTree;
   renderWidgetTree;
@@ -4514,6 +4602,7 @@ var ActionRuntime = class {
     this.actionFunctions = options.actionFunctions;
     this.nodeById = options.nodeById;
     this.stateById = options.stateById;
+    this.stateByKey = options.stateByKey;
     this.rerenderRoot = options.rerenderRoot;
     this.dispatchWidgetEventImpl = options.dispatchWidgetEvent;
     this.executeRequest = options.executeRequest;
@@ -4523,6 +4612,14 @@ var ActionRuntime = class {
     this.resolveMappedValue = options.resolveMappedValue;
     this.setWidgetEnabled = options.setWidgetEnabled;
     this.clearWidget = options.clearWidget;
+    this.clearListElementState = options.clearListElementState;
+    this.focusWidget = options.focusWidget;
+    this.playAudio = options.playAudio;
+    this.stopPlaying = options.stopPlaying;
+    this.startRecording = options.startRecording;
+    this.stopRecording = options.stopRecording;
+    this.startListening = options.startListening;
+    this.stopListening = options.stopListening;
     this.setUiReference = options.setUiReference;
     this.refreshWidgetTree = options.refreshWidgetTree;
     this.renderWidgetTree = options.renderWidgetTree;
@@ -4571,13 +4668,26 @@ var ActionRuntime = class {
       if (action.andThen?.length) {
         if (Array.isArray(output)) {
           const collected = [];
-          for (const entry of output) {
+          for (const [index, entry] of output.entries()) {
             if (entry === null || entry === void 0) {
               continue;
             }
-            const nestedOutput = await this.runActions(action.andThen, entry, { ...context, currentValue: entry });
+            const nestedOutput = await this.runActions(action.andThen, entry, {
+              ...context,
+              currentValue: entry,
+              currentList: output,
+              currentIndex: index
+            });
             if (nestedOutput !== null && nestedOutput !== void 0) {
-              collected.push(nestedOutput);
+              if (Array.isArray(nestedOutput)) {
+                for (const item of nestedOutput) {
+                  if (item !== null && item !== void 0) {
+                    collected.push(item);
+                  }
+                }
+              } else {
+                collected.push(nestedOutput);
+              }
             }
           }
           output = collected;
@@ -4641,6 +4751,30 @@ var ActionRuntime = class {
       await this.navigateTo(name.slice(9));
       return null;
     }
+    if (name.startsWith("play ")) {
+      await this.playAudio(this.resolveReference(name.slice(5), context.currentValue, context.responseValue));
+      return null;
+    }
+    if (name === "stopPlaying") {
+      await this.stopPlaying();
+      return null;
+    }
+    if (name === "startRecording") {
+      await this.startRecording();
+      return null;
+    }
+    if (name === "stopRecording") {
+      await this.stopRecording();
+      return null;
+    }
+    if (name === "startListening") {
+      await this.startListening();
+      return null;
+    }
+    if (name === "stopListening") {
+      await this.stopListening();
+      return null;
+    }
     if (name.startsWith("showMenu ")) {
       const menuId = name.slice(9);
       const menuState = this.stateById.get(menuId);
@@ -4680,6 +4814,10 @@ var ActionRuntime = class {
       this.clearWidget(name.slice(6));
       return null;
     }
+    if (name.startsWith("setFocus ")) {
+      this.focusWidget(name.slice(9));
+      return null;
+    }
     if (name.startsWith("setUi ")) {
       const widgetId = name.slice(6);
       const resourceRef = typeof inputValue === "string" ? inputValue : "";
@@ -4702,10 +4840,74 @@ var ActionRuntime = class {
       this.assignReference(name.slice(4), inputValue, context.currentValue, args);
       return inputValue;
     }
+    if (name.startsWith("append ")) {
+      const reference = name.slice(7);
+      const currentText = this.resolveReference(reference, context.currentValue, context.responseValue);
+      const nextValue = `${this.stringifyValue(currentText)}${this.stringifyValue(action.args)}`;
+      this.assignReference(reference, nextValue, context.currentValue);
+      return nextValue;
+    }
     if (name.startsWith("filter ")) {
       const value = this.resolveReference(name.slice(7), context.currentValue, context.responseValue);
       return value ? inputValue : null;
     }
+    if (name === "remove") {
+      const listState = this.getCurrentListState(context.currentValue);
+      if (listState && typeof context.currentValue === "object" && context.currentValue !== null && "index" in context.currentValue) {
+        const index = context.currentValue.index;
+        if (typeof index === "number" && Array.isArray(listState.elements)) {
+          listState.elements = listState.elements.filter((_, elementIndex) => elementIndex !== index);
+          this.clearListElementState(listState.key);
+          return listState.elements;
+        }
+      }
+      return null;
+    }
+    if (name.startsWith("add ")) {
+      const valueToAdd = this.cloneValue(this.unwrapListValue(this.resolveReference(name.slice(4), context.currentValue, context.responseValue)));
+      const listState = this.getCurrentListState(context.currentValue);
+      if (listState && Array.isArray(listState.elements)) {
+        listState.elements.push(valueToAdd);
+        this.clearListElementState(listState.key);
+        return listState.elements;
+      }
+      if (context.currentList && typeof context.currentIndex === "number") {
+        return context.currentIndex === context.currentList.length - 1 ? [this.unwrapListValue(inputValue), valueToAdd] : this.unwrapListValue(inputValue);
+      }
+      if (Array.isArray(inputValue)) {
+        const nextList = [];
+        for (const item of inputValue) {
+          nextList.push(item);
+        }
+        nextList.push(valueToAdd);
+        return nextList;
+      }
+      return inputValue;
+    }
+    if (name.startsWith("insert ")) {
+      const valueToInsert = this.cloneValue(this.unwrapListValue(this.resolveReference(name.slice(7), context.currentValue, context.responseValue)));
+      const listState = this.getCurrentListState(context.currentValue);
+      if (listState && Array.isArray(listState.elements) && typeof context.currentValue === "object" && context.currentValue !== null && "index" in context.currentValue) {
+        const index = context.currentValue.index;
+        if (typeof index === "number") {
+          listState.elements.splice(index + 1, 0, valueToInsert);
+          this.clearListElementState(listState.key);
+          return listState.elements;
+        }
+      }
+      if (context.currentList && typeof context.currentIndex === "number") {
+        return [this.unwrapListValue(inputValue), valueToInsert];
+      }
+      if (Array.isArray(inputValue)) {
+        const nextList = [];
+        for (const item of inputValue) {
+          nextList.push(item);
+        }
+        nextList.push(valueToInsert);
+        return nextList;
+      }
+      return inputValue;
+    }
     if (name === "map") {
       return this.resolveMappedValue(action.args, context.currentValue, context.responseValue);
     }
@@ -4722,10 +4924,40 @@ var ActionRuntime = class {
     }
     return inputValue;
   }
+  unwrapListValue(value) {
+    return isListElementLike(value) ? value.descriptor : value;
+  }
+  getCurrentListState(currentValue) {
+    if (!isListElementLike(currentValue) || typeof currentValue.listId !== "string") {
+      return null;
+    }
+    return this.stateByKey.get(currentValue.listId) ?? this.stateById.get(currentValue.listId) ?? null;
+  }
+  cloneValue(value) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (typeof value === "object") {
+      return structuredClone(value);
+    }
+    return value;
+  }
+  stringifyValue(value) {
+    if (value == null) {
+      return "";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+      return String(value);
+    }
+    return JSON.stringify(value);
+  }
 };
 function isIfElseArgs(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isListElementLike(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "list-element" && "listId" in value && typeof value.listId === "string" && "index" in value && typeof value.index === "number" && "descriptor" in value;
+}
 
 // src/lib/dom-state.ts
 function isPlainObject3(value) {
@@ -4754,7 +4986,7 @@ function isElementInsidePendingResetModal(element, pendingResetModalIds) {
   }
   return false;
 }
-function captureElementState(root, pendingResetModalIds, stateByKey) {
+function captureElementState(root, pendingResetModalIds) {
   const state = {
     activeId: null,
     values: /* @__PURE__ */ new Map(),
@@ -4782,20 +5014,6 @@ function captureElementState(root, pendingResetModalIds, stateByKey) {
     if (element instanceof HTMLInputElement && element.type === "checkbox" && element.id) {
       state.checked.set(element.id, element.checked);
     }
-    const widgetKey = element.dataset.widgetKey;
-    if (!widgetKey) {
-      continue;
-    }
-    const widgetState = stateByKey.get(widgetKey);
-    if (!widgetState || element.readOnly || element.disabled) {
-      continue;
-    }
-    if (widgetState.widget === "edit" || widgetState.widget === "textarea") {
-      widgetState.text = element.value;
-    }
-    if (widgetState.widget === "checkbox" && element instanceof HTMLInputElement && element.type === "checkbox") {
-      widgetState.checked = element.checked;
-    }
   }
   for (const element of Array.from(root.querySelectorAll("[id], [data-widget-key]"))) {
     const top = element.scrollTop;
@@ -4817,16 +5035,44 @@ function captureElementState(root, pendingResetModalIds, stateByKey) {
   }
   return state;
 }
-function restoreElementState(root, state) {
+function shouldRestoreTextValue(element, preservedValue, stateByKey) {
+  const widgetKey = element.dataset.widgetKey;
+  if (!widgetKey) {
+    return true;
+  }
+  const widgetState = stateByKey.get(widgetKey);
+  if (!widgetState || widgetState.widget !== "edit" && widgetState.widget !== "textarea") {
+    return true;
+  }
+  return (widgetState.text ?? "") === preservedValue;
+}
+function shouldRestoreCheckedValue(element, preservedValue, stateByKey) {
+  const widgetKey = element.dataset.widgetKey;
+  if (!widgetKey) {
+    return true;
+  }
+  const widgetState = stateByKey.get(widgetKey);
+  if (!widgetState || widgetState.widget !== "checkbox") {
+    return true;
+  }
+  return (widgetState.checked ?? false) === preservedValue;
+}
+function restoreElementState(root, state, stateByKey) {
   for (const [id, value] of state.values.entries()) {
     const element = root.querySelector(`#${CSS.escape(id)}`);
     if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+      if (!shouldRestoreTextValue(element, value, stateByKey)) {
+        continue;
+      }
       element.value = value;
     }
   }
   for (const [id, checked] of state.checked.entries()) {
     const element = root.querySelector(`#${CSS.escape(id)}`);
     if (element instanceof HTMLInputElement && element.type === "checkbox") {
+      if (!shouldRestoreCheckedValue(element, checked, stateByKey)) {
+        continue;
+      }
       element.checked = checked;
     }
   }
@@ -5129,6 +5375,430 @@ var DEFAULT_STYLE_MAP = {
   employeeLinkDark: "display:flex; align-items:center; width:100%; height:100%; color:#b8d0ea; font-weight:600;"
 };
 
+// src/lib/voice-runtime.ts
+var MAX_CONCURRENT_PLAYERS = 5;
+var MAX_RECORDING_MS = 10 * 60 * 1e3;
+var MAX_LISTENING_SILENCE_MS = 60 * 60 * 1e3;
+var SILENCE_STOP_MS = 2e3;
+var SPEECH_THRESHOLD = 0.035;
+var RECORDING_MIME_CANDIDATES = [
+  "audio/webm;codecs=opus",
+  "audio/webm",
+  "audio/mp4",
+  "audio/mp4;codecs=mp4a.40.2",
+  "audio/wav"
+];
+function isPlayableAudioPayload(value) {
+  return typeof value === "object" && value !== null;
+}
+function decodeBase64(base64) {
+  const normalized = base64.includes(",") ? base64.slice(base64.indexOf(",") + 1) : base64;
+  const binary = atob(normalized);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+function detectMimeType(bytes) {
+  if (bytes.length >= 4 && bytes[0] === 26 && bytes[1] === 69 && bytes[2] === 223 && bytes[3] === 163) {
+    return "audio/webm";
+  }
+  if (bytes.length >= 12 && bytes[4] === 102 && bytes[5] === 116 && bytes[6] === 121 && bytes[7] === 112) {
+    return "audio/mp4";
+  }
+  if (bytes.length >= 3 && bytes[0] === 73 && bytes[1] === 68 && bytes[2] === 51) {
+    return "audio/mpeg";
+  }
+  if (bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 224) === 224) {
+    return "audio/mpeg";
+  }
+  if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 65 && bytes[10] === 86 && bytes[11] === 69) {
+    return "audio/wav";
+  }
+  if (bytes.length >= 4 && bytes[0] === 79 && bytes[1] === 103 && bytes[2] === 103 && bytes[3] === 83) {
+    return "audio/ogg";
+  }
+  return "audio/mpeg";
+}
+function blobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error("Failed to read recorded audio data"));
+    reader.onloadend = () => {
+      const result = typeof reader.result === "string" ? reader.result : "";
+      const base64 = result.includes(",") ? result.slice(result.indexOf(",") + 1) : result;
+      resolve(base64);
+    };
+    reader.readAsDataURL(blob);
+  });
+}
+var VoiceRuntime = class {
+  debugLogging;
+  triggerSystemEvent;
+  activePlayers = [];
+  mediaStream = null;
+  mediaRecorder = null;
+  recordingChunks = [];
+  recordingTimeoutId = null;
+  listening = false;
+  listenContext = null;
+  listenAnalyser = null;
+  listenSource = null;
+  listenFrameId = null;
+  lastSpeechAt = 0;
+  listeningStartedAt = 0;
+  recordingStartedFromListening = false;
+  speechEventTriggered = false;
+  visibilityHandler;
+  pageHideHandler;
+  constructor(options) {
+    this.debugLogging = options.debugLogging;
+    this.triggerSystemEvent = options.triggerSystemEvent;
+    this.visibilityHandler = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+        void this.handlePageDeactivation();
+      }
+    };
+    this.pageHideHandler = () => {
+      void this.handlePageDeactivation();
+    };
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.visibilityHandler);
+    }
+    if (typeof window !== "undefined") {
+      window.addEventListener("pagehide", this.pageHideHandler);
+    }
+  }
+  async play(value) {
+    const payload = this.normalizePlayablePayload(value);
+    if (!payload) {
+      return;
+    }
+    const bytes = decodeBase64(payload.audioData);
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    const blob = new Blob([copy.buffer], { type: payload.mimeType });
+    const url = URL.createObjectURL(blob);
+    const audio = new Audio(url);
+    audio.preload = "auto";
+    const player = { audio, url, payload };
+    audio.onended = () => {
+      void this.finishPlayback(player, "finished");
+    };
+    audio.onerror = () => {
+      this.detachPlayer(player);
+      logRuntimeError("voice.play", new Error("Audio playback failed"), { mimeType: payload.mimeType });
+    };
+    this.activePlayers.push(player);
+    while (this.activePlayers.length > MAX_CONCURRENT_PLAYERS) {
+      const oldest = this.activePlayers.shift();
+      if (!oldest) {
+        break;
+      }
+      oldest.audio.pause();
+      void this.finishPlayback(oldest, "stopped");
+    }
+    logRuntimeDebug(this.debugLogging, "voice-play", {
+      mimeType: payload.mimeType,
+      bytes: bytes.byteLength,
+      activePlayers: this.activePlayers.length
+    });
+    await audio.play();
+  }
+  async stopPlaying() {
+    const players = [...this.activePlayers];
+    for (const player of players) {
+      player.audio.pause();
+      player.audio.currentTime = 0;
+      await this.finishPlayback(player, "stopped");
+    }
+  }
+  async startRecording() {
+    try {
+      const stream = await this.ensureInputStream();
+      this.startRecordingInternal(stream, false);
+    } catch (error) {
+      await this.handleRecordingError(error);
+    }
+  }
+  stopRecording() {
+    if (!this.mediaRecorder || this.mediaRecorder.state === "inactive") {
+      return;
+    }
+    this.clearRecordingTimeout();
+    this.mediaRecorder.stop();
+  }
+  async startListening() {
+    if (this.listening) {
+      return;
+    }
+    try {
+      const stream = await this.ensureInputStream();
+      const context = new AudioContext();
+      const analyser = context.createAnalyser();
+      analyser.fftSize = 2048;
+      const source = context.createMediaStreamSource(stream);
+      source.connect(analyser);
+      this.listening = true;
+      this.listenContext = context;
+      this.listenAnalyser = analyser;
+      this.listenSource = source;
+      this.lastSpeechAt = 0;
+      this.listeningStartedAt = performance.now();
+      this.speechEventTriggered = false;
+      const sampleBuffer = new Uint8Array(analyser.fftSize);
+      const step = async () => {
+        if (!this.listening || !this.listenAnalyser) {
+          return;
+        }
+        this.listenAnalyser.getByteTimeDomainData(sampleBuffer);
+        let squareSum = 0;
+        for (const sample of sampleBuffer) {
+          const centered = (sample - 128) / 128;
+          squareSum += centered * centered;
+        }
+        const rms = Math.sqrt(squareSum / sampleBuffer.length);
+        const now = performance.now();
+        if (rms >= SPEECH_THRESHOLD) {
+          this.lastSpeechAt = now;
+          this.listeningStartedAt = now;
+          if (!this.speechEventTriggered) {
+            this.speechEventTriggered = true;
+            await this.triggerSystemEvent("onSpeechDetected", null);
+          }
+          if (!this.mediaRecorder || this.mediaRecorder.state === "inactive") {
+            this.startRecordingInternal(stream, true);
+          }
+        } else if (this.recordingStartedFromListening && this.mediaRecorder && this.mediaRecorder.state !== "inactive" && this.lastSpeechAt > 0 && now - this.lastSpeechAt >= SILENCE_STOP_MS) {
+          this.stopRecording();
+          this.lastSpeechAt = 0;
+          this.speechEventTriggered = false;
+        } else if (!this.recordingStartedFromListening && now - this.listeningStartedAt >= MAX_LISTENING_SILENCE_MS) {
+          await this.stopListening();
+          return;
+        }
+        this.listenFrameId = window.requestAnimationFrame(() => {
+          void step();
+        });
+      };
+      void step();
+    } catch (error) {
+      await this.handleListeningError(error);
+    }
+  }
+  async stopListening() {
+    this.listening = false;
+    this.speechEventTriggered = false;
+    this.lastSpeechAt = 0;
+    this.listeningStartedAt = 0;
+    if (this.listenFrameId !== null) {
+      window.cancelAnimationFrame(this.listenFrameId);
+      this.listenFrameId = null;
+    }
+    try {
+      await this.listenContext?.close();
+    } catch (error) {
+      logRuntimeError("voice.stopListening", error);
+    }
+    this.listenContext = null;
+    this.listenAnalyser = null;
+    this.listenSource = null;
+    if (this.recordingStartedFromListening && this.mediaRecorder && this.mediaRecorder.state !== "inactive") {
+      this.stopRecording();
+    }
+    this.recordingStartedFromListening = false;
+    this.releaseInputStreamIfIdle();
+  }
+  dispose() {
+    void this.stopListening();
+    this.stopRecording();
+    this.clearRecordingTimeout();
+    void this.stopPlaying();
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+    }
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pagehide", this.pageHideHandler);
+    }
+    this.stopStreamTracks();
+  }
+  startRecordingInternal(stream, fromListening) {
+    if (this.mediaRecorder && this.mediaRecorder.state !== "inactive") {
+      return;
+    }
+    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.mediaRecorder = recorder;
+    this.recordingChunks = [];
+    this.recordingStartedFromListening = fromListening;
+    recorder.ondataavailable = (event) => {
+      if (event.data && event.data.size > 0) {
+        this.recordingChunks.push(event.data);
+      }
+    };
+    recorder.onerror = (event) => {
+      void this.handleRecordingError(event.error ?? new Error("Unknown recording error"));
+    };
+    recorder.onstart = () => {
+      logRuntimeDebug(this.debugLogging, "voice-recording-started", {
+        mimeType: recorder.mimeType || preferredMimeType || "unknown",
+        fromListening
+      });
+      void this.triggerSystemEvent("onRecordingStarted", null);
+    };
+    recorder.onstop = () => {
+      void this.handleRecorderStop(recorder);
+    };
+    recorder.start();
+    this.clearRecordingTimeout();
+    this.recordingTimeoutId = window.setTimeout(() => {
+      void this.stopRecording();
+    }, MAX_RECORDING_MS);
+  }
+  async handleRecorderStop(recorder) {
+    this.clearRecordingTimeout();
+    const mimeType = recorder.mimeType || this.getPreferredRecordingMimeType() || "audio/webm";
+    const blob = new Blob(this.recordingChunks, { type: mimeType });
+    this.recordingChunks = [];
+    this.mediaRecorder = null;
+    try {
+      const audioData = await blobToBase64(blob);
+      logRuntimeDebug(this.debugLogging, "voice-recording-stopped", {
+        mimeType,
+        size: blob.size,
+        fromListening: this.recordingStartedFromListening
+      });
+      await this.triggerSystemEvent("onRecordingStopped", {
+        audioData,
+        mimeType
+      });
+    } catch (error) {
+      await this.handleRecordingError(error);
+    } finally {
+      this.recordingStartedFromListening = false;
+      this.releaseInputStreamIfIdle();
+    }
+  }
+  async handleRecordingError(error) {
+    logRuntimeError("voice.recording", error);
+    await this.triggerSystemEvent("onRecordingError", this.normalizeErrorMessage(error));
+  }
+  async handleListeningError(error) {
+    logRuntimeError("voice.listening", error);
+    const message = this.normalizeErrorMessage(error);
+    await this.triggerSystemEvent("onListeningError", message);
+    await this.triggerSystemEvent("onListeringError", message);
+  }
+  normalizePlayablePayload(value) {
+    if (typeof value === "string" && value.trim()) {
+      const bytes = decodeBase64(value.trim());
+      return {
+        audioData: value.trim(),
+        mimeType: detectMimeType(bytes)
+      };
+    }
+    if (isPlayableAudioPayload(value) && typeof value.audioData === "string" && value.audioData.trim()) {
+      const audioData = value.audioData.trim();
+      const mimeType = typeof value.mimeType === "string" && value.mimeType.trim() ? value.mimeType.trim() : detectMimeType(decodeBase64(audioData));
+      return { audioData, mimeType };
+    }
+    return null;
+  }
+  getPreferredRecordingMimeType() {
+    if (typeof MediaRecorder === "undefined" || typeof MediaRecorder.isTypeSupported !== "function") {
+      return null;
+    }
+    for (const candidate of RECORDING_MIME_CANDIDATES) {
+      if (MediaRecorder.isTypeSupported(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  async ensureInputStream() {
+    if (this.mediaStream && this.mediaStream.active) {
+      return this.mediaStream;
+    }
+    if (!navigator.mediaDevices?.getUserMedia) {
+      throw new Error("Audio input is not supported in this browser");
+    }
+    this.mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    return this.mediaStream;
+  }
+  clearRecordingTimeout() {
+    if (this.recordingTimeoutId !== null) {
+      window.clearTimeout(this.recordingTimeoutId);
+      this.recordingTimeoutId = null;
+    }
+  }
+  releaseInputStreamIfIdle() {
+    if (this.listening) {
+      return;
+    }
+    if (this.mediaRecorder && this.mediaRecorder.state !== "inactive") {
+      return;
+    }
+    this.stopStreamTracks();
+  }
+  stopStreamTracks() {
+    if (!this.mediaStream) {
+      return;
+    }
+    for (const track of this.mediaStream.getTracks()) {
+      track.stop();
+    }
+    this.mediaStream = null;
+  }
+  normalizeErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+  detachPlayer(player) {
+    const index = this.activePlayers.indexOf(player);
+    if (index >= 0) {
+      this.activePlayers.splice(index, 1);
+    }
+    player.audio.onended = null;
+    player.audio.onerror = null;
+    URL.revokeObjectURL(player.url);
+  }
+  async finishPlayback(player, reason) {
+    if (!this.activePlayers.includes(player)) {
+      return;
+    }
+    const payload = {
+      audioData: player.payload.audioData,
+      mimeType: player.payload.mimeType
+    };
+    this.detachPlayer(player);
+    await this.triggerSystemEvent(reason === "finished" ? "onPlayFinished" : "onPlayingStopped", payload);
+  }
+  async handlePageDeactivation() {
+    const hadActiveRecording = Boolean(this.mediaRecorder && this.mediaRecorder.state !== "inactive");
+    const hadActiveListening = this.listening;
+    if (!hadActiveRecording && !hadActiveListening) {
+      return;
+    }
+    if (hadActiveRecording) {
+      await this.handleRecordingError(new Error("Recording stopped because the browser tab became inactive"));
+      this.stopRecording();
+    }
+    if (hadActiveListening) {
+      await this.stopListening();
+      if (!hadActiveRecording) {
+        await this.handleListeningError(new Error("Listening stopped because the browser tab became inactive"));
+      }
+    }
+  }
+};
+
 // src/lib/widgets/adaptive-layout.ts
 var renderAdaptiveLayout = (env, node, _state, key, path, itemContext) => {
   const mobile = env.isMobileViewport();
@@ -5587,7 +6257,7 @@ var renderOverlayContainer = (env, node, _state, key, path, itemContext) => {
 var renderTabs = (env, node, state, key, path, itemContext) => {
   const tabs = node.tabs ?? [];
   const enabled = state.enabled ?? env.normalizeBoolean(node.enabled, true);
-  const rawActiveTab = typeof node.activeTab === "number" ? node.activeTab : state.activeTab ?? 0;
+  const rawActiveTab = typeof state.activeTab === "number" ? state.activeTab : typeof node.activeTab === "number" ? node.activeTab : 0;
   const activeTab = Math.max(0, Math.min(rawActiveTab, Math.max(tabs.length - 1, 0)));
   const headers = tabs.map((tab, index) => `<button class="vjt-tab-button${index === activeTab ? " is-active" : ""}" type="button" role="tab" aria-selected="${index === activeTab ? "true" : "false"}" data-widget="tabs" data-widget-key="${env.escapeHtml(key)}" data-tab-index="${index}"${enabled ? "" : " disabled"}>${env.escapeHtml(env.resolveI18nValue(tab.name))}</button>`).join("");
   const content = tabs[activeTab]?.content ? env.renderNode(tabs[activeTab].content, `${path}.tabs.${activeTab}`, itemContext) : "";
@@ -5945,8 +6615,6 @@ function bindDelegatedUi(root, env) {
         const state = env.stateByKey.get(key);
         if (state) {
           state.activeTab = Number.parseInt(tabButton.dataset.tabIndex ?? "0", 10) || 0;
-          const tabsNode = node;
-          tabsNode.activeTab = state.activeTab;
         }
         await env.rerenderRoot();
         return;
@@ -6183,12 +6851,14 @@ var RuntimeRenderer = class {
   stateByKey = /* @__PURE__ */ new Map();
   nodeById = /* @__PURE__ */ new Map();
   stateById = /* @__PURE__ */ new Map();
+  vars = /* @__PURE__ */ new Map();
   resizeHandler = null;
   pointerHandler = null;
   eventSources = [];
   referenceRuntime;
   networkRuntime;
   actionRuntime;
+  voiceRuntime;
   splitterDragState = null;
   hasTriggeredInitialRefresh = false;
   activeModalId = null;
@@ -6255,6 +6925,10 @@ var RuntimeRenderer = class {
             break;
         }
       },
+      getVarValue: (name) => this.vars.get(name),
+      setVarValue: (name, value) => {
+        this.vars.set(name, value);
+      },
       ensureWidgetState: (node, key) => this.ensureWidgetState(node, key),
       resolveItemNodeKey: (node, listKey, index, fallbackPath) => this.resolveItemNodeKey(node, listKey, index, fallbackPath),
       indexListElementNodes: (listNode, element, index) => this.indexListElementNodes(listNode, element, index)
@@ -6268,12 +6942,17 @@ var RuntimeRenderer = class {
       runActions: (actions, inputValue, context) => this.actionRuntime.runActions(actions, inputValue, context),
       rerenderRoot: () => this.rerenderRoot()
     });
+    this.voiceRuntime = new VoiceRuntime({
+      debugLogging: this.debugLogging,
+      triggerSystemEvent: (eventName, inputValue) => this.triggerRuntimeSystemEvent(eventName, inputValue)
+    });
     this.actionRuntime = new ActionRuntime({
       debugLogging: this.debugLogging,
       actionsMap: this.actionsMap,
       actionFunctions: this.actionFunctions,
       nodeById: this.nodeById,
       stateById: this.stateById,
+      stateByKey: this.stateByKey,
       rerenderRoot: () => this.rerenderRoot(),
       dispatchWidgetEvent: (node, eventName, key, inputValue, pointer) => this.actionRuntime.dispatchWidgetEvent(node, eventName, key, inputValue, pointer),
       executeRequest: (requestName, currentValue) => this.networkRuntime.executeRequest(requestName, currentValue),
@@ -6283,6 +6962,14 @@ var RuntimeRenderer = class {
       resolveMappedValue: (template, currentValue, responseValue) => this.referenceRuntime.resolveMappedValue(template, currentValue, responseValue),
       setWidgetEnabled: (widgetId, enabled) => this.setWidgetEnabled(widgetId, enabled),
       clearWidget: (widgetId) => this.clearWidget(widgetId),
+      clearListElementState: (listKey) => this.clearListElementState(listKey),
+      focusWidget: (reference) => this.focusWidget(reference),
+      playAudio: (value) => this.voiceRuntime.play(value),
+      stopPlaying: () => this.voiceRuntime.stopPlaying(),
+      startRecording: () => this.voiceRuntime.startRecording(),
+      stopRecording: () => Promise.resolve(this.voiceRuntime.stopRecording()),
+      startListening: () => this.voiceRuntime.startListening(),
+      stopListening: () => this.voiceRuntime.stopListening(),
       setUiReference: (widgetId, resourceRef) => {
         const node = this.nodeById.get(widgetId);
         if (!node || node.widget !== "ui-reference") {
@@ -6376,6 +7063,7 @@ var RuntimeRenderer = class {
         source.close();
       }
       this.eventSources.length = 0;
+      this.voiceRuntime.dispose();
     };
   }
   rerenderRoot() {
@@ -6383,7 +7071,7 @@ var RuntimeRenderer = class {
       return Promise.resolve();
     }
     this.reindexStaticTree();
-    const preservedState = captureElementState(this.root, this.pendingResetModalIds, this.stateByKey);
+    const preservedState = captureElementState(this.root, this.pendingResetModalIds);
     this.root.innerHTML = this.renderMarkup();
     this.root.classList.toggle("vjt-root--mobile", isMobileViewport());
     this.root.classList.toggle("vjt-root--desktop", !isMobileViewport());
@@ -6392,7 +7080,7 @@ var RuntimeRenderer = class {
     }
     this.attachInputBehavior(this.root);
     this.attachWidgetEvents(this.root);
-    restoreElementState(this.root, preservedState);
+    restoreElementState(this.root, preservedState, this.stateByKey);
     this.activeContextMenu = adjustContextMenuPosition(this.root, this.activeContextMenu);
     this.pendingResetModalIds.clear();
     if (typeof this.onRuntimeSnapshot === "function") {
@@ -6407,6 +7095,17 @@ var RuntimeRenderer = class {
     }
     await this.actionRuntime.runActions(actions, null, { currentValue: null });
   }
+  async triggerRuntimeSystemEvent(eventName, inputValue) {
+    const actions = this.systemEvents[eventName];
+    if (!actions?.length) {
+      return;
+    }
+    await this.actionRuntime.runActions(actions, inputValue, {
+      currentValue: inputValue,
+      responseValue: inputValue
+    });
+    await this.rerenderRoot();
+  }
   async navigateTo(url) {
     if (typeof window === "undefined" || !url.trim()) {
       return;
@@ -6461,6 +7160,12 @@ var RuntimeRenderer = class {
         this.stateById.set(restoredState.id, restoredState);
       }
     }
+    this.vars.clear();
+    for (const [name, value] of snapshot.vars ?? []) {
+      if (typeof name === "string" && name.length > 0) {
+        this.vars.set(name, deepClone(value));
+      }
+    }
     if (snapshot.activeModalId && this.nodeById.get(snapshot.activeModalId)?.widget === "modal-window") {
       this.activeModalId = snapshot.activeModalId;
     }
@@ -6471,6 +7176,7 @@ var RuntimeRenderer = class {
   createRuntimeSnapshot() {
     return {
       stateByKey: Array.from(this.stateByKey.entries(), ([key, state]) => [key, deepClone(state)]),
+      vars: Array.from(this.vars.entries(), ([name, value]) => [name, deepClone(value)]),
       activeModalId: this.activeModalId,
       activeContextMenu: this.activeContextMenu ? deepClone(this.activeContextMenu) : null
     };
@@ -7414,6 +8120,28 @@ var RuntimeRenderer = class {
   clearListElementState(listKey) {
     this.referenceRuntime.clearListElementState(listKey);
   }
+  focusWidget(reference) {
+    if (!(this.root instanceof HTMLElement)) {
+      return;
+    }
+    const widgetId = reference.split(".")[0]?.trim();
+    if (!widgetId) {
+      return;
+    }
+    const directTarget = this.root.querySelector(`#${CSS.escape(widgetId)}`);
+    if (directTarget && typeof directTarget.focus === "function") {
+      directTarget.focus({ preventScroll: true });
+      return;
+    }
+    const widgetRoot = this.root.querySelector(`[data-widget-id="${CSS.escape(widgetId)}"]`);
+    if (!widgetRoot) {
+      return;
+    }
+    const nestedTarget = widgetRoot.matches("input, textarea, select, button, a[href], [tabindex]") ? widgetRoot : widgetRoot.querySelector("input, textarea, select, button, a[href], [tabindex]");
+    if (nestedTarget && typeof nestedTarget.focus === "function") {
+      nestedTarget.focus({ preventScroll: true });
+    }
+  }
 };
 function renderJson(description, options = {}) {
   const renderer = new RuntimeRenderer(description, options);

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

@@ -6,6 +6,8 @@ export type ActionExecutionContext = {
         x: number;
         y: number;
     } | null;
+    currentList?: unknown[];
+    currentIndex?: number;
 };
 type ActionRuntimeOptions = {
     debugLogging: boolean;
@@ -13,6 +15,7 @@ type ActionRuntimeOptions = {
     actionFunctions: Record<string, () => unknown>;
     nodeById: Map<string, DescriptionNode>;
     stateById: Map<string, WidgetState>;
+    stateByKey: Map<string, WidgetState>;
     rerenderRoot: () => Promise<void>;
     dispatchWidgetEvent: (node: DescriptionNode, eventName: WidgetEventName, key: string, inputValue?: unknown, pointer?: {
         x: number;
@@ -27,6 +30,14 @@ type ActionRuntimeOptions = {
     resolveMappedValue: (template: unknown, currentValue: unknown, responseValue: unknown) => unknown;
     setWidgetEnabled: (widgetId: string, enabled: boolean) => void;
     clearWidget: (widgetId: string) => void;
+    clearListElementState: (listKey: string) => void;
+    focusWidget: (reference: string) => void;
+    playAudio: (value: unknown) => Promise<void>;
+    stopPlaying: () => Promise<void>;
+    startRecording: () => Promise<void>;
+    stopRecording: () => Promise<void>;
+    startListening: () => Promise<void>;
+    stopListening: () => Promise<void>;
     setUiReference: (widgetId: string, resourceRef: string) => void;
     refreshWidgetTree: (widgetId: string) => Promise<void>;
     renderWidgetTree: (widgetId: string) => Promise<void>;
@@ -54,6 +65,7 @@ export declare class ActionRuntime {
     private readonly actionFunctions;
     private readonly nodeById;
     private readonly stateById;
+    private readonly stateByKey;
     private readonly rerenderRoot;
     private readonly dispatchWidgetEventImpl;
     private readonly executeRequest;
@@ -63,6 +75,14 @@ export declare class ActionRuntime {
     private readonly resolveMappedValue;
     private readonly setWidgetEnabled;
     private readonly clearWidget;
+    private readonly clearListElementState;
+    private readonly focusWidget;
+    private readonly playAudio;
+    private readonly stopPlaying;
+    private readonly startRecording;
+    private readonly stopRecording;
+    private readonly startListening;
+    private readonly stopListening;
     private readonly setUiReference;
     private readonly refreshWidgetTree;
     private readonly renderWidgetTree;
@@ -82,5 +102,9 @@ export declare class ActionRuntime {
     getInlineActionsForNode(node: DescriptionNode): ActionDefinition[] | undefined;
     private runSingleAction;
     private executeAction;
+    private unwrapListValue;
+    private getCurrentListState;
+    private cloneValue;
+    private stringifyValue;
 }
 export {};

package/dist/lib/dom-state.d.ts

@@ -15,8 +15,8 @@ export type PreservedElementState = {
     }>;
 };
 export declare function isElementInsidePendingResetModal(element: HTMLElement, pendingResetModalIds: Set<string>): boolean;
-export declare function captureElementState(root: HTMLElement, pendingResetModalIds: Set<string>, stateByKey: Map<string, WidgetState>): PreservedElementState;
-export declare function restoreElementState(root: HTMLElement, state: PreservedElementState): void;
+export declare function captureElementState(root: HTMLElement, pendingResetModalIds: Set<string>): PreservedElementState;
+export declare function restoreElementState(root: HTMLElement, state: PreservedElementState, stateByKey: Map<string, WidgetState>): void;
 export declare function adjustContextMenuPosition(root: HTMLElement, activeContextMenu: {
     id: string;
     x: number;

package/dist/lib/network.d.ts

@@ -25,6 +25,8 @@ export declare class NetworkRuntime {
     executeRequest(requestName: string, currentValue: unknown): Promise<unknown>;
     buildSchemaValue(schema: RequestSchema, currentValue: unknown, responseValue: unknown): Promise<unknown>;
     private stringifyPrimitive;
+    private createRequestError;
+    private toRequestErrorPayload;
     coercePrimitiveSchemaValue(type: PrimitiveRequestType, value: unknown): unknown;
     private handleSseEvent;
 }

package/dist/lib/references.d.ts

@@ -6,6 +6,8 @@ type ReferenceRuntimeHost = {
     readonly nodeByKey: Map<string, DescriptionNode>;
     getAppValue: (name: string) => unknown;
     setAppValue: (name: string, value: unknown) => void;
+    getVarValue: (name: string) => unknown;
+    setVarValue: (name: string, value: unknown) => void;
     ensureWidgetState: (node: DescriptionNode, key: string) => WidgetState;
     resolveItemNodeKey: (node: DescriptionNode, listKey: string, index: number, fallbackPath: string) => string;
     indexListElementNodes: (listNode: ListNode | GridViewNode, element: DescriptionNode, index: number) => void;

package/dist/lib/types.d.ts

@@ -4,7 +4,7 @@ export type TextAlign = 'left' | 'center' | 'right';
 export type VerticalAlign = 'top' | 'center' | 'bottom';
 export type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
 export type WidgetEventName = 'onClick' | 'onUserValueChange' | 'onRefresh' | 'onEnter' | 'onShiftEnter' | 'onControlEnter';
-export type SystemEventName = 'onBeforeRender' | 'onAfterRender' | 'onBeforeNavigate' | 'onAfterNavigate';
+export type SystemEventName = 'onBeforeRender' | 'onAfterRender' | 'onBeforeNavigate' | 'onAfterNavigate' | 'onSpeechDetected' | 'onRecordingStarted' | 'onRecordingStopped' | 'onRecordingError' | 'onListeningError' | 'onListeringError' | 'onPlayFinished' | 'onPlayingStopped';
 export type PrimitiveRequestType = 'int' | 'float' | 'boolean' | 'string';
 export type ActionDefinition = {
     action: string;
@@ -34,6 +34,7 @@ export type RequestDefinition = {
     request: RequestSchema;
     response?: RequestSchema;
     onResponse?: ActionDefinition[];
+    onError?: ActionDefinition[];
 };
 export type SseEventDefinition = {
     name: string;
@@ -114,6 +115,7 @@ export type WidgetState = {
 };
 export type RuntimeSnapshot = {
     stateByKey: Array<[string, WidgetState]>;
+    vars: Array<[string, unknown]>;
     activeModalId: string | null;
     activeContextMenu: {
         id: string;

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

@@ -0,0 +1,48 @@
+import type { SystemEventName } from './types.js';
+type VoiceRuntimeOptions = {
+    debugLogging: boolean;
+    triggerSystemEvent: (eventName: SystemEventName, inputValue: unknown) => Promise<void>;
+};
+export declare class VoiceRuntime {
+    private readonly debugLogging;
+    private readonly triggerSystemEvent;
+    private readonly activePlayers;
+    private mediaStream;
+    private mediaRecorder;
+    private recordingChunks;
+    private recordingTimeoutId;
+    private listening;
+    private listenContext;
+    private listenAnalyser;
+    private listenSource;
+    private listenFrameId;
+    private lastSpeechAt;
+    private listeningStartedAt;
+    private recordingStartedFromListening;
+    private speechEventTriggered;
+    private readonly visibilityHandler;
+    private readonly pageHideHandler;
+    constructor(options: VoiceRuntimeOptions);
+    play(value: unknown): Promise<void>;
+    stopPlaying(): Promise<void>;
+    startRecording(): Promise<void>;
+    stopRecording(): void;
+    startListening(): Promise<void>;
+    stopListening(): Promise<void>;
+    dispose(): void;
+    private startRecordingInternal;
+    private handleRecorderStop;
+    private handleRecordingError;
+    private handleListeningError;
+    private normalizePlayablePayload;
+    private getPreferredRecordingMimeType;
+    private ensureInputStream;
+    private clearRecordingTimeout;
+    private releaseInputStreamIfIdle;
+    private stopStreamTracks;
+    private normalizeErrorMessage;
+    private detachPlayer;
+    private finishPlayback;
+    private handlePageDeactivation;
+}
+export {};

package/package.json

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