@vortexm/vjt 0.1.4 → 0.1.6

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,17 @@ var ActionRuntime = class {
   resolveMappedValue;
   setWidgetEnabled;
   clearWidget;
+  clearListElementState;
+  focusWidget;
+  playAudio;
+  stopPlaying;
+  copyToClipboard;
+  selectFile;
+  confirmModal;
+  startRecording;
+  stopRecording;
+  startListening;
+  stopListening;
   setUiReference;
   refreshWidgetTree;
   renderWidgetTree;
@@ -4514,6 +4605,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 +4615,17 @@ 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.copyToClipboard = options.copyToClipboard;
+    this.selectFile = options.selectFile;
+    this.confirmModal = options.confirmModal;
+    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;
@@ -4557,7 +4660,7 @@ var ActionRuntime = class {
   async runActions(actions, inputValue, context) {
     let current = inputValue;
     for (const action of actions) {
-      current = await this.runSingleAction(action, current, context);
+      current = await this.runSingleAction(action, inputValue, context);
     }
     return current;
   }
@@ -4569,19 +4672,7 @@ var ActionRuntime = class {
     try {
       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);
-            }
-          }
-          output = collected;
-        } else if (output !== null && output !== void 0) {
+        if (output !== null && output !== void 0) {
           output = await this.runActions(action.andThen, output, { ...context, currentValue: output });
         } else {
           output = null;
@@ -4641,6 +4732,40 @@ 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 === "copyToClipboard") {
+      await this.copyToClipboard(inputValue);
+      return inputValue;
+    }
+    if (name === "selectFile") {
+      return this.selectFile(action.args);
+    }
+    if (name === "confirmModal") {
+      return await this.confirmModal(action.args, inputValue) ? inputValue : void 0;
+    }
+    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);
@@ -4651,7 +4776,9 @@ var ActionRuntime = class {
       this.setActiveContextMenu({
         id: menuId,
         x: position.x,
-        y: position.y
+        y: position.y,
+        currentValue: context.currentValue,
+        openPath: []
       });
       return null;
     }
@@ -4680,6 +4807,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 : "";
@@ -4689,7 +4820,11 @@ var ActionRuntime = class {
       return inputValue;
     }
     if (name.startsWith("get ")) {
-      return this.resolveReference(name.slice(4), context.currentValue, context.responseValue);
+      const reference = name.slice(4);
+      if (Array.isArray(context.currentValue) && this.isCurrentScopedReference(reference)) {
+        return context.currentValue.map((entry) => this.resolveReference(reference, entry, context.responseValue)).filter((entry) => entry !== null && entry !== void 0);
+      }
+      return this.resolveReference(reference, context.currentValue, context.responseValue);
     }
     if (name.startsWith("equals ")) {
       return this.resolveReference(name.slice(7), context.currentValue, context.responseValue) === action.args;
@@ -4702,11 +4837,82 @@ 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);
+      const reference = name.slice(7);
+      if (Array.isArray(context.currentValue) && this.isCurrentScopedReference(reference)) {
+        return context.currentValue.filter((entry) => this.resolveReference(reference, entry, context.responseValue));
+      }
+      const value = this.resolveReference(reference, 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") {
+      if (Array.isArray(context.currentValue)) {
+        return context.currentValue.map((entry) => this.resolveMappedValue(action.args, entry, context.responseValue));
+      }
       return this.resolveMappedValue(action.args, context.currentValue, context.responseValue);
     }
     if (name === "ifelse") {
@@ -4722,10 +4928,43 @@ 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);
+  }
+  isCurrentScopedReference(reference) {
+    return reference === "current" || reference.startsWith("current.") || reference.startsWith("this.") || reference === "this";
+  }
 };
 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 +4993,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 +5021,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 +5042,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 +5382,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 +6264,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) : "";
@@ -5654,6 +6331,21 @@ function renderModalOverlay(env, modalId) {
 }
 
 // src/lib/widgets/context-menu.ts
+var MENU_WIDTH = 220;
+var MENU_ITEM_HEIGHT = 44;
+var MENU_PADDING = 8;
+function getContextMenuItemAtPath(items, path) {
+  let currentItems = items ?? [];
+  let currentItem = null;
+  for (const index of path) {
+    currentItem = currentItems[index] ?? null;
+    if (!currentItem) {
+      return null;
+    }
+    currentItems = currentItem.items ?? [];
+  }
+  return currentItem;
+}
 function renderContextMenuOverlay(env, menu) {
   const node = env.nodeById.get(menu.id);
   if (!node || node.widget !== "context-menu") {
@@ -5661,8 +6353,52 @@ function renderContextMenuOverlay(env, menu) {
   }
   const state = env.ensureWidgetState(node, menu.id);
   const enabled = state.enabled ?? env.normalizeBoolean(node.enabled, true);
-  const items = (node.items ?? []).map((item, index) => `<button class="vjt-context-menu-item" type="button" data-context-menu-item="${env.escapeHtml(menu.id)}:${index}"${enabled ? "" : " disabled"}>${env.escapeHtml(env.resolveI18nValue(item.name))}</button>`).join("");
-  return `<div class="vjt-context-menu-backdrop" data-context-menu-backdrop="${env.escapeHtml(menu.id)}"><div class="vjt-context-menu" style="left:${menu.x}px;top:${menu.y}px">${items}</div></div>`;
+  const openPath = Array.isArray(menu.openPath) ? menu.openPath : [];
+  const layers = [];
+  let items = node.items ?? [];
+  let pathPrefix = [];
+  let layerX = menu.x;
+  let layerY = menu.y;
+  while (items.length > 0) {
+    layers.push(renderMenuLayer(env, menu.id, items, enabled, layerX, layerY, pathPrefix));
+    const nextIndex = openPath[pathPrefix.length];
+    if (typeof nextIndex !== "number") {
+      break;
+    }
+    const nextItem = items[nextIndex];
+    if (!nextItem?.items?.length) {
+      break;
+    }
+    const proposedY = layerY + MENU_PADDING + nextIndex * MENU_ITEM_HEIGHT;
+    const rightX = layerX + MENU_WIDTH - MENU_PADDING;
+    const leftX = layerX - MENU_WIDTH + MENU_PADDING;
+    layerX = rightX + MENU_WIDTH <= window.innerWidth ? rightX : Math.max(8, leftX);
+    layerY = Math.max(8, Math.min(proposedY, window.innerHeight - (16 + nextItem.items.length * MENU_ITEM_HEIGHT) - 8));
+    items = nextItem.items;
+    pathPrefix = [...pathPrefix, nextIndex];
+  }
+  return `<div class="vjt-context-menu-backdrop" data-context-menu-backdrop="${env.escapeHtml(menu.id)}">${layers.join("")}</div>`;
+}
+function renderMenuLayer(env, menuId, items, enabled, x, y, pathPrefix) {
+  const content = items.map((item, index) => {
+    const path = [...pathPrefix, index];
+    const pathText = path.join(".");
+    const label = env.escapeHtml(env.resolveI18nValue(item.name));
+    const disabled = enabled ? "" : " disabled";
+    if (item.items?.length) {
+      return `<button class="vjt-context-menu-item vjt-context-menu-item--parent" type="button" data-context-menu-expand="${env.escapeHtml(menuId)}:${env.escapeHtml(pathText)}"${disabled}><span>${label}</span><span class="vjt-context-menu-chevron">&gt;</span></button>`;
+    }
+    return `<button class="vjt-context-menu-item" type="button" data-context-menu-item="${env.escapeHtml(menuId)}:${env.escapeHtml(pathText)}"${disabled}>${label}</button>`;
+  }).join("");
+  return `<div class="vjt-context-menu" style="left:${x}px;top:${y}px">${content}</div>`;
+}
+
+// src/lib/widgets/confirm-modal.ts
+function renderConfirmModalOverlay(env, modal) {
+  const caption = env.escapeHtml(env.resolveI18nValue(modal.caption));
+  const yes = env.escapeHtml(env.resolveI18nValue(modal.yes));
+  const no = env.escapeHtml(env.resolveI18nValue(modal.no));
+  return `<div class="vjt-confirm-backdrop" data-confirm-backdrop="true"><div class="vjt-confirm-window"><div class="vjt-confirm-caption">${caption}</div><div class="vjt-confirm-actions"><button class="vjt-button vjt-button--bright" type="button" data-confirm-yes="true">${yes}</button><button class="vjt-button vjt-button--regular" type="button" data-confirm-no="true">${no}</button></div></div></div>`;
 }
 
 // src/lib/widgets/bindings.ts
@@ -5854,7 +6590,7 @@ function bindWidgetEvents(root, env) {
       });
       continue;
     }
-    if (element instanceof HTMLAnchorElement && element.dataset.widget === "link" && env.getInlineActions(node)?.length) {
+    if (element instanceof HTMLAnchorElement && element.dataset.widget === "link" && (node.events?.onClick?.length || env.getInlineActions(node)?.length)) {
       element.addEventListener("pointerdown", (event) => {
         env.setLastPointer({ x: event.clientX, y: event.clientY });
       });
@@ -5924,6 +6660,45 @@ function bindDelegatedUi(root, env) {
   window.addEventListener("pointercancel", () => {
     env.stopSplitterDrag();
   });
+  root.addEventListener("pointerover", (event) => {
+    void (async () => {
+      const target = event.target;
+      if (!(target instanceof Element)) {
+        return;
+      }
+      const hoveredItem = target.closest("[data-context-menu-item], [data-context-menu-expand]");
+      if (!(hoveredItem instanceof HTMLButtonElement)) {
+        return;
+      }
+      const descriptor = hoveredItem.dataset.contextMenuExpand ?? hoveredItem.dataset.contextMenuItem;
+      if (!descriptor) {
+        return;
+      }
+      const [menuId, pathText = ""] = descriptor.split(":");
+      const node = env.nodeById.get(menuId);
+      if (node?.widget !== "context-menu") {
+        return;
+      }
+      const activeMenu = env.getActiveContextMenu();
+      if (!activeMenu || activeMenu.id !== menuId) {
+        return;
+      }
+      const path = parseMenuPath(pathText);
+      const item = getContextMenuItemAtPath(node.items, path);
+      if (!item) {
+        return;
+      }
+      const nextOpenPath = item.items?.length ? path : path.slice(0, -1);
+      if (samePath(activeMenu.openPath ?? [], nextOpenPath)) {
+        return;
+      }
+      env.setActiveContextMenu({
+        ...activeMenu,
+        openPath: nextOpenPath
+      });
+      await env.rerenderRoot();
+    })();
+  });
   root.addEventListener("click", (event) => {
     void (async () => {
       const target = event.target;
@@ -5945,8 +6720,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;
@@ -6004,7 +6777,7 @@ function bindDelegatedUi(root, env) {
       }
       const menuItem = target.closest("[data-context-menu-item]");
       if (menuItem instanceof HTMLButtonElement) {
-        const [menuId, indexValue] = (menuItem.dataset.contextMenuItem ?? "").split(":");
+        const [menuId, pathText = ""] = (menuItem.dataset.contextMenuItem ?? "").split(":");
         const node = env.nodeById.get(menuId);
         if (node?.widget !== "context-menu") {
           return;
@@ -6012,14 +6785,30 @@ function bindDelegatedUi(root, env) {
         if (!env.isWidgetEnabled(node, menuId)) {
           return;
         }
-        const item = node.items?.[Number.parseInt(indexValue, 10) || 0];
+        const item = getContextMenuItemAtPath(node.items, parseMenuPath(pathText));
+        const menuContext = env.getActiveContextMenu();
+        const currentValue = menuContext?.id === menuId ? menuContext.currentValue ?? null : null;
         env.setActiveContextMenu(null);
         if (item?.actions?.length) {
-          await env.runActions(item.actions, null, { currentValue: null });
+          await env.runActions(item.actions, currentValue, { currentValue });
         }
         await env.rerenderRoot();
         return;
       }
+      const menuParentItem = target.closest("[data-context-menu-expand]");
+      if (menuParentItem instanceof HTMLButtonElement) {
+        const [menuId, pathText = ""] = (menuParentItem.dataset.contextMenuExpand ?? "").split(":");
+        const activeMenu = env.getActiveContextMenu();
+        if (!activeMenu || activeMenu.id !== menuId) {
+          return;
+        }
+        env.setActiveContextMenu({
+          ...activeMenu,
+          openPath: parseMenuPath(pathText)
+        });
+        await env.rerenderRoot();
+        return;
+      }
       const modalButton = target.closest("[data-modal-button]");
       if (modalButton instanceof HTMLButtonElement) {
         const [modalId, indexValue] = (modalButton.dataset.modalButton ?? "").split(":");
@@ -6035,10 +6824,32 @@ function bindDelegatedUi(root, env) {
           await env.runActions(item.actions, null, { currentValue: null });
         }
         await env.rerenderRoot();
+        return;
+      }
+      if (target.closest("[data-confirm-yes]")) {
+        env.resolveConfirmModal(true);
+        await env.rerenderRoot();
+        return;
+      }
+      if (target.closest("[data-confirm-no]")) {
+        env.resolveConfirmModal(false);
+        await env.rerenderRoot();
       }
     })();
   });
 }
+function parseMenuPath(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(".").map((part) => Number.parseInt(part, 10)).filter((part) => !Number.isNaN(part));
+}
+function samePath(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((value, index) => value === right[index]);
+}
 
 // src/lib/render.ts
 var DEFAULT_DATE_FORMAT = "dd.MM.yyyy";
@@ -6183,16 +6994,19 @@ 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;
   activeContextMenu = null;
+  activeConfirmModal = null;
   lastPointer = { x: 24, y: 24 };
   pendingResetModalIds = /* @__PURE__ */ new Set();
   constructor(description, options = {}) {
@@ -6255,6 +7069,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 +7086,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 +7106,17 @@ 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(),
+      copyToClipboard: (value) => this.copyToClipboard(value),
+      selectFile: (args) => this.selectFile(args),
+      confirmModal: (args, inputValue) => this.confirmModal(args, inputValue),
+      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 +7210,7 @@ var RuntimeRenderer = class {
         source.close();
       }
       this.eventSources.length = 0;
+      this.voiceRuntime.dispose();
     };
   }
   rerenderRoot() {
@@ -6383,7 +7218,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 +7227,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 +7242,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;
@@ -6425,6 +7271,138 @@ var RuntimeRenderer = class {
     await this.rerenderRoot();
     await this.runSystemEvent("onAfterNavigate");
   }
+  async copyToClipboard(value) {
+    const text = value == null ? "" : typeof value === "string" ? value : JSON.stringify(value) ?? "";
+    if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+      await navigator.clipboard.writeText(text);
+      return;
+    }
+    if (typeof document === "undefined") {
+      throw new Error("Clipboard API is unavailable");
+    }
+    const textarea = document.createElement("textarea");
+    textarea.value = text;
+    textarea.setAttribute("readonly", "true");
+    textarea.style.position = "fixed";
+    textarea.style.left = "-9999px";
+    textarea.style.top = "0";
+    document.body.append(textarea);
+    textarea.focus();
+    textarea.select();
+    const copied = document.execCommand("copy");
+    textarea.remove();
+    if (!copied) {
+      throw new Error("Failed to copy value to clipboard");
+    }
+  }
+  async selectFile(args) {
+    if (typeof document === "undefined") {
+      throw new Error("File selection is unavailable");
+    }
+    const options = isPlainObject4(args) ? args : {};
+    const input = document.createElement("input");
+    input.type = "file";
+    input.style.position = "fixed";
+    input.style.left = "-9999px";
+    input.style.top = "0";
+    if (typeof options.accept === "string" && options.accept.trim()) {
+      input.accept = options.accept;
+    }
+    input.multiple = options.multiple === true;
+    const selection = new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (value) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve(value);
+      };
+      const fail = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        reject(error instanceof Error ? error : new Error(String(error)));
+      };
+      const cleanup = () => {
+        window.removeEventListener("focus", handleFocus, true);
+        input.remove();
+      };
+      const handleFocus = () => {
+        window.setTimeout(() => {
+          if (!settled && (!input.files || input.files.length === 0)) {
+            cleanup();
+            finish(null);
+          }
+        }, 250);
+      };
+      input.addEventListener("change", () => {
+        void (async () => {
+          try {
+            const files = Array.from(input.files ?? []);
+            const converted = await Promise.all(files.map((file) => this.readSelectedFile(file)));
+            cleanup();
+            finish(input.multiple ? converted : converted[0] ?? null);
+          } catch (error) {
+            cleanup();
+            fail(error);
+          }
+        })();
+      }, { once: true });
+      input.addEventListener("cancel", () => {
+        cleanup();
+        finish(null);
+      }, { once: true });
+      window.addEventListener("focus", handleFocus, true);
+      document.body.append(input);
+      input.click();
+    });
+    return selection;
+  }
+  readSelectedFile(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onerror = () => {
+        reject(reader.error ?? new Error(`Failed to read file ${file.name}`));
+      };
+      reader.onload = () => {
+        const result = typeof reader.result === "string" ? reader.result : "";
+        const [, data = ""] = result.split(",", 2);
+        resolve({
+          name: file.name,
+          mimeType: file.type || "application/octet-stream",
+          size: file.size,
+          data
+        });
+      };
+      reader.readAsDataURL(file);
+    });
+  }
+  async confirmModal(args, _inputValue) {
+    const options = isPlainObject4(args) ? args : {};
+    const caption = typeof options.caption === "string" && options.caption ? options.caption : "Confirm?";
+    const yes = typeof options.yes === "string" && options.yes ? options.yes : "Yes";
+    const no = typeof options.no === "string" && options.no ? options.no : "No";
+    return new Promise((resolve) => {
+      this.activeConfirmModal?.resolve(false);
+      this.activeConfirmModal = {
+        caption,
+        yes,
+        no,
+        resolve
+      };
+      void this.rerenderRoot();
+    });
+  }
+  resolveConfirmModal(confirmed) {
+    const activeModal = this.activeConfirmModal;
+    if (!activeModal) {
+      return;
+    }
+    this.activeConfirmModal = null;
+    activeModal.resolve(confirmed);
+  }
   reindexStaticTree() {
     this.nodeByKey.clear();
     this.nodeById.clear();
@@ -6461,6 +7439,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,8 +7455,13 @@ 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
+      activeContextMenu: this.activeContextMenu ? {
+        id: this.activeContextMenu.id,
+        x: this.activeContextMenu.x,
+        y: this.activeContextMenu.y
+      } : null
     };
   }
   indexStaticNodes(node, path) {
@@ -6982,7 +7971,8 @@ var RuntimeRenderer = class {
     const env = this.getWidgetRenderEnvironment();
     const modalMarkup = this.activeModalId ? renderModalOverlay(env, this.activeModalId) : "";
     const menuMarkup = this.activeContextMenu ? renderContextMenuOverlay(env, this.activeContextMenu) : "";
-    return `${modalMarkup}${menuMarkup}`;
+    const confirmMarkup = this.activeConfirmModal ? renderConfirmModalOverlay(env, this.activeConfirmModal) : "";
+    return `${modalMarkup}${menuMarkup}${confirmMarkup}`;
   }
   updatePointerFromEvent(event) {
     this.lastPointer = updatePointerFromMouseEvent(event);
@@ -7209,6 +8199,7 @@ var RuntimeRenderer = class {
       nodeByKey: this.nodeByKey,
       stateByKey: this.stateByKey,
       getLastPointer: () => this.lastPointer,
+      getActiveContextMenu: () => this.activeContextMenu,
       setActiveContextMenu: (menu) => {
         this.activeContextMenu = menu;
       },
@@ -7218,6 +8209,7 @@ var RuntimeRenderer = class {
       updateSplitterDrag: (clientPosition) => this.updateSplitterDrag(clientPosition),
       stopSplitterDrag: () => this.stopSplitterDrag(),
       hasSplitterDrag: () => this.splitterDragState !== null,
+      resolveConfirmModal: (confirmed) => this.resolveConfirmModal(confirmed),
       closeModal: (modalId) => this.closeModal(modalId),
       rerenderRoot: () => this.rerenderRoot(),
       redispatchUnderlyingClick: (x, y) => this.redispatchUnderlyingClick(x, y),
@@ -7414,6 +8406,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);