@garrix82/reactgenie-lib 1.3.0

package/dist/shared-store.js

@@ -0,0 +1,589 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createImmutableConstructorParamsSnapshot = createImmutableConstructorParamsSnapshot;
+exports.displayResult = displayResult;
+exports.executeGenieCode = executeGenieCode;
+exports.extractQueryIntentFromAst = extractQueryIntentFromAst;
+exports.resetGenieNavigation = resetGenieNavigation;
+exports.useGenieSelector = exports.useGenieCodeSelector = exports.uiActive = void 0;
+var _modalityProviderV = require("./modality-provider-v2");
+var _reactDecorators = require("./react-decorators");
+var _reactRedux = require("react-redux");
+var _reactgenieDsl = require("@garrix82/reactgenie-dsl");
+var _logger = require("./logger");
+var _errors = require("./errors");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+let uiActive = exports.uiActive = true;
+const DEFAULT_RESULT_WINDOW_MAX = 40;
+const DEFAULT_RESULT_WINDOW_TTL_MS = 5 * 60 * 1000;
+function getConstructorParamsFromResultValue(value) {
+  if (!value || typeof value._getConstructorParams !== "function") {
+    return null;
+  }
+  return value._getConstructorParams();
+}
+function deepFreezeObject(value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    const nested = value[key];
+    if (nested && typeof nested === "object" && !Object.isFrozen(nested)) {
+      deepFreezeObject(nested);
+    }
+  }
+  return value;
+}
+function cloneDetachedValue(value) {
+  try {
+    const nativeStructuredClone = globalThis.structuredClone;
+    const cloned = typeof nativeStructuredClone === "function" ? nativeStructuredClone(value) : JSON.parse(JSON.stringify(value));
+    return deepFreezeObject(cloned);
+  } catch (error) {
+    _logger.logger.warn("[ReactGenie] Unable to clone constructor params for result window snapshot", error);
+    return null;
+  }
+}
+function createImmutableConstructorParamsSnapshot(value) {
+  const constructorParams = getConstructorParamsFromResultValue(value);
+  if (!constructorParams || typeof constructorParams !== "object") {
+    return null;
+  }
+  const snapshot = cloneDetachedValue(constructorParams);
+  if (!snapshot || typeof snapshot !== "object") {
+    return null;
+  }
+  return snapshot;
+}
+function ensureResultWindowDefaults(state) {
+  // `genieDispatch` starts from a shallow copy of the previous state.
+  // Clone mutable result-window containers before writes so we don't mutate
+  // references from the previous Redux state snapshot.
+  state.resultWindowByRef = state.resultWindowByRef ? _objectSpread({}, state.resultWindowByRef) : {};
+  state.resultWindowOrder = state.resultWindowOrder ? [...state.resultWindowOrder] : [];
+  if (!state.resultWindowMax || state.resultWindowMax <= 0) {
+    state.resultWindowMax = DEFAULT_RESULT_WINDOW_MAX;
+  }
+  if (!state.resultWindowTtlMs || state.resultWindowTtlMs <= 0) {
+    state.resultWindowTtlMs = DEFAULT_RESULT_WINDOW_TTL_MS;
+  }
+  if (!Number.isFinite(state.resultWindowSequence)) {
+    state.resultWindowSequence = 0;
+  }
+}
+function pruneResultWindow(state, now = Date.now()) {
+  ensureResultWindowDefaults(state);
+  const minCreatedAt = now - state.resultWindowTtlMs;
+  state.resultWindowOrder = state.resultWindowOrder.filter(resultRef => {
+    const entry = state.resultWindowByRef[resultRef];
+    if (!entry) {
+      return false;
+    }
+    if (entry.createdAt < minCreatedAt) {
+      delete state.resultWindowByRef[resultRef];
+      return false;
+    }
+    return true;
+  });
+  while (state.resultWindowOrder.length > state.resultWindowMax) {
+    const oldestRef = state.resultWindowOrder.shift();
+    if (!oldestRef) break;
+    delete state.resultWindowByRef[oldestRef];
+  }
+}
+function putResultWindowEntry(state, entry) {
+  ensureResultWindowDefaults(state);
+  state.resultWindowSequence += 1;
+  const resultRef = `rg-${entry.eventId}-${state.resultWindowSequence}`;
+  const createdAt = Date.now();
+  const completeEntry = _objectSpread(_objectSpread({}, entry), {}, {
+    resultRef,
+    createdAt
+  });
+  state.resultWindowByRef[resultRef] = completeEntry;
+  state.resultWindowOrder.push(resultRef);
+  pruneResultWindow(state, createdAt);
+  return completeEntry;
+}
+function hashString(value) {
+  let hash = 0;
+  for (let i = 0; i < value.length; i++) {
+    hash = (hash << 5) - hash + value.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+function accessorFieldToPath(field) {
+  if (typeof field === "string") {
+    return field;
+  }
+  if (!field || typeof field !== "object") {
+    return null;
+  }
+  if (field.type === "access") {
+    const parent = accessorFieldToPath(field.parent);
+    if (!parent || typeof field.access !== "string") {
+      return null;
+    }
+    return `${parent}.${field.access}`;
+  }
+  return null;
+}
+function astValueToPrimitive(ast) {
+  if (!ast || typeof ast !== "object") return undefined;
+  if (ast.type === "string" || ast.type === "int" || ast.type === "float" || ast.type === "boolean") {
+    return ast.value;
+  }
+  if (ast.type === "object") {
+    if (ast.objectType === "string" || ast.objectType === "number" || ast.objectType === "float" || ast.objectType === "int" || ast.objectType === "boolean" || ast.objectType === "bool") {
+      return ast.value;
+    }
+  }
+  return undefined;
+}
+function collectFunctionCalls(ast, calls = []) {
+  if (!ast || typeof ast !== "object") {
+    return calls;
+  }
+  if (ast.type === "index") {
+    calls.push({
+      type: "function_call",
+      func_name: "index",
+      parameters: [{
+        parameter: "index",
+        value: {
+          type: "int",
+          value: ast.index
+        }
+      }]
+    });
+    return collectFunctionCalls(ast.parent, calls);
+  }
+  if (ast.type === "access") {
+    if (ast.access && ast.access.type === "function_call") {
+      calls.push(ast.access);
+    }
+    return collectFunctionCalls(ast.parent, calls);
+  }
+  return calls;
+}
+function getCallParam(call, paramName) {
+  if (!call || !Array.isArray(call.parameters)) return undefined;
+  const entry = call.parameters.find(param => param.parameter === paramName);
+  return entry?.value;
+}
+function extractQueryIntentFromAst(ast) {
+  const calls = collectFunctionCalls(ast, []).reverse();
+  const ops = [];
+  for (const call of calls) {
+    const funcName = call?.func_name;
+    if (funcName === "matching" || funcName === "contains" || funcName === "equals") {
+      const fieldAst = getCallParam(call, "field");
+      const valueAst = getCallParam(call, "value");
+      const fieldPath = accessorFieldToPath(fieldAst?.field);
+      const value = astValueToPrimitive(valueAst);
+      if (fieldPath && value !== undefined) {
+        ops.push({
+          kind: funcName,
+          field: fieldPath,
+          value
+        });
+      }
+      continue;
+    }
+    if (funcName === "between") {
+      const fieldAst = getCallParam(call, "field");
+      const from = astValueToPrimitive(getCallParam(call, "from"));
+      const to = astValueToPrimitive(getCallParam(call, "to"));
+      const fieldPath = accessorFieldToPath(fieldAst?.field);
+      if (fieldPath && (from !== undefined || to !== undefined)) {
+        ops.push(_objectSpread(_objectSpread({
+          kind: "between",
+          field: fieldPath
+        }, from !== undefined ? {
+          from
+        } : {}), to !== undefined ? {
+          to
+        } : {}));
+      }
+      continue;
+    }
+    if (funcName === "sort") {
+      const fieldAst = getCallParam(call, "field");
+      const ascending = astValueToPrimitive(getCallParam(call, "ascending"));
+      const fieldPath = accessorFieldToPath(fieldAst?.field);
+      if (fieldPath) {
+        ops.push({
+          kind: "sort",
+          field: fieldPath,
+          ascending: ascending === undefined ? true : Boolean(ascending)
+        });
+      }
+      continue;
+    }
+    if (funcName === "index") {
+      const index = astValueToPrimitive(getCallParam(call, "index"));
+      if (typeof index === "number") {
+        ops.push({
+          kind: "index",
+          value: index
+        });
+      }
+      continue;
+    }
+    if (funcName === "length") {
+      ops.push({
+        kind: "length"
+      });
+    }
+  }
+  if (ops.length === 0) return null;
+  const serialized = JSON.stringify(ops);
+  return {
+    ops,
+    hash: hashString(serialized)
+  };
+}
+const useGenieCodeSelector = command => {
+  return async state => {
+    exports.uiActive = uiActive = false;
+    (0, _reactgenieDsl.setSharedState)(state);
+    const result = await _modalityProviderV.GenieInterpreter.dslInterpreter.interpret(command);
+    // logger.info(`executed result ${result}`);
+    // logger.info(`after executing state ${JSON.stringify(state)}`);
+    exports.uiActive = uiActive = true;
+    return result;
+  };
+};
+exports.useGenieCodeSelector = useGenieCodeSelector;
+const shallowEqualWithArray = (left, right) => {
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let i = 0; i < left.length; i++) {
+      if (!shallowEqualWithArray(left[i], right[i])) {
+        return false;
+      }
+    }
+    return true;
+  } else {
+    return (0, _reactRedux.shallowEqual)(left, right);
+  }
+};
+const convertGenieClassToState = obj => {
+  if (Array.isArray(obj)) {
+    return obj.map(element => convertGenieClassToState(element));
+  } else if (obj === null || obj === undefined || obj.constructor === undefined) {
+    return obj;
+  } else if (obj.constructor.prototype instanceof _reactgenieDsl.GenieObject) {
+    if (obj.constructor.prototype instanceof _reactgenieDsl.DataClass) {
+      return _objectSpread({
+        __genieObjectType: "DataClass",
+        __genieObjectClass: obj.constructor.name,
+        __genieObjectKey: obj[obj.genieKey]
+      }, obj.__getState());
+    } else if (obj.constructor.prototype instanceof _reactgenieDsl.HelperClass) {
+      return _objectSpread({
+        __genieObjectType: "HelperClass",
+        __genieObjectClass: obj.constructor.name
+      }, obj.localStore);
+    }
+    throw new Error("Unknown GenieObject type");
+  } else {
+    return obj;
+  }
+};
+const useGenieSelector = selector => {
+  let selectorResult = undefined;
+  (0, _reactRedux.useSelector)(state => {
+    (0, _reactgenieDsl.setSharedState)(state);
+    selectorResult = selector(state);
+    return convertGenieClassToState(selectorResult);
+  }, shallowEqualWithArray);
+  return selectorResult;
+};
+exports.useGenieSelector = useGenieSelector;
+const RESULT_PREVIEW_MAX_LENGTH = 160;
+function truncateText(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+function createSystemMessage(minimalText, fullText, type = "info", shouldSpeak = false, origin = "system") {
+  return {
+    minimalText,
+    fullText,
+    type,
+    shouldSpeak,
+    origin,
+    message: fullText
+  };
+}
+function createUserFacingMessage(error, origin, shouldSpeakByDefault) {
+  return {
+    minimalText: error.minimalText,
+    fullText: error.fullText,
+    type: error.type,
+    shouldSpeak: error.shouldSpeak ?? shouldSpeakByDefault,
+    origin,
+    message: error.fullText
+  };
+}
+function safeSerializeValue(value) {
+  if (value === null || value === undefined) {
+    return "none";
+  }
+  const serialized = String(value);
+  return truncateText(serialized, RESULT_PREVIEW_MAX_LENGTH);
+}
+function buildResultDigest(result, parsed) {
+  if (!result || typeof result !== "object") {
+    return {
+      parsed,
+      status: "unknown",
+      resultType: "unknown"
+    };
+  }
+  if (result.type === "array") {
+    const values = Array.isArray(result.value) ? result.value : [];
+    const first = values.length > 0 ? values[0] : null;
+    const firstObjectType = first?.objectType || null;
+    const firstPreview = first && first.type === "object" ? safeSerializeValue(first.value) : null;
+    return {
+      parsed,
+      status: "ok",
+      resultType: "array",
+      count: values.length,
+      firstObjectType,
+      firstPreview
+    };
+  }
+  if (result.type === "object") {
+    return {
+      parsed,
+      status: "ok",
+      resultType: "object",
+      objectType: result.objectType || "unknown",
+      preview: safeSerializeValue(result.value)
+    };
+  }
+  return {
+    parsed,
+    status: "ok",
+    resultType: "unknown"
+  };
+}
+async function executeGenieCode(command, options = {}) {
+  const sanitized = typeof command === "string" ? command.trim() : "";
+  const messageOrigin = options.origin ?? "system";
+  const shouldSpeakErrors = Boolean(options.shouldSpeakErrors);
+  // logger.info(`executing command : ${sanitized}`);
+
+  if (!sanitized) {
+    (0, _reactgenieDsl.genieDispatch)(() => {
+      const reactGenieState = _reactgenieDsl.sharedState;
+      reactGenieState.message = createSystemMessage("No actionable command.", "I heard you, but there is no actionable command to run.", "info", shouldSpeakErrors, messageOrigin);
+    });
+    return {
+      success: false,
+      results: [new Error("No actionable command")]
+    };
+  }
+
+  // Guard against GenieInterpreter not being initialized
+  if (!_modalityProviderV.GenieInterpreter || !_modalityProviderV.GenieInterpreter.dslInterpreter) {
+    _logger.logger.error('GenieInterpreter is not initialized');
+    (0, _reactgenieDsl.genieDispatch)(() => {
+      const reactGenieState = _reactgenieDsl.sharedState;
+      reactGenieState.message = createSystemMessage("System not ready.", "System not ready. Please try again.", "error", shouldSpeakErrors, messageOrigin);
+    });
+    return {
+      success: false,
+      results: [new Error('GenieInterpreter not initialized')]
+    };
+  }
+  try {
+    const result = await _modalityProviderV.GenieInterpreter.dslInterpreter.interpretSteps(sanitized);
+    // console.log(`executed result ${result}`);
+    return {
+      success: true,
+      results: result
+    };
+  } catch (e) {
+    _logger.logger.error('error executing command:', sanitized, e);
+    (0, _reactgenieDsl.genieDispatch)(() => {
+      const reactGenieState = _reactgenieDsl.sharedState;
+      reactGenieState.message = (0, _errors.isGenieUserFacingError)(e) ? createUserFacingMessage(e, messageOrigin, shouldSpeakErrors) : createSystemMessage("I could not process that.", "Sorry, I don't understand...", "error", shouldSpeakErrors, messageOrigin);
+    });
+    return {
+      success: false,
+      results: [e]
+    };
+  }
+}
+function displayResult(executionResult, transcript, parsed, genieInterfaces) {
+  (0, _reactgenieDsl.genieDispatch)(() => {
+    let allDisplayingObjects = [];
+    let displayingObject = null;
+    let displayingObjectType = "";
+    const statementResult = executionResult.results[0];
+    const statementAst = statementResult?.ast;
+    const resultSteps = statementResult["steps"];
+    const queryIntent = extractQueryIntentFromAst(statementAst);
+    let lastResult = true;
+    for (let i = resultSteps.length - 1; i >= 0; i--) {
+      if (i != resultSteps.length - 1) {
+        lastResult = false;
+      }
+      const step = resultSteps[i];
+      allDisplayingObjects = [];
+      // console.log(`last executed step ${JSON.stringify(step)}`);
+      const stepResult = step.result;
+      if (stepResult.type === "object") {
+        allDisplayingObjects.push(stepResult);
+      } else if (stepResult.type === "array") {
+        for (const element of stepResult.value) {
+          allDisplayingObjects.push(element);
+        }
+      }
+      const primaryValue = allDisplayingObjects.length > 0 ? allDisplayingObjects[0].value : null;
+      // check if object can be displayed
+      if (allDisplayingObjects.length === 1) {
+        displayingObjectType = allDisplayingObjects[0].objectType;
+        displayingObject = allDisplayingObjects[0];
+        if (primaryValue && Object.hasOwn(allDisplayingObjects[0], "value") && Object.hasOwn(primaryValue, "localStore") && allDisplayingObjects[0].value.localStore.__genieObjectType === "HelperClass") {
+          displayingObjectType = "undefined";
+          displayingObject = null;
+        }
+      } else if (allDisplayingObjects.length > 1) {
+        displayingObjectType = allDisplayingObjects[0].objectType + "[]";
+        displayingObject = allDisplayingObjects;
+        if (primaryValue && Object.hasOwn(allDisplayingObjects[0], "value") && Object.hasOwn(primaryValue, "localStore") && allDisplayingObjects[0].value.localStore.__genieObjectType === "HelperClass") {
+          displayingObjectType = "undefined";
+          displayingObject = null;
+        }
+      } else if (allDisplayingObjects.length === 0) {
+        displayingObjectType = "undefined";
+        displayingObject = null;
+      }
+      // if displayingObjectType in the keys of AllGenieObjectInterfaces
+      if (_reactDecorators.AllGenieObjectInterfaces.supportedTypes.has(displayingObjectType)) {
+        break;
+      }
+    }
+    let cannotdisplay = false;
+    let onScreen = true;
+    let instantiatedDisplayingObject = null;
+    if (displayingObject != null) {
+      // if displayingObject is an array
+      if (displayingObject instanceof Array) {
+        // always display
+        onScreen = false;
+        instantiatedDisplayingObject = [];
+        for (const element of displayingObject) {
+          const Instance = (0, _reactDecorators.InstantiateGenieObject)({
+            className: element.objectType,
+            key: element.value
+          });
+          if (Instance === undefined) {
+            cannotdisplay = true;
+            break;
+          }
+          instantiatedDisplayingObject.push(Instance);
+        }
+      } else {
+        const Instance = (0, _reactDecorators.InstantiateGenieObject)({
+          className: displayingObject.objectType,
+          key: displayingObject.value
+        });
+        if (Instance === undefined) cannotdisplay = true;else {
+          if (lastResult) {
+            // always display
+            onScreen = false;
+          } else {
+            // check if displayingObjects is on screen already
+            const targetInterface = genieInterfaces.find(genieInterface => genieInterface.className === Instance.constructor.name && (0, _reactRedux.shallowEqual)(genieInterface.key, Instance._getConstructorParams()));
+            if (!targetInterface) {
+              onScreen = false;
+            }
+          }
+          instantiatedDisplayingObject = Instance;
+        }
+      }
+    }
+    _modalityProviderV.GenieInterpreter.nlParser.respond(transcript, parsed, JSON.stringify(buildResultDigest(
+    // now we only display the last result
+    executionResult.results[executionResult.results.length - 1].result, parsed))).then(result => {
+      console.log(`respond result: ${result}`);
+      (0, _reactgenieDsl.genieDispatch)(() => {
+        const reactGenieState = _reactgenieDsl.sharedState;
+        if (result !== null) {
+          reactGenieState.message = _objectSpread(_objectSpread({}, result), {}, {
+            origin: "voice",
+            message: result.fullText
+          });
+        }
+        let resultEntry = null;
+        if (!cannotdisplay && allDisplayingObjects.length > 0) {
+          const orderedConstructorParams = allDisplayingObjects.map(displayingObject => createImmutableConstructorParamsSnapshot(displayingObject.value)).filter(params => params !== null && typeof params === "object");
+          if (orderedConstructorParams.length > 0 && displayingObjectType) {
+            const predictedEventId = reactGenieState.navStack + 1;
+            resultEntry = putResultWindowEntry(reactGenieState, {
+              eventId: predictedEventId,
+              resultObjectType: displayingObjectType,
+              orderedConstructorParams
+            });
+          }
+        }
+        if (!onScreen && !cannotdisplay) {
+          reactGenieState.navState = {
+            objectViewClassName: _reactDecorators.AllGenieObjectInterfaces.getInterfaces(instantiatedDisplayingObject).viewClassName,
+            objectConstructorParams: allDisplayingObjects.length === 1 ? allDisplayingObjects[0].value._getConstructorParams() : {
+              elements: allDisplayingObjects.map(displayingObject => displayingObject.value._getConstructorParams())
+            },
+            queryIntent,
+            resultRef: resultEntry?.resultRef ?? null,
+            resultObjectType: displayingObjectType || null
+          };
+          reactGenieState.navStack += 1;
+        }
+      });
+    }).catch(error => {
+      _logger.logger.error('error generating response:', error);
+      (0, _reactgenieDsl.genieDispatch)(() => {
+        const reactGenieState = _reactgenieDsl.sharedState;
+        reactGenieState.message = createSystemMessage("Done.", "Done.", "info", false);
+      });
+    });
+
+    // console.log(`after executing state ${JSON.stringify(sharedState)}`);
+  });
+}
+
+/**
+ * Reset navigation state to prevent infinite navigation loops
+ * Call this after intercepting and handling navigation in expo-router
+ */
+function resetGenieNavigation() {
+  (0, _reactgenieDsl.genieDispatch)(() => {
+    const reactGenieState = _reactgenieDsl.sharedState;
+    reactGenieState.navState = {
+      objectViewClassName: null,
+      objectConstructorParams: null,
+      queryIntent: null,
+      resultRef: null,
+      resultObjectType: null
+    };
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_modalityProviderV","require","_reactDecorators","_reactRedux","_reactgenieDsl","_logger","_errors","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","uiActive","exports","DEFAULT_RESULT_WINDOW_MAX","DEFAULT_RESULT_WINDOW_TTL_MS","getConstructorParamsFromResultValue","_getConstructorParams","deepFreezeObject","freeze","key","nested","isFrozen","cloneDetachedValue","nativeStructuredClone","globalThis","structuredClone","cloned","JSON","parse","stringify","error","logger","warn","createImmutableConstructorParamsSnapshot","constructorParams","snapshot","ensureResultWindowDefaults","state","resultWindowByRef","resultWindowOrder","resultWindowMax","resultWindowTtlMs","isFinite","resultWindowSequence","pruneResultWindow","now","Date","minCreatedAt","resultRef","entry","createdAt","oldestRef","shift","putResultWindowEntry","eventId","completeEntry","hashString","hash","charCodeAt","Math","abs","toString","accessorFieldToPath","field","type","parent","access","astValueToPrimitive","ast","undefined","objectType","collectFunctionCalls","calls","func_name","parameters","parameter","index","getCallParam","paramName","Array","isArray","find","param","extractQueryIntentFromAst","reverse","ops","funcName","fieldAst","valueAst","fieldPath","kind","from","to","ascending","Boolean","serialized","useGenieCodeSelector","command","setSharedState","result","GenieInterpreter","dslInterpreter","interpret","shallowEqualWithArray","left","right","shallowEqual","convertGenieClassToState","obj","map","element","constructor","prototype","GenieObject","DataClass","__genieObjectType","__genieObjectClass","name","__genieObjectKey","genieKey","__getState","HelperClass","localStore","Error","useGenieSelector","selector","selectorResult","useSelector","RESULT_PREVIEW_MAX_LENGTH","truncateText","maxLength","slice","max","trimEnd","createSystemMessage","minimalText","fullText","shouldSpeak","origin","message","createUserFacingMessage","shouldSpeakByDefault","safeSerializeValue","buildResultDigest","parsed","status","resultType","values","first","firstObjectType","firstPreview","count","preview","executeGenieCode","options","sanitized","trim","messageOrigin","shouldSpeakErrors","genieDispatch","reactGenieState","sharedState","success","results","interpretSteps","isGenieUserFacingError","displayResult","executionResult","transcript","genieInterfaces","allDisplayingObjects","displayingObject","displayingObjectType","statementResult","statementAst","resultSteps","queryIntent","lastResult","step","stepResult","primaryValue","hasOwn","AllGenieObjectInterfaces","supportedTypes","has","cannotdisplay","onScreen","instantiatedDisplayingObject","Instance","InstantiateGenieObject","className","targetInterface","genieInterface","nlParser","respond","then","console","log","resultEntry","orderedConstructorParams","params","predictedEventId","navStack","resultObjectType","navState","objectViewClassName","getInterfaces","viewClassName","objectConstructorParams","elements","catch","resetGenieNavigation"],"sources":["../src/shared-store.ts"],"sourcesContent":["import { GenieInterpreter } from \"./modality-provider-v2\";\nimport {\n  AllGenieObjectInterfaces,\n  GenieInterfaceSpec,\n  InstantiateGenieObject,\n} from \"./react-decorators\";\nimport { shallowEqual, useSelector } from \"react-redux\";\nimport {\n  DataClass,\n  GenieObject,\n  HelperClass,\n  setSharedState,\n} from \"@garrix82/reactgenie-dsl\";\nimport { genieDispatch, sharedState } from \"@garrix82/reactgenie-dsl\";\nimport { logger } from \"./logger\";\nimport { GenieUserFacingError, isGenieUserFacingError } from \"./errors\";\n\nexport type ReactGenieState = {\n  message: ReactGenieMessage;\n  navState: NavigatorState;\n  navStack: number;\n  resultWindowByRef: Record<string, ResultWindowEntry>;\n  resultWindowOrder: string[];\n  resultWindowMax: number;\n  resultWindowTtlMs: number;\n  resultWindowSequence: number;\n};\n\nexport type ReactGenieMessage = AgentResponsePayload & {\n  origin: \"voice\" | \"system\";\n  message?: string;\n};\n\nexport type QueryIntentOperation =\n  | {\n      kind: \"matching\" | \"contains\" | \"equals\";\n      field: string;\n      value: string | number | boolean;\n    }\n  | {\n      kind: \"between\";\n      field: string;\n      from?: string | number | boolean;\n      to?: string | number | boolean;\n    }\n  | {\n      kind: \"sort\";\n      field: string;\n      ascending: boolean;\n    }\n  | {\n      kind: \"index\";\n      value: number;\n    }\n  | {\n      kind: \"length\";\n    };\n\nexport type QueryIntent = {\n  ops: QueryIntentOperation[];\n  hash: string;\n};\n\nexport type ResultWindowEntry = {\n  resultRef: string;\n  eventId: number;\n  resultObjectType: string;\n  orderedConstructorParams: Record<string, any>[];\n  createdAt: number;\n};\n\ntype AgentResponsePayload = {\n  minimalText: string;\n  fullText: string;\n  type: \"info\" | \"error\" | \"success\" | \"warning\";\n  shouldSpeak: boolean;\n};\n\nexport let uiActive = true;\n\nexport interface NavigatorState {\n  objectViewClassName: string | null;\n  objectConstructorParams: any;\n  queryIntent?: QueryIntent | null;\n  resultRef?: string | null;\n  resultObjectType?: string | null;\n}\n\nconst DEFAULT_RESULT_WINDOW_MAX = 40;\nconst DEFAULT_RESULT_WINDOW_TTL_MS = 5 * 60 * 1000;\n\nfunction getConstructorParamsFromResultValue(value: any): any | null {\n  if (!value || typeof value._getConstructorParams !== \"function\") {\n    return null;\n  }\n  return value._getConstructorParams();\n}\n\nfunction deepFreezeObject<T>(value: T): T {\n  if (!value || typeof value !== \"object\") {\n    return value;\n  }\n  Object.freeze(value);\n  for (const key of Object.keys(value as any)) {\n    const nested = (value as any)[key];\n    if (nested && typeof nested === \"object\" && !Object.isFrozen(nested)) {\n      deepFreezeObject(nested);\n    }\n  }\n  return value;\n}\n\nfunction cloneDetachedValue<T>(value: T): T | null {\n  try {\n    const nativeStructuredClone = (globalThis as any).structuredClone;\n    const cloned =\n      typeof nativeStructuredClone === \"function\"\n        ? nativeStructuredClone(value)\n        : JSON.parse(JSON.stringify(value));\n    return deepFreezeObject(cloned);\n  } catch (error) {\n    logger.warn(\n      \"[ReactGenie] Unable to clone constructor params for result window snapshot\",\n      error,\n    );\n    return null;\n  }\n}\n\nexport function createImmutableConstructorParamsSnapshot(\n  value: any,\n): Record<string, any> | null {\n  const constructorParams = getConstructorParamsFromResultValue(value);\n  if (!constructorParams || typeof constructorParams !== \"object\") {\n    return null;\n  }\n  const snapshot = cloneDetachedValue(constructorParams);\n  if (!snapshot || typeof snapshot !== \"object\") {\n    return null;\n  }\n  return snapshot as Record<string, any>;\n}\n\nfunction ensureResultWindowDefaults(state: ReactGenieState) {\n  // `genieDispatch` starts from a shallow copy of the previous state.\n  // Clone mutable result-window containers before writes so we don't mutate\n  // references from the previous Redux state snapshot.\n  state.resultWindowByRef = state.resultWindowByRef\n    ? { ...state.resultWindowByRef }\n    : {};\n  state.resultWindowOrder = state.resultWindowOrder\n    ? [...state.resultWindowOrder]\n    : [];\n  if (!state.resultWindowMax || state.resultWindowMax <= 0) {\n    state.resultWindowMax = DEFAULT_RESULT_WINDOW_MAX;\n  }\n  if (!state.resultWindowTtlMs || state.resultWindowTtlMs <= 0) {\n    state.resultWindowTtlMs = DEFAULT_RESULT_WINDOW_TTL_MS;\n  }\n  if (!Number.isFinite(state.resultWindowSequence)) {\n    state.resultWindowSequence = 0;\n  }\n}\n\nfunction pruneResultWindow(state: ReactGenieState, now = Date.now()) {\n  ensureResultWindowDefaults(state);\n  const minCreatedAt = now - state.resultWindowTtlMs;\n  state.resultWindowOrder = state.resultWindowOrder.filter((resultRef) => {\n    const entry = state.resultWindowByRef[resultRef];\n    if (!entry) {\n      return false;\n    }\n    if (entry.createdAt < minCreatedAt) {\n      delete state.resultWindowByRef[resultRef];\n      return false;\n    }\n    return true;\n  });\n\n  while (state.resultWindowOrder.length > state.resultWindowMax) {\n    const oldestRef = state.resultWindowOrder.shift();\n    if (!oldestRef) break;\n    delete state.resultWindowByRef[oldestRef];\n  }\n}\n\nfunction putResultWindowEntry(\n  state: ReactGenieState,\n  entry: Omit<ResultWindowEntry, \"resultRef\" | \"createdAt\">,\n): ResultWindowEntry {\n  ensureResultWindowDefaults(state);\n  state.resultWindowSequence += 1;\n  const resultRef = `rg-${entry.eventId}-${state.resultWindowSequence}`;\n  const createdAt = Date.now();\n  const completeEntry: ResultWindowEntry = {\n    ...entry,\n    resultRef,\n    createdAt,\n  };\n  state.resultWindowByRef[resultRef] = completeEntry;\n  state.resultWindowOrder.push(resultRef);\n  pruneResultWindow(state, createdAt);\n  return completeEntry;\n}\n\nfunction hashString(value: string): string {\n  let hash = 0;\n  for (let i = 0; i < value.length; i++) {\n    hash = (hash << 5) - hash + value.charCodeAt(i);\n    hash |= 0;\n  }\n  return Math.abs(hash).toString(36);\n}\n\nfunction accessorFieldToPath(field: any): string | null {\n  if (typeof field === \"string\") {\n    return field;\n  }\n  if (!field || typeof field !== \"object\") {\n    return null;\n  }\n  if (field.type === \"access\") {\n    const parent = accessorFieldToPath(field.parent);\n    if (!parent || typeof field.access !== \"string\") {\n      return null;\n    }\n    return `${parent}.${field.access}`;\n  }\n  return null;\n}\n\nfunction astValueToPrimitive(ast: any): string | number | boolean | undefined {\n  if (!ast || typeof ast !== \"object\") return undefined;\n  if (ast.type === \"string\" || ast.type === \"int\" || ast.type === \"float\" || ast.type === \"boolean\") {\n    return ast.value;\n  }\n  if (ast.type === \"object\") {\n    if (\n      ast.objectType === \"string\" ||\n      ast.objectType === \"number\" ||\n      ast.objectType === \"float\" ||\n      ast.objectType === \"int\" ||\n      ast.objectType === \"boolean\" ||\n      ast.objectType === \"bool\"\n    ) {\n      return ast.value;\n    }\n  }\n  return undefined;\n}\n\nfunction collectFunctionCalls(ast: any, calls: any[] = []): any[] {\n  if (!ast || typeof ast !== \"object\") {\n    return calls;\n  }\n\n  if (ast.type === \"index\") {\n    calls.push({\n      type: \"function_call\",\n      func_name: \"index\",\n      parameters: [{ parameter: \"index\", value: { type: \"int\", value: ast.index } }],\n    });\n    return collectFunctionCalls(ast.parent, calls);\n  }\n\n  if (ast.type === \"access\") {\n    if (ast.access && ast.access.type === \"function_call\") {\n      calls.push(ast.access);\n    }\n    return collectFunctionCalls(ast.parent, calls);\n  }\n\n  return calls;\n}\n\nfunction getCallParam(call: any, paramName: string): any | undefined {\n  if (!call || !Array.isArray(call.parameters)) return undefined;\n  const entry = call.parameters.find((param: any) => param.parameter === paramName);\n  return entry?.value;\n}\n\nexport function extractQueryIntentFromAst(ast: any): QueryIntent | null {\n  const calls = collectFunctionCalls(ast, []).reverse();\n  const ops: QueryIntentOperation[] = [];\n\n  for (const call of calls) {\n    const funcName = call?.func_name;\n    if (funcName === \"matching\" || funcName === \"contains\" || funcName === \"equals\") {\n      const fieldAst = getCallParam(call, \"field\");\n      const valueAst = getCallParam(call, \"value\");\n      const fieldPath = accessorFieldToPath(fieldAst?.field);\n      const value = astValueToPrimitive(valueAst);\n      if (fieldPath && value !== undefined) {\n        ops.push({\n          kind: funcName,\n          field: fieldPath,\n          value,\n        });\n      }\n      continue;\n    }\n\n    if (funcName === \"between\") {\n      const fieldAst = getCallParam(call, \"field\");\n      const from = astValueToPrimitive(getCallParam(call, \"from\"));\n      const to = astValueToPrimitive(getCallParam(call, \"to\"));\n      const fieldPath = accessorFieldToPath(fieldAst?.field);\n      if (fieldPath && (from !== undefined || to !== undefined)) {\n        ops.push({\n          kind: \"between\",\n          field: fieldPath,\n          ...(from !== undefined ? { from } : {}),\n          ...(to !== undefined ? { to } : {}),\n        });\n      }\n      continue;\n    }\n\n    if (funcName === \"sort\") {\n      const fieldAst = getCallParam(call, \"field\");\n      const ascending = astValueToPrimitive(getCallParam(call, \"ascending\"));\n      const fieldPath = accessorFieldToPath(fieldAst?.field);\n      if (fieldPath) {\n        ops.push({\n          kind: \"sort\",\n          field: fieldPath,\n          ascending: ascending === undefined ? true : Boolean(ascending),\n        });\n      }\n      continue;\n    }\n\n    if (funcName === \"index\") {\n      const index = astValueToPrimitive(getCallParam(call, \"index\"));\n      if (typeof index === \"number\") {\n        ops.push({\n          kind: \"index\",\n          value: index,\n        });\n      }\n      continue;\n    }\n\n    if (funcName === \"length\") {\n      ops.push({ kind: \"length\" });\n    }\n  }\n\n  if (ops.length === 0) return null;\n\n  const serialized = JSON.stringify(ops);\n  return {\n    ops,\n    hash: hashString(serialized),\n  };\n}\n\nexport const useGenieCodeSelector = (command: string) => {\n  return async (state: any) => {\n    uiActive = false;\n    setSharedState(state);\n    const result = await GenieInterpreter.dslInterpreter.interpret(command);\n    // logger.info(`executed result ${result}`);\n    // logger.info(`after executing state ${JSON.stringify(state)}`);\n    uiActive = true;\n    return result;\n  };\n};\n\nconst shallowEqualWithArray = (left: any, right: any) => {\n  if (Array.isArray(left) && Array.isArray(right)) {\n    if (left.length !== right.length) {\n      return false;\n    }\n    for (let i = 0; i < left.length; i++) {\n      if (!shallowEqualWithArray(left[i], right[i])) {\n        return false;\n      }\n    }\n    return true;\n  } else {\n    return shallowEqual(left, right);\n  }\n};\n\nconst convertGenieClassToState = (obj: any) => {\n  if (Array.isArray(obj)) {\n    return obj.map((element) => convertGenieClassToState(element));\n  } else if (\n    obj === null ||\n    obj === undefined ||\n    obj.constructor === undefined\n  ) {\n    return obj;\n  } else if (obj.constructor.prototype instanceof GenieObject) {\n    if (obj.constructor.prototype instanceof DataClass) {\n      return {\n        __genieObjectType: \"DataClass\",\n        __genieObjectClass: obj.constructor.name,\n        __genieObjectKey: obj[obj.genieKey],\n        ...obj.__getState(),\n      };\n    } else if (obj.constructor.prototype instanceof HelperClass) {\n      return {\n        __genieObjectType: \"HelperClass\",\n        __genieObjectClass: obj.constructor.name,\n        ...obj.localStore,\n      };\n    }\n    throw new Error(\"Unknown GenieObject type\");\n  } else {\n    return obj;\n  }\n};\n\nexport const useGenieSelector = (selector: any) => {\n  let selectorResult: any = undefined;\n  useSelector((state: any) => {\n    setSharedState(state);\n    selectorResult = selector(state);\n    return convertGenieClassToState(selectorResult);\n  }, shallowEqualWithArray);\n  return selectorResult;\n};\n\ntype GenieCodeResult = {\n  success: boolean;\n  results: any[];\n};\n\nconst RESULT_PREVIEW_MAX_LENGTH = 160;\n\nfunction truncateText(value: string, maxLength: number): string {\n  if (value.length <= maxLength) {\n    return value;\n  }\n  return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;\n}\n\nfunction createSystemMessage(\n  minimalText: string,\n  fullText: string,\n  type: AgentResponsePayload[\"type\"] = \"info\",\n  shouldSpeak = false,\n  origin: ReactGenieMessage[\"origin\"] = \"system\",\n): ReactGenieMessage {\n  return {\n    minimalText,\n    fullText,\n    type,\n    shouldSpeak,\n    origin,\n    message: fullText,\n  };\n}\n\nfunction createUserFacingMessage(\n  error: GenieUserFacingError,\n  origin: ReactGenieMessage[\"origin\"],\n  shouldSpeakByDefault: boolean,\n): ReactGenieMessage {\n  return {\n    minimalText: error.minimalText,\n    fullText: error.fullText,\n    type: error.type,\n    shouldSpeak: error.shouldSpeak ?? shouldSpeakByDefault,\n    origin,\n    message: error.fullText,\n  };\n}\n\nfunction safeSerializeValue(value: unknown): string {\n  if (value === null || value === undefined) {\n    return \"none\";\n  }\n  const serialized = String(value);\n  return truncateText(serialized, RESULT_PREVIEW_MAX_LENGTH);\n}\n\nfunction buildResultDigest(result: any, parsed: string) {\n  if (!result || typeof result !== \"object\") {\n    return {\n      parsed,\n      status: \"unknown\",\n      resultType: \"unknown\",\n    };\n  }\n\n  if (result.type === \"array\") {\n    const values = Array.isArray(result.value) ? result.value : [];\n    const first = values.length > 0 ? values[0] : null;\n    const firstObjectType = first?.objectType || null;\n    const firstPreview =\n      first && first.type === \"object\"\n        ? safeSerializeValue(first.value)\n        : null;\n\n    return {\n      parsed,\n      status: \"ok\",\n      resultType: \"array\",\n      count: values.length,\n      firstObjectType,\n      firstPreview,\n    };\n  }\n\n  if (result.type === \"object\") {\n    return {\n      parsed,\n      status: \"ok\",\n      resultType: \"object\",\n      objectType: result.objectType || \"unknown\",\n      preview: safeSerializeValue(result.value),\n    };\n  }\n\n  return {\n    parsed,\n    status: \"ok\",\n    resultType: \"unknown\",\n  };\n}\n\nexport async function executeGenieCode(\n  command: unknown,\n  options: {\n    origin?: ReactGenieMessage[\"origin\"];\n    shouldSpeakErrors?: boolean;\n  } = {},\n): Promise<GenieCodeResult> {\n    const sanitized =\n      typeof command === \"string\" ? command.trim() : \"\";\n    const messageOrigin = options.origin ?? \"system\";\n    const shouldSpeakErrors = Boolean(options.shouldSpeakErrors);\n    // logger.info(`executing command : ${sanitized}`);\n\n    if (!sanitized) {\n      genieDispatch(() => {\n        const reactGenieState = sharedState as ReactGenieState;\n        reactGenieState.message = createSystemMessage(\n          \"No actionable command.\",\n          \"I heard you, but there is no actionable command to run.\",\n          \"info\",\n          shouldSpeakErrors,\n          messageOrigin,\n        );\n      });\n      return {\n        success: false,\n        results: [new Error(\"No actionable command\")],\n      };\n    }\n\n    // Guard against GenieInterpreter not being initialized\n    if (!GenieInterpreter || !GenieInterpreter.dslInterpreter) {\n      logger.error('GenieInterpreter is not initialized');\n      genieDispatch(() => {\n        const reactGenieState = sharedState as ReactGenieState;\n        reactGenieState.message = createSystemMessage(\n          \"System not ready.\",\n          \"System not ready. Please try again.\",\n          \"error\",\n          shouldSpeakErrors,\n          messageOrigin,\n        );\n      });\n      return {\n        success: false,\n        results: [new Error('GenieInterpreter not initialized')],\n      };\n    }\n\n    try {\n      const result =\n        await GenieInterpreter.dslInterpreter.interpretSteps(sanitized);\n      // console.log(`executed result ${result}`);\n      return {\n        success: true,\n        results: result,\n      };\n    } catch (e) {\n      logger.error('error executing command:', sanitized, e);\n      genieDispatch(() => {\n        const reactGenieState = sharedState as ReactGenieState;\n        reactGenieState.message = isGenieUserFacingError(e)\n          ? createUserFacingMessage(e, messageOrigin, shouldSpeakErrors)\n          : createSystemMessage(\n              \"I could not process that.\",\n              \"Sorry, I don't understand...\",\n              \"error\",\n              shouldSpeakErrors,\n              messageOrigin,\n            );\n      });\n      return {\n        success: false,\n        results: [e],\n      };\n    }\n}\n\nexport function displayResult(\n  executionResult: GenieCodeResult,\n  transcript: string,\n  parsed: string,\n  genieInterfaces: GenieInterfaceSpec[],\n) {\n  genieDispatch(() => {\n    let allDisplayingObjects = [];\n    let displayingObject = null;\n    let displayingObjectType = \"\";\n\n    const statementResult = executionResult.results[0];\n    const statementAst = statementResult?.ast;\n    const resultSteps: [{ ast: any; result: any }] =\n      statementResult[\"steps\"];\n    const queryIntent = extractQueryIntentFromAst(statementAst);\n    let lastResult = true;\n\n    for (let i = resultSteps.length - 1; i >= 0; i--) {\n      if (i != resultSteps.length - 1) {\n        lastResult = false;\n      }\n      const step = resultSteps[i];\n      allDisplayingObjects = [];\n      // console.log(`last executed step ${JSON.stringify(step)}`);\n      const stepResult = step.result;\n      if (stepResult.type === \"object\") {\n        allDisplayingObjects.push(stepResult);\n      } else if (stepResult.type === \"array\") {\n        for (const element of stepResult.value) {\n          allDisplayingObjects.push(element);\n        }\n      }\n      const primaryValue =\n        allDisplayingObjects.length > 0 ? allDisplayingObjects[0].value : null;\n      // check if object can be displayed\n      if (allDisplayingObjects.length === 1) {\n        displayingObjectType = allDisplayingObjects[0].objectType;\n        displayingObject = allDisplayingObjects[0];\n        if (\n          primaryValue &&\n          Object.hasOwn(allDisplayingObjects[0], \"value\") &&\n          Object.hasOwn(primaryValue, \"localStore\") &&\n          allDisplayingObjects[0].value.localStore.__genieObjectType ===\n            \"HelperClass\"\n        ) {\n          displayingObjectType = \"undefined\";\n          displayingObject = null;\n        }\n      } else if (allDisplayingObjects.length > 1) {\n        displayingObjectType = allDisplayingObjects[0].objectType + \"[]\";\n        displayingObject = allDisplayingObjects;\n        if (\n          primaryValue &&\n          Object.hasOwn(allDisplayingObjects[0], \"value\") &&\n          Object.hasOwn(primaryValue, \"localStore\") &&\n          allDisplayingObjects[0].value.localStore.__genieObjectType ===\n            \"HelperClass\"\n        ) {\n          displayingObjectType = \"undefined\";\n          displayingObject = null;\n        }\n      } else if (allDisplayingObjects.length === 0) {\n        displayingObjectType = \"undefined\";\n        displayingObject = null;\n      }\n      // if displayingObjectType in the keys of AllGenieObjectInterfaces\n      if (AllGenieObjectInterfaces.supportedTypes.has(displayingObjectType)) {\n        break;\n      }\n    }\n    let cannotdisplay = false;\n    let onScreen = true;\n    let instantiatedDisplayingObject = null;\n    if (displayingObject != null) {\n      // if displayingObject is an array\n      if (displayingObject instanceof Array) {\n        // always display\n        onScreen = false;\n        instantiatedDisplayingObject = [];\n        for (const element of displayingObject) {\n          const Instance = InstantiateGenieObject({\n            className: element.objectType,\n            key: element.value,\n          });\n          if (Instance === undefined) {\n            cannotdisplay = true;\n            break;\n          }\n          instantiatedDisplayingObject.push(Instance);\n        }\n      } else {\n        const Instance = InstantiateGenieObject({\n          className: displayingObject.objectType,\n          key: displayingObject.value,\n        });\n        if (Instance === undefined) cannotdisplay = true;\n        else {\n          if (lastResult) {\n            // always display\n            onScreen = false;\n          } else {\n            // check if displayingObjects is on screen already\n            const targetInterface = genieInterfaces.find(\n              (genieInterface) =>\n                genieInterface.className === Instance.constructor.name &&\n                shallowEqual(\n                  genieInterface.key,\n                  Instance._getConstructorParams(),\n                ),\n            );\n            if (!targetInterface) {\n              onScreen = false;\n            }\n          }\n\n          instantiatedDisplayingObject = Instance;\n        }\n      }\n    }\n    GenieInterpreter.nlParser\n      .respond(\n        transcript,\n        parsed,\n        JSON.stringify(\n          buildResultDigest(\n            // now we only display the last result\n            executionResult.results[executionResult.results.length - 1].result,\n            parsed,\n          ),\n        ),\n      )\n      .then((result) => {\n        console.log(`respond result: ${result}`);\n        genieDispatch(() => {\n          const reactGenieState = sharedState as ReactGenieState;\n          if (result !== null) {\n            reactGenieState.message = {\n              ...result,\n              origin: \"voice\",\n              message: result.fullText,\n            };\n          }\n\n          let resultEntry: ResultWindowEntry | null = null;\n          if (!cannotdisplay && allDisplayingObjects.length > 0) {\n            const orderedConstructorParams = allDisplayingObjects\n              .map((displayingObject) =>\n                createImmutableConstructorParamsSnapshot(displayingObject.value),\n              )\n              .filter(\n                (params): params is Record<string, any> =>\n                  params !== null && typeof params === \"object\",\n              );\n\n            if (orderedConstructorParams.length > 0 && displayingObjectType) {\n              const predictedEventId = reactGenieState.navStack + 1;\n              resultEntry = putResultWindowEntry(reactGenieState, {\n                eventId: predictedEventId,\n                resultObjectType: displayingObjectType,\n                orderedConstructorParams,\n              });\n            }\n          }\n\n          if (!onScreen && !cannotdisplay) {\n            reactGenieState.navState = {\n              objectViewClassName: AllGenieObjectInterfaces.getInterfaces(\n                instantiatedDisplayingObject,\n              ).viewClassName,\n              objectConstructorParams:\n                allDisplayingObjects.length === 1\n                  ? allDisplayingObjects[0].value._getConstructorParams()\n                  : {\n                      elements: allDisplayingObjects.map((displayingObject) =>\n                        displayingObject.value._getConstructorParams(),\n                      ),\n                    },\n              queryIntent,\n              resultRef: resultEntry?.resultRef ?? null,\n              resultObjectType: displayingObjectType || null,\n            };\n            reactGenieState.navStack += 1;\n          }\n        });\n      })\n      .catch((error) => {\n        logger.error('error generating response:', error);\n        genieDispatch(() => {\n          const reactGenieState = sharedState as ReactGenieState;\n          reactGenieState.message = createSystemMessage(\n            \"Done.\",\n            \"Done.\",\n            \"info\",\n            false,\n          );\n        });\n      });\n\n    // console.log(`after executing state ${JSON.stringify(sharedState)}`);\n  });\n}\n\n/**\n * Reset navigation state to prevent infinite navigation loops\n * Call this after intercepting and handling navigation in expo-router\n */\nexport function resetGenieNavigation() {\n  genieDispatch(() => {\n    const reactGenieState = sharedState as ReactGenieState;\n    reactGenieState.navState = {\n      objectViewClassName: null,\n      objectConstructorParams: null,\n      queryIntent: null,\n      resultRef: null,\n      resultObjectType: null,\n    };\n  });\n}\n"],"mappings":"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","ignoreList":[]}