@vortexm/vjt 0.1.3 → 0.1.5

package/dist/index.js

@@ -3682,6 +3682,16 @@ function logRuntimeError(scope, error, details) {
   }
   console.error("[VJT error]", payload);
 }
+function logRuntimeDebug(enabled, scope, payload) {
+  if (!enabled) {
+    return;
+  }
+  if (payload === void 0) {
+    console.log("[VJT debug]", scope);
+    return;
+  }
+  console.log("[VJT debug]", scope, payload);
+}
 
 // src/lib/security.ts
 var BLOCKED_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
@@ -3838,6 +3848,7 @@ function sanitizeSchemaValue(schema, value, path = "value") {
 
 // src/lib/network.ts
 var NetworkRuntime = class {
+  debugLogging;
   requestsMap;
   sseConfigs;
   backendUrl;
@@ -3845,6 +3856,7 @@ var NetworkRuntime = class {
   runActions;
   rerenderRoot;
   constructor(options) {
+    this.debugLogging = options.debugLogging;
     this.requestsMap = options.requestsMap;
     this.sseConfigs = options.sseConfigs;
     this.backendUrl = options.backendUrl;
@@ -3892,55 +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 response = await fetch(safeRequestUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(requestEnvelope)
-    });
-    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: ${String(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}`);
-    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") {
@@ -3978,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": {
@@ -4011,6 +4109,12 @@ var NetworkRuntime = class {
     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,
+      parsedMessage,
+      message
+    });
     if (!eventDefinition.onEvent?.length) {
       return;
     }
@@ -4154,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) {
@@ -4279,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);
@@ -4452,10 +4563,12 @@ var ReferenceRuntime = class {
 
 // src/lib/action-runtime.ts
 var ActionRuntime = class {
+  debugLogging;
   actionsMap;
   actionFunctions;
   nodeById;
   stateById;
+  stateByKey;
   rerenderRoot;
   dispatchWidgetEventImpl;
   executeRequest;
@@ -4465,6 +4578,14 @@ var ActionRuntime = class {
   resolveMappedValue;
   setWidgetEnabled;
   clearWidget;
+  clearListElementState;
+  focusWidget;
+  playAudio;
+  stopPlaying;
+  startRecording;
+  stopRecording;
+  startListening;
+  stopListening;
   setUiReference;
   refreshWidgetTree;
   renderWidgetTree;
@@ -4476,10 +4597,12 @@ var ActionRuntime = class {
   getInlineActions;
   isWidgetEnabled;
   constructor(options) {
+    this.debugLogging = options.debugLogging;
     this.actionsMap = options.actionsMap;
     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;
@@ -4489,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;
@@ -4531,30 +4662,68 @@ var ActionRuntime = class {
     return this.getInlineActions(node);
   }
   async runSingleAction(action, inputValue, context) {
-    let output = await this.executeAction(action, inputValue, context);
-    if (action.andThen?.length) {
-      if (Array.isArray(output)) {
-        const collected = [];
-        for (const entry of output) {
-          if (entry === null || entry === void 0) {
-            continue;
-          }
-          const nestedOutput = await this.runActions(action.andThen, entry, { ...context, currentValue: entry });
-          if (nestedOutput !== null && nestedOutput !== void 0) {
-            collected.push(nestedOutput);
+    const actionName = action.action.trim();
+    try {
+      let output = await this.executeAction(action, inputValue, context);
+      if (action.andThen?.length) {
+        if (Array.isArray(output)) {
+          const collected = [];
+          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,
+              currentList: output,
+              currentIndex: index
+            });
+            if (nestedOutput !== null && nestedOutput !== void 0) {
+              if (Array.isArray(nestedOutput)) {
+                for (const item of nestedOutput) {
+                  if (item !== null && item !== void 0) {
+                    collected.push(item);
+                  }
+                }
+              } else {
+                collected.push(nestedOutput);
+              }
+            }
           }
+          output = collected;
+        } else if (output !== null && output !== void 0) {
+          output = await this.runActions(action.andThen, output, { ...context, currentValue: output });
+        } else {
+          output = null;
         }
-        output = collected;
-      } else if (output !== null && output !== void 0) {
-        output = await this.runActions(action.andThen, output, { ...context, currentValue: output });
-      } else {
-        output = null;
       }
+      logRuntimeDebug(this.debugLogging, "action-result", {
+        action: actionName,
+        output
+      });
+      return output;
+    } catch (error) {
+      logRuntimeError("action", error, {
+        action: actionName,
+        args: action.args,
+        inputValue,
+        currentValue: context.currentValue,
+        responseValue: context.responseValue,
+        pointer: context.pointer ?? null
+      });
+      throw error;
     }
-    return output;
   }
   async executeAction(action, inputValue, context) {
     const name = action.action.trim();
+    logRuntimeDebug(this.debugLogging, "action", {
+      action: name,
+      args: action.args,
+      inputValue,
+      currentValue: context.currentValue,
+      responseValue: context.responseValue,
+      pointer: context.pointer ?? null
+    });
     if (this.actionsMap[name]) {
       return this.runActions(this.actionsMap[name], inputValue, context);
     }
@@ -4582,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);
@@ -4621,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 : "";
@@ -4643,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);
     }
@@ -4663,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) {
@@ -4695,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(),
@@ -4723,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;
@@ -4758,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;
     }
   }
@@ -5070,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();
@@ -5528,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) : "";
@@ -5886,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;
@@ -6112,6 +6839,7 @@ var RuntimeRenderer = class {
   systemEvents;
   resourceManager;
   actionFunctions;
+  debugLogging;
   backendUrl;
   initialRuntimeSnapshot;
   onRuntimeSnapshot;
@@ -6123,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;
@@ -6152,6 +6882,7 @@ var RuntimeRenderer = class {
     this.sseConfigs = Array.isArray(resolvedSseConfigs) ? resolvedSseConfigs : resolvedSseConfigs ? [resolvedSseConfigs] : [];
     this.systemEvents = options.systemEvents ?? this.resourceManager?.getSystemEvents() ?? {};
     this.actionFunctions = options.actionFunctions ?? {};
+    this.debugLogging = options.debugLogging === true;
     this.backendUrl = options.backendUrl;
     this.initialRuntimeSnapshot = options.runtimeSnapshot ? deepClone(options.runtimeSnapshot) : null;
     this.onRuntimeSnapshot = options.onRuntimeSnapshot;
@@ -6194,11 +6925,16 @@ 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)
     });
     this.networkRuntime = new NetworkRuntime({
+      debugLogging: this.debugLogging,
       requestsMap: this.requestsMap,
       sseConfigs: this.sseConfigs,
       backendUrl: this.backendUrl,
@@ -6206,11 +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),
@@ -6220,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") {
@@ -6252,7 +7002,9 @@ var RuntimeRenderer = class {
     this.applyRuntimeSnapshot(this.initialRuntimeSnapshot);
   }
   renderMarkup() {
-    return `${this.renderNode(this.description, "root", null)}${this.renderGlobalOverlays()}`;
+    const markup = `${this.renderNode(this.description, "root", null)}${this.renderGlobalOverlays()}`;
+    logRuntimeDebug(this.debugLogging, "html", markup);
+    return markup;
   }
   mount(root, options = {}) {
     if (!(root instanceof HTMLElement)) {
@@ -6311,6 +7063,7 @@ var RuntimeRenderer = class {
         source.close();
       }
       this.eventSources.length = 0;
+      this.voiceRuntime.dispose();
     };
   }
   rerenderRoot() {
@@ -6318,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());
@@ -6327,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") {
@@ -6342,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;
@@ -6396,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;
     }
@@ -6406,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
     };
@@ -7349,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);