@memberjunction/realtime-widget 6.2.0-edge.6 → 6.2.0-edge.8

package/dist/embed/chunks/{chunk-ZX4SRAYD.js → chunk-DIDGGUK7.js}

@@ -4146,7 +4146,7 @@ var require_lodash = __commonJS({
           var tag = baseGetTag(value);
           return tag == errorTag || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value);
         }
-        function isFinite(value) {
+        function isFinite2(value) {
           return typeof value == "number" && nativeIsFinite(value);
         }
         function isFunction2(value) {
@@ -5247,7 +5247,7 @@ var require_lodash = __commonJS({
         lodash.isEqual = isEqual;
         lodash.isEqualWith = isEqualWith;
         lodash.isError = isError;
-        lodash.isFinite = isFinite;
+        lodash.isFinite = isFinite2;
         lodash.isFunction = isFunction2;
         lodash.isInteger = isInteger;
         lodash.isLength = isLength;
@@ -7821,6 +7821,7 @@ var ClassFactory = class _ClassFactory {
     this._registrationCache = /* @__PURE__ */ new Map();
     this._lazyLoaders = [];
     this._reportedResolutionFailures = /* @__PURE__ */ new Set();
+    this._reportedDuplicateCopies = /* @__PURE__ */ new Set();
   }
   static {
     this.MAX_FALLBACK_REPORTS_PER_BASE = 3;
@@ -7930,6 +7931,10 @@ var ClassFactory = class _ClassFactory {
           console.warn(`*** ClassFactory.Register: Registering class ${subClassName} for base class ${effectiveBaseClassName} and key/priority ${key}/${priority}. ${existing.length} registrations already exist for that combination. While this is allowed it is not desired and when matching class requests occur, we will simply use the LAST registration we happen to have which can lead to unintended behavior. ***`);
         }
       } else if (priority === 0 || priority === null || priority === void 0) {
+        if (this.isDuplicateCopy(registrations, subClass, subClassName)) {
+          this.warnDuplicateCopyOnce(subClassName, effectiveBaseClassName, key);
+          return;
+        }
         let highestPriority = 0;
         for (let i = 0; i < registrations.length; i++) {
           if (registrations[i].Priority > highestPriority)
@@ -8002,6 +8007,37 @@ var ClassFactory = class _ClassFactory {
       rootBucket.push(reg);
     }
   }
+  /**
+   * True when `subClass` is a second physical copy of a class that is already registered for
+   * this base class + key: a distinct constructor with the same name and the same source text.
+   *
+   * A class whose parent has its own name (`class X extends X`) is an override of that parent,
+   * not a copy, even when its source matches an earlier registration, so it is never treated as
+   * a duplicate. Name alone cannot tell a copy from a different class that happens to share the
+   * name; the identical source is what separates them.
+   */
+  isDuplicateCopy(registrations, subClass, subClassName) {
+    if (typeof subClass !== "function") {
+      return false;
+    }
+    const parent = Object.getPrototypeOf(subClass);
+    if (typeof parent === "function" && parent.name === subClassName) {
+      return false;
+    }
+    const source = Function.prototype.toString.call(subClass);
+    return registrations.some((r) => r.SubClass !== subClass && typeof r.SubClass === "function" && r.SubClass.name === subClassName && Function.prototype.toString.call(r.SubClass) === source);
+  }
+  /**
+   * Warns, once per base class + key + class, that a second copy of a registration was ignored.
+   */
+  warnDuplicateCopyOnce(subClassName, effectiveBaseClassName, key) {
+    const reportKey = `${effectiveBaseClassName}|${key ?? ""}|${subClassName}`;
+    if (this._reportedDuplicateCopies.has(reportKey)) {
+      return;
+    }
+    this._reportedDuplicateCopies.add(reportKey);
+    console.warn(`*** ClassFactory.Register: ignored a second copy of ${subClassName} for base class ${effectiveBaseClassName} with key '${key}'. Its source is identical to a class already registered under that name, which means the package that defines it is installed more than once (for example, nested by peer-dependency resolution). The first registration is kept, so any subclass registered after it still wins. Deduplicate the package to remove this warning. ***`);
+  }
   /**
    * Emits a single warning when an incoming registration collides with one or more EXISTING
    * registrations for the same base class + key that are **not in its inheritance chain**.
@@ -8091,6 +8127,23 @@ var ClassFactory = class _ClassFactory {
       }
     };
   }
+  /**
+   * Describes a key that has no registration for `baseClass`, listing every key that IS
+   * registered for it. Callers that look a class up with `GetRegistration`/`GetRegistrationAsync`
+   * and get nothing back can use this to build an error that shows the known keys next to the
+   * requested one, so a typo or a missing (uninstalled or tree-shaken) class is visible.
+   *
+   * @param baseClass - the base class that was looked up
+   * @param key - the key that was requested
+   * @returns e.g. `ClassFactory: no registration found for base class 'X' with key 'Y'. Registered keys for 'X': 'A', 'B'.`
+   */
+  DescribeMissingRegistration(baseClass, key) {
+    const baseClassName = baseClass.name;
+    const known = this.GetAllRegistrations(baseClass).map((r) => r.Key).filter((k) => k != null);
+    const uniqueKnown = Array.from(new Set(known)).sort();
+    const knownText = uniqueKnown.length > 0 ? uniqueKnown.map((k) => `'${k}'`).join(", ") : "(none)";
+    return `ClassFactory: no registration found for base class '${baseClassName}' with key '${key ?? "(null)"}'. Registered keys for '${baseClassName}': ${knownText}.`;
+  }
   /**
    * Builds the diagnostic message for a failed key resolution. The registered-key list is the
    * highest-value part: a typo'd or tree-shaken key is immediately obvious next to the keys the
@@ -8098,10 +8151,7 @@ var ClassFactory = class _ClassFactory {
    */
   describeResolutionFailure(baseClass, key, requiresSubclass) {
     const baseClassName = baseClass.name;
-    const known = this.GetAllRegistrations(baseClass).map((r) => r.Key).filter((k) => k != null);
-    const uniqueKnown = Array.from(new Set(known)).sort();
-    const knownText = uniqueKnown.length > 0 ? uniqueKnown.map((k) => `'${k}'`).join(", ") : "(none)";
-    return `ClassFactory: no registration found for base class '${baseClassName}' with key '${key ?? "(null)"}'. Registered keys for '${baseClassName}': ${knownText}. RequiresSubclass=${requiresSubclass}. ` + (requiresSubclass ? `'${baseClassName}' is marked '@RequiresSubclass()', so it CANNOT be used as a fallback \u2014 no instance was created. Likely causes: a typo in the key, a class that was never imported (tree-shaken out \u2014 check the class-registration manifest), or a missing @RegisterClass decorator.` : `Falling back to an instance of '${baseClassName}' itself. If that base cannot function standalone, apply the '@RequiresSubclass()' decorator to it so this becomes a hard error.`);
+    return this.DescribeMissingRegistration(baseClass, key) + ` RequiresSubclass=${requiresSubclass}. ` + (requiresSubclass ? `'${baseClassName}' is marked '@RequiresSubclass()', so it CANNOT be used as a fallback \u2014 no instance was created. Likely causes: a typo in the key, a class that was never imported (tree-shaken out \u2014 check the class-registration manifest), or a missing @RegisterClass decorator.` : `Falling back to an instance of '${baseClassName}' itself. If that base cannot function standalone, apply the '@RequiresSubclass()' decorator to it so this becomes a hard error.`);
   }
   /**
    * Emits the fallback diagnostic exactly once per (baseClass, key) pair — resolution happens on
@@ -9320,9 +9370,7 @@ function BytesToBase64(bytes) {
   return GetBase64Codec().Encode(bytes);
 }
 var FLOAT32_VECTOR_BYTES_PER_VALUE = 4;
-function hostIsLittleEndian() {
-  return new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
-}
+var IS_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
 var TypedArrayFloat32Codec = {
   Name: "typed array (little-endian host)",
   Encode(values) {
@@ -9350,7 +9398,7 @@ var DataViewFloat32Codec = {
     return values;
   }
 };
-var float32Codec = hostIsLittleEndian() ? TypedArrayFloat32Codec : DataViewFloat32Codec;
+var float32Codec = IS_LITTLE_ENDIAN ? TypedArrayFloat32Codec : DataViewFloat32Codec;
 function Float32VectorToBytes(values) {
   return float32Codec.Encode(values);
 }
@@ -15083,8 +15131,8 @@ function parse3(input, options) {
 }
 
 // ../../MJGlobal/dist/SafeExpressionEvaluator.js
-var SAFE_GLOBAL_NAMESPACE_METHODS = /* @__PURE__ */ new Map([
-  ["Math", /* @__PURE__ */ new Set([
+var APPROVED_EXPRESSION_GLOBALS = /* @__PURE__ */ new Map([
+  ["Math", { Callable: false, Methods: /* @__PURE__ */ new Set([
     "abs",
     "ceil",
     "floor",
@@ -15101,275 +15149,159 @@ var SAFE_GLOBAL_NAMESPACE_METHODS = /* @__PURE__ */ new Map([
     "log10",
     "exp",
     "hypot"
-  ])],
-  ["JSON", /* @__PURE__ */ new Set(["parse", "stringify"])],
-  ["Object", /* @__PURE__ */ new Set(["keys", "values", "entries"])],
-  ["Array", /* @__PURE__ */ new Set(["isArray"])],
-  ["Number", /* @__PURE__ */ new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"])],
-  ["Date", /* @__PURE__ */ new Set(["now"])]
+  ]) }],
+  ["JSON", { Callable: false, Methods: /* @__PURE__ */ new Set(["parse", "stringify"]) }],
+  ["Object", { Callable: false, Methods: /* @__PURE__ */ new Set(["keys", "values", "entries"]) }],
+  ["Array", { Callable: false, Methods: /* @__PURE__ */ new Set(["isArray"]) }],
+  ["Number", { Callable: true, Methods: /* @__PURE__ */ new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"]) }],
+  ["String", { Callable: true, Methods: /* @__PURE__ */ new Set() }],
+  ["Boolean", { Callable: true, Methods: /* @__PURE__ */ new Set() }],
+  ["Date", { Callable: false, Methods: /* @__PURE__ */ new Set(["now"]) }],
+  ["parseInt", { Callable: true, Methods: /* @__PURE__ */ new Set() }],
+  ["parseFloat", { Callable: true, Methods: /* @__PURE__ */ new Set() }],
+  ["isNaN", { Callable: true, Methods: /* @__PURE__ */ new Set() }],
+  ["isFinite", { Callable: true, Methods: /* @__PURE__ */ new Set() }]
 ]);
-var SAFE_GLOBAL_CALLABLES = /* @__PURE__ */ new Set([
-  "parseInt",
-  "parseFloat",
-  "isNaN",
-  "isFinite",
-  "Number",
-  "String",
-  "Boolean"
+var APPROVED_VALUE_GLOBALS = /* @__PURE__ */ new Set(["undefined", "NaN", "Infinity"]);
+var SAFE_GLOBAL_NAMESPACE_METHODS = new Map([...APPROVED_EXPRESSION_GLOBALS].filter(([, g]) => g.Methods.size > 0).map(([name, g]) => [name, g.Methods]));
+var SAFE_GLOBAL_CALLABLES = new Set([...APPROVED_EXPRESSION_GLOBALS].filter(([, g]) => g.Callable).map(([name]) => name));
+var SAFE_EXPRESSION_GLOBALS = new Set(APPROVED_EXPRESSION_GLOBALS.keys());
+var DANGEROUS_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "eval",
+  "Function",
+  "globalThis",
+  "global",
+  "window",
+  "document",
+  "process",
+  "require",
+  "module",
+  "exports",
+  "__dirname",
+  "__filename",
+  "self",
+  "top",
+  "parent",
+  "frames",
+  "Reflect",
+  "Proxy",
+  "WebAssembly",
+  "Atomics",
+  "SharedArrayBuffer",
+  "import",
+  "arguments",
+  "constructor",
+  "prototype",
+  "__proto__"
 ]);
-var SAFE_EXPRESSION_GLOBALS = /* @__PURE__ */ new Set([
-  ...SAFE_GLOBAL_NAMESPACE_METHODS.keys(),
-  ...SAFE_GLOBAL_CALLABLES
+var DANGEROUS_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+  "constructor",
+  "__proto__",
+  "prototype"
 ]);
-var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
-  constructor() {
-    this._compiledExpressionCache = new MJLruCache({ maxSize: 1e3 });
-  }
-  static {
-    this.DANGEROUS_IDENTIFIERS = /* @__PURE__ */ new Set([
-      "eval",
-      "Function",
-      "globalThis",
-      "global",
-      "window",
-      "document",
-      "process",
-      "require",
-      "module",
-      "exports",
-      "__dirname",
-      "__filename",
-      "self",
-      "top",
-      "parent",
-      "frames",
-      "Reflect",
-      "Proxy",
-      "WebAssembly",
-      "Atomics",
-      "SharedArrayBuffer",
-      "import",
-      "arguments",
-      "constructor",
-      "prototype",
-      "__proto__"
-    ]);
-  }
-  static {
-    this.DANGEROUS_PROPERTY_NAMES = /* @__PURE__ */ new Set([
-      "constructor",
-      "__proto__",
-      "prototype"
-    ]);
-  }
-  static {
-    this.ALLOWED_BINARY_OPERATORS = /* @__PURE__ */ new Set([
-      "==",
-      "!=",
-      "===",
-      "!==",
-      "<",
-      "<=",
-      ">",
-      ">=",
-      "+",
-      "-",
-      "*",
-      "/",
-      "%"
-    ]);
-  }
-  static {
-    this.ALLOWED_UNARY_OPERATORS = /* @__PURE__ */ new Set(["!", "-", "+", "typeof"]);
-  }
-  static {
-    this.SAFE_METHODS = [
-      "length",
-      "includes",
-      "startsWith",
-      "endsWith",
-      "indexOf",
-      "lastIndexOf",
-      "toLowerCase",
-      "toUpperCase",
-      "trim",
-      "trimStart",
-      "trimEnd",
-      "toString",
-      "valueOf",
-      "some",
-      "every",
-      "find",
-      "filter",
-      "map",
-      "reduce"
-    ];
-  }
-  /**
-   * Evaluates a boolean expression against a context object
-   *
-   * @param {string} expression - The boolean expression to evaluate
-   * @param {Record<string, any>} context - The context object containing variables
-   * @param {boolean} [enableDiagnostics=false] - Whether to include diagnostic information
-   *
-   * @returns {ExpressionEvaluationResult} The evaluation result
-   */
-  Evaluate(expression, context2, enableDiagnostics = false) {
-    const startTime = Date.now();
-    try {
-      const validationError = this.validateExpression(expression);
-      if (validationError) {
-        return {
-          success: false,
-          error: validationError,
-          diagnostics: enableDiagnostics ? {
-            expression,
-            context: context2,
-            evaluationTime: Date.now() - startTime
-          } : void 0
-        };
-      }
-      const safeContext = this.createSafeContext(context2);
-      const contextKeys = Object.keys(safeContext);
-      const contextValues = contextKeys.map((key) => safeContext[key]);
-      const cacheKey = `${expression}|${contextKeys.join(",")}`;
-      let evaluator = this._compiledExpressionCache.Get(cacheKey);
-      if (!evaluator) {
-        const functionBody = `
-                    "use strict";
-                    try {
-                        return Boolean(${expression});
-                    } catch (e) {
-                        throw new Error('Expression evaluation failed: ' + e.message);
-                    }
-                `;
-        evaluator = new Function(...contextKeys, functionBody);
-        this._compiledExpressionCache.Set(cacheKey, evaluator);
-      }
-      const result = evaluator(...contextValues);
-      return {
-        success: true,
-        value: Boolean(result),
-        diagnostics: enableDiagnostics ? {
-          expression,
-          context: context2,
-          evaluationTime: Date.now() - startTime
-        } : void 0
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        diagnostics: enableDiagnostics ? {
-          expression,
-          context: context2,
-          evaluationTime: Date.now() - startTime
-        } : void 0
-      };
-    }
-  }
-  /** @deprecated Use {@link Evaluate}. */
-  evaluate(expression, context2, enableDiagnostics = false) {
-    return this.Evaluate(expression, context2, enableDiagnostics);
-  }
-  /**
-   * Validates an expression for safety by parsing it and walking the AST against
-   * an allowlist. Returns an error message if any construct is not permitted.
-   *
-   * @param {string} expression - The expression to validate
-   *
-   * @returns {string | null} Error message if invalid, null if valid
-   *
-   * @private
-   */
-  validateExpression(expression) {
-    if (!expression || typeof expression !== "string") {
-      return "Expression must be a non-empty string";
-    }
-    if (expression.length > 1e3) {
-      return "Expression exceeds maximum length of 1000 characters";
-    }
-    let parenCount = 0;
-    for (const char of expression) {
-      if (char === "(")
-        parenCount++;
-      if (char === ")")
-        parenCount--;
-      if (parenCount < 0) {
-        return "Unbalanced parentheses in expression";
-      }
-    }
-    if (parenCount !== 0) {
-      return "Unbalanced parentheses in expression";
-    }
-    if (expression.trim() === "") {
-      return null;
-    }
-    let program;
-    try {
-      program = parse3(expression, { ecmaVersion: 2022 });
-    } catch (e) {
-      return this.forbidden(`it is not a parseable single expression (${e instanceof Error ? e.message : String(e)})`);
-    }
-    if (program.body.length !== 1 || program.body[0].type !== "ExpressionStatement") {
-      return this.forbidden("only a single expression is permitted \u2014 no statements, blocks, or semicolons");
-    }
-    return this.checkNode(program.body[0].expression);
-  }
-  /** Builds the standard rejection message. @private */
-  forbidden(detail) {
-    return `Expression contains a forbidden construct: ${detail}`;
+var ALLOWED_BINARY_OPERATORS = /* @__PURE__ */ new Set([
+  "==",
+  "!=",
+  "===",
+  "!==",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%"
+]);
+var ALLOWED_UNARY_OPERATORS = /* @__PURE__ */ new Set(["!", "-", "+", "typeof"]);
+var SAFE_METHODS = /* @__PURE__ */ new Set([
+  "length",
+  "includes",
+  "startsWith",
+  "endsWith",
+  "indexOf",
+  "lastIndexOf",
+  "toLowerCase",
+  "toUpperCase",
+  "trim",
+  "trimStart",
+  "trimEnd",
+  "toString",
+  "valueOf",
+  "some",
+  "every",
+  "find",
+  "filter",
+  "map",
+  "reduce",
+  "split",
+  "slice",
+  "substring",
+  "join",
+  "concat",
+  "charAt",
+  "at",
+  "padStart",
+  "padEnd",
+  "toFixed",
+  "toPrecision"
+]);
+var CALLBACK_METHODS = /* @__PURE__ */ new Set(["some", "every", "find", "filter", "map", "reduce"]);
+var NON_FUNCTION_ARGUMENT_SLOTS = /* @__PURE__ */ new Map([
+  ["JSON.parse", 1],
+  ["JSON.stringify", 1]
+]);
+var CONTEXT_KEY_PATTERN = /^[A-Za-z_$][\w$]*$/;
+var MAX_EXPRESSION_LENGTH = 1e3;
+function forbidden(detail) {
+  return `Expression contains a forbidden construct: ${detail}`;
+}
+var ExpressionScreen = class {
+  constructor(contextKeys) {
+    this.contextKeys = contextKeys;
+    this.scopes = [];
   }
-  /**
-   * Walks an AST node against the allowlist. Returns an error message on the first
-   * disallowed construct, or null if the entire subtree is permitted.
-   * @private
-   */
-  checkNode(node) {
+  Check(node) {
     switch (node.type) {
       case "Literal": {
         const lit = node;
         if (lit.value instanceof RegExp || "regex" in lit) {
-          return this.forbidden("regular expression literals are not allowed");
-        }
-        return null;
-      }
-      case "Identifier": {
-        const name = node.name;
-        if (_SafeExpressionEvaluator.DANGEROUS_IDENTIFIERS.has(name)) {
-          return this.forbidden(`the identifier "${name}"`);
+          return forbidden("regular expression literals are not allowed");
         }
         return null;
       }
+      case "Identifier":
+        return this.checkValueIdentifier(node.name);
       case "ChainExpression":
-        return this.checkNode(node.expression);
+        return this.Check(node.expression);
       case "MemberExpression":
         return this.checkMemberExpression(node);
       case "CallExpression":
         return this.checkCallExpression(node);
       case "ArrowFunctionExpression":
-        return this.checkArrowFunction(node);
+        return forbidden(`arrow functions are allowed only as the inline callback of ${[...CALLBACK_METHODS].map((m) => `.${m}()`).join(", ")}`);
       case "BinaryExpression": {
         const bin = node;
-        if (!_SafeExpressionEvaluator.ALLOWED_BINARY_OPERATORS.has(bin.operator)) {
-          return this.forbidden(`the operator "${bin.operator}"`);
+        if (!ALLOWED_BINARY_OPERATORS.has(bin.operator)) {
+          return forbidden(`the operator "${bin.operator}"`);
         }
-        return this.checkNode(bin.left) ?? this.checkNode(bin.right);
+        return this.Check(bin.left) ?? this.Check(bin.right);
       }
       case "LogicalExpression": {
         const log = node;
-        return this.checkNode(log.left) ?? this.checkNode(log.right);
+        return this.Check(log.left) ?? this.Check(log.right);
       }
       case "UnaryExpression": {
         const un = node;
-        if (!_SafeExpressionEvaluator.ALLOWED_UNARY_OPERATORS.has(un.operator)) {
-          return this.forbidden(`the unary operator "${un.operator}"`);
+        if (!ALLOWED_UNARY_OPERATORS.has(un.operator)) {
+          return forbidden(`the unary operator "${un.operator}"`);
         }
-        return this.checkNode(un.argument);
+        return this.Check(un.argument);
       }
       case "ConditionalExpression": {
         const cond = node;
-        return this.checkNode(cond.test) ?? this.checkNode(cond.consequent) ?? this.checkNode(cond.alternate);
+        return this.Check(cond.test) ?? this.Check(cond.consequent) ?? this.Check(cond.alternate);
       }
       case "ArrayExpression": {
         const arr = node;
@@ -15377,128 +15309,314 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
           if (!el)
             continue;
           if (el.type === "SpreadElement") {
-            return this.forbidden("spread elements are not allowed");
+            return forbidden("spread elements are not allowed");
           }
-          const err = this.checkNode(el);
+          const err = this.Check(el);
           if (err)
             return err;
         }
         return null;
       }
       default:
-        return this.forbidden(`${node.type} is not allowed`);
+        return forbidden(`${node.type} is not allowed`);
+    }
+  }
+  /** Whether `name` is bound by an enclosing arrow function. */
+  isBoundParameter(name) {
+    return this.scopes.some((scope) => scope.has(name));
+  }
+  /**
+   * An identifier in VALUE position (anything but the callee of a call): it must be an arrow
+   * parameter in scope, a context key, or an approved value global (`undefined`). Approved function
+   * globals are refused here — `items.map(Number)` and `[Math][0]` hand a host function out as a value.
+   */
+  checkValueIdentifier(name) {
+    if (this.isBoundParameter(name)) {
+      return null;
+    }
+    if (this.contextKeys?.has(name)) {
+      return null;
+    }
+    if (DANGEROUS_IDENTIFIERS.has(name)) {
+      return forbidden(`the identifier "${name}"`);
+    }
+    if (APPROVED_VALUE_GLOBALS.has(name)) {
+      return null;
     }
+    if (APPROVED_EXPRESSION_GLOBALS.has(name)) {
+      return forbidden(`"${name}" may only be called (e.g. ${name}${APPROVED_EXPRESSION_GLOBALS.get(name)?.Callable ? "(x)" : ".method(x)"}), not used as a value or callback`);
+    }
+    if (this.contextKeys === null) {
+      return null;
+    }
+    return forbidden(`the identifier "${name}" is not defined in the evaluation context and is not an arrow-function parameter`);
   }
   /**
-   * Member access is allowed for dotted property reads and literal-key bracket
-   * reads, but never for a computed key built at runtime (the string-concat
-   * escape route) or a prototype-chain property.
-   * @private
+   * Member access is allowed for dotted property reads and literal-key bracket reads, but never
+   * for a computed key built at runtime (the string-concat escape route) or a prototype-chain
+   * property.
    */
   checkMemberExpression(node) {
     if (node.property.type === "PrivateIdentifier") {
-      return this.forbidden("private fields are not allowed");
+      return forbidden("private fields are not allowed");
     }
     if (node.computed) {
       if (node.property.type !== "Literal") {
-        return this.forbidden("computed member access must use a literal index/key");
+        return forbidden("computed member access must use a literal index/key");
       }
       const value = node.property.value;
       if (typeof value === "string") {
-        if (_SafeExpressionEvaluator.DANGEROUS_PROPERTY_NAMES.has(value)) {
-          return this.forbidden(`access to "${value}"`);
+        if (DANGEROUS_PROPERTY_NAMES.has(value)) {
+          return forbidden(`access to "${value}"`);
         }
       } else if (typeof value !== "number") {
-        return this.forbidden("computed member access must use a string or numeric literal");
+        return forbidden("computed member access must use a string or numeric literal");
       }
     } else {
       const name = node.property.name;
-      if (_SafeExpressionEvaluator.DANGEROUS_PROPERTY_NAMES.has(name)) {
-        return this.forbidden(`access to "${name}"`);
+      if (DANGEROUS_PROPERTY_NAMES.has(name)) {
+        return forbidden(`access to "${name}"`);
       }
     }
-    return this.checkNode(node.object);
+    return this.Check(node.object);
   }
   /**
-   * A call is admitted only when its callee is a FIXED name on one of two allowlists: a bare
-   * safe global (`parseInt(...)`) or a dotted method that is either a safe instance method or a
-   * method of a safe global namespace (`Math.abs(...)`). Everything else — a computed callee, an
-   * unlisted bare identifier (`eval(...)`, `Function(...)`), a call on a call's result that is
-   * not itself a safe method — is rejected.
-   * @private
+   * A call is admitted only when its callee is a FIXED name: a callable approved global
+   * (`parseInt(...)`), a listed method of an approved global namespace (`Math.abs(...)`), or a safe
+   * instance method on a screened receiver (`payload.title.includes(...)`). Everything else — a
+   * computed callee, an unlisted bare identifier, a call on an arrow or call result that is not
+   * itself a safe method — is rejected.
    */
   checkCallExpression(node) {
     const callee = node.callee;
     if (callee.type === "Identifier") {
       const name = callee.name;
-      if (!SAFE_GLOBAL_CALLABLES.has(name)) {
-        return this.forbidden(`calling "${name}" \u2014 only safe methods and safe global functions may be invoked`);
+      if (this.isBoundParameter(name) || !SAFE_GLOBAL_CALLABLES.has(name)) {
+        return forbidden(`calling "${name}" \u2014 only safe methods and approved global functions may be invoked`);
       }
-      return this.checkCallArguments(node);
+      return this.checkCallArguments(node, null, null);
     }
     if (callee.type !== "MemberExpression") {
-      return this.forbidden("only method calls on the safe-method allowlist may be invoked");
+      return forbidden("only method calls on the safe-method allowlist may be invoked");
     }
     const member = callee;
     if (member.computed || member.property.type !== "Identifier") {
-      return this.forbidden("methods must be called by a dotted, non-computed name");
+      return forbidden("methods must be called by a dotted, non-computed name");
     }
     const method = member.property.name;
-    if (!this.isCallableMethod(member.object, method)) {
-      return this.forbidden(`the method "${method}" is not on the safe-method allowlist`);
+    const receiver = member.object;
+    if (receiver.type === "Identifier") {
+      const namespace = receiver.name;
+      const shadowed = this.isBoundParameter(namespace) || this.contextKeys?.has(namespace) === true;
+      if (!shadowed && SAFE_GLOBAL_NAMESPACE_METHODS.get(namespace)?.has(method) === true) {
+        return this.checkCallArguments(node, null, `${namespace}.${method}`);
+      }
+    }
+    if (!SAFE_METHODS.has(method)) {
+      return forbidden(`the method "${method}" is not on the safe-method allowlist`);
     }
-    const receiverError = this.checkNode(member.object);
+    const receiverError = this.checkReceiver(receiver);
     if (receiverError)
       return receiverError;
-    return this.checkCallArguments(node);
+    return this.checkCallArguments(node, method, null);
   }
-  /**
-   * Whether `<receiver>.<method>()` names a permitted call: a safe instance method on any value,
-   * or a method of a safe global namespace when the receiver is that namespace by bare name.
-   * @private
-   */
-  isCallableMethod(receiver, method) {
-    if (_SafeExpressionEvaluator.SAFE_METHODS.includes(method)) {
-      return true;
+  /** Screens the receiver of a safe instance method. `super.x()` is never valid. */
+  checkReceiver(receiver) {
+    if (receiver.type === "Super") {
+      return forbidden("super is not allowed");
     }
-    if (receiver.type !== "Identifier") {
-      return false;
-    }
-    return SAFE_GLOBAL_NAMESPACE_METHODS.get(receiver.name)?.has(method) === true;
+    return this.Check(receiver);
   }
-  /** Walks a call's arguments; spreads are rejected outright. @private */
-  checkCallArguments(node) {
-    for (const arg of node.arguments) {
+  /**
+   * Walks a call's arguments. Spreads are rejected outright. For a callback method the first
+   * argument must be an inline arrow function; for `JSON.parse`/`JSON.stringify` the reviver /
+   * replacer slot must be a literal or array literal.
+   */
+  checkCallArguments(node, instanceMethod, globalMethod) {
+    const callbackMethod = instanceMethod !== null && CALLBACK_METHODS.has(instanceMethod);
+    const nonFunctionSlot = globalMethod !== null ? NON_FUNCTION_ARGUMENT_SLOTS.get(globalMethod) : void 0;
+    for (let i = 0; i < node.arguments.length; i++) {
+      const arg = node.arguments[i];
       if (arg.type === "SpreadElement") {
-        return this.forbidden("spread arguments are not allowed");
+        return forbidden("spread arguments are not allowed");
+      }
+      if (callbackMethod && i === 0) {
+        if (arg.type !== "ArrowFunctionExpression") {
+          return forbidden(`the callback of .${instanceMethod}() must be an inline arrow function (e.g. x => x.price > 100)`);
+        }
+        const err2 = this.checkArrowFunction(arg);
+        if (err2)
+          return err2;
+        continue;
+      }
+      if (nonFunctionSlot === i && arg.type !== "Literal" && arg.type !== "ArrayExpression") {
+        return forbidden(`argument ${i + 1} of ${globalMethod}() must be a literal or an array literal`);
       }
-      const err = this.checkNode(arg);
+      const err = this.Check(arg);
       if (err)
         return err;
     }
     return null;
   }
   /**
-   * Arrow functions are permitted only as callback arguments to the safe array
-   * methods; parameters must be simple identifiers and the body an expression.
-   * @private
+   * An inline callback: parameters must be simple identifiers that do not shadow an approved or
+   * denied global, and the body must be an expression. Parameters are in scope for the body only.
    */
   checkArrowFunction(node) {
     if (node.async) {
-      return this.forbidden("async functions are not allowed");
+      return forbidden("async functions are not allowed");
+    }
+    if (node.body.type === "BlockStatement") {
+      return forbidden("arrow-function bodies must be an expression, not a block");
     }
+    const params = /* @__PURE__ */ new Set();
     for (const param of node.params) {
       if (param.type !== "Identifier") {
-        return this.forbidden("arrow-function parameters must be simple identifiers");
+        return forbidden("arrow-function parameters must be simple identifiers");
       }
-      if (_SafeExpressionEvaluator.DANGEROUS_IDENTIFIERS.has(param.name)) {
-        return this.forbidden(`the parameter "${param.name}"`);
+      const name = param.name;
+      if (DANGEROUS_IDENTIFIERS.has(name) || APPROVED_EXPRESSION_GLOBALS.has(name) || APPROVED_VALUE_GLOBALS.has(name)) {
+        return forbidden(`the parameter "${name}"`);
       }
+      params.add(name);
     }
-    if (node.body.type === "BlockStatement") {
-      return this.forbidden("arrow-function bodies must be an expression, not a block");
+    this.scopes.push(params);
+    try {
+      return this.Check(node.body);
+    } finally {
+      this.scopes.pop();
+    }
+  }
+};
+var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
+  constructor() {
+    this._compiledExpressionCache = new MJLruCache({ maxSize: 1e3 });
+  }
+  /**
+   * Evaluates a boolean expression against a context object
+   *
+   * @param {string} expression - The boolean expression to evaluate
+   * @param {Record<string, any>} [context={}] - The context object containing variables. Its keys
+   *        are the only free names the expression may use; a key named like an approved global
+   *        shadows it (see {@link ScreenExpression}).
+   * @param {boolean} [enableDiagnostics=false] - Whether to include diagnostic information
+   *
+   * @returns {ExpressionEvaluationResult} The evaluation result
+   */
+  Evaluate(expression, context2 = {}, enableDiagnostics = false) {
+    const startTime = Date.now();
+    try {
+      const safeContext = this.createSafeContext(context2);
+      const contextKeys = Object.keys(safeContext);
+      const validationError = _SafeExpressionEvaluator.ScreenExpression(expression, contextKeys);
+      if (validationError) {
+        return {
+          success: false,
+          error: validationError,
+          diagnostics: enableDiagnostics ? {
+            expression,
+            context: context2,
+            evaluationTime: Date.now() - startTime
+          } : void 0
+        };
+      }
+      const contextValues = contextKeys.map((key) => safeContext[key]);
+      const cacheKey = `${expression}|${contextKeys.join(",")}`;
+      let evaluator = this._compiledExpressionCache.Get(cacheKey);
+      if (!evaluator) {
+        const functionBody = `
+                    "use strict";
+                    try {
+                        return Boolean(${expression});
+                    } catch (e) {
+                        throw new Error('Expression evaluation failed: ' + e.message);
+                    }
+                `;
+        evaluator = new Function(...contextKeys, functionBody);
+        this._compiledExpressionCache.Set(cacheKey, evaluator);
+      }
+      const result = evaluator(...contextValues);
+      return {
+        success: true,
+        value: Boolean(result),
+        diagnostics: enableDiagnostics ? {
+          expression,
+          context: context2,
+          evaluationTime: Date.now() - startTime
+        } : void 0
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        diagnostics: enableDiagnostics ? {
+          expression,
+          context: context2,
+          evaluationTime: Date.now() - startTime
+        } : void 0
+      };
     }
-    return this.checkNode(node.body);
+  }
+  /** @deprecated Use {@link Evaluate}. */
+  evaluate(expression, context2 = {}, enableDiagnostics = false) {
+    return this.Evaluate(expression, context2, enableDiagnostics);
+  }
+  /**
+   * Screens an expression against the allowlist WITHOUT compiling or running it. Returns the
+   * rejection message, or `null` when every construct is permitted.
+   *
+   * This is the single policy gate for every place MemberJunction compiles a user- or LLM-authored
+   * expression: {@link Evaluate}, {@link ValidateSyntax}, and the field-rule / integration formula
+   * engine (`FieldTransformEngine`), which passes `['value', 'fields']`.
+   *
+   * A context key or arrow parameter named like an approved global (`Math`, `JSON`, ...) shadows
+   * it and is screened as data, so `Math.abs(x)` with a `Math` context key is refused because
+   * `abs` is not a safe instance method. Do not pass approved-global names as context keys.
+   *
+   * @param expression the expression to screen
+   * @param allowedIdentifiers the names the expression may reference as values — the evaluation
+   *        context keys. Pass `null` only when they are not yet known (authoring-time syntax
+   *        checks); free identifiers are then left for evaluation time to decide, while approved
+   *        globals used as values, callbacks that are not inline arrows, and every structural rule
+   *        are still enforced.
+   */
+  static ScreenExpression(expression, allowedIdentifiers) {
+    if (!expression || typeof expression !== "string") {
+      return "Expression must be a non-empty string";
+    }
+    if (expression.length > MAX_EXPRESSION_LENGTH) {
+      return `Expression exceeds maximum length of ${MAX_EXPRESSION_LENGTH} characters`;
+    }
+    if (expression.trim() === "") {
+      return null;
+    }
+    let program;
+    try {
+      program = parse3(expression, { ecmaVersion: 2022 });
+    } catch (e) {
+      if (_SafeExpressionEvaluator.hasUnbalancedParentheses(expression)) {
+        return "Unbalanced parentheses in expression";
+      }
+      return forbidden(`it is not a parseable single expression (${e instanceof Error ? e.message : String(e)})`);
+    }
+    if (program.body.length !== 1 || program.body[0].type !== "ExpressionStatement") {
+      return forbidden("only a single expression is permitted \u2014 no statements, blocks, or semicolons");
+    }
+    const keys = allowedIdentifiers === null ? null : new Set(allowedIdentifiers);
+    return new ExpressionScreen(keys).Check(program.body[0].expression);
+  }
+  /** Counts parentheses textually; used only to word the error for an expression that failed to parse. @private */
+  static hasUnbalancedParentheses(expression) {
+    let depth = 0;
+    for (const char of expression) {
+      if (char === "(")
+        depth++;
+      if (char === ")")
+        depth--;
+      if (depth < 0)
+        return true;
+    }
+    return depth !== 0;
   }
   /**
    * Creates a safe context object with only allowed properties
@@ -15510,11 +15628,17 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
    * @private
    */
   createSafeContext(context2) {
+    if (context2 === null || typeof context2 !== "object") {
+      throw new Error("Context must be an object");
+    }
     const safeContext = {};
     for (const [key, value] of Object.entries(context2)) {
       if (this.isDangerousPropertyName(key)) {
         continue;
       }
+      if (!CONTEXT_KEY_PATTERN.test(key)) {
+        throw new Error(`Context key "${key}" is not a valid identifier; context keys must match ${CONTEXT_KEY_PATTERN.source}`);
+      }
       safeContext[key] = this.cloneValue(value);
     }
     return safeContext;
@@ -15541,6 +15665,11 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
   /**
    * Safely clones a value for use in evaluation context
    *
+   * Functions are never carried into the context: a context should hold data, and a function
+   * reachable from an expression is one more thing that could be invoked. A function value
+   * becomes `undefined`, and function-valued properties are dropped from plain objects and
+   * class instances alike.
+   *
    * @param {any} value - The value to clone
    *
    * @returns {any} The cloned value
@@ -15552,6 +15681,9 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
       return value;
     }
     const type = typeof value;
+    if (type === "function") {
+      return void 0;
+    }
     if (type === "string" || type === "number" || type === "boolean") {
       return value;
     }
@@ -15561,7 +15693,7 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
     if (type === "object" && value.constructor === Object) {
       const cloned = {};
       for (const [key, val] of Object.entries(value)) {
-        if (!this.isDangerousPropertyName(key)) {
+        if (!this.isDangerousPropertyName(key) && typeof val !== "function") {
           cloned[key] = this.cloneValue(val);
         }
       }
@@ -15573,7 +15705,7 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
     if (type === "object" && typeof value.constructor === "function") {
       const cloned = {};
       for (const [key, val] of Object.entries(value)) {
-        if (!this.isDangerousPropertyName(key)) {
+        if (!this.isDangerousPropertyName(key) && typeof val !== "function") {
           cloned[key] = val;
         }
       }
@@ -15595,43 +15727,43 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
    * is a perfectly good condition that simply has no data yet. A submit-time check built on
    * `evaluate` therefore refuses every legitimate condition.
    *
-   * So this compiles and never runs. The expression goes through the same policy screen
-   * `evaluate` applies (the AST allowlist), then the same function body is BUILT and discarded —
-   * never invoked. Values are never consulted, which is precisely the property wanted: unknown
+   * So this parses and never runs. The expression goes through the same policy screen
+   * `evaluate` applies (the AST allowlist), then the same function body `evaluate` compiles is
+   * parsed in strict mode — never compiled, never invoked. Values are never consulted, which is precisely the property wanted: unknown
    * identifiers, absent properties and undefined chains all PASS, because none of them is a syntax
-   * error and whether they resolve is a question about a run that has not happened yet.
+   * error and whether they resolve is a question about a run that has not happened yet. Pass
+   * `contextKeys` when the evaluation context's keys ARE known, and unknown identifiers are refused
+   * here exactly as {@link Evaluate} would refuse them.
    *
-   * **Compilation is not evaluation**, and the distinction is load-bearing for safety: `Function`
-   * parses the body and returns; nothing in the expression executes. The policy screen still runs
-   * first, so the constructs `evaluate` refuses are refused here too — those produce a permanent
-   * runtime refusal, and an author is better told now.
+   * **Parsing is not evaluation**, and the distinction is load-bearing for safety: no code is
+   * constructed from the expression here, so nothing in it can execute. The policy screen still
+   * runs first, so the constructs `evaluate` refuses are refused here too — those produce a
+   * permanent runtime refusal, and an author is better told now.
    *
-   * `Undecidable` is the honest third answer. A host that forbids dynamic compilation (a strict
-   * CSP without `unsafe-eval`) cannot answer the question at all, and a validator that read that
-   * as "invalid" would refuse every condition in the browser. Callers should treat it as a pass.
+   * Because nothing is compiled, the answer does not depend on the host allowing dynamic code (a
+   * strict CSP without `unsafe-eval`). `Undecidable` is kept in the result type for callers that
+   * check it, and is no longer returned.
    *
    * @param expression the expression to check
-   * @returns `Valid: true` when it parses; `Valid: false` with `Error` when it definitely does
-   *          not; `Valid: true` with `Undecidable: true` when this environment cannot compile
+   * @param contextKeys the names the expression may reference, when known; omitted, free
+   *        identifiers are left for evaluation time (see {@link ScreenExpression})
+   * @returns `Valid: true` when it parses; `Valid: false` with `Error` when it does not
    */
-  ValidateSyntax(expression) {
-    const policyError = this.validateExpression(expression);
+  ValidateSyntax(expression, contextKeys) {
+    const policyError = _SafeExpressionEvaluator.ScreenExpression(expression, contextKeys ?? null);
     if (policyError) {
       return { Valid: false, Error: policyError };
     }
     try {
-      new Function(`"use strict"; return Boolean(${expression});`);
+      parse3(`"use strict"; return Boolean(${expression});`, { ecmaVersion: 2022, allowReturnOutsideFunction: true });
       return { Valid: true };
     } catch (e) {
-      if (e instanceof SyntaxError) {
-        return { Valid: false, Error: e.message };
-      }
-      return { Valid: true, Undecidable: true };
+      return { Valid: false, Error: e instanceof Error ? e.message : String(e) };
     }
   }
   /** @deprecated Use {@link ValidateSyntax}. */
-  validateSyntax(expression) {
-    return this.ValidateSyntax(expression);
+  validateSyntax(expression, contextKeys) {
+    return this.ValidateSyntax(expression, contextKeys);
   }
   /**
    * Evaluates multiple expressions and returns all results
@@ -15656,6 +15788,77 @@ var SafeExpressionEvaluator = class _SafeExpressionEvaluator {
 };
 var DefaultExpressionEvaluator = new SafeExpressionEvaluator();
 
+// ../../MJGlobal/dist/fieldRules/SafeTransformAstEvaluator.js
+var OPTIONAL_SHORT_CIRCUIT = Symbol("OPTIONAL_SHORT_CIRCUIT");
+var HIGHER_ORDER_ARRAY_METHODS = /* @__PURE__ */ new Set([
+  "some",
+  "every",
+  "find",
+  "findIndex",
+  "filter",
+  "map",
+  "reduce",
+  "flatMap"
+]);
+var SAFE_STRING_METHODS = /* @__PURE__ */ new Set([
+  "includes",
+  "startsWith",
+  "endsWith",
+  "indexOf",
+  "lastIndexOf",
+  "toLowerCase",
+  "toUpperCase",
+  "trim",
+  "trimStart",
+  "trimEnd",
+  "slice",
+  "substring",
+  "split",
+  "replace",
+  "replaceAll",
+  "padStart",
+  "padEnd",
+  "charAt",
+  "charCodeAt",
+  "at",
+  "concat",
+  "toString",
+  "valueOf"
+]);
+var SAFE_ARRAY_VALUE_METHODS = /* @__PURE__ */ new Set([
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "join",
+  "slice",
+  "concat",
+  "flat",
+  "at",
+  "toString"
+]);
+var SAFE_NUMBER_METHODS = /* @__PURE__ */ new Set(["toFixed", "toPrecision", "toString", "valueOf"]);
+var SAFE_BOOLEAN_METHODS = /* @__PURE__ */ new Set(["toString", "valueOf"]);
+var SAFE_DATE_METHODS = /* @__PURE__ */ new Set([
+  "toISOString",
+  "getTime",
+  "getFullYear",
+  "getUTCFullYear",
+  "getMonth",
+  "getUTCMonth",
+  "getDate",
+  "getUTCDate",
+  "toString",
+  "valueOf"
+]);
+var ALL_SAFE_INSTANCE_METHODS = /* @__PURE__ */ new Set([
+  ...SAFE_STRING_METHODS,
+  ...SAFE_ARRAY_VALUE_METHODS,
+  ...HIGHER_ORDER_ARRAY_METHODS,
+  ...SAFE_NUMBER_METHODS,
+  ...SAFE_BOOLEAN_METHODS,
+  ...SAFE_DATE_METHODS
+]);
+
 // ../../MJGlobal/dist/SQLScreeningScanner.js
 var SQL_SCREENING_DIALECTS = ["sqlserver", "postgresql"];
 var LEXICAL_RULES = {
@@ -16924,6 +17127,16 @@ var WarningManager = class _WarningManager extends BaseSingleton {
 
 // ../../MJGlobal/dist/EncryptionUtils.js
 var ENCRYPTION_MARKER = "$ENC$";
+var ENCRYPTED_SENTINEL = "[!ENCRYPTED$]";
+function IsValueEncrypted(value, encryptionMarker) {
+  if (!value || typeof value !== "string") {
+    return false;
+  }
+  return IsEncryptedSentinel(value) || value.startsWith(encryptionMarker || ENCRYPTION_MARKER);
+}
+function IsEncryptedSentinel(value) {
+  return value === ENCRYPTED_SENTINEL;
+}
 
 // ../../MJGlobal/dist/hashing/canonicalize.js
 function Canonicalize(value) {
@@ -16990,6 +17203,7 @@ export {
   UUIDsEqual,
   IsValidUUID,
   UUIDSet,
+  UUIDMap,
   GroupByUUID,
   IndexByUUID,
   UserCacheKeySegment,
@@ -17009,6 +17223,8 @@ export {
   SQLExpressionValidator,
   WarningManager,
   ENCRYPTION_MARKER,
+  ENCRYPTED_SENTINEL,
+  IsValueEncrypted,
   ComputeContentHashAsync,
   Subscription,
   Observable,