@dyrected/core 2.8.3 → 2.10.0

package/dist/server.cjs

@@ -8,6 +8,9 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,6 +33,1757 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/interopRequireDefault.js
+var require_interopRequireDefault = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/interopRequireDefault.js"(exports2, module2) {
+    "use strict";
+    function _interopRequireDefault(e) {
+      return e && e.__esModule ? e : {
+        "default": e
+      };
+    }
+    module2.exports = _interopRequireDefault, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/typeof.js
+var require_typeof = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/typeof.js"(exports2, module2) {
+    "use strict";
+    function _typeof(o) {
+      "@babel/helpers - typeof";
+      return module2.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+        return typeof o2;
+      } : function(o2) {
+        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _typeof(o);
+    }
+    module2.exports = _typeof, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPrimitive.js
+var require_toPrimitive = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPrimitive.js"(exports2, module2) {
+    "use strict";
+    var _typeof = require_typeof()["default"];
+    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);
+    }
+    module2.exports = toPrimitive, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPropertyKey.js
+var require_toPropertyKey = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPropertyKey.js"(exports2, module2) {
+    "use strict";
+    var _typeof = require_typeof()["default"];
+    var toPrimitive = require_toPrimitive();
+    function toPropertyKey(t) {
+      var i = toPrimitive(t, "string");
+      return "symbol" == _typeof(i) ? i : i + "";
+    }
+    module2.exports = toPropertyKey, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/defineProperty.js
+var require_defineProperty = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/defineProperty.js"(exports2, module2) {
+    "use strict";
+    var toPropertyKey = require_toPropertyKey();
+    function _defineProperty(e, r, t) {
+      return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+        value: t,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      }) : e[r] = t, e;
+    }
+    module2.exports = _defineProperty, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/classCallCheck.js
+var require_classCallCheck = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/classCallCheck.js"(exports2, module2) {
+    "use strict";
+    function _classCallCheck(a, n) {
+      if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+    }
+    module2.exports = _classCallCheck, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/createClass.js
+var require_createClass = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/createClass.js"(exports2, module2) {
+    "use strict";
+    var toPropertyKey = require_toPropertyKey();
+    function _defineProperties(e, r) {
+      for (var t = 0; t < r.length; t++) {
+        var o = r[t];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e, r, t) {
+      return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+        writable: false
+      }), e;
+    }
+    module2.exports = _createClass, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
+var require_arrayLikeToArray = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayLikeToArray.js"(exports2, module2) {
+    "use strict";
+    function _arrayLikeToArray(r, a) {
+      (null == a || a > r.length) && (a = r.length);
+      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+      return n;
+    }
+    module2.exports = _arrayLikeToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
+var require_arrayWithoutHoles = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js"(exports2, module2) {
+    "use strict";
+    var arrayLikeToArray = require_arrayLikeToArray();
+    function _arrayWithoutHoles(r) {
+      if (Array.isArray(r)) return arrayLikeToArray(r);
+    }
+    module2.exports = _arrayWithoutHoles, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/iterableToArray.js
+var require_iterableToArray = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/iterableToArray.js"(exports2, module2) {
+    "use strict";
+    function _iterableToArray(r) {
+      if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+    }
+    module2.exports = _iterableToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js
+var require_unsupportedIterableToArray = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"(exports2, module2) {
+    "use strict";
+    var arrayLikeToArray = require_arrayLikeToArray();
+    function _unsupportedIterableToArray(r, a) {
+      if (r) {
+        if ("string" == typeof r) return arrayLikeToArray(r, a);
+        var t = {}.toString.call(r).slice(8, -1);
+        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;
+      }
+    }
+    module2.exports = _unsupportedIterableToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/nonIterableSpread.js
+var require_nonIterableSpread = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/nonIterableSpread.js"(exports2, module2) {
+    "use strict";
+    function _nonIterableSpread() {
+      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    module2.exports = _nonIterableSpread, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toConsumableArray.js
+var require_toConsumableArray = __commonJS({
+  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toConsumableArray.js"(exports2, module2) {
+    "use strict";
+    var arrayWithoutHoles = require_arrayWithoutHoles();
+    var iterableToArray = require_iterableToArray();
+    var unsupportedIterableToArray = require_unsupportedIterableToArray();
+    var nonIterableSpread = require_nonIterableSpread();
+    function _toConsumableArray(r) {
+      return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();
+    }
+    module2.exports = _toConsumableArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/handlers.js
+var require_handlers = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/handlers.js"(exports2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
+    var poolNames = {
+      functions: "Jexl Function",
+      transforms: "Transform"
+    };
+    exports2.ArrayLiteral = function(ast) {
+      return this.evalArray(ast.value);
+    };
+    exports2.BinaryExpression = function(ast) {
+      var _this = this;
+      var grammarOp = this._grammar.elements[ast.operator];
+      if (grammarOp.evalOnDemand) {
+        var wrap = function wrap2(subAst) {
+          return {
+            eval: function _eval() {
+              return _this.eval(subAst);
+            }
+          };
+        };
+        return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right));
+      }
+      return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then(function(arr) {
+        return grammarOp.eval(arr[0], arr[1]);
+      });
+    };
+    exports2.ConditionalExpression = function(ast) {
+      var _this2 = this;
+      return this.eval(ast.test).then(function(res) {
+        if (res) {
+          if (ast.consequent) {
+            return _this2.eval(ast.consequent);
+          }
+          return res;
+        }
+        return _this2.eval(ast.alternate);
+      });
+    };
+    exports2.FilterExpression = function(ast) {
+      var _this3 = this;
+      return this.eval(ast.subject).then(function(subject) {
+        if (ast.relative) {
+          return _this3._filterRelative(subject, ast.expr);
+        }
+        return _this3._filterStatic(subject, ast.expr);
+      });
+    };
+    exports2.Identifier = function(ast) {
+      if (!ast.from) {
+        return ast.relative ? this._relContext[ast.value] : this._context[ast.value];
+      }
+      return this.eval(ast.from).then(function(context) {
+        if (context === void 0 || context === null) {
+          return void 0;
+        }
+        if (Array.isArray(context)) {
+          context = context[0];
+        }
+        return context[ast.value];
+      });
+    };
+    exports2.Literal = function(ast) {
+      return ast.value;
+    };
+    exports2.ObjectLiteral = function(ast) {
+      return this.evalMap(ast.value);
+    };
+    exports2.FunctionCall = function(ast) {
+      var poolName = poolNames[ast.pool];
+      if (!poolName) {
+        throw new Error("Corrupt AST: Pool '".concat(ast.pool, "' not found"));
+      }
+      var pool = this._grammar[ast.pool];
+      var func = pool[ast.name];
+      if (!func) {
+        throw new Error("".concat(poolName, " ").concat(ast.name, " is not defined."));
+      }
+      return this.evalArray(ast.args || []).then(function(args) {
+        return func.apply(void 0, (0, _toConsumableArray2.default)(args));
+      });
+    };
+    exports2.UnaryExpression = function(ast) {
+      var _this4 = this;
+      return this.eval(ast.right).then(function(right) {
+        return _this4._grammar.elements[ast.operator].eval(right);
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/Evaluator.js
+var require_Evaluator = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/Evaluator.js"(exports2, module2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+    var _createClass2 = _interopRequireDefault(require_createClass());
+    var handlers = require_handlers();
+    var Evaluator = /* @__PURE__ */ (function() {
+      function Evaluator2(grammar, context, relativeContext) {
+        var promise = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Promise;
+        (0, _classCallCheck2.default)(this, Evaluator2);
+        this._grammar = grammar;
+        this._context = context || {};
+        this._relContext = relativeContext || this._context;
+        this.Promise = promise;
+      }
+      (0, _createClass2.default)(Evaluator2, [{
+        key: "eval",
+        value: function _eval(ast) {
+          var _this = this;
+          return this.Promise.resolve().then(function() {
+            return handlers[ast.type].call(_this, ast);
+          });
+        }
+        /**
+         * Simultaneously evaluates each expression within an array, and delivers the
+         * response as an array with the resulting values at the same indexes as their
+         * originating expressions.
+         * @param {Array<string>} arr An array of expression strings to be evaluated
+         * @returns {Promise<Array<{}>>} resolves with the result array
+         */
+      }, {
+        key: "evalArray",
+        value: function evalArray(arr) {
+          var _this2 = this;
+          return this.Promise.all(arr.map(function(elem) {
+            return _this2.eval(elem);
+          }));
+        }
+        /**
+         * Simultaneously evaluates each expression within a map, and delivers the
+         * response as a map with the same keys, but with the evaluated result for each
+         * as their value.
+         * @param {{}} map A map of expression names to expression trees to be
+         *      evaluated
+         * @returns {Promise<{}>} resolves with the result map.
+         */
+      }, {
+        key: "evalMap",
+        value: function evalMap(map) {
+          var _this3 = this;
+          var keys = Object.keys(map);
+          var result = {};
+          var asts = keys.map(function(key) {
+            return _this3.eval(map[key]);
+          });
+          return this.Promise.all(asts).then(function(vals) {
+            vals.forEach(function(val, idx) {
+              result[keys[idx]] = val;
+            });
+            return result;
+          });
+        }
+        /**
+         * Applies a filter expression with relative identifier elements to a subject.
+         * The intent is for the subject to be an array of subjects that will be
+         * individually used as the relative context against the provided expression
+         * tree. Only the elements whose expressions result in a truthy value will be
+         * included in the resulting array.
+         *
+         * If the subject is not an array of values, it will be converted to a single-
+         * element array before running the filter.
+         * @param {*} subject The value to be filtered usually an array. If this value is
+         *      not an array, it will be converted to an array with this value as the
+         *      only element.
+         * @param {{}} expr The expression tree to run against each subject. If the
+         *      tree evaluates to a truthy result, then the value will be included in
+         *      the returned array otherwise, it will be eliminated.
+         * @returns {Promise<Array>} resolves with an array of values that passed the
+         *      expression filter.
+         * @private
+         */
+      }, {
+        key: "_filterRelative",
+        value: function _filterRelative(subject, expr) {
+          var _this4 = this;
+          var promises = [];
+          if (!Array.isArray(subject)) {
+            subject = subject === void 0 ? [] : [subject];
+          }
+          subject.forEach(function(elem) {
+            var evalInst = new Evaluator2(_this4._grammar, _this4._context, elem, _this4.Promise);
+            promises.push(evalInst.eval(expr));
+          });
+          return this.Promise.all(promises).then(function(values) {
+            var results = [];
+            values.forEach(function(value, idx) {
+              if (value) {
+                results.push(subject[idx]);
+              }
+            });
+            return results;
+          });
+        }
+        /**
+         * Applies a static filter expression to a subject value.  If the filter
+         * expression evaluates to boolean true, the subject is returned if false,
+         * undefined.
+         *
+         * For any other resulting value of the expression, this function will attempt
+         * to respond with the property at that name or index of the subject.
+         * @param {*} subject The value to be filtered.  Usually an Array (for which
+         *      the expression would generally resolve to a numeric index) or an
+         *      Object (for which the expression would generally resolve to a string
+         *      indicating a property name)
+         * @param {{}} expr The expression tree to run against the subject
+         * @returns {Promise<*>} resolves with the value of the drill-down.
+         * @private
+         */
+      }, {
+        key: "_filterStatic",
+        value: function _filterStatic(subject, expr) {
+          return this.eval(expr).then(function(res) {
+            if (typeof res === "boolean") {
+              return res ? subject : void 0;
+            }
+            return subject[res];
+          });
+        }
+      }]);
+      return Evaluator2;
+    })();
+    module2.exports = Evaluator;
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Lexer.js
+var require_Lexer = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Lexer.js"(exports2, module2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+    var _createClass2 = _interopRequireDefault(require_createClass());
+    var numericRegex = /^-?(?:(?:[0-9]*\.[0-9]+)|[0-9]+)$/;
+    var identRegex = /^[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][a-zA-Zа-яА-Я0-9_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*$/;
+    var escEscRegex = /\\\\/;
+    var whitespaceRegex = /^\s*$/;
+    var preOpRegexElems = [
+      // Strings
+      "'(?:(?:\\\\')|[^'])*'",
+      '"(?:(?:\\\\")|[^"])*"',
+      // Whitespace
+      "\\s+",
+      // Booleans
+      "\\btrue\\b",
+      "\\bfalse\\b"
+    ];
+    var postOpRegexElems = [
+      // Identifiers
+      "[a-zA-Z\u0430-\u044F\u0410-\u042F_\xC0-\xD6\xD8-\xF6\xF8-\xFF\\$][a-zA-Z0-9\u0430-\u044F\u0410-\u042F_\xC0-\xD6\xD8-\xF6\xF8-\xFF\\$]*",
+      // Numerics (without negative symbol)
+      "(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)"
+    ];
+    var minusNegatesAfter = ["binaryOp", "unaryOp", "openParen", "openBracket", "question", "colon"];
+    var Lexer = /* @__PURE__ */ (function() {
+      function Lexer2(grammar) {
+        (0, _classCallCheck2.default)(this, Lexer2);
+        this._grammar = grammar;
+      }
+      (0, _createClass2.default)(Lexer2, [{
+        key: "getElements",
+        value: function getElements(str) {
+          var regex = this._getSplitRegex();
+          return str.split(regex).filter(function(elem) {
+            return elem;
+          });
+        }
+        /**
+         * Converts an array of expression elements into an array of tokens.  Note that
+         * the resulting array may not equal the element array in length, as any
+         * elements that consist only of whitespace get appended to the previous
+         * token's "raw" property.  For the structure of a token object, please see
+         * {@link Lexer#tokenize}.
+         * @param {Array<string>} elements An array of Jexl expression elements to be
+         *      converted to tokens
+         * @returns {Array<{type, value, raw}>} an array of token objects.
+         */
+      }, {
+        key: "getTokens",
+        value: function getTokens(elements) {
+          var tokens = [];
+          var negate = false;
+          for (var i = 0; i < elements.length; i++) {
+            if (this._isWhitespace(elements[i])) {
+              if (tokens.length) {
+                tokens[tokens.length - 1].raw += elements[i];
+              }
+            } else if (elements[i] === "-" && this._isNegative(tokens)) {
+              negate = true;
+            } else {
+              if (negate) {
+                elements[i] = "-" + elements[i];
+                negate = false;
+              }
+              tokens.push(this._createToken(elements[i]));
+            }
+          }
+          if (negate) {
+            tokens.push(this._createToken("-"));
+          }
+          return tokens;
+        }
+        /**
+         * Converts a Jexl string into an array of tokens.  Each token is an object
+         * in the following format:
+         *
+         *     {
+         *         type: <string>,
+         *         [name]: <string>,
+         *         value: <boolean|number|string>,
+         *         raw: <string>
+         *     }
+         *
+         * Type is one of the following:
+         *
+         *      literal, identifier, binaryOp, unaryOp
+         *
+         * OR, if the token is a control character its type is the name of the element
+         * defined in the Grammar.
+         *
+         * Name appears only if the token is a control string found in
+         * {@link grammar#elements}, and is set to the name of the element.
+         *
+         * Value is the value of the token in the correct type (boolean or numeric as
+         * appropriate). Raw is the string representation of this value taken directly
+         * from the expression string, including any trailing spaces.
+         * @param {string} str The Jexl string to be tokenized
+         * @returns {Array<{type, value, raw}>} an array of token objects.
+         * @throws {Error} if the provided string contains an invalid token.
+         */
+      }, {
+        key: "tokenize",
+        value: function tokenize(str) {
+          var elements = this.getElements(str);
+          return this.getTokens(elements);
+        }
+        /**
+         * Creates a new token object from an element of a Jexl string. See
+         * {@link Lexer#tokenize} for a description of the token object.
+         * @param {string} element The element from which a token should be made
+         * @returns {{value: number|boolean|string, [name]: string, type: string,
+         *      raw: string}} a token object describing the provided element.
+         * @throws {Error} if the provided string is not a valid expression element.
+         * @private
+         */
+      }, {
+        key: "_createToken",
+        value: function _createToken(element) {
+          var token = {
+            type: "literal",
+            value: element,
+            raw: element
+          };
+          if (element[0] === '"' || element[0] === "'") {
+            token.value = this._unquote(element);
+          } else if (element.match(numericRegex)) {
+            token.value = parseFloat(element);
+          } else if (element === "true" || element === "false") {
+            token.value = element === "true";
+          } else if (this._grammar.elements[element]) {
+            token.type = this._grammar.elements[element].type;
+          } else if (element.match(identRegex)) {
+            token.type = "identifier";
+          } else {
+            throw new Error("Invalid expression token: ".concat(element));
+          }
+          return token;
+        }
+        /**
+         * Escapes a string so that it can be treated as a string literal within a
+         * regular expression.
+         * @param {string} str The string to be escaped
+         * @returns {string} the RegExp-escaped string.
+         * @see https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions
+         * @private
+         */
+      }, {
+        key: "_escapeRegExp",
+        value: function _escapeRegExp(str) {
+          str = str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          if (str.match(identRegex)) {
+            str = "\\b" + str + "\\b";
+          }
+          return str;
+        }
+        /**
+         * Gets a RegEx object appropriate for splitting a Jexl string into its core
+         * elements.
+         * @returns {RegExp} An element-splitting RegExp object
+         * @private
+         */
+      }, {
+        key: "_getSplitRegex",
+        value: function _getSplitRegex() {
+          var _this = this;
+          if (!this._splitRegex) {
+            var elemArray = Object.keys(this._grammar.elements).sort(function(a, b) {
+              return b.length - a.length;
+            }).map(function(elem) {
+              return _this._escapeRegExp(elem);
+            }, this);
+            this._splitRegex = new RegExp("(" + [preOpRegexElems.join("|"), elemArray.join("|"), postOpRegexElems.join("|")].join("|") + ")");
+          }
+          return this._splitRegex;
+        }
+        /**
+         * Determines whether the addition of a '-' token should be interpreted as a
+         * negative symbol for an upcoming number, given an array of tokens already
+         * processed.
+         * @param {Array<Object>} tokens An array of tokens already processed
+         * @returns {boolean} true if adding a '-' should be considered a negative
+         *      symbol; false otherwise
+         * @private
+         */
+      }, {
+        key: "_isNegative",
+        value: function _isNegative(tokens) {
+          if (!tokens.length) return true;
+          return minusNegatesAfter.some(function(type) {
+            return type === tokens[tokens.length - 1].type;
+          });
+        }
+        /**
+         * A utility function to determine if a string consists of only space
+         * characters.
+         * @param {string} str A string to be tested
+         * @returns {boolean} true if the string is empty or consists of only spaces;
+         *      false otherwise.
+         * @private
+         */
+      }, {
+        key: "_isWhitespace",
+        value: function _isWhitespace(str) {
+          return !!str.match(whitespaceRegex);
+        }
+        /**
+         * Removes the beginning and trailing quotes from a string, unescapes any
+         * escaped quotes on its interior, and unescapes any escaped escape
+         * characters. Note that this function is not defensive; it assumes that the
+         * provided string is not empty, and that its first and last characters are
+         * actually quotes.
+         * @param {string} str A string whose first and last characters are quotes
+         * @returns {string} a string with the surrounding quotes stripped and escapes
+         *      properly processed.
+         * @private
+         */
+      }, {
+        key: "_unquote",
+        value: function _unquote(str) {
+          var quote = str[0];
+          var escQuoteRegex = new RegExp("\\\\" + quote, "g");
+          return str.substr(1, str.length - 2).replace(escQuoteRegex, quote).replace(escEscRegex, "\\");
+        }
+      }]);
+      return Lexer2;
+    })();
+    module2.exports = Lexer;
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/handlers.js
+var require_handlers2 = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/handlers.js"(exports2) {
+    "use strict";
+    exports2.argVal = function(ast) {
+      if (ast) this._cursor.args.push(ast);
+    };
+    exports2.arrayStart = function() {
+      this._placeAtCursor({
+        type: "ArrayLiteral",
+        value: []
+      });
+    };
+    exports2.arrayVal = function(ast) {
+      if (ast) {
+        this._cursor.value.push(ast);
+      }
+    };
+    exports2.binaryOp = function(token) {
+      var precedence = this._grammar.elements[token.value].precedence || 0;
+      var parent = this._cursor._parent;
+      while (parent && parent.operator && this._grammar.elements[parent.operator].precedence >= precedence) {
+        this._cursor = parent;
+        parent = parent._parent;
+      }
+      var node = {
+        type: "BinaryExpression",
+        operator: token.value,
+        left: this._cursor
+      };
+      this._setParent(this._cursor, node);
+      this._cursor = parent;
+      this._placeAtCursor(node);
+    };
+    exports2.dot = function() {
+      this._nextIdentEncapsulate = this._cursor && this._cursor.type !== "UnaryExpression" && (this._cursor.type !== "BinaryExpression" || this._cursor.type === "BinaryExpression" && this._cursor.right);
+      this._nextIdentRelative = !this._cursor || this._cursor && !this._nextIdentEncapsulate;
+      if (this._nextIdentRelative) {
+        this._relative = true;
+      }
+    };
+    exports2.filter = function(ast) {
+      this._placeBeforeCursor({
+        type: "FilterExpression",
+        expr: ast,
+        relative: this._subParser.isRelative(),
+        subject: this._cursor
+      });
+    };
+    exports2.functionCall = function() {
+      this._placeBeforeCursor({
+        type: "FunctionCall",
+        name: this._cursor.value,
+        args: [],
+        pool: "functions"
+      });
+    };
+    exports2.identifier = function(token) {
+      var node = {
+        type: "Identifier",
+        value: token.value
+      };
+      if (this._nextIdentEncapsulate) {
+        node.from = this._cursor;
+        this._placeBeforeCursor(node);
+        this._nextIdentEncapsulate = false;
+      } else {
+        if (this._nextIdentRelative) {
+          node.relative = true;
+          this._nextIdentRelative = false;
+        }
+        this._placeAtCursor(node);
+      }
+    };
+    exports2.literal = function(token) {
+      this._placeAtCursor({
+        type: "Literal",
+        value: token.value
+      });
+    };
+    exports2.objKey = function(token) {
+      this._curObjKey = token.value;
+    };
+    exports2.objStart = function() {
+      this._placeAtCursor({
+        type: "ObjectLiteral",
+        value: {}
+      });
+    };
+    exports2.objVal = function(ast) {
+      this._cursor.value[this._curObjKey] = ast;
+    };
+    exports2.subExpression = function(ast) {
+      this._placeAtCursor(ast);
+    };
+    exports2.ternaryEnd = function(ast) {
+      this._cursor.alternate = ast;
+    };
+    exports2.ternaryMid = function(ast) {
+      this._cursor.consequent = ast;
+    };
+    exports2.ternaryStart = function() {
+      this._tree = {
+        type: "ConditionalExpression",
+        test: this._tree
+      };
+      this._cursor = this._tree;
+    };
+    exports2.transform = function(token) {
+      this._placeBeforeCursor({
+        type: "FunctionCall",
+        name: token.value,
+        args: [this._cursor],
+        pool: "transforms"
+      });
+    };
+    exports2.unaryOp = function(token) {
+      this._placeAtCursor({
+        type: "UnaryExpression",
+        operator: token.value
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/states.js
+var require_states = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/states.js"(exports2) {
+    "use strict";
+    var h = require_handlers2();
+    exports2.states = {
+      expectOperand: {
+        tokenTypes: {
+          literal: {
+            toState: "expectBinOp"
+          },
+          identifier: {
+            toState: "identifier"
+          },
+          unaryOp: {},
+          openParen: {
+            toState: "subExpression"
+          },
+          openCurl: {
+            toState: "expectObjKey",
+            handler: h.objStart
+          },
+          dot: {
+            toState: "traverse"
+          },
+          openBracket: {
+            toState: "arrayVal",
+            handler: h.arrayStart
+          }
+        }
+      },
+      expectBinOp: {
+        tokenTypes: {
+          binaryOp: {
+            toState: "expectOperand"
+          },
+          pipe: {
+            toState: "expectTransform"
+          },
+          dot: {
+            toState: "traverse"
+          },
+          question: {
+            toState: "ternaryMid",
+            handler: h.ternaryStart
+          }
+        },
+        completable: true
+      },
+      expectTransform: {
+        tokenTypes: {
+          identifier: {
+            toState: "postTransform",
+            handler: h.transform
+          }
+        }
+      },
+      expectObjKey: {
+        tokenTypes: {
+          identifier: {
+            toState: "expectKeyValSep",
+            handler: h.objKey
+          },
+          closeCurl: {
+            toState: "expectBinOp"
+          }
+        }
+      },
+      expectKeyValSep: {
+        tokenTypes: {
+          colon: {
+            toState: "objVal"
+          }
+        }
+      },
+      postTransform: {
+        tokenTypes: {
+          openParen: {
+            toState: "argVal"
+          },
+          binaryOp: {
+            toState: "expectOperand"
+          },
+          dot: {
+            toState: "traverse"
+          },
+          openBracket: {
+            toState: "filter"
+          },
+          pipe: {
+            toState: "expectTransform"
+          }
+        },
+        completable: true
+      },
+      postArgs: {
+        tokenTypes: {
+          binaryOp: {
+            toState: "expectOperand"
+          },
+          dot: {
+            toState: "traverse"
+          },
+          openBracket: {
+            toState: "filter"
+          },
+          pipe: {
+            toState: "expectTransform"
+          }
+        },
+        completable: true
+      },
+      identifier: {
+        tokenTypes: {
+          binaryOp: {
+            toState: "expectOperand"
+          },
+          dot: {
+            toState: "traverse"
+          },
+          openBracket: {
+            toState: "filter"
+          },
+          openParen: {
+            toState: "argVal",
+            handler: h.functionCall
+          },
+          pipe: {
+            toState: "expectTransform"
+          },
+          question: {
+            toState: "ternaryMid",
+            handler: h.ternaryStart
+          }
+        },
+        completable: true
+      },
+      traverse: {
+        tokenTypes: {
+          identifier: {
+            toState: "identifier"
+          }
+        }
+      },
+      filter: {
+        subHandler: h.filter,
+        endStates: {
+          closeBracket: "identifier"
+        }
+      },
+      subExpression: {
+        subHandler: h.subExpression,
+        endStates: {
+          closeParen: "expectBinOp"
+        }
+      },
+      argVal: {
+        subHandler: h.argVal,
+        endStates: {
+          comma: "argVal",
+          closeParen: "postArgs"
+        }
+      },
+      objVal: {
+        subHandler: h.objVal,
+        endStates: {
+          comma: "expectObjKey",
+          closeCurl: "expectBinOp"
+        }
+      },
+      arrayVal: {
+        subHandler: h.arrayVal,
+        endStates: {
+          comma: "arrayVal",
+          closeBracket: "expectBinOp"
+        }
+      },
+      ternaryMid: {
+        subHandler: h.ternaryMid,
+        endStates: {
+          colon: "ternaryEnd"
+        }
+      },
+      ternaryEnd: {
+        subHandler: h.ternaryEnd,
+        completable: true
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/Parser.js
+var require_Parser = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/Parser.js"(exports2, module2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+    var _createClass2 = _interopRequireDefault(require_createClass());
+    var handlers = require_handlers2();
+    var states = require_states().states;
+    var Parser = /* @__PURE__ */ (function() {
+      function Parser2(grammar, prefix, stopMap) {
+        (0, _classCallCheck2.default)(this, Parser2);
+        this._grammar = grammar;
+        this._state = "expectOperand";
+        this._tree = null;
+        this._exprStr = prefix || "";
+        this._relative = false;
+        this._stopMap = stopMap || {};
+      }
+      (0, _createClass2.default)(Parser2, [{
+        key: "addToken",
+        value: function addToken(token) {
+          if (this._state === "complete") {
+            throw new Error("Cannot add a new token to a completed Parser");
+          }
+          var state = states[this._state];
+          var startExpr = this._exprStr;
+          this._exprStr += token.raw;
+          if (state.subHandler) {
+            if (!this._subParser) {
+              this._startSubExpression(startExpr);
+            }
+            var stopState = this._subParser.addToken(token);
+            if (stopState) {
+              this._endSubExpression();
+              if (this._parentStop) return stopState;
+              this._state = stopState;
+            }
+          } else if (state.tokenTypes[token.type]) {
+            var typeOpts = state.tokenTypes[token.type];
+            var handleFunc = handlers[token.type];
+            if (typeOpts.handler) {
+              handleFunc = typeOpts.handler;
+            }
+            if (handleFunc) {
+              handleFunc.call(this, token);
+            }
+            if (typeOpts.toState) {
+              this._state = typeOpts.toState;
+            }
+          } else if (this._stopMap[token.type]) {
+            return this._stopMap[token.type];
+          } else {
+            throw new Error("Token ".concat(token.raw, " (").concat(token.type, ") unexpected in expression: ").concat(this._exprStr));
+          }
+          return false;
+        }
+        /**
+         * Processes an array of tokens iteratively through the {@link #addToken}
+         * function.
+         * @param {Array<{type: <string>}>} tokens An array of tokens, as provided by
+         *      the {@link Lexer#tokenize} function.
+         */
+      }, {
+        key: "addTokens",
+        value: function addTokens(tokens) {
+          tokens.forEach(this.addToken, this);
+        }
+        /**
+         * Marks this Parser instance as completed and retrieves the full AST.
+         * @returns {{}|null} a full expression tree, ready for evaluation by the
+         *      {@link Evaluator#eval} function, or null if no tokens were passed to
+         *      the parser before complete was called
+         * @throws {Error} if the parser is not in a state where it's legal to end
+         *      the expression, indicating that the expression is incomplete
+         */
+      }, {
+        key: "complete",
+        value: function complete() {
+          if (this._cursor && !states[this._state].completable) {
+            throw new Error("Unexpected end of expression: ".concat(this._exprStr));
+          }
+          if (this._subParser) {
+            this._endSubExpression();
+          }
+          this._state = "complete";
+          return this._cursor ? this._tree : null;
+        }
+        /**
+         * Indicates whether the expression tree contains a relative path identifier.
+         * @returns {boolean} true if a relative identifier exists false otherwise.
+         */
+      }, {
+        key: "isRelative",
+        value: function isRelative() {
+          return this._relative;
+        }
+        /**
+         * Ends a subexpression by completing the subParser and passing its result
+         * to the subHandler configured in the current state.
+         * @private
+         */
+      }, {
+        key: "_endSubExpression",
+        value: function _endSubExpression() {
+          states[this._state].subHandler.call(this, this._subParser.complete());
+          this._subParser = null;
+        }
+        /**
+         * Places a new tree node at the current position of the cursor (to the 'right'
+         * property) and then advances the cursor to the new node. This function also
+         * handles setting the parent of the new node.
+         * @param {{type: <string>}} node A node to be added to the AST
+         * @private
+         */
+      }, {
+        key: "_placeAtCursor",
+        value: function _placeAtCursor(node) {
+          if (!this._cursor) {
+            this._tree = node;
+          } else {
+            this._cursor.right = node;
+            this._setParent(node, this._cursor);
+          }
+          this._cursor = node;
+        }
+        /**
+         * Places a tree node before the current position of the cursor, replacing
+         * the node that the cursor currently points to. This should only be called in
+         * cases where the cursor is known to exist, and the provided node already
+         * contains a pointer to what's at the cursor currently.
+         * @param {{type: <string>}} node A node to be added to the AST
+         * @private
+         */
+      }, {
+        key: "_placeBeforeCursor",
+        value: function _placeBeforeCursor(node) {
+          this._cursor = this._cursor._parent;
+          this._placeAtCursor(node);
+        }
+        /**
+         * Sets the parent of a node by creating a non-enumerable _parent property
+         * that points to the supplied parent argument.
+         * @param {{type: <string>}} node A node of the AST on which to set a new
+         *      parent
+         * @param {{type: <string>}} parent An existing node of the AST to serve as the
+         *      parent of the new node
+         * @private
+         */
+      }, {
+        key: "_setParent",
+        value: function _setParent(node, parent) {
+          Object.defineProperty(node, "_parent", {
+            value: parent,
+            writable: true
+          });
+        }
+        /**
+         * Prepares the Parser to accept a subexpression by (re)instantiating the
+         * subParser.
+         * @param {string} [exprStr] The expression string to prefix to the new Parser
+         * @private
+         */
+      }, {
+        key: "_startSubExpression",
+        value: function _startSubExpression(exprStr) {
+          var endStates = states[this._state].endStates;
+          if (!endStates) {
+            this._parentStop = true;
+            endStates = this._stopMap;
+          }
+          this._subParser = new Parser2(this._grammar, exprStr, endStates);
+        }
+      }]);
+      return Parser2;
+    })();
+    module2.exports = Parser;
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/PromiseSync.js
+var require_PromiseSync = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/PromiseSync.js"(exports2, module2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+    var _createClass2 = _interopRequireDefault(require_createClass());
+    var PromiseSync = /* @__PURE__ */ (function() {
+      function PromiseSync2(fn) {
+        (0, _classCallCheck2.default)(this, PromiseSync2);
+        fn(this._resolve.bind(this), this._reject.bind(this));
+      }
+      (0, _createClass2.default)(PromiseSync2, [{
+        key: "catch",
+        value: function _catch(rejected) {
+          if (this.error) {
+            try {
+              this._resolve(rejected(this.error));
+            } catch (e) {
+              this._reject(e);
+            }
+          }
+          return this;
+        }
+      }, {
+        key: "then",
+        value: function then(resolved, rejected) {
+          if (!this.error) {
+            try {
+              this._resolve(resolved(this.value));
+            } catch (e) {
+              this._reject(e);
+            }
+          }
+          if (rejected) this.catch(rejected);
+          return this;
+        }
+      }, {
+        key: "_reject",
+        value: function _reject(error) {
+          this.value = void 0;
+          this.error = error;
+        }
+      }, {
+        key: "_resolve",
+        value: function _resolve(val) {
+          if (val instanceof PromiseSync2) {
+            if (val.error) {
+              this._reject(val.error);
+            } else {
+              this._resolve(val.value);
+            }
+          } else {
+            this.value = val;
+            this.error = void 0;
+          }
+        }
+      }]);
+      return PromiseSync2;
+    })();
+    PromiseSync.all = function(vals) {
+      return new PromiseSync(function(resolve) {
+        var resolved = vals.map(function(val) {
+          while (val instanceof PromiseSync) {
+            if (val.error) throw Error(val.error);
+            val = val.value;
+          }
+          return val;
+        });
+        resolve(resolved);
+      });
+    };
+    PromiseSync.resolve = function(val) {
+      return new PromiseSync(function(resolve) {
+        return resolve(val);
+      });
+    };
+    PromiseSync.reject = function(error) {
+      return new PromiseSync(function(resolve, reject) {
+        return reject(error);
+      });
+    };
+    module2.exports = PromiseSync;
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Expression.js
+var require_Expression = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Expression.js"(exports2, module2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+    var _createClass2 = _interopRequireDefault(require_createClass());
+    var Evaluator = require_Evaluator();
+    var Lexer = require_Lexer();
+    var Parser = require_Parser();
+    var PromiseSync = require_PromiseSync();
+    var Expression = /* @__PURE__ */ (function() {
+      function Expression2(grammar, exprStr) {
+        (0, _classCallCheck2.default)(this, Expression2);
+        this._grammar = grammar;
+        this._exprStr = exprStr;
+        this._ast = null;
+      }
+      (0, _createClass2.default)(Expression2, [{
+        key: "compile",
+        value: function compile() {
+          var lexer = new Lexer(this._grammar);
+          var parser = new Parser(this._grammar);
+          var tokens = lexer.tokenize(this._exprStr);
+          parser.addTokens(tokens);
+          this._ast = parser.complete();
+          return this;
+        }
+        /**
+         * Asynchronously evaluates the expression within an optional context.
+         * @param {Object} [context] A mapping of variables to values, which will be
+         *      made accessible to the Jexl expression when evaluating it
+         * @returns {Promise<*>} resolves with the result of the evaluation.
+         */
+      }, {
+        key: "eval",
+        value: function _eval() {
+          var context = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          return this._eval(context, Promise);
+        }
+        /**
+         * Synchronously evaluates the expression within an optional context.
+         * @param {Object} [context] A mapping of variables to values, which will be
+         *      made accessible to the Jexl expression when evaluating it
+         * @returns {*} the result of the evaluation.
+         * @throws {*} on error
+         */
+      }, {
+        key: "evalSync",
+        value: function evalSync() {
+          var context = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          var res = this._eval(context, PromiseSync);
+          if (res.error) throw res.error;
+          return res.value;
+        }
+      }, {
+        key: "_eval",
+        value: function _eval(context, promise) {
+          var _this = this;
+          return promise.resolve().then(function() {
+            var ast = _this._getAst();
+            var evaluator = new Evaluator(_this._grammar, context, void 0, promise);
+            return evaluator.eval(ast);
+          });
+        }
+      }, {
+        key: "_getAst",
+        value: function _getAst() {
+          if (!this._ast) this.compile();
+          return this._ast;
+        }
+      }]);
+      return Expression2;
+    })();
+    module2.exports = Expression;
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/grammar.js
+var require_grammar = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/grammar.js"(exports2) {
+    "use strict";
+    exports2.getGrammar = function() {
+      return {
+        /**
+         * A map of all expression elements to their properties. Note that changes
+         * here may require changes in the Lexer or Parser.
+         * @type {{}}
+         */
+        elements: {
+          ".": {
+            type: "dot"
+          },
+          "[": {
+            type: "openBracket"
+          },
+          "]": {
+            type: "closeBracket"
+          },
+          "|": {
+            type: "pipe"
+          },
+          "{": {
+            type: "openCurl"
+          },
+          "}": {
+            type: "closeCurl"
+          },
+          ":": {
+            type: "colon"
+          },
+          ",": {
+            type: "comma"
+          },
+          "(": {
+            type: "openParen"
+          },
+          ")": {
+            type: "closeParen"
+          },
+          "?": {
+            type: "question"
+          },
+          "+": {
+            type: "binaryOp",
+            precedence: 30,
+            eval: function _eval(left, right) {
+              return left + right;
+            }
+          },
+          "-": {
+            type: "binaryOp",
+            precedence: 30,
+            eval: function _eval(left, right) {
+              return left - right;
+            }
+          },
+          "*": {
+            type: "binaryOp",
+            precedence: 40,
+            eval: function _eval(left, right) {
+              return left * right;
+            }
+          },
+          "/": {
+            type: "binaryOp",
+            precedence: 40,
+            eval: function _eval(left, right) {
+              return left / right;
+            }
+          },
+          "//": {
+            type: "binaryOp",
+            precedence: 40,
+            eval: function _eval(left, right) {
+              return Math.floor(left / right);
+            }
+          },
+          "%": {
+            type: "binaryOp",
+            precedence: 50,
+            eval: function _eval(left, right) {
+              return left % right;
+            }
+          },
+          "^": {
+            type: "binaryOp",
+            precedence: 50,
+            eval: function _eval(left, right) {
+              return Math.pow(left, right);
+            }
+          },
+          "==": {
+            type: "binaryOp",
+            precedence: 20,
+            eval: function _eval(left, right) {
+              return left == right;
+            }
+          },
+          "!=": {
+            type: "binaryOp",
+            precedence: 20,
+            eval: function _eval(left, right) {
+              return left != right;
+            }
+          },
+          ">": {
+            type: "binaryOp",
+            precedence: 20,
+            eval: function _eval(left, right) {
+              return left > right;
+            }
+          },
+          ">=": {
+            type: "binaryOp",
+            precedence: 20,
+            eval: function _eval(left, right) {
+              return left >= right;
+            }
+          },
+          "<": {
+            type: "binaryOp",
+            precedence: 20,
+            eval: function _eval(left, right) {
+              return left < right;
+            }
+          },
+          "<=": {
+            type: "binaryOp",
+            precedence: 20,
+            eval: function _eval(left, right) {
+              return left <= right;
+            }
+          },
+          "&&": {
+            type: "binaryOp",
+            precedence: 10,
+            evalOnDemand: function evalOnDemand(left, right) {
+              return left.eval().then(function(leftVal) {
+                if (!leftVal) return leftVal;
+                return right.eval();
+              });
+            }
+          },
+          "||": {
+            type: "binaryOp",
+            precedence: 10,
+            evalOnDemand: function evalOnDemand(left, right) {
+              return left.eval().then(function(leftVal) {
+                if (leftVal) return leftVal;
+                return right.eval();
+              });
+            }
+          },
+          in: {
+            type: "binaryOp",
+            precedence: 20,
+            eval: function _eval(left, right) {
+              if (typeof right === "string") {
+                return right.indexOf(left) !== -1;
+              }
+              if (Array.isArray(right)) {
+                return right.some(function(elem) {
+                  return elem === left;
+                });
+              }
+              return false;
+            }
+          },
+          "!": {
+            type: "unaryOp",
+            precedence: Infinity,
+            eval: function _eval(right) {
+              return !right;
+            }
+          }
+        },
+        /**
+         * A map of function names to javascript functions. A Jexl function
+         * takes zero ore more arguemnts:
+         *
+         *     - {*} ...args: A variable number of arguments passed to this function.
+         *       All of these are pre-evaluated to their actual values before calling
+         *       the function.
+         *
+         * The Jexl function should return either the transformed value, or
+         * a Promises/A+ Promise object that resolves with the value and rejects
+         * or throws only when an unrecoverable error occurs. Functions should
+         * generally return undefined when they don't make sense to be used on the
+         * given value type, rather than throw/reject. An error is only
+         * appropriate when the function would normally return a value, but
+         * cannot due to some other failure.
+         */
+        functions: {},
+        /**
+         * A map of transform names to transform functions. A transform function
+         * takes one ore more arguemnts:
+         *
+         *     - {*} val: A value to be transformed
+         *     - {*} ...args: A variable number of arguments passed to this transform.
+         *       All of these are pre-evaluated to their actual values before calling
+         *       the function.
+         *
+         * The transform function should return either the transformed value, or
+         * a Promises/A+ Promise object that resolves with the value and rejects
+         * or throws only when an unrecoverable error occurs. Transforms should
+         * generally return undefined when they don't make sense to be used on the
+         * given value type, rather than throw/reject. An error is only
+         * appropriate when the transform would normally return a value, but
+         * cannot due to some other failure.
+         */
+        transforms: {}
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Jexl.js
+var require_Jexl = __commonJS({
+  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Jexl.js"(exports2, module2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
+    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+    var _createClass2 = _interopRequireDefault(require_createClass());
+    var Expression = require_Expression();
+    var _require = require_grammar();
+    var getGrammar = _require.getGrammar;
+    var Jexl = /* @__PURE__ */ (function() {
+      function Jexl2() {
+        (0, _classCallCheck2.default)(this, Jexl2);
+        this.expr = this.expr.bind(this);
+        this._grammar = getGrammar();
+      }
+      (0, _createClass2.default)(Jexl2, [{
+        key: "addBinaryOp",
+        value: function addBinaryOp(operator, precedence, fn, manualEval) {
+          this._addGrammarElement(operator, (0, _defineProperty2.default)({
+            type: "binaryOp",
+            precedence
+          }, manualEval ? "evalOnDemand" : "eval", fn));
+        }
+        /**
+         * Adds or replaces an expression function in this Jexl instance.
+         * @param {string} name The name of the expression function, as it will be
+         *      used within Jexl expressions
+         * @param {function} fn The javascript function to be executed when this
+         *      expression function is invoked. It will be provided with each argument
+         *      supplied in the expression, in the same order.
+         */
+      }, {
+        key: "addFunction",
+        value: function addFunction(name, fn) {
+          this._grammar.functions[name] = fn;
+        }
+        /**
+         * Syntactic sugar for calling {@link #addFunction} repeatedly. This function
+         * accepts a map of one or more expression function names to their javascript
+         * function counterpart.
+         * @param {{}} map A map of expression function names to javascript functions
+         */
+      }, {
+        key: "addFunctions",
+        value: function addFunctions(map) {
+          for (var key in map) {
+            this._grammar.functions[key] = map[key];
+          }
+        }
+        /**
+         * Adds a unary operator to Jexl. Unary operators are currently only supported
+         * on the left side of the value on which it will operate.
+         * @param {string} operator The operator string to be added
+         * @param {function} fn A function to run to calculate the result. The function
+         *      will be called with one argument: the literal value to the right of the
+         *      operator. It should return either the resulting value, or a Promise
+         *      that resolves with the resulting value.
+         */
+      }, {
+        key: "addUnaryOp",
+        value: function addUnaryOp(operator, fn) {
+          this._addGrammarElement(operator, {
+            type: "unaryOp",
+            weight: Infinity,
+            eval: fn
+          });
+        }
+        /**
+         * Adds or replaces a transform function in this Jexl instance.
+         * @param {string} name The name of the transform function, as it will be used
+         *      within Jexl expressions
+         * @param {function} fn The function to be executed when this transform is
+         *      invoked. It will be provided with at least one argument:
+         *          - {*} value: The value to be transformed
+         *          - {...*} args: The arguments for this transform
+         */
+      }, {
+        key: "addTransform",
+        value: function addTransform(name, fn) {
+          this._grammar.transforms[name] = fn;
+        }
+        /**
+         * Syntactic sugar for calling {@link #addTransform} repeatedly.  This function
+         * accepts a map of one or more transform names to their transform function.
+         * @param {{}} map A map of transform names to transform functions
+         */
+      }, {
+        key: "addTransforms",
+        value: function addTransforms(map) {
+          for (var key in map) {
+            this._grammar.transforms[key] = map[key];
+          }
+        }
+        /**
+         * Creates an Expression object from the given Jexl expression string, and
+         * immediately compiles it. The returned Expression object can then be
+         * evaluated multiple times with new contexts, without generating any
+         * additional string processing overhead.
+         * @param {string} expression The Jexl expression to be compiled
+         * @returns {Expression} The compiled Expression object
+         */
+      }, {
+        key: "compile",
+        value: function compile(expression) {
+          var exprObj = this.createExpression(expression);
+          return exprObj.compile();
+        }
+        /**
+         * Constructs an Expression object from a Jexl expression string.
+         * @param {string} expression The Jexl expression to be wrapped in an
+         *    Expression object
+         * @returns {Expression} The Expression object representing the given string
+         */
+      }, {
+        key: "createExpression",
+        value: function createExpression(expression) {
+          return new Expression(this._grammar, expression);
+        }
+        /**
+         * Retrieves a previously set expression function.
+         * @param {string} name The name of the expression function
+         * @returns {function} The expression function
+         */
+      }, {
+        key: "getFunction",
+        value: function getFunction(name) {
+          return this._grammar.functions[name];
+        }
+        /**
+         * Retrieves a previously set transform function.
+         * @param {string} name The name of the transform function
+         * @returns {function} The transform function
+         */
+      }, {
+        key: "getTransform",
+        value: function getTransform(name) {
+          return this._grammar.transforms[name];
+        }
+        /**
+         * Asynchronously evaluates a Jexl string within an optional context.
+         * @param {string} expression The Jexl expression to be evaluated
+         * @param {Object} [context] A mapping of variables to values, which will be
+         *      made accessible to the Jexl expression when evaluating it
+         * @returns {Promise<*>} resolves with the result of the evaluation.
+         */
+      }, {
+        key: "eval",
+        value: function _eval(expression) {
+          var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+          var exprObj = this.createExpression(expression);
+          return exprObj.eval(context);
+        }
+        /**
+         * Synchronously evaluates a Jexl string within an optional context.
+         * @param {string} expression The Jexl expression to be evaluated
+         * @param {Object} [context] A mapping of variables to values, which will be
+         *      made accessible to the Jexl expression when evaluating it
+         * @returns {*} the result of the evaluation.
+         * @throws {*} on error
+         */
+      }, {
+        key: "evalSync",
+        value: function evalSync(expression) {
+          var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+          var exprObj = this.createExpression(expression);
+          return exprObj.evalSync(context);
+        }
+        /**
+         * A JavaScript template literal to allow expressions to be defined by the
+         * syntax: expr`40 + 2`
+         * @param {Array<string>} strs
+         * @param  {...any} args
+         */
+      }, {
+        key: "expr",
+        value: function expr(strs) {
+          for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            args[_key - 1] = arguments[_key];
+          }
+          var exprStr = strs.reduce(function(acc, str, idx) {
+            var arg = idx < args.length ? args[idx] : "";
+            acc += str + arg;
+            return acc;
+          }, "");
+          return this.createExpression(exprStr);
+        }
+        /**
+         * Removes a binary or unary operator from the Jexl grammar.
+         * @param {string} operator The operator string to be removed
+         */
+      }, {
+        key: "removeOp",
+        value: function removeOp(operator) {
+          if (this._grammar.elements[operator] && (this._grammar.elements[operator].type === "binaryOp" || this._grammar.elements[operator].type === "unaryOp")) {
+            delete this._grammar.elements[operator];
+          }
+        }
+        /**
+         * Adds an element to the grammar map used by this Jexl instance.
+         * @param {string} str The key string to be added
+         * @param {{type: <string>}} obj A map of configuration options for this
+         *      grammar element
+         * @private
+         */
+      }, {
+        key: "_addGrammarElement",
+        value: function _addGrammarElement(str, obj) {
+          this._grammar.elements[str] = obj;
+        }
+      }]);
+      return Jexl2;
+    })();
+    module2.exports = new Jexl();
+    module2.exports.Jexl = Jexl;
+  }
+});
+
 // src/observability.ts
 var observability_exports = {};
 __export(observability_exports, {
@@ -628,6 +2382,7 @@ __export(server_exports, {
   renderPrometheusMetrics: () => renderPrometheusMetrics,
   resolveObservabilityConfig: () => resolveObservabilityConfig,
   serializeDetailForApi: () => serializeDetailForApi,
+  serializeViewForApi: () => serializeViewForApi,
   shouldSampleRequest: () => shouldSampleRequest
 });
 module.exports = __toCommonJS(server_exports);
@@ -681,7 +2436,7 @@ var DefaultsService = class {
 };
 
 // src/services/population.service.ts
-var import_jexl = __toESM(require("jexl"), 1);
+var import_jexl = __toESM(require_Jexl(), 1);
 var PopulationService = class {
   db;
   collections;
@@ -1115,13 +2870,13 @@ function createSessionId() {
 }
 
 // src/utils/hooks.ts
-var import_jexl4 = __toESM(require("jexl"), 1);
+var import_jexl4 = __toESM(require_Jexl(), 1);
 
 // src/utils/declarative-hooks.ts
-var import_jexl3 = __toESM(require("jexl"), 1);
+var import_jexl3 = __toESM(require_Jexl(), 1);
 
 // src/utils/jexl-helpers.ts
-var import_jexl2 = __toESM(require("jexl"), 1);
+var import_jexl2 = __toESM(require_Jexl(), 1);
 function slugify(val) {
   if (val === void 0 || val === null) return "";
   return String(val).normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -2283,7 +4038,7 @@ function validateUpload(file, config) {
 }
 
 // src/auth/jexl.ts
-var import_jexl5 = __toESM(require("jexl"), 1);
+var import_jexl5 = __toESM(require_Jexl(), 1);
 async function evaluateAccess(expression, context) {
   if (expression === void 0 || expression === null) return false;
   if (typeof expression === "boolean") return expression;
@@ -2737,6 +4492,45 @@ function mergeWhereConstraint(where, constraint) {
   return where ? { AND: [where, constraint] } : constraint;
 }
 
+// src/utils/action-mutation.ts
+function resolveActionMutation(mutation, ctx) {
+  if (!mutation) return {};
+  return resolveValue(mutation, ctx);
+}
+function resolveValue(value, ctx) {
+  if (typeof value === "string") return resolveExpression(value, ctx);
+  if (Array.isArray(value)) return value.map((item) => resolveValue(item, ctx));
+  if (isPlainObject2(value)) {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = resolveValue(entry, ctx);
+    }
+    return out;
+  }
+  return value;
+}
+function resolveExpression(expression, ctx) {
+  if (expression === "now()") return (/* @__PURE__ */ new Date()).toISOString();
+  const inputPath = expression.match(/^input\.([A-Za-z0-9_.-]+)$/)?.[1];
+  if (inputPath !== void 0) return getPath(ctx.input, inputPath);
+  const docPath = expression.match(/^doc\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/)?.[1];
+  if (docPath !== void 0) return getPath(ctx.doc, docPath);
+  const userPath = expression.match(/^user\.([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)$/)?.[1];
+  if (userPath !== void 0 && ctx.user) return getPath(ctx.user, userPath);
+  return expression;
+}
+function getPath(source, path) {
+  let cursor = source;
+  for (const segment of path.split(".")) {
+    if (!cursor || typeof cursor !== "object") return void 0;
+    cursor = cursor[segment];
+  }
+  return cursor;
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/workflows.ts
 var WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
 var LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
@@ -3822,12 +5616,24 @@ var CollectionController = class {
         externalSubject: member.id
       });
     }
-    const readonlyDb = createReadonlyDb(db);
     const id = c.req.param("id");
     if (!id) return c.json({ message: "Missing ID" }, 400);
     const body = await c.req.json();
+    return this.performUpdate(c, id, body);
+  }
+  /**
+   * Core update pipeline shared by PATCH requests and operational actions:
+   * auth-field stripping, timestamps, access enforcement, field write access,
+   * beforeChange hooks, persistence (or workflow draft), audit logging,
+   * afterChange/afterRead hooks, and field read access on the response.
+   */
+  async performUpdate(c, id, rawData) {
+    const config = c.get("config");
+    const db = config.db;
+    if (!db) return c.json({ message: "Database not configured" }, 500);
+    const readonlyDb = createReadonlyDb(db);
     const user = c.get("user");
-    let data = { ...body };
+    let data = { ...rawData };
     if (this.collection.auth) {
       delete data.password;
       delete data.oldPassword;
@@ -3947,6 +5753,119 @@ var CollectionController = class {
     );
     return c.json(accessibleDoc);
   }
+  /**
+   * Runs an operational view action (`defineAction`) against one or more documents.
+   * Declarative mutations are resolved server-side (`now()`, `input.*`, `doc.*`)
+   * and every write flows through the standard update pipeline so the
+   * collection's lifecycle hooks and audit trail still apply.
+   */
+  async runViewAction(c) {
+    const config = c.get("config");
+    const db = config.db;
+    if (!db) return c.json({ message: "Database not configured" }, 500);
+    if (!this.collection.views?.length) {
+      return c.json({ error: true, message: `Collection ${this.collection.slug} has no views` }, 404);
+    }
+    const actionName = c.req.param("action");
+    const viewSlugParam = c.req.param("viewSlug");
+    let action;
+    for (const view2 of this.collection.views) {
+      if (viewSlugParam && view2.slug !== viewSlugParam) continue;
+      const match = view2.actions?.find((candidate) => candidate.name === actionName);
+      if (match) {
+        action = match;
+        break;
+      }
+    }
+    if (!action) {
+      return c.json(
+        { error: true, message: `Action "${actionName}" was not found${viewSlugParam ? ` in view "${viewSlugParam}"` : ""}` },
+        404
+      );
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const requestedIds = Array.isArray(body?.ids) ? body.ids.filter((value) => typeof value === "string") : typeof body?.id === "string" ? [body.id] : [];
+    if (!requestedIds.length) {
+      return c.json(
+        { error: true, message: "Provide an `id` or an `ids` array of documents to act on." },
+        400
+      );
+    }
+    const input = body?.input ?? {};
+    const user = c.get("user");
+    const accessArgs = { user, req: this.toHookRequestContext(c) };
+    const view = viewSlugParam ? this.collection.views.find((candidate) => candidate.slug === viewSlugParam) : void 0;
+    if (view?.access) {
+      const allowed = await resolveBooleanAccess(config, view.access.update ?? view.access.read ?? true, {
+        ...accessArgs,
+        data: input
+      });
+      if (!allowed) {
+        return c.json({ error: true, message: `Access denied: view "${view.slug}"` }, 403);
+      }
+    }
+    if (action.access) {
+      const actionAccess = await resolveBooleanAccess(config, action.access.update ?? true, {
+        ...accessArgs,
+        data: input
+      });
+      if (!actionAccess) {
+        return c.json({ error: true, message: `Access denied: action "${action.name}"` }, 403);
+      }
+    }
+    const results = [];
+    for (const id of requestedIds) {
+      const targetDoc = await db.findOne({ collection: this.collection.slug, id });
+      if (!targetDoc) {
+        results.push({ id, ok: false, status: 404, error: "Not Found" });
+        continue;
+      }
+      let resolvedData;
+      if (typeof action.handler === "function") {
+        try {
+          const handlerResult = await action.handler({
+            doc: targetDoc,
+            docs: [targetDoc],
+            user: user ?? null,
+            input,
+            collection: { slug: this.collection.slug, label: this.collection.labels?.singular ?? this.collection.slug }
+          });
+          resolvedData = handlerResult ?? {};
+        } catch (error) {
+          results.push({ id, ok: false, status: 500, error: error instanceof Error ? error.message : String(error) });
+          continue;
+        }
+      } else {
+        resolvedData = resolveActionMutation(action.mutation, {
+          doc: targetDoc,
+          input,
+          user: user ?? null
+        });
+      }
+      const response = await this.performUpdate(c, id, resolvedData);
+      const ok = response.ok;
+      let payload;
+      try {
+        payload = await response.clone().json();
+      } catch {
+        payload = void 0;
+      }
+      results.push({ id, ok, status: response.status, ...ok ? { doc: payload } : { error: payload } });
+    }
+    if (requestedIds.length === 1) {
+      const single = results[0];
+      if (!single.ok) {
+        return c.json(single.error ?? { error: true, message: "Action failed" }, single.status ?? 500);
+      }
+      return c.json(single.doc);
+    }
+    const failed = results.filter((result) => !result.ok).length;
+    return c.json({
+      updated: results.length - failed,
+      failed,
+      results
+    });
+  }
   async transition(c) {
     const config = c.get("config");
     if (!config.db) return c.json({ message: "Database not configured" }, 500);
@@ -4328,9 +6247,23 @@ var CollectionController = class {
         400
       );
     }
+    let rawAggregates;
+    let groupBy;
+    if ("aggregates" in body && typeof body.aggregates === "object" && body.aggregates !== null && !Array.isArray(body.aggregates)) {
+      rawAggregates = body.aggregates;
+      if (typeof body.groupBy === "string" && body.groupBy.trim()) {
+        groupBy = body.groupBy.trim();
+      }
+    } else {
+      rawAggregates = body;
+      const queryGroupBy = c.req.query("groupBy");
+      if (typeof queryGroupBy === "string" && queryGroupBy.trim()) {
+        groupBy = queryGroupBy.trim();
+      }
+    }
     const { sanitizeWhereClause: sanitizeWhereClause2 } = await Promise.resolve().then(() => (init_where_sanitizer(), where_sanitizer_exports));
     const sanitizedAggregates = {};
-    for (const [key, op] of Object.entries(body)) {
+    for (const [key, op] of Object.entries(rawAggregates)) {
       if (!op || typeof op !== "object" || Array.isArray(op)) {
         return c.json(
           {
@@ -4355,7 +6288,8 @@ var CollectionController = class {
     }
     const result = await db.aggregate({
       collection: this.collection.slug,
-      aggregates: sanitizedAggregates
+      aggregates: sanitizedAggregates,
+      ...groupBy ? { groupBy } : {}
     });
     return c.json(result);
   }
@@ -7040,39 +8974,94 @@ function generateOpenApi(config) {
       post: {
         tags: [collectionTag],
         summary: `Aggregate ${labels.plural}`,
-        description: `Compute statistical aggregations (count, sum, avg, min, max) across ${labels.plural}.`,
+        description: `Compute statistical aggregations (count, countDistinct, distinct, sum, avg, min, max, groupBy) across ${labels.plural}.`,
+        parameters: [
+          {
+            name: "groupBy",
+            in: "query",
+            description: "Optional field name to compute aggregates grouped by distinct values",
+            required: false,
+            schema: { type: "string" }
+          }
+        ],
         requestBody: {
           required: true,
           content: {
             "application/json": {
               schema: {
-                type: "object",
-                additionalProperties: {
-                  type: "object",
-                  properties: {
-                    count: { type: "string", example: "*" },
-                    sum: { type: "string", description: "Field to sum" },
-                    avg: { type: "string", description: "Field to average" },
-                    min: { type: "string", description: "Field for minimum" },
-                    max: { type: "string", description: "Field for maximum" },
-                    cast: {
-                      type: "string",
-                      enum: [
-                        "number",
-                        "integer",
-                        "float",
-                        "boolean",
-                        "date",
-                        "string"
-                      ]
-                    },
-                    where: {
+                oneOf: [
+                  {
+                    type: "object",
+                    description: "Flat aggregate operations dictionary",
+                    additionalProperties: {
                       type: "object",
-                      description: "Per-aggregate filter condition",
-                      additionalProperties: true
+                      properties: {
+                        count: { type: "string", example: "*" },
+                        countDistinct: { type: "string", description: "Field to count unique non-null values" },
+                        distinct: { type: "string", description: "Field to extract unique non-null values" },
+                        sum: { type: "string", description: "Field to sum" },
+                        avg: { type: "string", description: "Field to average" },
+                        min: { type: "string", description: "Field for minimum" },
+                        max: { type: "string", description: "Field for maximum" },
+                        cast: {
+                          type: "string",
+                          enum: [
+                            "number",
+                            "integer",
+                            "float",
+                            "boolean",
+                            "date",
+                            "string"
+                          ]
+                        },
+                        where: {
+                          type: "object",
+                          description: "Per-aggregate filter condition",
+                          additionalProperties: true
+                        }
+                      }
                     }
+                  },
+                  {
+                    type: "object",
+                    description: "Grouped aggregate payload with explicit groupBy property",
+                    properties: {
+                      groupBy: { type: "string", description: "Field name to group aggregates by" },
+                      aggregates: {
+                        type: "object",
+                        additionalProperties: {
+                          type: "object",
+                          properties: {
+                            count: { type: "string", example: "*" },
+                            countDistinct: { type: "string", description: "Field to count unique non-null values" },
+                            distinct: { type: "string", description: "Field to extract unique non-null values" },
+                            sum: { type: "string", description: "Field to sum" },
+                            avg: { type: "string", description: "Field to average" },
+                            min: { type: "string", description: "Field for minimum" },
+                            max: { type: "string", description: "Field for maximum" },
+                            cast: {
+                              type: "string",
+                              enum: [
+                                "number",
+                                "integer",
+                                "float",
+                                "boolean",
+                                "date",
+                                "string"
+                              ]
+                            },
+                            where: {
+                              type: "object",
+                              description: "Per-aggregate filter condition",
+                              additionalProperties: true
+                            }
+                          }
+                        }
+                      }
+                    },
+                    required: ["aggregates"]
                   }
-                }
+                ]
               }
             }
           }
@@ -7083,11 +9072,36 @@ function generateOpenApi(config) {
             content: {
               "application/json": {
                 schema: {
-                  type: "object",
-                  additionalProperties: {
-                    type: "number",
-                    nullable: true
-                  }
+                  oneOf: [
+                    {
+                      type: "object",
+                      description: "Flat aggregate results map",
+                      additionalProperties: {
+                        oneOf: [
+                          { type: "number", nullable: true },
+                          { type: "array", items: { type: "string" } }
+                        ]
+                      }
+                    },
+                    {
+                      type: "object",
+                      description: "Grouped aggregate results breakdown",
+                      properties: {
+                        groups: {
+                          type: "object",
+                          additionalProperties: {
+                            type: "object",
+                            additionalProperties: {
+                              oneOf: [
+                                { type: "number", nullable: true },
+                                { type: "array", items: { type: "string" } }
+                              ]
+                            }
+                          }
+                        }
+                      }
+                    }
+                  ]
                 }
               }
             }
@@ -7811,6 +9825,47 @@ function serializeDetailForApi(detail) {
   if (!detail || !Array.isArray(detail)) return void 0;
   return detail.map(serializeDetailItemForApi);
 }
+async function serializeViewForApi(view, serializeAccess) {
+  if (!view) return view;
+  const serializeAccessConfig = async (access) => {
+    if (!access) return void 0;
+    const serialized = {};
+    for (const key of ["read", "create", "update", "delete"]) {
+      if (access[key] !== void 0) serialized[key] = await serializeAccess(access[key]);
+    }
+    return serialized;
+  };
+  return {
+    slug: view.slug,
+    label: view.label,
+    icon: view.icon,
+    layout: view.layout ?? "table",
+    filter: view.filter,
+    groupBy: view.groupBy,
+    dateField: view.dateField,
+    startDateField: view.startDateField,
+    endDateField: view.endDateField,
+    columns: view.columns,
+    sort: view.sort,
+    metrics: view.metrics,
+    features: view.features,
+    actionOrder: view.actionOrder,
+    actions: await Promise.all(
+      (view.actions || []).map(async (action) => ({
+        name: action.name,
+        label: action.label,
+        icon: action.icon,
+        type: action.type ?? "row",
+        confirm: action.confirm,
+        fields: action.fields?.map(serializeFieldForApi),
+        mutation: action.mutation,
+        // Self-hosted handlers are intentionally omitted: they never leave the server.
+        access: action.access ? await serializeAccessConfig(action.access) : void 0
+      }))
+    ),
+    access: view.access ? await serializeAccessConfig(view.access) : void 0
+  };
+}
 function registerRoutes(app, config) {
   const optionsCache = /* @__PURE__ */ new Map();
   app.get("/api/schemas", optionalAuth(config), async (c) => {
@@ -7871,6 +9926,8 @@ function registerRoutes(app, config) {
         auth: !!col.auth,
         audit: !!col.audit,
         drafts: !!col.drafts,
+        defaultView: col.defaultView ?? col.admin?.defaultView,
+        views: await Promise.all((col.views || []).map((view) => serializeViewForApi(view, serializeAccess))),
         admin: col.admin,
         detail: serializeDetailForApi(col.detail),
         workflow: col.workflow ? {
@@ -7945,9 +10002,9 @@ function registerRoutes(app, config) {
     const { collection: colSlug, field: fieldName } = c.req.param();
     const siteId = c.req.header("X-Site-Id");
     const requestConfig = siteId && config.onSchemaFetch ? mergeDynamicConfig(config, await config.onSchemaFetch(siteId)) : config;
-    let collections = [...requestConfig.collections];
+    const collections = [...requestConfig.collections];
     const user = c.get("user");
-    let collection = collections.find((col) => col.slug === colSlug);
+    const collection = collections.find((col) => col.slug === colSlug);
     let field;
     if (collection) {
       const accessExpr = collection.access?.read;
@@ -8073,13 +10130,12 @@ function registerRoutes(app, config) {
   app.get("/api/docs", (c) => {
     return c.html(getSwaggerHtml());
   });
-  app.get("/api/preferences/:key", requireAuth(config), async (c) => {
+  app.get("/api/preferences/:key", optionalAuth(config), async (c) => {
     const db = config.db;
     const user = c.get("user");
     const key = c.req.param("key");
     const scope = c.req.query("scope");
     if (!db) return c.json({ message: "Database not configured" }, 500);
-    if (!user?.collection || !user.sub) return c.json({ error: true, message: "Authentication required." }, 401);
     if (!key) return c.json({ error: true, message: "Preference key is required." }, 400);
     const getGlobalPreference = async () => {
       const globalDoc = await db.findOne({
@@ -8088,12 +10144,15 @@ function registerRoutes(app, config) {
       });
       return globalDoc ? globalDoc.value : null;
     };
-    if (scope === "global") {
+    if (scope === "global" || !user?.collection || !user.sub) {
       const globalValue2 = await getGlobalPreference();
       return c.json({ key, value: globalValue2 });
     }
     const doc = await db.findOne({ collection: user.collection, id: user.sub });
-    if (!doc) return c.json({ error: true, message: "User not found." }, 404);
+    if (!doc) {
+      const globalValue2 = await getGlobalPreference();
+      return c.json({ key, value: globalValue2 });
+    }
     const preferences = typeof doc.__preferences === "object" && doc.__preferences !== null ? doc.__preferences : {};
     if (key in preferences) {
       return c.json({ key, value: preferences[key] ?? null });
@@ -8232,6 +10291,10 @@ function registerRoutes(app, config) {
     app.post(`${path}/media`, (c) => controller.create(c));
     app.delete(`${path}/delete-many`, (c) => controller.deleteMany(c));
     app.post(`${path}/aggregate`, (c) => controller.aggregate(c));
+    if (collection.views?.length) {
+      app.post(`${path}/views/:viewSlug/actions/:action`, optionalAuth(config), (c) => controller.runViewAction(c));
+      app.post(`${path}/actions/:action`, optionalAuth(config), (c) => controller.runViewAction(c));
+    }
     if (collection.audit) {
       app.get(`${path}/__audit`, (c) => auditController.findForCollection(c, collection));
     }
@@ -9026,5 +11089,6 @@ init_observability();
   renderPrometheusMetrics,
   resolveObservabilityConfig,
   serializeDetailForApi,
+  serializeViewForApi,
   shouldSampleRequest
 });