@genesislcap/mock-server 15.59.0 → 15.61.0

package/dist/db/criteria.js

@@ -1,172 +1,125 @@
 // Evaluator for Genesis CRITERIA_MATCH expressions, e.g.:
-//   TRADE_STATUS == 'CONFIRMED' AND QUANTITY > 100
-//   NOT (SIDE == 'SELL') OR PRICE >= 100.5
+//   TRADE_STATUS == 'CONFIRMED' && QUANTITY > 100
+//   !(SIDE == 'SELL') || PRICE >= 100.5
 //   Expr.dateTimeIsGreaterEqual(TRADE_DATE, '20240101-00:00:00') && COUNTERPARTY_ID == 'CPTY001'
 //
-// Supports: == = != <> > >= < <=, AND OR NOT (also && || !), parentheses,
-// string/number/boolean literals, bare field identifiers, and two
-// function-call dialects real clients emit:
-//   - `Expr.<fn>(field, value)` — foundation-criteria's serialisers.ts
-//     (grid date/text filters);
-//   - `<FIELD>.<fn>(value)` method-call form — e.g.
-//     `DEAL_CURRENCIES.containsIgnoreCase('USD')`, as emitted by
-//     project-level filter builders. Same EXPR_FUNCTIONS, with the receiver
-//     field as the implicit first argument.
+// Supports: == != > >= < <=, && || !, parentheses, string/number/boolean/null
+// literals, field names, and calls in both forms GSF takes:
+//   - `Expr.<fn>(args)` — every function of GSF's Expr whitelist
+//     (CriteriaValidatorVisitor, v8.15.29), with Expr.java's overloads;
+//   - `<FIELD>.<method>(args)` — the field methods GSF allows: String's
+//     startsWith / equals / equalsIgnoreCase / contains and the
+//     ExtraOperators.kt extensions containsIgnoreCase,
+//     containsWordsStartingWithIgnoreCase and dateIsToday.
+// A call may be an operand (`Expr.longLocalDate(D) == Expr.stringLocalDate('20240101')`)
+// or an argument of another. What the functions compute, and when they throw
+// (making the row not match), is GSF's: see gsfExpr.ts.
+//
+// It also reads what GSF refuses — = <>, AND OR NOT, and the functions this
+// engine used to offer (Expr.contains, Expr.equals, Expr.equalsIgnoreCase,
+// Expr.startsWith, Expr.endsWith, Expr.dateTimeIsEqual, FIELD.endsWith, and
+// any Expr function called as a field method). Strict criteria refuse those
+// before they get here (criteriaDialect.ts); only fidelity: 'legacy'
+// evaluates them.
+//
+// Types: GSF compiles a criteria against the entity's Java types — a STRING
+// or ENUM field is a String, DATE and DATETIME a Joda DateTime, LONG a Long —
+// which picks each function's overload and lets ExtraOperators compare a
+// DateTime with a date string (`TRADE_DATE > '20240101'`). With
+// CriteriaOptions.types the evaluator does the same; a field without a known
+// type is read by its value (a number as a Long, a string as a String).
+// criteriaCompileRefusal reports what that compilation refuses.
+//
 // Deliberately NOT eval()/new Function() — this parses a small typed grammar
 // so a malformed or hostile criteria string can only fail to parse, never
 // execute arbitrary JS.
-// A criteria this grammar can't parse: unbalanced parentheses, a missing
-// operand, text it can't tokenize. GSF fails to compile those too.
-export class CriteriaSyntaxError extends Error {
-    name = 'CriteriaSyntaxError';
-}
-// A well-formed call to a function EXPR_FUNCTIONS doesn't have. It may well be
-// valid Groovy, so callers that refuse malformed criteria still fail open on
-// this one.
-export class UnsupportedCriteriaError extends Error {
-    name = 'UnsupportedCriteriaError';
-}
-const TOKEN_RE = /\s*(&&|\|\||<=|>=|!=|<>|==|=|<|>|!|\(|\)|,|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?|[A-Za-z_][A-Za-z0-9_.]*)/g;
-function tokenize(input) {
-    const tokens = [];
-    let match;
-    let lastIndex = 0;
-    TOKEN_RE.lastIndex = 0;
-    while ((match = TOKEN_RE.exec(input))) {
-        if (match.index !== lastIndex) {
-            throw new CriteriaSyntaxError(`Unable to tokenize criteria near: ${input.slice(lastIndex)}`);
-        }
-        tokens.push(match[1]);
-        lastIndex = TOKEN_RE.lastIndex;
+import { CriteriaSyntaxError, tokenizeCriteria, UnsupportedCriteriaError, } from "./criteriaTokens.js";
+import * as gsf from "./gsfExpr.js";
+import { CriteriaEvaluationError, evaluationError } from "./gsfExpr.js";
+import { parseLegacyCriteria } from "./legacyCriteria.js";
+import { epochMillis } from "./values.js";
+export { CriteriaSyntaxError, parseGenesisDateTime, tokenizeCriteria, UnsupportedCriteriaError, } from "./criteriaTokens.js";
+// A generated entity's getter types (ENUM getters are read with toString()).
+const ENTITY_TYPES = {
+    STRING: 'String',
+    ENUM: 'String',
+    INT: 'Integer',
+    SHORT: 'Short',
+    LONG: 'Long',
+    NANO_TIMESTAMP: 'Long',
+    DOUBLE: 'Double',
+    BIGDECIMAL: 'BigDecimal',
+    BOOLEAN: 'Boolean',
+    DATE: 'DateTime',
+    DATETIME: 'DateTime',
+};
+// A Joda DateTime: an instant, in epoch millis.
+class DateTimeValue {
+    millis;
+    constructor(millis) {
+        this.millis = millis;
     }
-    if (lastIndex !== input.length) {
-        throw new CriteriaSyntaxError(`Unable to tokenize criteria near: ${input.slice(lastIndex)}`);
+}
+// A Joda LocalDate: a day, in days since 1970-01-01.
+class LocalDateValue {
+    day;
+    constructor(day) {
+        this.day = day;
     }
-    return tokens;
 }
+const INT_MIN = -2_147_483_648;
+const INT_MAX = 2_147_483_647;
+const NULL_POINTER = 'java.lang.NullPointerException';
 function parseLiteral(token) {
-    if (/^['"]/.test(token))
-        return token.slice(1, -1).replace(/\\(.)/g, '$1');
-    if (/^-?\d+(?:\.\d+)?$/.test(token))
-        return Number(token);
-    if (token === 'true')
-        return true;
-    if (token === 'false')
-        return false;
+    if (/^['"]/.test(token)) {
+        return { value: token.slice(1, -1).replace(/\\(.)/g, '$1'), type: 'String' };
+    }
+    if (/^-?\d+$/.test(token)) {
+        const value = Number(token);
+        const type = value >= INT_MIN && value <= INT_MAX ? 'Integer' : 'Long';
+        return { value, type };
+    }
+    if (/^-?\d+\.\d+$/.test(token))
+        return { value: Number(token), type: 'BigDecimal' };
+    if (token === 'true' || token === 'false')
+        return { value: token === 'true', type: 'Boolean' };
     if (token === 'null')
-        return null;
-    return undefined; // not a literal -> treat as a field reference
+        return { value: null, type: 'null' };
+    return undefined; // not a literal -> a field reference
 }
-const COMPARATORS = new Set(['==', '=', '!=', '<>', '<', '<=', '>', '>=']);
-// Genesis date/datetime values serialize as 'YYYYMMDD-HH:MM[:SS[.mmm]]' —
-// foundation-criteria's serialisers.ts formatDate stops at seconds, but
-// getGroovyDateFormat() emits milliseconds too, and a parser that rejects
-// them makes every Expr.dateTimeIs* comparison silently false (date-filtered
-// grids render zero rows with no warning). Row values may already be epoch
-// millis (number) or an ISO string. Returns null if unparseable.
-export function parseGenesisDateTime(value) {
-    if (typeof value === 'number')
+const isNullish = (value) => value === null || value === undefined;
+// Groovy truth: false for null, false, '', 0; true for anything else.
+function groovyTruth(value) {
+    if (isNullish(value))
+        return false;
+    if (typeof value === 'boolean')
         return value;
-    if (typeof value !== 'string')
-        return null;
-    const match = value.match(/^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/);
-    if (match) {
-        const MS_DIGITS = 3; // '.5' means 500ms, not 5ms — right-pad to full precision
-        const [, y, mo, d, h, mi, s, ms] = match;
-        return Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s ?? '0'), Number((ms ?? '0').padEnd(MS_DIGITS, '0')));
-    }
-    const parsed = Date.parse(value);
-    return Number.isNaN(parsed) ? null : parsed;
-}
-const HOURS_PER_DAY = 24;
-const MINUTES_PER_HOUR = 60;
-const SECONDS_PER_MINUTE = 60;
-const MS_PER_SECOND = 1000;
-const MS_PER_DAY = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
-function toEpochDay(value) {
-    const epoch = parseGenesisDateTime(value);
-    return epoch === null ? null : Math.floor(epoch / MS_PER_DAY);
-}
-// Expr.<fn>(field, value) function-call criteria, as emitted by
-// foundation-criteria's serialisers.ts (contains/containsIgnoreCase/dateIs*)
-// and foundation-ui's date-range filter.ts (dateTimeIsAfter/dateTimeIsBefore,
-// which operator-map.ts maps onto the same >=/<= semantics as
-// dateTimeIsGreaterEqual/dateTimeIsLessEqual). `dateIs*` compares by calendar
-// day (UTC), `dateTimeIs*` compares full timestamps.
-const EXPR_FUNCTIONS = {
-    // Multi-value fields (e.g. DEAL_CURRENCIES) may hold an array — treat
-    // "contains" as membership there, substring match on strings.
-    contains: (record, args, resolve) => {
-        const value = resolve(args[0], record);
-        const needle = resolve(args[1], record);
-        if (typeof needle !== 'string')
-            return false;
-        if (Array.isArray(value))
-            return value.some((v) => typeof v === 'string' && v === needle);
-        return typeof value === 'string' && value.includes(needle);
-    },
-    containsIgnoreCase: (record, args, resolve) => {
-        const value = resolve(args[0], record);
-        const needle = resolve(args[1], record);
-        if (typeof needle !== 'string')
-            return false;
-        const lowered = needle.toLowerCase();
-        if (Array.isArray(value)) {
-            return value.some((v) => typeof v === 'string' && v.toLowerCase() === lowered);
-        }
-        return typeof value === 'string' && value.toLowerCase().includes(lowered);
-    },
-    // Groovy/Java String methods the client emits in the FIELD.method(args)
-    // form — e.g. pbc-notify-ui's inbox subscribes with
-    // `((ALERT_STATUS.equals("NEW")))`. Without these the criteria fails to
-    // compile, the filter is dropped, and the grid shows every row instead of
-    // the filtered set.
-    equals: (record, args, resolve) => resolve(args[0], record) === resolve(args[1], record),
-    equalsIgnoreCase: (record, args, resolve) => {
-        const value = resolve(args[0], record);
-        const other = resolve(args[1], record);
-        if (typeof value !== 'string' || typeof other !== 'string')
-            return value === other;
-        return value.toLowerCase() === other.toLowerCase();
-    },
-    startsWith: (record, args, resolve) => {
-        const value = resolve(args[0], record);
-        const prefix = resolve(args[1], record);
-        return typeof value === 'string' && typeof prefix === 'string' && value.startsWith(prefix);
-    },
-    endsWith: (record, args, resolve) => {
-        const value = resolve(args[0], record);
-        const suffix = resolve(args[1], record);
-        return typeof value === 'string' && typeof suffix === 'string' && value.endsWith(suffix);
-    },
-    dateIsToday: (record, args, resolve) => {
-        const day = toEpochDay(resolve(args[0], record));
-        return day !== null && day === toEpochDay(Date.now());
-    },
-    dateIsEqual: (record, args, resolve) => compareByDay(record, args, resolve, (a, b) => a === b),
-    dateIsGreaterEqual: (record, args, resolve) => compareByDay(record, args, resolve, (a, b) => a >= b),
-    dateIsLessEqual: (record, args, resolve) => compareByDay(record, args, resolve, (a, b) => a <= b),
-    dateTimeIsEqual: (record, args, resolve) => compareByTime(record, args, resolve, (a, b) => a === b),
-    dateTimeIsGreaterEqual: (record, args, resolve) => compareByTime(record, args, resolve, (a, b) => a >= b),
-    dateTimeIsLessEqual: (record, args, resolve) => compareByTime(record, args, resolve, (a, b) => a <= b),
-    dateTimeIsAfter: (record, args, resolve) => compareByTime(record, args, resolve, (a, b) => a >= b),
-    dateTimeIsBefore: (record, args, resolve) => compareByTime(record, args, resolve, (a, b) => a <= b),
-};
-function compareByDay(record, args, resolve, cmp) {
-    const a = toEpochDay(resolve(args[0], record));
-    const b = toEpochDay(resolve(args[1], record));
-    return a !== null && b !== null && cmp(a, b);
-}
-function compareByTime(record, args, resolve, cmp) {
-    const a = parseGenesisDateTime(resolve(args[0], record));
-    const b = parseGenesisDateTime(resolve(args[1], record));
-    return a !== null && b !== null && cmp(a, b);
+    if (typeof value === 'string')
+        return value.length > 0;
+    if (typeof value === 'number')
+        return value !== 0;
+    return true;
 }
+const COMPARATORS = new Set(['==', '=', '!=', '<>', '<', '<=', '>', '>=']);
+// CriteriaValidatorVisitor's allowedConstructors (GSF v8.15.29).
+const CONSTRUCTORS = {
+    BigDecimal: 'BigDecimal',
+    'java.math.BigDecimal': 'BigDecimal',
+    Integer: 'Integer',
+    'java.lang.Integer': 'Integer',
+    Long: 'Long',
+    'java.lang.Long': 'Long',
+    Double: 'Double',
+    'java.lang.Double': 'Double',
+    String: 'String',
+    'java.lang.String': 'String',
+};
+const NAME = /^[A-Za-z_][A-Za-z0-9_.]*$/;
 class Parser {
     tokens;
     pos = 0;
-    // Every field the expression reads: bare identifiers in comparisons, and
-    // function-call arguments and receivers.
+    // Every field the expression reads: field operands, call arguments and
+    // call receivers.
     fields = new Set();
     constructor(tokens) {
         this.tokens = tokens;
@@ -182,16 +135,11 @@ class Parser {
         this.pos += 1;
         return token;
     }
-    parseExpression() {
-        return this.parseOr();
-    }
     parseOr() {
         let left = this.parseAnd();
         while (this.peek() === '||' || this.peek()?.toUpperCase() === 'OR') {
             this.next();
-            const right = this.parseAnd();
-            const prev = left;
-            left = (record) => prev(record) || right(record);
+            left = { kind: 'or', left, right: this.parseAnd() };
         }
         return left;
     }
@@ -199,9 +147,7 @@ class Parser {
         let left = this.parseNot();
         while (this.peek() === '&&' || this.peek()?.toUpperCase() === 'AND') {
             this.next();
-            const right = this.parseNot();
-            const prev = left;
-            left = (record) => prev(record) && right(record);
+            left = { kind: 'and', left, right: this.parseNot() };
         }
         return left;
     }
@@ -209,133 +155,556 @@ class Parser {
         const next = this.peek();
         if (next === '!' || next?.toUpperCase() === 'NOT') {
             this.next();
-            const operand = this.parseNot();
-            return (record) => !operand(record);
+            return { kind: 'not', operand: this.parseNot() };
         }
-        return this.parseComparison();
+        return this.parsePrimary();
     }
-    parseComparison() {
+    parsePrimary() {
         if (this.peek() === '(') {
             this.next();
-            const inner = this.parseExpression();
+            const inner = this.parseOr();
             if (this.next() !== ')')
                 throw new CriteriaSyntaxError('Missing closing parenthesis in criteria');
             return inner;
         }
-        const leftToken = this.next();
-        if (leftToken === undefined) {
-            throw new CriteriaSyntaxError('Expected operand on the left side of comparison');
-        }
-        // Both function-call dialects arrive as one dotted token followed by '(':
-        // 'Expr.containsIgnoreCase' (foundation-criteria) or
-        // 'DEAL_CURRENCIES.containsIgnoreCase' (field method-call form).
-        if (leftToken.includes('.') && this.peek() === '(') {
-            return this.parseFunctionCall(leftToken);
-        }
+        const left = this.parseOperand();
         const op = this.peek();
-        if (!op || !COMPARATORS.has(op)) {
-            throw new CriteriaSyntaxError(`Expected comparator, got: ${op}`);
-        }
-        this.next();
-        const rightToken = this.next();
-        if (rightToken === undefined) {
-            throw new CriteriaSyntaxError('Expected operand on the right side of comparison');
+        if (op !== undefined && COMPARATORS.has(op)) {
+            this.next();
+            return { kind: 'compare', op, left, right: this.parseOperand() };
         }
-        this.noteField(leftToken);
-        this.noteField(rightToken);
-        const resolveLeft = (record) => this.resolveValue(leftToken, record);
-        const resolveRight = (record) => this.resolveValue(rightToken, record);
-        return (record) => {
-            const a = resolveLeft(record);
-            const b = resolveRight(record);
-            switch (op) {
-                case '==':
-                case '=':
-                    return a === b;
-                case '!=':
-                case '<>':
-                    return a !== b;
-                case '>':
-                    return a > b;
-                case '>=':
-                    return a >= b;
-                case '<':
-                    return a < b;
-                case '<=':
-                    return a <= b;
-                default:
-                    return false;
-            }
-        };
-    }
-    noteField(token) {
-        if (parseLiteral(token) === undefined)
-            this.fields.add(token);
+        // An operand alone is the condition, by Groovy truth (`ENABLED`,
+        // `Expr.isNullOrBlank(NAME)`).
+        return left;
     }
-    resolveValue(token, record) {
+    parseOperand() {
+        const token = this.next();
+        if (token === undefined)
+            throw new CriteriaSyntaxError('Expected an operand');
+        if (token === 'new' && this.tokens[this.pos + 1] === '(')
+            return this.parseConstructor();
+        if (token.includes('.') && this.peek() === '(')
+            return this.parseCall(token);
         const literal = parseLiteral(token);
-        if (literal !== undefined)
-            return literal;
-        return record[token];
+        if (literal)
+            return { kind: 'literal', ...literal };
+        if (!NAME.test(token))
+            throw new CriteriaSyntaxError(`Unexpected token: ${token}`);
+        this.fields.add(token);
+        return { kind: 'field', name: token };
     }
-    parseFunctionCall(name) {
-        this.next(); // consume '('
+    // The arguments after a call's or a constructor's '('.
+    parseArguments(name) {
+        this.next(); // '('
         const args = [];
         if (this.peek() !== ')') {
-            const arg = this.next();
-            if (arg === undefined)
-                throw new CriteriaSyntaxError(`Unterminated argument list in ${name}(...)`);
-            args.push(arg);
+            args.push(this.parseOperand());
             while (this.peek() === ',') {
                 this.next();
-                const nextArg = this.next();
-                if (nextArg === undefined)
-                    throw new CriteriaSyntaxError(`Unterminated argument list in ${name}(...)`);
-                args.push(nextArg);
+                args.push(this.parseOperand());
             }
         }
         if (this.next() !== ')')
             throw new CriteriaSyntaxError(`Missing closing parenthesis in ${name}(...)`);
-        // 'Expr.<fn>(field, value)' passes args through as-is; the method-call
-        // form '<FIELD>.<fn>(value)' makes the receiver field the implicit first
-        // argument, so both dialects share EXPR_FUNCTIONS.
-        const dotIndex = name.lastIndexOf('.');
-        const receiver = name.slice(0, dotIndex);
-        const fnName = name.slice(dotIndex + 1);
-        const handler = EXPR_FUNCTIONS[fnName];
-        if (!handler)
-            throw new UnsupportedCriteriaError(`Unsupported criteria function: ${name}`);
-        const allArgs = receiver === 'Expr' ? args : [receiver, ...args];
-        for (const arg of allArgs)
-            this.noteField(arg);
-        const resolve = (token, record) => this.resolveValue(token, record);
-        return (record) => handler(record, allArgs, resolve);
+        return args;
+    }
+    // `new BigDecimal('1.5')`: the constructors GSF's validator allows.
+    parseConstructor() {
+        const name = this.next();
+        const type = Object.hasOwn(CONSTRUCTORS, name) ? CONSTRUCTORS[name] : undefined;
+        if (!type)
+            throw new UnsupportedCriteriaError(`Unsupported constructor: new ${name}`);
+        return { kind: 'ctor', type, args: this.parseArguments(`new ${name}`) };
+    }
+    parseCall(name) {
+        const args = this.parseArguments(name);
+        const dot = name.lastIndexOf('.');
+        const [receiver, method] = [name.slice(0, dot), name.slice(dot + 1)];
+        if (receiver === 'Expr') {
+            if (!Object.hasOwn(EXPR_FUNCTIONS, method)) {
+                throw new UnsupportedCriteriaError(`Unsupported criteria function: ${name}`);
+            }
+        }
+        else {
+            if (!Object.hasOwn(FIELD_METHODS, method) && !Object.hasOwn(EXPR_FUNCTIONS, method)) {
+                throw new UnsupportedCriteriaError(`Unsupported criteria function: ${name}`);
+            }
+            this.fields.add(receiver);
+        }
+        return { kind: 'call', receiver, method, args };
+    }
+}
+function parse(criteria) {
+    const tokens = tokenizeCriteria(criteria.trim()).map((token) => token.text);
+    const parser = new Parser(tokens);
+    const root = parser.parseOr();
+    if (parser.position !== tokens.length) {
+        throw new CriteriaSyntaxError(`Unexpected trailing tokens in criteria: ${criteria}`);
+    }
+    return { root, fields: [...parser.fields] };
+}
+// --- argument readers --------------------------------------------------------
+// A date in one of GSF's formats; for `untyped` text (a field without a
+// declared type: mock data) ISO-8601 and epoch-millis text as well.
+function instantOfText(text, untyped) {
+    if (!untyped)
+        return gsf.stringDateTime(text);
+    try {
+        return gsf.stringDateTime(text);
+    }
+    catch (error) {
+        const millis = epochMillis(text);
+        if (millis === undefined)
+            throw error;
+        return millis;
+    }
+}
+const dayOfText = (text, untyped) => gsf.epochDay(instantOfText(text, untyped));
+const isWholeNumber = (value) => typeof value === 'number' || (typeof value === 'string' && /^-?\d+$/.test(value));
+const LONG_TYPES = new Set(['Long', 'Integer', 'Short']);
+// The first argument of a date function, by the overload GSF picks: an
+// instant for a DateTime or a Long (epoch millis), text for a String.
+function dateOperand(arg) {
+    if (arg === undefined)
+        return evaluationError('Missing argument');
+    const { value, type } = arg;
+    if (isNullish(value))
+        return evaluationError(NULL_POINTER);
+    if (value instanceof DateTimeValue)
+        return { millis: value.millis };
+    if (LONG_TYPES.has(type) || (type === undefined && typeof value === 'number')) {
+        return isWholeNumber(value)
+            ? { millis: Number(value) }
+            : evaluationError(`Not a Long: ${String(value)}`);
+    }
+    if ((type === 'String' || type === undefined) && typeof value === 'string')
+        return { text: value };
+    return evaluationError(`No date overload for ${String(value)}`);
+}
+// A String argument: null stays null.
+function stringArg(arg) {
+    if (arg === undefined)
+        return evaluationError('Missing argument');
+    if (isNullish(arg.value))
+        return null;
+    return typeof arg.value === 'string'
+        ? arg.value
+        : evaluationError(`Not a String: ${String(arg.value)}`);
+}
+// A String argument that is dereferenced: null throws.
+function requiredString(arg) {
+    return stringArg(arg) ?? evaluationError(NULL_POINTER);
+}
+// The delimiter of containsWordsStartingWithIgnoreCase: its first character.
+function delimiterArg(arg) {
+    if (arg === undefined)
+        return undefined;
+    const text = requiredString(arg);
+    return text.length > 0 ? text[0] : evaluationError('String index out of range: 0');
+}
+function instantOf(arg) {
+    const operand = dateOperand(arg);
+    return 'millis' in operand ? operand.millis : instantOfText(operand.text, arg.untyped === true);
+}
+// dateIs*(date, comparableDate): by day. A DateTime or Long date is compared
+// with a yyyyMMdd date only; a String date and its comparable with any of
+// GSF's formats.
+function compareDays(compare) {
+    return ([date, comparable]) => {
+        const operand = dateOperand(date);
+        const other = requiredString(comparable);
+        if ('millis' in operand) {
+            return compare(gsf.epochDay(operand.millis), gsf.singlePatternLocalDate(other));
+        }
+        const day = dayOfText(operand.text, date.untyped === true);
+        return compare(day, gsf.stringLocalDate(other));
+    };
+}
+// dateTimeIs*(date, comparableDate): by instant.
+function compareInstants(compare) {
+    return ([date, comparable]) => compare(instantOf(date), gsf.stringDateTime(requiredString(comparable)));
+}
+function isNullOrBlank([text]) {
+    const value = stringArg(text);
+    return value === null || gsf.isBlank(value);
+}
+// A mock row may hold a list in a field (DEAL_CURRENCIES: ['USD', 'GBP']):
+// contains / containsIgnoreCase then test membership. GSF has no such field.
+function listMember(list, needle, ignoreCase) {
+    const search = needle === undefined ? null : stringArg(needle);
+    if (search === null)
+        return false;
+    return list.some((item) => typeof item === 'string' &&
+        (ignoreCase ? item.toLowerCase() === search.toLowerCase() : item === search));
+}
+function containsIgnoreCase([text, search]) {
+    if (Array.isArray(text?.value))
+        return listMember(text.value, search, true);
+    return gsf.containsIgnoreCase(stringArg(text), stringArg(search));
+}
+function containsWordsStartingWithIgnoreCase([text, search, delimiter]) {
+    const separator = delimiterArg(delimiter);
+    return gsf.containsWordsStartingWithIgnoreCase(stringArg(text), stringArg(search), separator);
+}
+function dateIsToday([date]) {
+    const operand = dateOperand(date);
+    const day = 'millis' in operand
+        ? gsf.epochDay(operand.millis)
+        : dayOfText(operand.text, date.untyped === true);
+    return day === gsf.today();
+}
+function longArg(arg) {
+    if (arg === undefined)
+        return evaluationError('Missing argument');
+    if (isNullish(arg.value))
+        return evaluationError(NULL_POINTER);
+    return isWholeNumber(arg.value)
+        ? Number(arg.value)
+        : evaluationError(`Not a Long: ${String(arg.value)}`);
+}
+// What this engine evaluated before GSF's semantics, kept for fidelity:
+// 'legacy' (strict criteria refuse them: GSF's validator doesn't allow them).
+const legacyFunctions = {
+    contains: ([text, search]) => {
+        if (Array.isArray(text?.value))
+            return listMember(text.value, search, false);
+        return (typeof text?.value === 'string' &&
+            typeof search?.value === 'string' &&
+            text.value.includes(search.value));
+    },
+    equals: ([a, b]) => a?.value === b?.value,
+    equalsIgnoreCase: ([a, b]) => {
+        if (typeof a?.value !== 'string' || typeof b?.value !== 'string')
+            return a?.value === b?.value;
+        return a.value.toLowerCase() === b.value.toLowerCase();
+    },
+    startsWith: ([text, prefix]) => typeof text?.value === 'string' &&
+        typeof prefix?.value === 'string' &&
+        text.value.startsWith(prefix.value),
+    endsWith: ([text, suffix]) => typeof text?.value === 'string' &&
+        typeof suffix?.value === 'string' &&
+        text.value.endsWith(suffix.value),
+    dateTimeIsEqual: compareInstants((a, b) => a === b),
+};
+// Expr.java (GSF v8.15.29), every function its validator allows plus
+// stringDateTime (GSF has it, its validator refuses it).
+const EXPR_FUNCTIONS = {
+    ...legacyFunctions,
+    isNullOrBlank,
+    notNullOrBlank: (args) => !isNullOrBlank(args),
+    containsIgnoreCase,
+    containsWordsStartingWithIgnoreCase,
+    dateIsToday,
+    dateIsEqual: compareDays((a, b) => a === b),
+    dateIsBefore: compareDays((a, b) => a < b),
+    dateIsAfter: compareDays((a, b) => a > b),
+    dateIsGreaterEqual: compareDays((a, b) => a >= b),
+    dateIsLessEqual: compareDays((a, b) => a <= b),
+    dateTimeIsAfter: compareInstants((a, b) => a > b),
+    dateTimeIsGreaterEqual: compareInstants((a, b) => a >= b),
+    dateTimeIsBefore: compareInstants((a, b) => a < b),
+    dateTimeIsLessEqual: compareInstants((a, b) => a <= b),
+    dateTimeIsInRange: ([date, range, context]) => {
+        const [rangeName, contextName] = [requiredString(range), requiredString(context)];
+        return gsf.dateTimeIsInRange(instantOf(date), rangeName, contextName);
+    },
+    longLocalDate: ([date]) => new LocalDateValue(gsf.epochDay(longArg(date))),
+    longDateTime: ([date]) => new DateTimeValue(longArg(date)),
+    stringLocalDate: ([date]) => new LocalDateValue(dayOfText(requiredString(date), date.untyped === true)),
+    stringDateTime: ([date]) => new DateTimeValue(instantOfText(requiredString(date), date.untyped === true)),
+};
+// --- field methods ------------------------------------------------------------
+// Object.equals: the same Java class and value. A field without a known type
+// equals a value of the same kind.
+function javaEquals(receiver, other) {
+    const [a, b] = [receiver.value, other.value];
+    if (isNullish(b))
+        return false;
+    if (a instanceof DateTimeValue)
+        return b instanceof DateTimeValue && a.millis === b.millis;
+    if (a instanceof LocalDateValue)
+        return b instanceof LocalDateValue && a.day === b.day;
+    if (typeof a === 'number' && typeof b === 'number') {
+        // Long.equals(5) is false: 5 is an Integer.
+        if (receiver.type && other.type && receiver.type !== other.type)
+            return false;
+        return a === b;
     }
+    return a === b;
+}
+// The receiver of a String method: null throws (the call dereferences it).
+function stringReceiver(receiver) {
+    if (isNullish(receiver.value))
+        return evaluationError(NULL_POINTER);
+    return typeof receiver.value === 'string'
+        ? receiver.value
+        : evaluationError(`Not a String: ${String(receiver.value)}`);
+}
+// String's own methods, then the ExtraOperators.kt extensions (whose String?
+// receiver may be null: containsIgnoreCase and
+// containsWordsStartingWithIgnoreCase answer false for it).
+const FIELD_METHODS = {
+    startsWith: (receiver, [prefix, offset]) => {
+        const text = stringReceiver(receiver);
+        const start = requiredString(prefix);
+        const from = offset === undefined ? 0 : longArg(offset);
+        if (from < 0 || from > text.length - start.length)
+            return false;
+        return text.startsWith(start, from);
+    },
+    equals: (receiver, [other]) => {
+        if (isNullish(receiver.value))
+            return evaluationError(NULL_POINTER);
+        return other !== undefined && javaEquals(receiver, other);
+    },
+    equalsIgnoreCase: (receiver, [other]) => {
+        const text = stringReceiver(receiver);
+        const value = stringArg(other);
+        return value !== null && value.length === text.length && gsf.containsIgnoreCase(text, value);
+    },
+    contains: (receiver, [search]) => {
+        if (Array.isArray(receiver.value))
+            return listMember(receiver.value, search, false);
+        return stringReceiver(receiver).includes(requiredString(search));
+    },
+    containsIgnoreCase: (receiver, [search]) => containsIgnoreCase([receiver, search]),
+    containsWordsStartingWithIgnoreCase: (receiver, [search, delimiter]) => containsWordsStartingWithIgnoreCase([receiver, search, ...(delimiter ? [delimiter] : [])]),
+    dateIsToday: (receiver) => dateIsToday([receiver]),
+};
+// --- comparisons ----------------------------------------------------------------
+// Groovy orders null before everything.
+function compareNullable(a, b) {
+    if (!isNullish(a) && !isNullish(b))
+        return undefined;
+    if (isNullish(a) && isNullish(b))
+        return 0;
+    return isNullish(a) ? -1 : 1;
+}
+function fromOrder(op, order) {
+    switch (op) {
+        case '==':
+        case '=':
+            return order === 0;
+        case '!=':
+        case '<>':
+            return order !== 0;
+        case '<':
+            return order < 0;
+        case '<=':
+            return order <= 0;
+        case '>':
+            return order > 0;
+        default:
+            return order >= 0;
+    }
+}
+const EQUALITY = new Set(['==', '=', '!=', '<>']);
+// What a DateTime compares with (ExtraOperators.kt compareTo): another
+// DateTime, epoch millis (a Long or an int), a date string. undefined for
+// anything else — a Double, a BigDecimal, a Boolean.
+function instantOperand(operand) {
+    const { value, type } = operand;
+    if (value instanceof DateTimeValue)
+        return value.millis;
+    if (typeof value === 'number') {
+        return type === 'Double' || type === 'BigDecimal' ? undefined : value;
+    }
+    if (typeof value === 'string')
+        return gsf.stringDateTime(value);
+    return undefined;
+}
+// A comparison with a DateTime or a LocalDate on one side. `==` takes a
+// DateTime equal to a date string naming its instant, and never to a
+// one-character string literal (Groovy types that as a char; a field's
+// one-character value is parsed like any other), a Double, a BigDecimal or a
+// Boolean; an unparseable date string throws. A relational
+// operator throws for a pair it can't compare.
+function compareDates(op, a, b) {
+    const equality = EQUALITY.has(op);
+    const unrelated = () => equality ? op === '!=' || op === '<>' : evaluationError('Cannot compare these values');
+    if (a.value instanceof LocalDateValue || b.value instanceof LocalDateValue) {
+        if (a.value instanceof LocalDateValue && b.value instanceof LocalDateValue) {
+            return fromOrder(op, Math.sign(a.value.day - b.value.day));
+        }
+        return unrelated();
+    }
+    const char = (operand) => operand.literal === true && typeof operand.value === 'string' && operand.value.length === 1;
+    if (equality && (char(a) || char(b)))
+        return unrelated();
+    const [x, y] = [instantOperand(a), instantOperand(b)];
+    if (x === undefined || y === undefined)
+        return unrelated();
+    return fromOrder(op, Math.sign(x - y));
+}
+const isDated = (operand) => operand.value instanceof DateTimeValue || operand.value instanceof LocalDateValue;
+function compareValues(op, left, right) {
+    const [a, b] = [left.value, right.value];
+    const order = compareNullable(a, b);
+    if (order !== undefined)
+        return fromOrder(op, order);
+    if (isDated(left) || isDated(right))
+        return compareDates(op, left, right);
+    switch (op) {
+        case '==':
+        case '=':
+            return a === b;
+        case '!=':
+        case '<>':
+            return a !== b;
+        case '>':
+            return a > b;
+        case '>=':
+            return a >= b;
+        case '<':
+            return a < b;
+        default:
+            return a <= b;
+    }
+}
+// A field as the entity's getter returns it: a DateTime for DATE and
+// DATETIME, a String for STRING and ENUM.
+function readField(name, type, record) {
+    const raw = record[name] ?? null;
+    if (type === undefined)
+        return { value: raw, untyped: true };
+    if (raw === null)
+        return { value: null, type };
+    if (type === 'DateTime') {
+        const millis = epochMillis(raw);
+        return millis === undefined
+            ? evaluationError(`Not a date: ${String(raw)}`)
+            : { value: new DateTimeValue(millis), type };
+    }
+    if (type === 'String' && (typeof raw === 'number' || typeof raw === 'boolean')) {
+        return { value: String(raw), type };
+    }
+    return { value: raw, type };
+}
+function compileNode(node, options) {
+    switch (node.kind) {
+        case 'literal': {
+            const value = { value: node.value, type: node.type, literal: true };
+            return () => value;
+        }
+        case 'field': {
+            const typeName = options.types?.get(node.name);
+            const type = typeName ? ENTITY_TYPES[typeName] : undefined;
+            return (record) => readField(node.name, type, record);
+        }
+        case 'compare': {
+            const [left, right] = [compileNode(node.left, options), compileNode(node.right, options)];
+            return (record) => ({
+                value: compareValues(node.op, left(record), right(record)),
+                type: 'Boolean',
+            });
+        }
+        case 'and':
+        case 'or': {
+            const [left, right] = [compileNode(node.left, options), compileNode(node.right, options)];
+            const and = node.kind === 'and';
+            return (record) => {
+                const first = groovyTruth(left(record).value);
+                if (and ? !first : first)
+                    return { value: first, type: 'Boolean' };
+                return { value: groovyTruth(right(record).value), type: 'Boolean' };
+            };
+        }
+        case 'not': {
+            const operand = compileNode(node.operand, options);
+            return (record) => ({ value: !groovyTruth(operand(record).value), type: 'Boolean' });
+        }
+        case 'call':
+            return compileCall(node, options);
+        case 'ctor': {
+            const args = node.args.map((arg) => compileNode(arg, options));
+            return (record) => ({
+                value: construct(node.type, args.map((arg) => arg(record))),
+                type: node.type,
+            });
+        }
+    }
+}
+const JAVA_DECIMAL = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const JAVA_INTEGER = /^[+-]?\d+$/;
+const JAVA_DOUBLE = /^[+-]?(?:(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?[dDfF]?|Infinity|NaN)$/;
+// `new X(arg)`: the value Java's constructor makes, or the exception it
+// throws (a NumberFormatException for text that isn't the number).
+function construct(type, args) {
+    if (type === 'String' && args.length === 0)
+        return '';
+    if (args.length !== 1)
+        return evaluationError('No such constructor');
+    const { value } = args[0];
+    if (isNullish(value))
+        return evaluationError(NULL_POINTER);
+    if (type === 'String')
+        return typeof value === 'string' ? value : String(value);
+    if (typeof value === 'number')
+        return value;
+    if (typeof value !== 'string')
+        return evaluationError('No such constructor');
+    const text = type === 'Double' ? value.trim() : value; // only Double.parseDouble trims
+    const pattern = type === 'BigDecimal' ? JAVA_DECIMAL : type === 'Double' ? JAVA_DOUBLE : JAVA_INTEGER;
+    if (!pattern.test(text))
+        return evaluationError(`NumberFormatException: ${value}`);
+    const number = Number(text.replace(/[dDfF]$/, ''));
+    if (type === 'Integer' && (number < INT_MIN || number > INT_MAX)) {
+        return evaluationError(`NumberFormatException: ${value}`);
+    }
+    return number;
+}
+function compileCall(node, options) {
+    const args = node.args.map((arg) => compileNode(arg, options));
+    const readArgs = (record) => args.map((arg) => arg(record));
+    if (node.receiver === 'Expr') {
+        const fn = EXPR_FUNCTIONS[node.method];
+        return (record) => ({ value: fn(readArgs(record)) });
+    }
+    const receiver = compileNode({ kind: 'field', name: node.receiver }, options);
+    const method = Object.hasOwn(FIELD_METHODS, node.method) ? FIELD_METHODS[node.method] : undefined;
+    if (method) {
+        return (record) => ({
+            value: method(receiver(record), readArgs(record)),
+            type: 'Boolean',
+        });
+    }
+    // fidelity: 'legacy' — an Expr function called on its first argument.
+    const fn = EXPR_FUNCTIONS[node.method];
+    return (record) => ({ value: fn([receiver(record), ...readArgs(record)]) });
 }
 // Parses a CRITERIA_MATCH without failing open: throws CriteriaSyntaxError for
 // a malformed one and UnsupportedCriteriaError for a call to a function the
-// grammar doesn't have. A blank criteria matches everything.
-export function parseCriteria(criteria) {
+// grammar doesn't have. A blank criteria matches everything. A row the
+// criteria throws on (gsfExpr.ts) doesn't match.
+export function parseCriteria(criteria, options = {}) {
     if (!criteria || typeof criteria !== 'string' || criteria.trim() === '') {
         return { predicate: () => true, fields: [] };
     }
-    const tokens = tokenize(criteria.trim());
-    const parser = new Parser(tokens);
-    const predicate = parser.parseExpression();
-    if (parser.position !== tokens.length) {
-        throw new CriteriaSyntaxError(`Unexpected trailing tokens in criteria: ${criteria}`);
-    }
-    return { predicate, fields: [...parser.fields] };
+    if (options.lenient)
+        return parseLegacyCriteria(criteria);
+    const { root, fields } = parse(criteria);
+    const evaluate = compileNode(root, options);
+    const predicate = (record) => {
+        try {
+            return groovyTruth(evaluate(record).value);
+        }
+        catch (error) {
+            if (error instanceof CriteriaEvaluationError)
+                return false;
+            throw error;
+        }
+    };
+    return { predicate, fields };
 }
 /** Compiles a CRITERIA_MATCH string into a predicate function(record) => boolean. */
-export function compileCriteria(criteria) {
+export function compileCriteria(criteria, options = {}) {
     // Real Genesis clients can emit CRITERIA_MATCH syntax this grammar doesn't
-    // cover yet (e.g. function-call criteria like Expr.dateTimeIsGreaterEqual(...)
-    // from date-range filters). Failing open — matching everything and logging —
-    // keeps DATA_LOGON/broadcast working (unfiltered) instead of crashing the
-    // handler and leaving the client's grid stuck on "Loading...".
+    // cover. Failing open — matching everything and logging — keeps
+    // DATA_LOGON/broadcast working (unfiltered) instead of crashing the handler
+    // and leaving the client's grid stuck on "Loading...". Strict criteria
+    // refuse what GSF refuses before they get here.
     try {
-        return parseCriteria(criteria).predicate;
+        return parseCriteria(criteria, options).predicate;
     }
     catch (error) {
         console.warn(`[mock-server] Unsupported CRITERIA_MATCH syntax, ignoring filter: ${criteria}`, error);
@@ -353,8 +722,8 @@ export function criteriaFields(criteria) {
         return undefined;
     }
 }
-export function filterByCriteria(rows, criteria) {
-    const predicate = compileCriteria(criteria);
+export function filterByCriteria(rows, criteria, options = {}) {
+    const predicate = compileCriteria(criteria, options);
     return rows.filter((row) => {
         try {
             return predicate(row);
@@ -364,3 +733,232 @@ export function filterByCriteria(rows, criteria) {
         }
     });
 }
+const S = 'String';
+const DATE_OVERLOADS = [
+    [S, S],
+    ['Long', S],
+    ['DateTime', S],
+];
+// Expr.java's overloads, and what each function returns.
+const EXPR_SIGNATURES = {
+    isNullOrBlank: { overloads: [[S]], returns: 'Boolean' },
+    notNullOrBlank: { overloads: [[S]], returns: 'Boolean' },
+    containsIgnoreCase: { overloads: [[S, S]], returns: 'Boolean' },
+    containsWordsStartingWithIgnoreCase: {
+        overloads: [
+            [S, S],
+            [S, S, S],
+            [S, S, 'Character'],
+        ],
+        returns: 'Boolean',
+    },
+    dateIsToday: { overloads: [['Long'], [S], ['DateTime']], returns: 'Boolean' },
+    ...Object.fromEntries([
+        'dateIsEqual',
+        'dateIsBefore',
+        'dateIsAfter',
+        'dateIsGreaterEqual',
+        'dateIsLessEqual',
+        'dateTimeIsAfter',
+        'dateTimeIsGreaterEqual',
+        'dateTimeIsBefore',
+        'dateTimeIsLessEqual',
+    ].map((name) => [name, { overloads: DATE_OVERLOADS, returns: 'Boolean' }])),
+    dateTimeIsInRange: {
+        overloads: [
+            ['DateTime', S, S],
+            ['Long', S, S],
+            [S, S, S],
+        ],
+        returns: 'Boolean',
+    },
+    longLocalDate: { overloads: [['Long']], returns: 'LocalDate' },
+    stringLocalDate: { overloads: [[S]], returns: 'LocalDate' },
+    longDateTime: { overloads: [['Long']], returns: 'DateTime' },
+    stringDateTime: { overloads: [[S]], returns: 'DateTime' },
+};
+const EQUALS = [['Object']];
+const TODAY = [[]];
+// The field methods each receiver type has (String's, Object.equals and the
+// ExtraOperators.kt extensions, whose delimiter is a primitive char).
+const FIELD_SIGNATURES = {
+    String: {
+        startsWith: [[S], [S, 'int']],
+        equals: EQUALS,
+        equalsIgnoreCase: [[S]],
+        contains: [['CharSequence']],
+        containsIgnoreCase: [[S]],
+        containsWordsStartingWithIgnoreCase: [[S], [S, S], [S, 'char']],
+        dateIsToday: TODAY,
+    },
+    Long: { equals: EQUALS, dateIsToday: TODAY },
+    DateTime: { equals: EQUALS, dateIsToday: TODAY },
+    Integer: { equals: EQUALS },
+    Short: { equals: EQUALS },
+    Double: { equals: EQUALS },
+    BigDecimal: { equals: EQUALS },
+    Boolean: { equals: EQUALS },
+};
+const PRIMITIVES = new Set(['int', 'char']);
+// Whether Groovy's static type checker passes an argument of type `arg` for a
+// parameter of type `param` (null to any object, Integer and Short widened
+// to Long).
+function assignable(arg, param) {
+    if (arg === param || param === 'Object')
+        return true;
+    if (arg === 'null')
+        return !PRIMITIVES.has(param);
+    if (param === 'CharSequence')
+        return arg === 'String';
+    if (param === 'Long')
+        return arg === 'Integer' || arg === 'Short';
+    if (param === 'int')
+        return arg === 'Integer' || arg === 'Short';
+    return false;
+}
+class CompileFailure extends Error {
+}
+const NUMBERS = new Set([
+    'Integer',
+    'Short',
+    'Long',
+    'BigInteger',
+    'Double',
+    'BigDecimal',
+]);
+// Whether `left < right` compiles: a compareTo for the pair exists — numbers
+// with numbers, a String with a String, a Boolean with a Boolean, and a
+// DateTime with a DateTime, a date string or epoch millis (ExtraOperators.kt).
+// Never with null on the left (Object#compareTo). A LocalDate's comparisons
+// fail when they run, if at all.
+function comparable(left, right) {
+    if (left === 'null')
+        return false;
+    if (right === 'null' || left === 'LocalDate' || right === 'LocalDate')
+        return true;
+    if (left === 'DateTime')
+        return ['DateTime', 'String', 'Long', 'Integer', 'Short'].includes(right);
+    if (right === 'DateTime')
+        return left === 'String' || left === 'Long';
+    if (NUMBERS.has(left))
+        return NUMBERS.has(right);
+    return left === right;
+}
+// Whether exactly one overload takes these arguments. An argument of unknown
+// type passes any parameter (it can't be checked).
+function checkOverloads(overloads, args) {
+    const matching = overloads.filter((params) => params.length === args.length &&
+        params.every((param, index) => args[index] === undefined || assignable(args[index], param)));
+    if (matching.length === 0)
+        throw new CompileFailure();
+    // Overloads that all take the arguments (a null) are ambiguous — when the
+    // arguments they differ on have known types.
+    const differing = args.flatMap((_arg, index) => matching.some((params) => params[index] !== matching[0][index]) ? [index] : []);
+    if (matching.length > 1 && differing.every((index) => args[index] !== undefined)) {
+        throw new CompileFailure();
+    }
+}
+// The type GSF's compiler gives a node, checking every call in it; undefined
+// when it can't be known (a field without a declared type).
+function staticType(node, types) {
+    switch (node.kind) {
+        case 'literal':
+            return node.type;
+        case 'field': {
+            const typeName = types?.get(node.name);
+            return typeName ? ENTITY_TYPES[typeName] : undefined;
+        }
+        case 'compare': {
+            const [left, right] = [staticType(node.left, types), staticType(node.right, types)];
+            const relational = !EQUALITY.has(node.op);
+            if (relational && left && right && !comparable(left, right))
+                throw new CompileFailure();
+            return 'Boolean';
+        }
+        case 'and':
+        case 'or':
+            staticType(node.left, types);
+            staticType(node.right, types);
+            return 'Boolean';
+        case 'not':
+            staticType(node.operand, types);
+            return 'Boolean';
+        case 'ctor':
+            return node.type;
+        case 'call': {
+            const args = node.args.map((arg) => staticType(arg, types));
+            if (node.receiver === 'Expr') {
+                const signature = EXPR_SIGNATURES[node.method];
+                if (!signature)
+                    return undefined; // not GSF's: the validator refuses it
+                checkOverloads(signature.overloads, args);
+                return signature.returns;
+            }
+            const receiver = staticType({ kind: 'field', name: node.receiver }, types);
+            if (receiver === undefined || !Object.hasOwn(FIELD_METHODS, node.method))
+                return undefined;
+            const overloads = FIELD_SIGNATURES[receiver]?.[node.method];
+            if (!overloads)
+                throw new CompileFailure();
+            checkOverloads(overloads, args);
+            return 'Boolean';
+        }
+    }
+}
+// Guava's UPPER_UNDERSCORE to UPPER_CAMEL / LOWER_CAMEL, as GSF names getters.
+function camelCase(name, upperFirst) {
+    const words = name.split('_').map((word, index) => {
+        const lowered = word.toLowerCase();
+        if (index === 0 && !upperFirst)
+            return lowered;
+        return lowered.charAt(0).toUpperCase() + lowered.slice(1);
+    });
+    const joined = words.join('');
+    return /^\d/.test(joined) ? `_${joined}` : joined;
+}
+// The getter call CriteriaFilterFactory puts in place of a field.
+function getterOf(name, type) {
+    if (type === 'ENUM')
+        return `row.get${camelCase(name, true)}()?.toString()`;
+    if (type === 'BOOLEAN' && name.startsWith('IS'))
+        return `row.${camelCase(name, false)}()`;
+    return `row.get${camelCase(name, true)}()`;
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+// The INVALID_CRITERIA TEXT GSF sends when its @CompileStatic compilation
+// of a criteria fails (CriteriaFilterBuilder.getCriteriaFilter, v8.15.29):
+// the criteria as it was compiled — each field the validator saw it read
+// replaced by the entity's getter (CriteriaFilterFactory: longest name
+// first, not where a quote or a word character touches it).
+export function compileFailureText(criteria, fields, types) {
+    let replaced = criteria;
+    for (const field of [...new Set(fields)].sort((a, b) => b.length - a.length)) {
+        const pattern = new RegExp(`(?<!["'\\w])${escapeRegExp(field)}(?!["'\\w])`, 'g');
+        replaced = replaced.replace(pattern, () => getterOf(field, types?.get(field)));
+    }
+    return `Error compiling criteria expression: Failed to compile criteria expression ${replaced}`;
+}
+// What GSF's compilation refuses in a criteria its validator passes: a call
+// no overload takes — the wrong number of arguments, or (where the fields'
+// types are known) an argument of the wrong type, a field method the
+// field's type doesn't have, an ambiguous null — and a relational operator
+// between types that don't compare (`QTY > '5'`). The INVALID_CRITERIA
+// TEXT, or undefined when it compiles or doesn't parse here.
+export function criteriaCompileRefusal(criteria, types) {
+    let parsed;
+    try {
+        parsed = parse(criteria);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        staticType(parsed.root, types);
+        return undefined;
+    }
+    catch (error) {
+        if (!(error instanceof CompileFailure))
+            throw error;
+    }
+    return compileFailureText(criteria, parsed.fields, types);
+}