@genesislcap/mock-server 15.60.0 → 15.61.0

package/src/db/criteria.ts

@@ -1,208 +1,212 @@
 // 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.
 
 import type { Row } from '../types.ts';
+import {
+  CriteriaSyntaxError,
+  tokenizeCriteria,
+  UnsupportedCriteriaError,
+} from './criteriaTokens.ts';
+import * as gsf from './gsfExpr.ts';
+import { CriteriaEvaluationError, evaluationError } from './gsfExpr.ts';
+import { parseLegacyCriteria } from './legacyCriteria.ts';
+import { epochMillis } from './values.ts';
 
 export type Predicate = (record: Row) => boolean;
 
-// 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 {
-  override name = 'CriteriaSyntaxError';
-}
+export {
+  CriteriaSyntaxError,
+  type CriteriaToken,
+  parseGenesisDateTime,
+  tokenizeCriteria,
+  UnsupportedCriteriaError,
+} from './criteriaTokens.ts';
 
-// 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 {
-  override name = 'UnsupportedCriteriaError';
+/**
+ * How {@link compileCriteria} and {@link filterByCriteria} read a criteria.
+ * Without options they evaluate it as GSF 8.15 does, each field read by its
+ * value.
+ * @public
+ */
+export interface CriteriaOptions {
+  /**
+   * Each field's Genesis type (`STRING`, `DATETIME`, ...), where it is
+   * declared: GSF compiles a criteria against these, which picks each
+   * function's overload (a `DATETIME` is a Joda DateTime, a `STRING` a
+   * String).
+   */
+  types?: ReadonlyMap<string, string>;
+  /**
+   * `fidelity: 'legacy'`: evaluate the criteria as this engine did up to
+   * 15.47 — its comparisons, its function semantics (inclusive
+   * `dateTimeIsAfter`, `false` instead of an exception, dates read by
+   * `Date.parse` too), its `AND`/`OR`/`NOT` dialect — plus the GSF functions
+   * it didn't have. `types` is ignored.
+   */
+  lenient?: boolean;
 }
 
-const TOKEN_RE =
-  /\s*(&&|\|\||<=|>=|!=|<>|==|=|<|>|!|\(|\)|,|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?|[A-Za-z_][A-Za-z0-9_.]*)/g;
+// --- values ------------------------------------------------------------------
 
-function tokenize(input: string): string[] {
-  const tokens: string[] = [];
-  let match: RegExpExecArray | null;
-  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;
+// The Java types a criteria's values have in GSF's compiled filter. 'null' is
+// the null literal; 'int' and 'char' are primitive parameters (null can't be
+// passed); 'Object' and 'CharSequence' only appear as parameters.
+type JavaType =
+  | 'String'
+  | 'Integer'
+  | 'Short'
+  | 'Long'
+  | 'BigInteger'
+  | 'Double'
+  | 'BigDecimal'
+  | 'Boolean'
+  | 'DateTime'
+  | 'LocalDate'
+  | 'null'
+  | 'Object'
+  | 'CharSequence'
+  | 'Character'
+  | 'char'
+  | 'int';
+
+// A generated entity's getter types (ENUM getters are read with toString()).
+const ENTITY_TYPES: Record<string, JavaType> = {
+  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 {
+  readonly millis: number;
+  constructor(millis: number) {
+    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 {
+  readonly day: number;
+  constructor(day: number) {
+    this.day = day;
   }
-  return tokens;
 }
 
-function parseLiteral(token: string): unknown {
-  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 (token === 'null') return null;
-  return undefined; // not a literal -> treat as a field reference
+// One evaluated operand: its value, its Java type when known, and whether it
+// is a field read without one (mock data, read leniently).
+interface Value {
+  value: unknown;
+  type?: JavaType;
+  untyped?: boolean;
+  // Written in the criteria: Groovy types a one-character string literal
+  // as a char where it compares one with a DateTime.
+  literal?: boolean;
 }
 
-const COMPARATORS = new Set(['==', '=', '!=', '<>', '<', '<=', '>', '>=']);
+const INT_MIN = -2_147_483_648;
+const INT_MAX = 2_147_483_647;
+const NULL_POINTER = 'java.lang.NullPointerException';
 
-// 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: unknown): number | null {
-  if (typeof value === 'number') 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')),
-    );
+function parseLiteral(token: string): { value: unknown; type: JavaType } | undefined {
+  if (/^['"]/.test(token)) {
+    return { value: token.slice(1, -1).replace(/\\(.)/g, '$1'), type: 'String' };
   }
-  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: unknown): number | null {
-  const epoch = parseGenesisDateTime(value);
-  return epoch === null ? null : Math.floor(epoch / MS_PER_DAY);
-}
-
-type ExprResolver = (token: string, record: Row) => unknown;
-
-// 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: Record<
-  string,
-  (record: Row, args: string[], resolve: ExprResolver) => boolean
-> = {
-  // 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: Row,
-  args: string[],
-  resolve: ExprResolver,
-  cmp: (a: number, b: number) => boolean,
-): boolean {
-  const a = toEpochDay(resolve(args[0], record));
-  const b = toEpochDay(resolve(args[1], record));
-  return a !== null && b !== null && cmp(a, b);
+  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 { value: null, type: 'null' };
+  return undefined; // not a literal -> a field reference
 }
 
-function compareByTime(
-  record: Row,
-  args: string[],
-  resolve: ExprResolver,
-  cmp: (a: number, b: number) => boolean,
-): boolean {
-  const a = parseGenesisDateTime(resolve(args[0], record));
-  const b = parseGenesisDateTime(resolve(args[1], record));
-  return a !== null && b !== null && cmp(a, b);
+const isNullish = (value: unknown) => value === null || value === undefined;
+
+// Groovy truth: false for null, false, '', 0; true for anything else.
+function groovyTruth(value: unknown): boolean {
+  if (isNullish(value)) return false;
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value.length > 0;
+  if (typeof value === 'number') return value !== 0;
+  return true;
 }
 
+// --- the syntax tree ---------------------------------------------------------
+
+type Node =
+  | { kind: 'literal'; value: unknown; type: JavaType }
+  | { kind: 'field'; name: string }
+  | { kind: 'call'; receiver: string; method: string; args: Node[] }
+  | { kind: 'ctor'; type: JavaType; args: Node[] }
+  | { kind: 'compare'; op: string; left: Node; right: Node }
+  | { kind: 'and' | 'or'; left: Node; right: Node }
+  | { kind: 'not'; operand: Node };
+
+const COMPARATORS = new Set(['==', '=', '!=', '<>', '<', '<=', '>', '>=']);
+
+// CriteriaValidatorVisitor's allowedConstructors (GSF v8.15.29).
+const CONSTRUCTORS: Record<string, JavaType> = {
+  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 {
   private tokens: string[];
   private 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.
   readonly fields = new Set<string>();
 
   constructor(tokens: string[]) {
@@ -213,155 +217,579 @@ class Parser {
     return this.pos;
   }
 
-  peek(): string | undefined {
+  private peek(): string | undefined {
     return this.tokens[this.pos];
   }
 
-  next(): string | undefined {
+  private next(): string | undefined {
     const token = this.tokens[this.pos];
     this.pos += 1;
     return token;
   }
 
-  parseExpression(): Predicate {
-    return this.parseOr();
-  }
-
-  parseOr(): Predicate {
+  parseOr(): Node {
     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;
   }
 
-  parseAnd(): Predicate {
+  private parseAnd(): Node {
     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;
   }
 
-  parseNot(): Predicate {
+  private parseNot(): Node {
     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(): Predicate {
+  private parsePrimary(): Node {
     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: Row) => this.resolveValue(leftToken, record);
-    const resolveRight = (record: Row) => this.resolveValue(rightToken, record);
-
-    return (record: Row) => {
-      const a = resolveLeft(record);
-      const b = resolveRight(record);
-      switch (op) {
-        case '==':
-        case '=':
-          return a === b;
-        case '!=':
-        case '<>':
-          return a !== b;
-        case '>':
-          return (a as any) > (b as any);
-        case '>=':
-          return (a as any) >= (b as any);
-        case '<':
-          return (a as any) < (b as any);
-        case '<=':
-          return (a as any) <= (b as any);
-        default:
-          return false;
-      }
-    };
-  }
-
-  noteField(token: string): void {
-    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: string, record: Row): unknown {
+  private parseOperand(): Node {
+    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: string): Predicate {
-    this.next(); // consume '('
-    const args: string[] = [];
+  // The arguments after a call's or a constructor's '('.
+  private parseArguments(name: string): Node[] {
+    this.next(); // '('
+    const args: Node[] = [];
     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}(...)`);
+    return args;
+  }
+
+  // `new BigDecimal('1.5')`: the constructors GSF's validator allows.
+  private parseConstructor(): Node {
+    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}`) };
+  }
+
+  private parseCall(name: string): Node {
+    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: string): { root: Node; fields: string[] } {
+  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: string, untyped: boolean): number {
+  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: string, untyped: boolean) => gsf.epochDay(instantOfText(text, untyped));
+
+const isWholeNumber = (value: unknown) =>
+  typeof value === 'number' || (typeof value === 'string' && /^-?\d+$/.test(value));
+
+const LONG_TYPES = new Set<JavaType | undefined>(['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: Value | undefined): { millis: number } | { text: string } {
+  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: Value | undefined): string | null {
+  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: Value | undefined): string {
+  return stringArg(arg) ?? evaluationError(NULL_POINTER);
+}
+
+// The delimiter of containsWordsStartingWithIgnoreCase: its first character.
+function delimiterArg(arg: Value | undefined): string | undefined {
+  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: Value): number {
+  const operand = dateOperand(arg);
+  return 'millis' in operand ? operand.millis : instantOfText(operand.text, arg.untyped === true);
+}
+
+// --- Expr ---------------------------------------------------------------------
+
+type ExprFunction = (args: Value[]) => unknown;
+
+// 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: (a: number, b: number) => boolean): ExprFunction {
+  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: (a: number, b: number) => boolean): ExprFunction {
+  return ([date, comparable]) =>
+    compare(instantOf(date), gsf.stringDateTime(requiredString(comparable)));
+}
+
+function isNullOrBlank([text]: Value[]): boolean {
+  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: unknown[], needle: Value | undefined, ignoreCase: boolean): boolean {
+  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]: Value[]): boolean {
+  if (Array.isArray(text?.value)) return listMember(text.value, search, true);
+  return gsf.containsIgnoreCase(stringArg(text), stringArg(search));
+}
+
+function containsWordsStartingWithIgnoreCase([text, search, delimiter]: Value[]): boolean {
+  const separator = delimiterArg(delimiter);
+  return gsf.containsWordsStartingWithIgnoreCase(stringArg(text), stringArg(search), separator);
+}
+
+function dateIsToday([date]: Value[]): boolean {
+  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: Value | undefined): number {
+  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: Record<string, ExprFunction> = {
+  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: Record<string, ExprFunction> = {
+  ...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)),
+};
 
-    // '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);
+// --- field methods ------------------------------------------------------------
 
-    const resolve: ExprResolver = (token, record) => this.resolveValue(token, record);
-    return (record: Row) => handler(record, allArgs, resolve);
+// Object.equals: the same Java class and value. A field without a known type
+// equals a value of the same kind.
+function javaEquals(receiver: Value, other: Value): boolean {
+  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;
+}
+
+type FieldMethod = (receiver: Value, args: Value[]) => boolean;
+
+// The receiver of a String method: null throws (the call dereferences it).
+function stringReceiver(receiver: Value): string {
+  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: Record<string, FieldMethod> = {
+  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: unknown, b: unknown): number | undefined {
+  if (!isNullish(a) && !isNullish(b)) return undefined;
+  if (isNullish(a) && isNullish(b)) return 0;
+  return isNullish(a) ? -1 : 1;
+}
+
+function fromOrder(op: string, order: number): boolean {
+  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: Value): number | undefined {
+  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: string, a: Value, b: Value): boolean {
+  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: Value) =>
+    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: Value) =>
+  operand.value instanceof DateTimeValue || operand.value instanceof LocalDateValue;
+
+function compareValues(op: string, left: Value, right: Value): boolean {
+  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 as any) > (b as any);
+    case '>=':
+      return (a as any) >= (b as any);
+    case '<':
+      return (a as any) < (b as any);
+    default:
+      return (a as any) <= (b as any);
+  }
+}
+
+// --- evaluation -------------------------------------------------------------------
+
+type Evaluator = (record: Row) => Value;
+
+// A field as the entity's getter returns it: a DateTime for DATE and
+// DATETIME, a String for STRING and ENUM.
+function readField(name: string, type: JavaType | undefined, record: Row): Value {
+  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: Node, options: CriteriaOptions): Evaluator {
+  switch (node.kind) {
+    case 'literal': {
+      const value: 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: JavaType, args: Value[]): unknown {
+  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: Extract<Node, { kind: 'call' }>, options: CriteriaOptions): Evaluator {
+  const args = node.args.map((arg) => compileNode(arg, options));
+  const readArgs = (record: Row) => 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)]) });
 }
 
 export interface ParsedCriteria {
@@ -372,29 +800,41 @@ export interface ParsedCriteria {
 
 // 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?: string | null): ParsedCriteria {
+// grammar doesn't have. A blank criteria matches everything. A row the
+// criteria throws on (gsfExpr.ts) doesn't match.
+export function parseCriteria(
+  criteria?: string | null,
+  options: CriteriaOptions = {},
+): ParsedCriteria {
   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: 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?: string | null): Predicate {
+export function compileCriteria(
+  criteria?: string | null,
+  options: CriteriaOptions = {},
+): Predicate {
   // 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}`,
@@ -415,8 +855,12 @@ export function criteriaFields(criteria?: string | null): string[] | undefined {
   }
 }
 
-export function filterByCriteria(rows: Row[], criteria?: string | null): Row[] {
-  const predicate = compileCriteria(criteria);
+export function filterByCriteria(
+  rows: Row[],
+  criteria?: string | null,
+  options: CriteriaOptions = {},
+): Row[] {
+  const predicate = compileCriteria(criteria, options);
   return rows.filter((row) => {
     try {
       return predicate(row);
@@ -425,3 +869,248 @@ export function filterByCriteria(rows: Row[], criteria?: string | null): Row[] {
     }
   });
 }
+
+// --- GSF's compilation ------------------------------------------------------------
+
+type Signature = JavaType[];
+
+const S: JavaType = 'String';
+const DATE_OVERLOADS: Signature[] = [
+  [S, S],
+  ['Long', S],
+  ['DateTime', S],
+];
+
+// Expr.java's overloads, and what each function returns.
+const EXPR_SIGNATURES: Record<string, { overloads: Signature[]; returns: JavaType }> = {
+  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' as JavaType }]),
+  ),
+  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: Signature[] = [['Object']];
+const TODAY: Signature[] = [[]];
+
+// 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: Partial<Record<JavaType, Record<string, Signature[]>>> = {
+  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<JavaType>(['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: JavaType, param: JavaType): boolean {
+  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<JavaType>([
+  '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: JavaType, right: JavaType): boolean {
+  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: Signature[], args: Array<JavaType | undefined>): void {
+  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: Node,
+  types: ReadonlyMap<string, string> | undefined,
+): JavaType | undefined {
+  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: string, upperFirst: boolean): string {
+  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: string, type: string | undefined): string {
+  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: string) => 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: string,
+  fields: Iterable<string>,
+  types?: ReadonlyMap<string, string>,
+): string {
+  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: string,
+  types?: ReadonlyMap<string, string>,
+): string | undefined {
+  let parsed: { root: Node; fields: string[] };
+  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);
+}