@briza/illogical 2.0.2 → 2.1.0

package/lib/illogical.esm.js

@@ -21,6 +21,30 @@ function _toPropertyKey(t) {
   return "symbol" == typeof i ? i : i + "";
 }
 
+/**
+ * Valid types for context members
+ */
+
+/**
+ * Evaluation Context
+ * Holds references used during the evaluation process.
+ * Format: key: value.
+ */
+
+/**
+ * Evaluation result
+ */
+
+let EvaluableType = /*#__PURE__*/function (EvaluableType) {
+  EvaluableType["Operand"] = "Operand";
+  EvaluableType["Expression"] = "Expression";
+  return EvaluableType;
+}({});
+
+/**
+ * Evaluable
+ */
+
 /**
  * Is number predicate.
  * @param value Tested value.
@@ -94,30 +118,6 @@ function areAllNumbers(results) {
   return results.every(isNumber);
 }
 
-/**
- * Valid types for context members
- */
-
-/**
- * Evaluation Context
- * Holds references used during the evaluation process.
- * Format: key: value.
- */
-
-/**
- * Evaluation result
- */
-
-let EvaluableType = /*#__PURE__*/function (EvaluableType) {
-  EvaluableType["Operand"] = "Operand";
-  EvaluableType["Expression"] = "Expression";
-  return EvaluableType;
-}({});
-
-/**
- * Evaluable
- */
-
 /**
  * Abstract arithmetic expression
  */
@@ -233,20 +233,20 @@ class Divide extends Arithmetic {
   }
 }
 
-const getNumDecimals = num => {
+const getNumDecimals$1 = num => {
   const numberSplit = num.toString().split('.');
   return numberSplit.length == 2 ? numberSplit[1].length : 0;
 };
-const operateWithExpectedDecimals = operation => (first, second) => {
-  const numDecimals1 = getNumDecimals(first);
-  const numDecimals2 = getNumDecimals(second);
+const operateWithExpectedDecimals$1 = operation => (first, second) => {
+  const numDecimals1 = getNumDecimals$1(first);
+  const numDecimals2 = getNumDecimals$1(second);
   const maxDecimals = operation === 'multiply' ? numDecimals1 + numDecimals2 : numDecimals1 > numDecimals2 ? numDecimals1 : numDecimals2;
   return operation === 'sum' ? Number((first + second).toFixed(maxDecimals)) : operation === 'subtract' ? Number((first - second).toFixed(maxDecimals)) : Number((first * second).toFixed(maxDecimals));
 };
 
 // Operator key
 const OPERATOR$k = Symbol('MULTIPLY');
-const multiplyWithExpectedDecimals = operateWithExpectedDecimals('multiply');
+const multiplyWithExpectedDecimals = operateWithExpectedDecimals$1('multiply');
 
 /**
  * Multiply operation expression
@@ -278,7 +278,7 @@ class Multiply extends Arithmetic {
 
 // Operator key
 const OPERATOR$j = Symbol('SUBTRACT');
-const subtractWithExpectedDecimals = operateWithExpectedDecimals('subtract');
+const subtractWithExpectedDecimals = operateWithExpectedDecimals$1('subtract');
 
 /**
  * Subtract operation expression
@@ -310,7 +310,7 @@ class Subtract extends Arithmetic {
 
 // Operator key
 const OPERATOR$i = Symbol('SUM');
-const addWithExpectedDecimals = operateWithExpectedDecimals('sum');
+const addWithExpectedDecimals = operateWithExpectedDecimals$1('sum');
 
 /**
  * Sum operation expression
@@ -411,6 +411,7 @@ class Value extends Operand {
    * {@link Evaluable.serialize}
    */
   serialize() {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     return this.value;
   }
 
@@ -464,21 +465,21 @@ const toDateNumber = value => {
   return NaN;
 };
 
-const keyWithArrayIndexRegex = /^(?<currentKey>[^[\]]+?)(?<indexes>(?:\[\d+])+)?$/;
-const arrayIndexRegex = /\[(\d+)]/g;
-function parseBacktickWrappedKey(key) {
+const keyWithArrayIndexRegex$1 = /^(?<currentKey>[^[\]]+?)(?<indexes>(?:\[\d+])+)?$/;
+const arrayIndexRegex$1 = /\[(\d+)]/g;
+function parseBacktickWrappedKey$1(key) {
   return key[0] === '`' && key[key.length - 1] === '`' ? key.slice(1, -1) : key;
 }
-function parseKeyComponents(key) {
-  const unwrappedKey = parseBacktickWrappedKey(key);
+function parseKeyComponents$1(key) {
+  const unwrappedKey = parseBacktickWrappedKey$1(key);
   const keys = [];
-  const parseResult = keyWithArrayIndexRegex.exec(unwrappedKey);
+  const parseResult = keyWithArrayIndexRegex$1.exec(unwrappedKey);
   if (parseResult) {
-    const extractedKey = parseBacktickWrappedKey(parseResult?.groups?.currentKey ?? unwrappedKey);
+    const extractedKey = parseBacktickWrappedKey$1(parseResult?.groups?.currentKey ?? unwrappedKey);
     keys.push(extractedKey);
     const rawIndexes = parseResult?.groups?.indexes;
     if (rawIndexes) {
-      for (const indexResult of rawIndexes.matchAll(arrayIndexRegex)) {
+      for (const indexResult of rawIndexes.matchAll(arrayIndexRegex$1)) {
         keys.push(parseInt(indexResult[1]));
       }
     }
@@ -487,10 +488,10 @@ function parseKeyComponents(key) {
   }
   return keys;
 }
-const parseKeyRegex = /(`[^[\]]+`(\[\d+\])*|[^`.]+)/g;
+const parseKeyRegex$1 = /(`[^[\]]+`(\[\d+\])*|[^`.]+)/g;
 function parseKey(key) {
-  const keys = key.match(parseKeyRegex);
-  return !keys ? [] : keys.flatMap(parseKeyComponents);
+  const keys = key.match(parseKeyRegex$1);
+  return !keys ? [] : keys.flatMap(parseKeyComponents$1);
 }
 const complexKeyExpression = /{([^{}]+)}/;
 function extractComplexKeys(ctx, key) {
@@ -546,9 +547,12 @@ let DataType = /*#__PURE__*/function (DataType) {
 }({});
 
 // Equivalent to /^.+\.\((Number|String)\)$/
-const dataTypeRegex = new RegExp(`^.+\\.\\((${Object.keys(DataType).join('|')})\\)$`);
+const dataTypeRegex$1 = new RegExp(`^.+\\.\\((${Object.keys(DataType).join('|')})\\)$`);
 const isComplexKey = key => key.indexOf('{') > -1;
-const castingRegex = /\.\(.+\)$/;
+function isDataTypeKey$1(k) {
+  return k in DataType;
+}
+const castingRegex$1 = /\.\(.+\)$/;
 
 /**
  * Reference operand resolved within the context
@@ -568,10 +572,13 @@ class Reference extends Operand {
     _defineProperty(this, "valueLookup", void 0);
     _defineProperty(this, "getKeys", void 0);
     this.key = key;
-    const dataTypeMatch = dataTypeRegex.exec(this.key);
+    const dataTypeMatch = dataTypeRegex$1.exec(this.key);
     if (dataTypeMatch) {
-      this.dataType = DataType[dataTypeMatch[1]];
-      this.key = this.key.replace(castingRegex, '');
+      const dtKey = dataTypeMatch[1];
+      if (isDataTypeKey$1(dtKey)) {
+        this.dataType = DataType[dtKey];
+      }
+      this.key = this.key.replace(castingRegex$1, '');
     }
     if (isComplexKey(this.key)) {
       this.valueLookup = context => complexValueLookup(context, this.key);
@@ -859,10 +866,13 @@ class In extends Comparison {
     if (!leftArray && !rightArray) {
       throw new Error('invalid IN expression, non of the operands is array');
     }
-    if (leftArray) {
+    if (Array.isArray(left)) {
       return left.indexOf(right) > -1;
     }
-    return right.indexOf(left) > -1;
+    if (Array.isArray(right)) {
+      return right.indexOf(left) > -1;
+    }
+    return false;
   }
 
   /**
@@ -1014,10 +1024,13 @@ class NotIn extends Comparison {
     if (!leftArray && !rightArray) {
       throw new Error('invalid NOT IN expression, one operand must be array');
     }
-    if (leftArray) {
+    if (Array.isArray(left)) {
       return left.indexOf(right) === -1;
     }
-    return right.indexOf(left) === -1;
+    if (Array.isArray(right)) {
+      return right.indexOf(left) === -1;
+    }
+    return true;
   }
 
   /**
@@ -1064,12 +1077,10 @@ class Overlap extends Comparison {
     if (!Array.isArray(left) || !Array.isArray(right)) {
       throw new Error('invalid OVERLAP expression, both operands must be array');
     }
-    const leftArray = left;
-    const rightArray = right;
-    if (leftArray.length === 0 && rightArray.length === 0) {
+    if (left.length === 0 && right.length === 0) {
       return true;
     }
-    return leftArray.some(element => rightArray.includes(element));
+    return left.some(element => right.includes(element));
   }
 
   /**
@@ -1568,11 +1579,8 @@ class Xor extends Logical {
   evaluate(ctx) {
     let res = null;
     for (const operand of this.operands) {
-      if (res === null) {
-        res = operand.evaluate(ctx);
-      } else {
-        res = xor(res, operand.evaluate(ctx));
-      }
+      const val = Boolean(operand.evaluate(ctx));
+      res = res === null ? val : xor(res, val);
     }
     return res;
   }
@@ -1614,147 +1622,3108 @@ class Xor extends Logical {
 }
 
 /**
- * Collection operand resolved containing mixture of value and references.
+ * Bytecode opcodes for the illogical expression interpreter.
+ *
+ * Each opcode is a small integer. Some opcodes consume the next element(s)
+ * in the bytecode array as operand data (e.g. OP_PUSH_VALUE reads the next
+ * element as the literal value to push).
  */
-class Collection extends Operand {
-  /**
-   * Get the items in the collection.
-   * @returns {Array<Value | Reference>}
-   */
-  getItems() {
-    return this.items;
-  }
 
-  /**
-   * @constructor
-   * @param {Operand[]} items Collection of operands.
-   */
-  constructor(items) {
-    super();
-    _defineProperty(this, "items", void 0);
-    this.items = items;
+const OP_PUSH_VALUE = 1; // next: literal — push literal onto stack
+const OP_PUSH_REF_KEY = 6; // next: index into refs (CompactRef string) — ctx[key]
+const OP_PUSH_REF_KEYS = 7; // next: index into refs (CompactRef string[]) — inline multi-key walk
+const OP_PUSH_REF_TOKENS = 8; // next: index into refs (CompactRef token/dataType obj) — token walk
+const OP_PUSH_REF_DYNAMIC = 9; // next: index into refs (CompactRef dynamic obj) — runtime substitution
+const OP_MAKE_COLLECTION = 3; // next: N — pop N items, push as array
+const OP_PUSH_CONST = 4; // next: constIdx — push consts[constIdx] (static array) onto stack
+const OP_OVERLAP_CONST = 5; // next: constIdx — pop dynamic array, Set-intersect against consts[constIdx]
+
+const OP_EQ = 10; // pop 2, push (left === right)
+const OP_NE = 11; // pop 2, push (left !== right)
+const OP_GT = 12; // pop 2, push (left > right), with date fallback
+const OP_GE = 13; // pop 2, push (left >= right), with date fallback
+const OP_LT = 14; // pop 2, push (left < right), with date fallback
+const OP_LE = 15; // pop 2, push (left <= right), with date fallback
+const OP_IN = 16; // pop 2, push membership check (one must be array) — dynamic fallback
+const OP_NOT_IN = 17; // pop 2, push non-membership check — dynamic fallback
+const OP_IN_COLLECTION = 45; // next: N — pop scalar, scan N stack items, push membership result
+const OP_NOT_IN_COLLECTION = 46; // next: N — pop scalar, scan N stack items, push non-membership result
+const OP_IN_CONST = 49; // next: constIdx — pop scalar, Set-lookup in consts[constIdx], push membership result
+const OP_NOT_IN_CONST = 50; // next: constIdx — pop scalar, Set-lookup in consts[constIdx], push !membership
+// next: N, ref0..refN-1, constIdx — resolve each ref inline against Set, no stack alloc
+const OP_OVERLAP_SCAN_REFS_CONST = 51;
+// next: ref1Idx, ref2Idx, M, v0, setBIdx0, v1, setBIdx1, ..., vM-1, setBIdxM-1
+// Inverted-index form: M entries of (literal setA value, constIdx of merged setB).
+// At runtime: resolve ref1, look up matching entries by value (O(1) via cached Map),
+// for each match check ref2 ∈ mergedSetB. Refs resolved once; setBs union-merged per setA value.
+const OP_OR_AND_IN_CONST_2 = 52;
+const OP_PREFIX = 18; // pop 2, push right.startsWith(left)
+const OP_SUFFIX = 19; // pop 2, push left.endsWith(right)
+const OP_OVERLAP = 20; // pop 2, push array intersection check
+const OP_PRESENT = 21; // pop 1, push (value !== undefined && value !== null)
+const OP_UNDEFINED = 22; // pop 1, push (value === undefined)
+
+const OP_SUM = 30; // next: N — pop N numbers, push decimal-corrected sum
+const OP_SUBTRACT = 31; // next: N — pop N numbers, push decimal-corrected subtraction
+const OP_MULTIPLY = 32; // next: N — pop N numbers, push decimal-corrected multiplication
+const OP_DIVIDE = 33; // next: N — pop N numbers, push division result
+
+const OP_STORE_LOCAL = 47; // next: slot — peek top of stack, store into locals[slot]
+const OP_LOAD_LOCAL = 48; // next: slot — push locals[slot] onto stack
+
+const OP_NOT = 40; // pop 1 boolean, push negation
+const OP_JUMP_IF_FALSE = 41; // next: offset — peek stack; if false jump forward by offset
+const OP_JUMP_IF_TRUE = 42; // next: offset — peek stack; if true jump forward by offset
+const OP_POP = 43; // pop and discard top of stack
+const OP_XOR = 44; // pop 2 booleans, push (a || b) && !(a && b)
+
+// Logical marker opcodes — emitted after the short-circuit sequence.
+// The evaluate interpreter skips them (consumes the operand count byte).
+// The simplify interpreter uses them to identify the operator and arity for residual reconstruction.
+const OP_AND = 53; // next: N — marker for AND with N operands
+const OP_OR = 54; // next: N — marker for OR with N operands
+const OP_NOR = 55; // next: N — marker for NOR with N operands
+// next: N, ref0..refN-1, constIdx — resolve each ref inline, check ∈ consts[constIdx], no stack alloc
+const OP_IN_SCAN_REFS_CONST = 56;
+// next: N, ref0..refN-1, constIdx — resolve each ref inline, check ∉ consts[constIdx], no stack alloc
+const OP_NOT_IN_SCAN_REFS_CONST = 57;
+
+/**
+ * Reference path descriptors for the bytecode compiler and interpreter.
+ *
+ * CompactRef is the single runtime type stored in CompiledExpression.refs.
+ * The compiler picks the right opcode per ref kind so the interpreter
+ * dispatches to a dedicated handler with no secondary branching.
+ *
+ *   string          — OP_PUSH_REF_KEY    — ctx[key]
+ *   string[]        — OP_PUSH_REF_KEYS   — inline multi-key walk
+ *   CompactRefFull (tokens)  — OP_PUSH_REF_TOKENS  — token walk + optional cast
+ *   CompactRefFull (dynamic) — OP_PUSH_REF_DYNAMIC — runtime {placeholder} substitution
+ */
+
+
+// array index: [0]
+
+/** Full compact form for refs that don't fit the short string/string[] forms. */
+
+/**
+ * Runtime ref representation stored in CompiledExpression.refs:
+ *   - `string`         → single plain-key (most common)
+ *   - `string[]`       → multi-key inline path
+ *   - `CompactRefFull` → token-based or dynamic
+ */
+
+// ---------------------------------------------------------------------------
+// Regex — parsed once at compile time
+// ---------------------------------------------------------------------------
+const keyWithArrayIndexRegex = /^(?<currentKey>[^[\]]+?)(?<indexes>(?:\[\d+])+)?$/;
+const arrayIndexRegex = /\[(\d+)]/g;
+const parseKeyRegex = /(`[^[\]]+`(\[\d+\])*|[^`.]+)/g;
+const dataTypeRegex = new RegExp(`^.+\\.\\((${Object.keys(DataType).join('|')})\\)$`);
+const castingRegex = /\.\(.+\)$/;
+function parseBacktickWrappedKey(key) {
+  return key[0] === '`' && key[key.length - 1] === '`' ? key.slice(1, -1) : key;
+}
+function parseKeyComponents(key) {
+  const unwrapped = parseBacktickWrappedKey(key);
+  const tokens = [];
+  const match = keyWithArrayIndexRegex.exec(unwrapped);
+  if (match) {
+    tokens.push({
+      kind: 'key',
+      value: parseBacktickWrappedKey(match.groups?.currentKey ?? unwrapped)
+    });
+    const rawIndexes = match.groups?.indexes;
+    if (rawIndexes) {
+      for (const idxMatch of rawIndexes.matchAll(arrayIndexRegex)) {
+        tokens.push({
+          kind: 'index',
+          value: parseInt(idxMatch[1])
+        });
+      }
+    }
+  } else {
+    tokens.push({
+      kind: 'key',
+      value: unwrapped
+    });
   }
+  return tokens;
+}
+function parseStaticKey(key) {
+  const parts = key.match(parseKeyRegex);
+  return !parts ? [] : parts.flatMap(parseKeyComponents);
+}
+function isDataTypeKey(k) {
+  return k in DataType;
+}
 
-  /**
-   * Evaluate in the given context.
-   * @param {Context} ctx
-   * @return {boolean}
-   */
-  evaluate(ctx) {
-    return this.items.map(item => item.evaluate(ctx));
+/**
+ * Build a CompactRef from a raw reference key string (without the $ prefix).
+ * Called once at compile time; the result is stored in CompiledExpression.refs.
+ */
+function buildCompactRef(rawKey) {
+  let key = rawKey;
+  let dataType;
+  const dataTypeMatch = dataTypeRegex.exec(key);
+  if (dataTypeMatch) {
+    const dtKey = dataTypeMatch[1];
+    if (!isDataTypeKey(dtKey)) {
+      throw new Error(`unknown DataType: ${dtKey}`);
+    }
+    dataType = DataType[dtKey];
+    key = key.replace(castingRegex, '');
   }
+  const hasDynamic = key.indexOf('{') > -1;
+  if (hasDynamic) {
+    const full = {
+      k: key,
+      d: true
+    };
+    if (dataType !== undefined) {
+      full.t = dataType;
+    }
+    return full;
+  }
+  const tokens = parseStaticKey(key);
 
-  /**
-   * {@link Evaluable.simplify}
-   */
-  simplify(...args) {
-    const values = [];
-    for (const item of this.items) {
-      const simplifiedItem = item.simplify(...args);
-      if (isEvaluable(simplifiedItem)) {
-        return this;
-      }
-      values.push(simplifiedItem);
+  // Pure key-only path with no dataType → string or string[]
+  if (!dataType && tokens.every(t => t.kind === 'key')) {
+    if (tokens.length === 1) {
+      return tokens[0].value;
     }
-    return values;
+    return tokens.map(t => t.value);
   }
 
-  /**
-   * {@link Evaluable.serialize}
-   */
-  serialize(options) {
-    return this.items.map(item => isEvaluable(item) ? item.serialize(options) : item);
+  // Token-based path (array indexes) or dataType cast
+  const full = {
+    tokens
+  };
+  if (dataType !== undefined) {
+    full.t = dataType;
   }
+  return full;
+}
 
-  /**
-   * Get the strict representation of the operand.
-   * @return {string}
-   */
-  toString() {
-    return '[' + this.items.map(item => item.toString()).join(', ') + ']';
+// ---------------------------------------------------------------------------
+// Runtime resolution — called by the interpreter on every evaluate()
+// ---------------------------------------------------------------------------
+
+function castValue(value, dataType) {
+  let result;
+  if (dataType === DataType.Number) {
+    result = toNumber(value);
+  } else {
+    result = toString(value);
+  }
+  if (value && result === undefined) {
+    console.warn(`Casting ${value} to ${dataType} resulted in ${result}`);
   }
+  return result;
 }
 
-// Option value whitelist
+// Matches the innermost {ref} — non-nested braces only
+const dynamicKeyRegex = /{([^{}]+)}/;
 
-// Parser options
+/** Type-safe property access on an object narrowed from `unknown`. */
+function propAt(obj, key) {
+  return Reflect.get(obj, key);
+}
+
+/** Narrow a CompactRef to its string form (OP_PUSH_REF_KEY). Throws on mismatch. */
+function asKeyRef(ref) {
+  if (typeof ref !== 'string') {
+    throw new Error('bytecode integrity: expected string ref');
+  }
+  return ref;
+}
+
+/** Narrow a CompactRef to its string[] form (OP_PUSH_REF_KEYS). Throws on mismatch. */
+function asKeysRef(ref) {
+  if (!Array.isArray(ref)) {
+    throw new Error('bytecode integrity: expected string[] ref');
+  }
+  return ref;
+}
+
+/** Narrow a CompactRef to CompactRefFull (OP_PUSH_REF_TOKENS / OP_PUSH_REF_DYNAMIC). Throws on mismatch. */
+function asFullRef(ref) {
+  if (typeof ref === 'string' || Array.isArray(ref)) {
+    throw new Error('bytecode integrity: expected CompactRefFull ref');
+  }
+  return ref;
+}
 
 /**
- * Default reference predicate.
- * The "$" symbol at the begging of the operand is used
- * to predicate the reference type.
- * E.g. "$State", "$Country"
- * @param {string} key
- * @return {boolean}
+ * Resolve a multi-key inline path (string[]) against a context.
+ * Used by OP_PUSH_REF_KEYS and OP_PUSH_REF_DYNAMIC (after substitution).
  */
-function defaultReferencePredicate(key) {
-  return key[0] === '$';
+function resolveKeys(ks, ctx) {
+  const p0 = ctx[ks[0]];
+  if (ks.length === 1) {
+    return p0;
+  }
+  if (p0 === undefined || p0 === null || typeof p0 !== 'object' || Array.isArray(p0)) {
+    return undefined;
+  }
+  const p1 = propAt(p0, ks[1]);
+  if (ks.length === 2) {
+    return p1;
+  }
+  if (p1 === undefined || p1 === null || typeof p1 !== 'object' || Array.isArray(p1)) {
+    return undefined;
+  }
+  const p2 = propAt(p1, ks[2]);
+  if (ks.length === 3) {
+    return p2;
+  }
+  let p = p2;
+  for (let k = 3; k < ks.length; k++) {
+    if (p === undefined || p === null || typeof p !== 'object' || Array.isArray(p)) {
+      return undefined;
+    }
+    p = propAt(p, ks[k]);
+  }
+  return p;
 }
 
 /**
- * Default reference transform.
- * It removes the "$" symbol at the begging of the operand name.
- * @param {string} key
- * @return {string}
+ * Resolve a token-based path against a context.
+ * Used by OP_PUSH_REF_TOKENS.
  */
-function defaultReferenceTransform(key) {
-  return key.slice(1);
+function resolveTokens(tokens, dataType, ctx) {
+  const len = tokens.length;
+  let pointer = ctx;
+  for (let i = 0; i < len; i++) {
+    const token = tokens[i];
+    if (pointer === undefined || pointer === null) {
+      return dataType !== undefined ? castValue(undefined, dataType) : undefined;
+    }
+    if (token.kind === 'key') {
+      if (typeof pointer !== 'object' || Array.isArray(pointer)) {
+        return dataType !== undefined ? castValue(undefined, dataType) : undefined;
+      }
+      pointer = propAt(pointer, token.value);
+    } else {
+      if (!Array.isArray(pointer)) {
+        return dataType !== undefined ? castValue(undefined, dataType) : undefined;
+      }
+      pointer = pointer[token.value];
+    }
+  }
+  return dataType !== undefined ? castValue(pointer, dataType) : pointer;
 }
-function defaultReferenceSerialization(key) {
-  return `$${key}`;
+
+/**
+ * Resolve a dynamic ref (with {placeholder} substitution) against a context.
+ * Used by OP_PUSH_REF_DYNAMIC.
+ */
+function resolveDynamic(key, dataType, ctx) {
+  let current = key;
+  let match = dynamicKeyRegex.exec(current);
+  while (match) {
+    const inner = resolveTokens(parseStaticKey(match[1]), undefined, ctx);
+    if (inner === undefined) {
+      return undefined;
+    }
+    current = current.replace(dynamicKeyRegex, `${inner}`);
+    match = dynamicKeyRegex.exec(current);
+  }
+  const tokens = parseStaticKey(current);
+  const raw = resolveTokens(tokens, undefined, ctx);
+  return dataType !== undefined ? castValue(raw, dataType) : raw;
 }
 
-// Default operator mapping
-// Unique operator key <-> raw expression key
-const defaultOperatorMapping = new Map([
-// Comparison
-[OPERATOR$h, '=='], [OPERATOR$b, '!='], [OPERATOR$f, '>'], [OPERATOR$g, '>='], [OPERATOR$c, '<'], [OPERATOR$d, '<='], [OPERATOR$e, 'IN'], [OPERATOR$a, 'NOT IN'], [OPERATOR$8, 'PREFIX'], [OPERATOR$6, 'SUFFIX'], [OPERATOR$9, 'OVERLAP'], [OPERATOR$5, 'UNDEFINED'], [OPERATOR$7, 'PRESENT'],
-// Logical
-[OPERATOR$4, 'AND'], [OPERATOR$1, 'OR'], [OPERATOR$2, 'NOR'], [OPERATOR, 'XOR'], [OPERATOR$3, 'NOT'],
-// Arithmetic
-[OPERATOR$i, '+'], [OPERATOR$j, '-'], [OPERATOR$k, '*'], [OPERATOR$l, '/']]);
+/**
+ * Resolve any CompactRef against a context.
+ * Used in ops that embed ref indices but weren't split by kind
+ * (OP_OVERLAP_SCAN_REFS_CONST, OP_OR_AND_IN_CONST_2).
+ */
+function resolveCompactRef(ref, ctx) {
+  if (typeof ref === 'string') {
+    return ctx[ref];
+  }
+  if (Array.isArray(ref)) {
+    return resolveKeys(ref, ctx);
+  }
+  if (ref.d) {
+    return resolveDynamic(ref.k, ref.t, ctx);
+  }
+  return resolveTokens(ref.tokens ?? [], ref.t, ctx);
+}
 
 /**
- * Default parser options
+ * Bytecode compiler.
+ *
+ * Transforms a raw ExpressionInput (plain array) into a flat Bytecode array
+ * that the interpreter can execute. This runs once per unique expression;
+ * the result should be cached and reused across evaluate() calls.
  */
-const defaultOptions = {
-  referencePredicate: defaultReferencePredicate,
-  referenceTransform: defaultReferenceTransform,
-  referenceSerialization: defaultReferenceSerialization,
-  operatorMapping: defaultOperatorMapping
-};
 
-// Input types
 
-const invalidExpression = 'invalid expression';
-const logicalIfValidOperands = (operands, logical) => {
-  if (operands.every(operand => operand instanceof Logical || operand instanceof Comparison)) {
-    return logical;
+// Bytecode is a flat array of numbers (opcodes and index operands) interspersed
+// with literal Result values (for OP_PUSH_VALUE).
+
+// Lookup tables built once per Options instance — operator string → opcode.
+// Stored outside emitExpression so they are not recreated on every compile call.
+
+function getOperator(m, op) {
+  const v = m.get(op);
+  if (v === undefined) {
+    throw new Error(`operator mapping missing for symbol ${op.toString()}`);
   }
-  throw new Error(invalidExpression);
-};
+  return v;
+}
+function buildOperatorMaps(opts) {
+  const m = opts.operatorMapping;
+  const get = op => getOperator(m, op);
+  return {
+    binary: {
+      [get(OPERATOR$h)]: OP_EQ,
+      [get(OPERATOR$b)]: OP_NE,
+      [get(OPERATOR$f)]: OP_GT,
+      [get(OPERATOR$g)]: OP_GE,
+      [get(OPERATOR$c)]: OP_LT,
+      [get(OPERATOR$d)]: OP_LE,
+      [get(OPERATOR$e)]: OP_IN,
+      [get(OPERATOR$a)]: OP_NOT_IN,
+      [get(OPERATOR$8)]: OP_PREFIX,
+      [get(OPERATOR$6)]: OP_SUFFIX,
+      [get(OPERATOR$9)]: OP_OVERLAP
+    },
+    arithmetic: {
+      [get(OPERATOR$i)]: OP_SUM,
+      [get(OPERATOR$j)]: OP_SUBTRACT,
+      [get(OPERATOR$k)]: OP_MULTIPLY,
+      [get(OPERATOR$l)]: OP_DIVIDE
+    },
+    presentOp: get(OPERATOR$7),
+    undefinedOp: get(OPERATOR$5),
+    andOp: get(OPERATOR$4),
+    orOp: get(OPERATOR$1),
+    norOp: get(OPERATOR$2),
+    notOp: get(OPERATOR$3),
+    xorOp: get(OPERATOR),
+    inOp: get(OPERATOR$e),
+    notInOp: get(OPERATOR$a),
+    overlapOp: get(OPERATOR$9),
+    eqOp: get(OPERATOR$h)
+  };
+}
+function isStaticCollection(raw, opts) {
+  return Array.isArray(raw) && !raw.some(v => typeof v === 'string' && opts.referencePredicate(v));
+}
+function isPureRefCollection(raw, opts) {
+  return Array.isArray(raw) && raw.length > 0 && raw.every(v => typeof v === 'string' && opts.referencePredicate(v));
+}
+function internConst(items, state) {
+  const key = JSON.stringify(items);
+  let idx = state.constIndex.get(key);
+  if (idx === undefined) {
+    idx = state.consts.length;
+    state.consts.push(items);
+    state.constIndex.set(key, idx);
+  }
+  return idx;
+}
 
 /**
- * Parser of raw expressions into Evaluable expression
+ * Returns the first context key for a multi-key ref (e.g. 'account' for $account.region),
+ * or undefined for single-key refs (no heuristic needed) and dynamic refs (unknowable statically).
+ * Used by the simplify interpreter to replicate OOP Reference.simplify()'s first-key check.
  */
-class Parser {
-  /**
-   * @constructor
-   * @param {Options?} options Parser options.
-   */
-  constructor(options) {
-    _defineProperty(this, "opts", void 0);
-    _defineProperty(this, "expectedRootOperators", void 0);
-    _defineProperty(this, "unexpectedRootSymbols", new Set([OPERATOR$i, OPERATOR$j, OPERATOR$k, OPERATOR$l]));
-    _defineProperty(this, "referenceCache", new Map());
-    this.opts = {
-      ...defaultOptions
-    };
-    // Apply exclusive options overrides
-    if (options) {
-      for (const key of Object.keys(options)) {
-        if (key in this.opts) {
-          this.opts[key] = options[key];
+function getFirstCtxKey(ref) {
+  if (typeof ref === 'string') {
+    return undefined; // single-key ref — OOP checks ctx[key] directly, no first-key shortcut
+  }
+  if (Array.isArray(ref)) {
+    return ref[0]; // multi-key path: first element is the top-level context key
+  }
+  if (ref.d) {
+    return undefined; // dynamic ref with {placeholder}: can't determine first key statically
+  }
+  const tokens = ref.tokens;
+  if (tokens && tokens.length > 0 && tokens[0].kind === 'key') {
+    return tokens[0].value;
+  }
+  return undefined;
+}
+function refOpcode(ref) {
+  if (typeof ref === 'string') {
+    return OP_PUSH_REF_KEY;
+  }
+  if (Array.isArray(ref)) {
+    return OP_PUSH_REF_KEYS;
+  }
+  if (ref.d) {
+    return OP_PUSH_REF_DYNAMIC;
+  }
+  return OP_PUSH_REF_TOKENS;
+}
+function internRef(raw, state) {
+  const key = state.opts.referenceTransform(raw);
+  let refIndex = state.refIndex.get(key);
+  if (refIndex === undefined) {
+    refIndex = state.refs.length;
+    state.refs.push(buildCompactRef(key));
+    state.refIndex.set(key, refIndex);
+    state.refRawKeys.push(key);
+    state.refKeys.push(raw);
+  }
+  return refIndex;
+}
+function emitOperand(raw, state) {
+  const {
+    bytecode,
+    refs,
+    opts
+  } = state;
+  if (Array.isArray(raw)) {
+    const hasDynamic = raw.some(v => typeof v === 'string' && opts.referencePredicate(v));
+    if (hasDynamic) {
+      // CSE: if this dynamic collection has been seen before, reuse the cached local slot
+      const cseKey = JSON.stringify(raw);
+      const existingSlot = state.collectionCse.get(cseKey);
+      if (existingSlot !== undefined) {
+        bytecode.push(OP_LOAD_LOCAL, existingSlot);
+        return;
+      }
+      // First occurrence: emit normally, then store result in a new local slot
+      for (const item of raw) {
+        emitOperand(item, state);
+      }
+      bytecode.push(OP_MAKE_COLLECTION, raw.length);
+      const slot = state.numLocals++;
+      state.collectionCse.set(cseKey, slot);
+      bytecode.push(OP_STORE_LOCAL, slot);
+      return;
+    }
+
+    // Static collection: intern into consts table, emit OP_PUSH_CONST
+    bytecode.push(OP_PUSH_CONST, internConst(raw, state));
+    return;
+  }
+  if (typeof raw === 'string' && opts.referencePredicate(raw)) {
+    const refIndex = internRef(raw, state);
+    bytecode.push(refOpcode(refs[refIndex]), refIndex);
+    return;
+  }
+  bytecode.push(OP_PUSH_VALUE, raw);
+}
+
+/**
+ * Return the ref key and static value array for a branch child that is either:
+ *   IN(ref, [v1, v2, ...])  — ref ∈ static collection
+ *   ==(ref, scalar)         — ref === scalar, treated as IN with [scalar]
+ * Returns null if the child does not match either form.
+ */
+function extractInLikeChild(ca, state) {
+  const op = ca[0];
+  const left = ca[1];
+  if (typeof left !== 'string' || !state.opts.referencePredicate(left)) {
+    return null;
+  }
+  // left is narrowed to string by the guard above
+  const rawRef = left;
+  const refKey = state.opts.referenceTransform(rawRef);
+  if (op === state.maps.inOp) {
+    const right = ca[2];
+    if (!isStaticCollection(right, state.opts)) {
+      return null;
+    }
+    return {
+      rawRef,
+      refKey,
+      vals: right
+    };
+  }
+
+  // == (EQ): scalar equality treated as single-element IN
+  if (op === state.maps.eqOp) {
+    const right = ca[2];
+    if (typeof right === 'string' && state.opts.referencePredicate(right)) {
+      return null;
+    }
+    if (Array.isArray(right)) {
+      return null;
+    }
+    return {
+      rawRef,
+      refKey,
+      vals: [right]
+    };
+  }
+  return null;
+}
+
+/**
+ * Check whether an OR expression matches the pattern:
+ *   OR( AND(IN-like(ref1, set1), IN-like(ref2, set2)), ... )
+ * where IN-like is either IN(ref, staticSet) or ==(ref, scalar),
+ * and every branch uses the exact same two refs in the same order.
+ *
+ * Builds an inverted index: for each unique value in any setA, union-merges all
+ * setB values across branches where that setA value appears, and emits one
+ * (literal value, mergedSetBIdx) entry per distinct setA value.
+ *
+ * This lets the interpreter do a single O(1) Map lookup on ref1 to find all
+ * relevant setB indices, instead of a linear scan through N setA Sets.
+ * Returns null if the pattern does not match.
+ */
+function detectOrAndIn2Pattern(arr, state) {
+  const nBranches = arr.length - 1;
+  if (nBranches < 2) {
+    return null;
+  }
+  let ref1Raw = null;
+  let ref2Raw = null;
+  let refKey1 = null;
+  let refKey2 = null;
+
+  // Inverted index: each distinct setA value → merged setB values across all branches containing it
+  const setBValsByAValue = new Map();
+  for (let b = 1; b <= nBranches; b++) {
+    const branch = arr[b];
+    if (!Array.isArray(branch)) {
+      return null;
+    }
+    if (branch[0] !== state.maps.andOp) {
+      return null;
+    }
+    if (branch.length !== 3) {
+      return null;
+    }
+    let extA = null;
+    let extB = null;
+    for (let c = 1; c <= 2; c++) {
+      const child = branch[c];
+      if (!Array.isArray(child)) {
+        return null;
+      }
+      const extracted = extractInLikeChild(child, state);
+      if (extracted === null) {
+        return null;
+      }
+      const {
+        rawRef,
+        refKey
+      } = extracted;
+      if (c === 1) {
+        extA = extracted;
+        if (b === 1) {
+          ref1Raw = rawRef;
+          refKey1 = refKey;
+        } else if (refKey !== refKey1) {
+          return null;
+        }
+      } else {
+        extB = extracted;
+        if (b === 1) {
+          ref2Raw = rawRef;
+          refKey2 = refKey;
+        } else if (refKey !== refKey2) {
+          return null;
+        }
+      }
+    }
+    if (extA === null || extB === null) {
+      return null;
+    }
+
+    // For each value in setA, union-merge all setB values
+    for (const aVal of extA.vals) {
+      let setBVals = setBValsByAValue.get(aVal);
+      if (setBVals === undefined) {
+        setBVals = new Set();
+        setBValsByAValue.set(aVal, setBVals);
+      }
+      for (const bVal of extB.vals) {
+        setBVals.add(bVal);
+      }
+    }
+  }
+  if (ref1Raw === null || ref2Raw === null) {
+    return null;
+  }
+
+  // Build entries: one (literal aVal, mergedSetBIdx) per distinct setA value
+  const entries = [];
+  for (const [aVal, setBVals] of setBValsByAValue) {
+    const mergedSetB = [...setBVals].filter(v => v !== undefined);
+    entries.push([aVal, internConst(mergedSetB, state)]);
+  }
+  return {
+    ref1Raw,
+    ref2Raw,
+    entries
+  };
+}
+
+// arr[0] is the operator; operands are arr[1..arr.length-1]
+function emitShortCircuit(arr, jumpOp, markerOp, state) {
+  const {
+    bytecode
+  } = state;
+  const jumpSlots = [];
+  const last = arr.length - 1;
+  for (let i = 1; i < last; i++) {
+    emitExpression(arr[i], state);
+    bytecode.push(jumpOp);
+    jumpSlots.push(bytecode.length);
+    bytecode.push(0); // placeholder — backpatched below
+    bytecode.push(OP_POP); // discard result before evaluating next operand
+  }
+  emitExpression(arr[last], state);
+  const end = bytecode.length;
+  for (const slot of jumpSlots) {
+    bytecode[slot] = end - slot - 1;
+  }
+
+  // Emit marker so the simplify interpreter knows the operator and operand count
+  bytecode.push(markerOp, last);
+}
+function emitExpression(raw, state) {
+  const {
+    bytecode,
+    maps
+  } = state;
+  if (!Array.isArray(raw)) {
+    emitOperand(raw, state);
+    return;
+  }
+  const arr = raw;
+  const operator = arr[0];
+  const nOperands = arr.length - 1;
+  if (typeof operator !== 'string') {
+    emitOperand(raw, state);
+    return;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Logical — short-circuit with jump instructions
+  // ---------------------------------------------------------------------------
+  if (operator === maps.andOp) {
+    emitShortCircuit(arr, OP_JUMP_IF_FALSE, OP_AND, state);
+    return;
+  }
+  if (operator === maps.orOp) {
+    const orAnd2 = detectOrAndIn2Pattern(arr, state);
+    if (orAnd2 !== null) {
+      const {
+        ref1Raw,
+        ref2Raw,
+        entries
+      } = orAnd2;
+      const {
+        bytecode
+      } = state;
+      const ref1Idx = internRef(ref1Raw, state);
+      const ref2Idx = internRef(ref2Raw, state);
+      // Emit: OP_OR_AND_IN_CONST_2 ref1Idx ref2Idx M v0 setBIdx0 v1 setBIdx1 ... vM-1 setBIdxM-1
+      // M is the number of distinct setA values across all branches (after inverted-index merge).
+      bytecode.push(OP_OR_AND_IN_CONST_2, ref1Idx, ref2Idx, entries.length);
+      for (const [aVal, mergedSetBIdx] of entries) {
+        bytecode.push(aVal, mergedSetBIdx);
+      }
+      return;
+    }
+    emitShortCircuit(arr, OP_JUMP_IF_TRUE, OP_OR, state);
+    return;
+  }
+  if (operator === maps.norOp) {
+    // NOR = NOT OR: emit as OR with short-circuit, then negate
+    emitShortCircuit(arr, OP_JUMP_IF_TRUE, OP_NOR, state);
+    bytecode.push(OP_NOT);
+    return;
+  }
+  if (operator === maps.notOp) {
+    emitExpression(arr[1], state);
+    bytecode.push(OP_NOT);
+    return;
+  }
+  if (operator === maps.xorOp) {
+    // XOR is associative: chain binary XOR operations
+    // (A XOR B) XOR C XOR D ...
+    emitExpression(arr[1], state);
+    for (let i = 2; i <= nOperands; i++) {
+      emitExpression(arr[i], state);
+      bytecode.push(OP_XOR);
+    }
+    return;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Comparison — binary (left, right)
+  // ---------------------------------------------------------------------------
+
+  // IN / NOT_IN: optimized paths when one operand is a collection
+  if (operator === maps.inOp || operator === maps.notInOp) {
+    const left = arr[1];
+    const right = arr[2];
+    if (Array.isArray(left) && !Array.isArray(right)) {
+      const leftArr = left;
+      const leftHasDynamic = leftArr.some(v => typeof v === 'string' && state.opts.referencePredicate(v));
+      const constOp = operator === maps.inOp ? OP_IN_CONST : OP_NOT_IN_CONST;
+      const collectionOp = operator === maps.inOp ? OP_IN_COLLECTION : OP_NOT_IN_COLLECTION;
+      if (!leftHasDynamic) {
+        // fully static collection on left — intern as const, Set-lookup the scalar
+        emitExpression(right, state);
+        const opcodePos = bytecode.length;
+        bytecode.push(constOp, internConst(leftArr, state));
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 0
+        });
+      } else if (isPureRefCollection(leftArr, state.opts) && !(typeof right === 'string' && state.opts.referencePredicate(right))) {
+        // pure-ref collection on left, concrete scalar on right — inline ref scan, no stack alloc
+        const scanOp = operator === maps.inOp ? OP_IN_SCAN_REFS_CONST : OP_NOT_IN_SCAN_REFS_CONST;
+        const constIdx = internConst([right], state);
+        const opcodePos = bytecode.length;
+        const refIdxs = [];
+        bytecode.push(scanOp, leftArr.length);
+        for (const item of leftArr) {
+          const refIdx = internRef(item, state);
+          bytecode.push(refIdx);
+          refIdxs.push(refIdx);
+        }
+        bytecode.push(constIdx);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 0
+        });
+        state.overlapRefsEntries.push({
+          pos: opcodePos,
+          refIdxs
+        });
+      } else {
+        // mixed dynamic collection on left — inline stack scan
+        for (const item of leftArr) {
+          emitOperand(item, state);
+        }
+        emitExpression(right, state);
+        const opcodePos = bytecode.length;
+        bytecode.push(collectionOp, leftArr.length);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 0
+        });
+      }
+      return;
+    }
+    if (Array.isArray(right) && !Array.isArray(left)) {
+      const rightArr = right;
+      const rightHasDynamic = rightArr.some(v => typeof v === 'string' && state.opts.referencePredicate(v));
+      const constOp = operator === maps.inOp ? OP_IN_CONST : OP_NOT_IN_CONST;
+      const collectionOp = operator === maps.inOp ? OP_IN_COLLECTION : OP_NOT_IN_COLLECTION;
+      if (!rightHasDynamic) {
+        // fully static collection on right — intern as const, Set-lookup the scalar
+        emitExpression(left, state);
+        const opcodePos = bytecode.length;
+        bytecode.push(constOp, internConst(rightArr, state));
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 1
+        });
+      } else if (isPureRefCollection(rightArr, state.opts) && !(typeof left === 'string' && state.opts.referencePredicate(left))) {
+        // pure-ref collection on right, concrete scalar on left — inline ref scan, no stack alloc
+        const scanOp = operator === maps.inOp ? OP_IN_SCAN_REFS_CONST : OP_NOT_IN_SCAN_REFS_CONST;
+        const constIdx = internConst([left], state);
+        const opcodePos = bytecode.length;
+        const refIdxs = [];
+        bytecode.push(scanOp, rightArr.length);
+        for (const item of rightArr) {
+          const refIdx = internRef(item, state);
+          bytecode.push(refIdx);
+          refIdxs.push(refIdx);
+        }
+        bytecode.push(constIdx);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 1
+        });
+        state.overlapRefsEntries.push({
+          pos: opcodePos,
+          refIdxs
+        });
+      } else {
+        // mixed dynamic collection on right — inline stack scan
+        for (const item of rightArr) {
+          emitOperand(item, state);
+        }
+        emitExpression(left, state);
+        const opcodePos = bytecode.length;
+        bytecode.push(collectionOp, rightArr.length);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 1
+        });
+      }
+      return;
+    }
+    // both sides are dynamic (refs) — fall through to generic OP_IN / OP_NOT_IN
+  }
+
+  // OVERLAP: if exactly one operand is a static collection, emit optimized path
+  if (operator === maps.overlapOp) {
+    const left = arr[1];
+    const right = arr[2];
+    if (isStaticCollection(left, state.opts) && !isStaticCollection(right, state.opts)) {
+      const constIdx = internConst(left, state);
+      if (isPureRefCollection(right, state.opts)) {
+        // dynamic side is all refs — inline ref indices, resolve+check at runtime, no stack alloc
+        const opcodePos = bytecode.length;
+        bytecode.push(OP_OVERLAP_SCAN_REFS_CONST, right.length);
+        const refIdxs = [];
+        for (const item of right) {
+          if (typeof item !== 'string') {
+            throw new Error('OVERLAP: expected string ref in pure-ref collection');
+          }
+          const refIdx = internRef(item, state);
+          bytecode.push(refIdx);
+          refIdxs.push(refIdx);
+        }
+        bytecode.push(constIdx);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 0
+        });
+        state.overlapRefsEntries.push({
+          pos: opcodePos,
+          refIdxs
+        });
+      } else {
+        emitExpression(right, state);
+        const opcodePos = bytecode.length;
+        bytecode.push(OP_OVERLAP_CONST, constIdx);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 0
+        });
+      }
+      return;
+    }
+    if (isStaticCollection(right, state.opts) && !isStaticCollection(left, state.opts)) {
+      const constIdx = internConst(right, state);
+      if (isPureRefCollection(left, state.opts)) {
+        // dynamic side is all refs — inline ref indices, resolve+check at runtime, no stack alloc
+        const opcodePos = bytecode.length;
+        bytecode.push(OP_OVERLAP_SCAN_REFS_CONST, left.length);
+        const refIdxs = [];
+        for (const item of left) {
+          if (typeof item !== 'string') {
+            throw new Error('OVERLAP: expected string ref in pure-ref collection');
+          }
+          const refIdx = internRef(item, state);
+          bytecode.push(refIdx);
+          refIdxs.push(refIdx);
+        }
+        bytecode.push(constIdx);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 1
+        });
+        state.overlapRefsEntries.push({
+          pos: opcodePos,
+          refIdxs
+        });
+      } else {
+        emitExpression(left, state);
+        const opcodePos = bytecode.length;
+        bytecode.push(OP_OVERLAP_CONST, constIdx);
+        state.directionEntries.push({
+          pos: opcodePos,
+          dir: 1
+        });
+      }
+      return;
+    }
+    // Both static or both dynamic: fall through to generic OP_OVERLAP
+  }
+  if (operator in maps.binary) {
+    emitExpression(arr[1], state);
+    emitExpression(arr[2], state);
+    bytecode.push(maps.binary[operator]);
+    return;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Unary comparison
+  // ---------------------------------------------------------------------------
+  if (operator === maps.presentOp) {
+    emitExpression(arr[1], state);
+    bytecode.push(OP_PRESENT);
+    return;
+  }
+  if (operator === maps.undefinedOp) {
+    emitExpression(arr[1], state);
+    bytecode.push(OP_UNDEFINED);
+    return;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Arithmetic — N operands
+  // ---------------------------------------------------------------------------
+  if (operator in maps.arithmetic) {
+    for (let i = 1; i <= nOperands; i++) {
+      emitExpression(arr[i], state);
+    }
+    bytecode.push(maps.arithmetic[operator], nOperands);
+    return;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Fallback: treat as collection (array of values/refs)
+  // ---------------------------------------------------------------------------
+  emitOperand(raw, state);
+}
+/**
+ * Compile a raw ExpressionInput into bytecode.
+ * The result should be cached and reused across evaluate() calls.
+ */
+function compile(raw, opts) {
+  const maps = buildOperatorMaps(opts);
+  const state = {
+    bytecode: [],
+    refs: [],
+    refIndex: new Map(),
+    refRawKeys: [],
+    refKeys: [],
+    opts,
+    maps,
+    collectionCse: new Map(),
+    numLocals: 0,
+    consts: [],
+    constIndex: new Map(),
+    overlapRefsEntries: [],
+    directionEntries: []
+  };
+  emitExpression(raw, state);
+
+  // Build reverse map: opcode → operator string for residual reconstruction
+  const opNames = {};
+  for (const [str, code] of Object.entries(maps.binary)) {
+    opNames[code] = str;
+  }
+  for (const [str, code] of Object.entries(maps.arithmetic)) {
+    opNames[code] = str;
+  }
+  opNames[OP_NOT] = maps.notOp;
+  opNames[OP_AND] = maps.andOp;
+  opNames[OP_OR] = maps.orOp;
+  opNames[OP_NOR] = maps.norOp;
+  opNames[OP_XOR] = maps.xorOp;
+  opNames[OP_PRESENT] = maps.presentOp;
+  opNames[OP_UNDEFINED] = maps.undefinedOp;
+  opNames[OP_IN_COLLECTION] = maps.inOp;
+  opNames[OP_NOT_IN_COLLECTION] = maps.notInOp;
+  opNames[OP_IN_CONST] = maps.inOp;
+  opNames[OP_NOT_IN_CONST] = maps.notInOp;
+  opNames[OP_OVERLAP_CONST] = maps.overlapOp;
+  opNames[OP_OVERLAP_SCAN_REFS_CONST] = maps.overlapOp;
+  opNames[OP_IN_SCAN_REFS_CONST] = maps.inOp;
+  opNames[OP_NOT_IN_SCAN_REFS_CONST] = maps.notInOp;
+
+  // Pre-build residual Input[] arrays for OP_OVERLAP_SCAN_REFS_CONST — eliminates per-call allocation in the simplifier
+  const overlapRefsResiduals = state.overlapRefsEntries.map(({
+    pos,
+    refIdxs
+  }) => [pos, refIdxs.map(idx => state.refKeys[idx])]);
+
+  // Build direction entries as serializable tuple array
+  const directionMap = state.directionEntries.map(({
+    pos,
+    dir
+  }) => [pos, dir]);
+  return {
+    bytecode: state.bytecode,
+    refs: state.refs,
+    numLocals: state.numLocals,
+    consts: state.consts,
+    opNames,
+    refKeys: state.refKeys,
+    refRawKeys: state.refRawKeys,
+    overlapRefsResiduals,
+    directionMap,
+    refFirstCtxKeys: state.refs.map(getFirstCtxKey)
+  };
+}
+
+const getNumDecimals = num => {
+  const numberSplit = num.toString().split('.');
+  return numberSplit.length == 2 ? numberSplit[1].length : 0;
+};
+const operateWithExpectedDecimals = operation => (first, second) => {
+  const numDecimals1 = getNumDecimals(first);
+  const numDecimals2 = getNumDecimals(second);
+  const maxDecimals = operation === 'multiply' ? numDecimals1 + numDecimals2 : numDecimals1 > numDecimals2 ? numDecimals1 : numDecimals2;
+  return operation === 'sum' ? Number((first + second).toFixed(maxDecimals)) : operation === 'subtract' ? Number((first - second).toFixed(maxDecimals)) : Number((first * second).toFixed(maxDecimals));
+};
+
+/**
+ * Bytecode interpreter.
+ *
+ * Executes a compiled bytecode array against a context object.
+ * Zero allocations in the hot path: uses a pre-allocated stack
+ * and operates on the flat bytecode array directly.
+ */
+
+
+// Read a numeric value from a bytecode slot — opcodes and index operands are always numbers.
+// Throws if the slot contains a non-number (guards against compiler bugs).
+function numAt$1(v) {
+  if (typeof v !== 'number') {
+    throw new Error(`bytecode integrity error: expected number, got ${typeof v}`);
+  }
+  return v;
+}
+const addDecimals$1 = operateWithExpectedDecimals('sum');
+const subtractDecimals$1 = operateWithExpectedDecimals('subtract');
+const multiplyDecimals$1 = operateWithExpectedDecimals('multiply');
+const divideDecimals$1 = (a, b) => a / b;
+
+// Pre-allocated stack — safe because evaluation is synchronous and non-reentrant
+const MAX_STACK$1 = 512;
+const stack$1 = new Array(MAX_STACK$1);
+let stackTop$1 = -1;
+
+// Pre-allocated locals for CSE collection caching — grown on demand
+const MAX_LOCALS$1 = 64;
+const locals$1 = new Array(MAX_LOCALS$1);
+function relationalCompare$1(left, right, op) {
+  if (isNumber(left) && isNumber(right)) {
+    if (op === OP_GT) {
+      return left > right;
+    }
+    if (op === OP_GE) {
+      return left >= right;
+    }
+    if (op === OP_LT) {
+      return left < right;
+    }
+    return left <= right;
+  }
+  const ld = toDateNumber(left);
+  const rd = toDateNumber(right);
+  if (!isNaN(ld) && !isNaN(rd)) {
+    if (op === OP_GT) {
+      return ld > rd;
+    }
+    if (op === OP_GE) {
+      return ld >= rd;
+    }
+    if (op === OP_LT) {
+      return ld < rd;
+    }
+    return ld <= rd;
+  }
+  return false;
+}
+function arithmeticReduce$1(values, op) {
+  if (op === OP_SUM) {
+    return values.reduce(addDecimals$1);
+  }
+  if (op === OP_SUBTRACT) {
+    return values.reduce(subtractDecimals$1);
+  }
+  if (op === OP_MULTIPLY) {
+    return values.reduce(multiplyDecimals$1);
+  }
+  return values.reduce(divideDecimals$1);
+}
+
+/**
+ * Execute compiled bytecode against a context.
+ * Returns the top-of-stack value when execution completes.
+ */
+// Per-compiled-expression Set cache — one WeakMap lookup per interpret() call,
+// then all Set lookups use plain array indexing by constIdx.
+const constSetsCache = new WeakMap();
+function interpret(compiled, ctx) {
+  const {
+    bytecode,
+    refs,
+    consts
+  } = compiled;
+  let constSets = constSetsCache.get(compiled);
+  if (constSets === undefined) {
+    constSets = new Array(consts.length);
+    for (let j = 0; j < consts.length; j++) {
+      constSets[j] = new Set(consts[j]);
+    }
+    constSetsCache.set(compiled, constSets);
+  }
+  const len = bytecode.length;
+  stackTop$1 = -1;
+  let i = 0;
+  while (i < len) {
+    const op = numAt$1(bytecode[i]);
+    switch (op) {
+      // -----------------------------------------------------------------------
+      // Operands
+      // -----------------------------------------------------------------------
+      case OP_PUSH_VALUE:
+        stack$1[++stackTop$1] = bytecode[++i];
+        break;
+      case OP_PUSH_REF_KEY:
+        stack$1[++stackTop$1] = ctx[asKeyRef(refs[numAt$1(bytecode[++i])])];
+        break;
+      case OP_PUSH_REF_KEYS:
+        stack$1[++stackTop$1] = resolveKeys(asKeysRef(refs[numAt$1(bytecode[++i])]), ctx);
+        break;
+      case OP_PUSH_REF_TOKENS:
+        {
+          const ref = asFullRef(refs[numAt$1(bytecode[++i])]);
+          stack$1[++stackTop$1] = resolveTokens(ref.tokens ?? [], ref.t, ctx);
+          break;
+        }
+      case OP_PUSH_REF_DYNAMIC:
+        {
+          const ref = asFullRef(refs[numAt$1(bytecode[++i])]);
+          stack$1[++stackTop$1] = resolveDynamic(ref.k, ref.t, ctx);
+          break;
+        }
+      case OP_MAKE_COLLECTION:
+        {
+          const n = numAt$1(bytecode[++i]);
+          const arr = new Array(n);
+          for (let j = n - 1; j >= 0; j--) {
+            arr[j] = stack$1[stackTop$1--];
+          }
+          stack$1[++stackTop$1] = arr;
+          break;
+        }
+      case OP_PUSH_CONST:
+        stack$1[++stackTop$1] = consts[numAt$1(bytecode[++i])];
+        break;
+      case OP_OVERLAP_CONST:
+        {
+          const constIdx = numAt$1(bytecode[++i]);
+          const constArr = consts[constIdx];
+          const dynamic = stack$1[stackTop$1--];
+          if (!Array.isArray(dynamic)) {
+            stack$1[++stackTop$1] = false;
+            break;
+          }
+          const dLen = dynamic.length;
+          const cLen = constArr.length;
+          if (cLen === 0 && dLen === 0) {
+            stack$1[++stackTop$1] = true;
+            break;
+          }
+          let found = false;
+          if (cLen === 1) {
+            const target = constArr[0];
+            for (let j = 0; j < dLen; j++) {
+              if (dynamic[j] === target) {
+                found = true;
+                break;
+              }
+            }
+          } else {
+            const s = constSets[constIdx];
+            for (let j = 0; j < dLen; j++) {
+              if (s.has(dynamic[j])) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stack$1[++stackTop$1] = found;
+          break;
+        }
+      case OP_STORE_LOCAL:
+        // Peek top (don't pop) and store into locals slot
+        locals$1[numAt$1(bytecode[++i])] = stack$1[stackTop$1];
+        break;
+      case OP_LOAD_LOCAL:
+        stack$1[++stackTop$1] = locals$1[numAt$1(bytecode[++i])];
+        break;
+
+      // -----------------------------------------------------------------------
+      // Equality
+      // -----------------------------------------------------------------------
+      case OP_EQ:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          stack$1[++stackTop$1] = left === right;
+          break;
+        }
+      case OP_NE:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          stack$1[++stackTop$1] = left !== right;
+          break;
+        }
+
+      // -----------------------------------------------------------------------
+      // Relational
+      // -----------------------------------------------------------------------
+      case OP_GT:
+      case OP_GE:
+      case OP_LT:
+      case OP_LE:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          stack$1[++stackTop$1] = relationalCompare$1(left, right, op);
+          break;
+        }
+
+      // -----------------------------------------------------------------------
+      // Containment
+      // -----------------------------------------------------------------------
+      case OP_IN:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          if (left === null || left === undefined || right === null || right === undefined) {
+            stack$1[++stackTop$1] = false;
+            break;
+          }
+          if (Array.isArray(left) && Array.isArray(right)) {
+            throw new Error('IN: both operands are arrays');
+          }
+          if (!Array.isArray(left) && !Array.isArray(right)) {
+            throw new Error('IN: neither operand is an array');
+          }
+          if (Array.isArray(left)) {
+            stack$1[++stackTop$1] = left.indexOf(right) > -1;
+          } else if (Array.isArray(right)) {
+            stack$1[++stackTop$1] = right.indexOf(left) > -1;
+          }
+          break;
+        }
+      case OP_NOT_IN:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          if (left === null || left === undefined || right === null || right === undefined) {
+            stack$1[++stackTop$1] = true;
+            break;
+          }
+          if (Array.isArray(left) && Array.isArray(right)) {
+            throw new Error('NOT IN: both operands are arrays');
+          }
+          if (!Array.isArray(left) && !Array.isArray(right)) {
+            throw new Error('NOT IN: neither operand is an array');
+          }
+          if (Array.isArray(left)) {
+            stack$1[++stackTop$1] = left.indexOf(right) === -1;
+          } else if (Array.isArray(right)) {
+            stack$1[++stackTop$1] = right.indexOf(left) === -1;
+          }
+          break;
+        }
+
+      // Inline collection scan — no array allocation.
+      // Stack layout: [item0, item1, ..., itemN-1, scalar]
+      // The compiler always emits collection items first, scalar last.
+      case OP_IN_COLLECTION:
+        {
+          const n = numAt$1(bytecode[++i]);
+          const scalar = stack$1[stackTop$1--];
+          let found = false;
+          if (scalar !== null && scalar !== undefined) {
+            for (let j = 0; j < n; j++) {
+              if (stack$1[stackTop$1 - j] === scalar) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stackTop$1 -= n;
+          stack$1[++stackTop$1] = found;
+          break;
+        }
+      case OP_NOT_IN_COLLECTION:
+        {
+          const n = numAt$1(bytecode[++i]);
+          const scalar = stack$1[stackTop$1--];
+          let found = false;
+          if (scalar !== null && scalar !== undefined) {
+            for (let j = 0; j < n; j++) {
+              if (stack$1[stackTop$1 - j] === scalar) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stackTop$1 -= n;
+          stack$1[++stackTop$1] = !found;
+          break;
+        }
+      case OP_IN_CONST:
+        {
+          const constIdx = numAt$1(bytecode[++i]);
+          const scalar = stack$1[stackTop$1--];
+          if (scalar === null || scalar === undefined) {
+            stack$1[++stackTop$1] = false;
+            break;
+          }
+          stack$1[++stackTop$1] = constSets[constIdx].has(scalar);
+          break;
+        }
+      case OP_NOT_IN_CONST:
+        {
+          const constIdx = numAt$1(bytecode[++i]);
+          const scalar = stack$1[stackTop$1--];
+          if (scalar === null || scalar === undefined) {
+            stack$1[++stackTop$1] = true;
+            break;
+          }
+          stack$1[++stackTop$1] = !constSets[constIdx].has(scalar);
+          break;
+        }
+      case OP_OVERLAP_SCAN_REFS_CONST:
+        {
+          // bytecode layout: n, ref0, ref1, ..., refN-1, constIdx
+          const n = numAt$1(bytecode[++i]);
+          const refStart = i + 1;
+          i += n;
+          const constIdx = numAt$1(bytecode[++i]);
+          const constArr = consts[constIdx];
+          const cLen = constArr.length;
+          let found = false;
+          if (cLen === 0) {
+            // n > 0 here, so cannot be two empty arrays
+            found = false;
+          } else if (cLen === 1) {
+            const target = constArr[0];
+            for (let j = 0; j < n; j++) {
+              const v = resolveCompactRef(refs[numAt$1(bytecode[refStart + j])], ctx);
+              if (v === target) {
+                found = true;
+                break;
+              }
+            }
+          } else {
+            const s = constSets[constIdx];
+            const hasUndefined = s.has(undefined);
+            const hasNull = s.has(null);
+            for (let j = 0; j < n; j++) {
+              const v = resolveCompactRef(refs[numAt$1(bytecode[refStart + j])], ctx);
+              if (v === undefined) {
+                if (hasUndefined) {
+                  found = true;
+                  break;
+                }
+                continue;
+              }
+              if (v === null) {
+                if (hasNull) {
+                  found = true;
+                  break;
+                }
+                continue;
+              }
+              if (s.has(v)) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stack$1[++stackTop$1] = found;
+          break;
+        }
+      case OP_IN_SCAN_REFS_CONST:
+      case OP_NOT_IN_SCAN_REFS_CONST:
+        {
+          // bytecode layout: n, ref0, ref1, ..., refN-1, constIdx (always 1-element const)
+          const n = numAt$1(bytecode[++i]);
+          const refStart = i + 1;
+          i += n;
+          const constIdx = numAt$1(bytecode[++i]);
+          const target = consts[constIdx][0]; // always a 1-element set: the scalar operand
+          let found = false;
+          if (target !== null && target !== undefined) {
+            for (let j = 0; j < n; j++) {
+              const v = resolveCompactRef(refs[numAt$1(bytecode[refStart + j])], ctx);
+              if (v === target) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stack$1[++stackTop$1] = op === OP_IN_SCAN_REFS_CONST ? found : !found;
+          break;
+        }
+      case OP_OR_AND_IN_CONST_2:
+        {
+          // bytecode layout: ref1Idx, ref2Idx, M, v0, setBIdx0, v1, setBIdx1, ..., vM-1, setBIdxM-1
+          // constSets[setBIdx] is pre-built at first interpret() call — plain Set.has lookup.
+          const ref1Idx = numAt$1(bytecode[++i]);
+          const ref2Idx = numAt$1(bytecode[++i]);
+          const m = numAt$1(bytecode[++i]);
+          const entriesStart = i + 1;
+          i += m * 2;
+          const v1 = resolveCompactRef(refs[ref1Idx], ctx);
+          const v2 = resolveCompactRef(refs[ref2Idx], ctx);
+          let found = false;
+          if (v1 !== undefined && v1 !== null && v2 !== undefined && v2 !== null) {
+            for (let j = 0; j < m; j++) {
+              if (bytecode[entriesStart + j * 2] === v1) {
+                found = constSets[numAt$1(bytecode[entriesStart + j * 2 + 1])].has(v2);
+                break;
+              }
+            }
+          }
+          stack$1[++stackTop$1] = found;
+          break;
+        }
+
+      // -----------------------------------------------------------------------
+      // String
+      // -----------------------------------------------------------------------
+      case OP_PREFIX:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          stack$1[++stackTop$1] = isString(left) && isString(right) ? right.startsWith(left) : false;
+          break;
+        }
+      case OP_SUFFIX:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          stack$1[++stackTop$1] = isString(left) && isString(right) ? left.endsWith(right) : false;
+          break;
+        }
+
+      // -----------------------------------------------------------------------
+      // Array
+      // -----------------------------------------------------------------------
+      case OP_OVERLAP:
+        {
+          const right = stack$1[stackTop$1--];
+          const left = stack$1[stackTop$1--];
+          if (left === null || left === undefined || right === null || right === undefined) {
+            stack$1[++stackTop$1] = false;
+            break;
+          }
+          if (!Array.isArray(left) || !Array.isArray(right)) {
+            throw new Error('OVERLAP: both operands must be arrays');
+          }
+          if (left.length === 0 && right.length === 0) {
+            stack$1[++stackTop$1] = true;
+            break;
+          }
+          stack$1[++stackTop$1] = left.some(el => right.includes(el));
+          break;
+        }
+
+      // -----------------------------------------------------------------------
+      // Presence
+      // -----------------------------------------------------------------------
+      case OP_PRESENT:
+        stack$1[stackTop$1] = stack$1[stackTop$1] !== undefined && stack$1[stackTop$1] !== null;
+        break;
+      case OP_UNDEFINED:
+        stack$1[stackTop$1] = stack$1[stackTop$1] === undefined;
+        break;
+
+      // -----------------------------------------------------------------------
+      // Arithmetic
+      // -----------------------------------------------------------------------
+      case OP_SUM:
+      case OP_SUBTRACT:
+      case OP_MULTIPLY:
+      case OP_DIVIDE:
+        {
+          const n = numAt$1(bytecode[++i]);
+          // Fast path for the common 2-operand case — no array allocation
+          if (n === 2) {
+            const b = stack$1[stackTop$1--];
+            const a = stack$1[stackTop$1--];
+            if (a === null || a === undefined || b === null || b === undefined) {
+              stack$1[++stackTop$1] = false;
+              break;
+            }
+            if (!isNumber(a) || !isNumber(b)) {
+              throw new Error(`arithmetic operand is not a number: ${!isNumber(a) ? a : b}`);
+            }
+            if (op === OP_SUM) {
+              stack$1[++stackTop$1] = addDecimals$1(a, b);
+            } else if (op === OP_SUBTRACT) {
+              stack$1[++stackTop$1] = subtractDecimals$1(a, b);
+            } else if (op === OP_MULTIPLY) {
+              stack$1[++stackTop$1] = multiplyDecimals$1(a, b);
+            } else {
+              stack$1[++stackTop$1] = divideDecimals$1(a, b);
+            }
+            break;
+          }
+          const values = new Array(n);
+          let hasNull = false;
+          for (let j = n - 1; j >= 0; j--) {
+            const v = stack$1[stackTop$1--];
+            if (v === null || v === undefined) {
+              hasNull = true;
+              break;
+            }
+            if (!isNumber(v)) {
+              throw new Error(`arithmetic operand is not a number: ${v}`);
+            }
+            values[j] = v;
+          }
+          stack$1[++stackTop$1] = hasNull ? false : arithmeticReduce$1(values, op);
+          break;
+        }
+
+      // -----------------------------------------------------------------------
+      // Logical
+      // -----------------------------------------------------------------------
+      case OP_NOT:
+        {
+          const val = stack$1[stackTop$1];
+          if (typeof val !== 'boolean') {
+            throw new Error('NOT: operand must be boolean');
+          }
+          stack$1[stackTop$1] = !val;
+          break;
+        }
+      case OP_XOR:
+        {
+          const b = stack$1[stackTop$1--];
+          const a = stack$1[stackTop$1--];
+          if (typeof a !== 'boolean' || typeof b !== 'boolean') {
+            throw new Error('XOR: operands must be boolean');
+          }
+          stack$1[++stackTop$1] = (a || b) && !(a && b);
+          break;
+        }
+      case OP_JUMP_IF_FALSE:
+        {
+          const offset = numAt$1(bytecode[++i]);
+          if (stack$1[stackTop$1] === false) {
+            i += offset;
+          }
+          break;
+        }
+      case OP_JUMP_IF_TRUE:
+        {
+          const offset = numAt$1(bytecode[++i]);
+          if (stack$1[stackTop$1] === true) {
+            i += offset;
+          }
+          break;
+        }
+      case OP_POP:
+        stackTop$1--;
+        break;
+      case OP_AND:
+      case OP_OR:
+      case OP_NOR:
+        i++; // skip operand count
+        break;
+    }
+    i++;
+  }
+  return stack$1[stackTop$1];
+}
+
+/**
+ * Bytecode simplify interpreter.
+ *
+ * Runs the same bytecode as the evaluate interpreter but supports partial
+ * evaluation. Stack slots hold either a Result (fully resolved) or an Input
+ * fragment (residual — a ref string or a sub-expression array). When an
+ * operator receives any residual operand it reconstructs the sub-expression
+ * as an Input array instead of computing a value.
+ *
+ * Short-circuit logic still applies: AND with a false short-circuits even if
+ * other operands are unknown; OR with a true short-circuits likewise.
+ */
+
+
+// Detect Infinity and NaN — these should not be used as concrete values in
+// comparisons when the other operand is residual, matching the OOP simplifier's
+// isInfinite guard in isSimplifiedArithmeticExpression.
+function isUnusableResult(v) {
+  return typeof v === 'number' && !isFinite(v);
+}
+const addDecimals = operateWithExpectedDecimals('sum');
+const subtractDecimals = operateWithExpectedDecimals('subtract');
+const multiplyDecimals = operateWithExpectedDecimals('multiply');
+const divideDecimals = (a, b) => a / b;
+
+// WeakMap Set cache for OP_OVERLAP_CONST, OP_OVERLAP_SCAN_REFS_CONST, and OP_IN_CONST —
+// same pattern as the evaluate interpreter.
+// Keyed on the const array identity so Sets are released when the CompiledExpression is GC'd.
+const overlapSetCache = new WeakMap();
+
+// Per-compiled-expression Map caches — built lazily from the serializable tuple arrays on the
+// CompiledExpression. Same WeakMap pattern as constSetsCache in the evaluate interpreter so
+// the Maps are released when the CompiledExpression is GC'd.
+const overlapRefsResidualsCache = new WeakMap();
+const directionMapCache = new WeakMap();
+
+// Read a numeric operand from a bytecode slot — opcodes and index operands are always numbers.
+// Throws if the slot contains a non-number (guards against compiler bugs).
+function numAt(v) {
+  if (typeof v !== 'number') {
+    throw new Error(`bytecode integrity error: expected number, got ${typeof v}`);
+  }
+  return v;
+}
+
+// Read a literal value from a bytecode slot — stored literals are string|number|boolean|null.
+// Throws if the slot contains undefined, an array, or an object (guards against compiler bugs).
+// Returns string|number|boolean|null, which is a subtype of Input.
+function literalAt(v) {
+  if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' || v === null) {
+    return v;
+  }
+  throw new Error(`bytecode integrity error: expected literal, got ${typeof v}`);
+}
+
+// Retrieve a required entry from a map — throws if the key is missing.
+// Eliminates the Map.get() undefined return in contexts where the entry is compiler-guaranteed.
+function requireMapEntry(map, key) {
+  const v = map.get(key);
+  if (v === undefined) {
+    throw new Error(`bytecode integrity error: missing required map entry for key ${String(key)}`);
+  }
+  return v;
+}
+
+// A resolved ref carries its computed value and original serialized form.
+// Used so that when a comparison partially resolves, we reconstruct using
+// the original ref key (e.g. '$a') rather than the resolved value (e.g. 10).
+// Numeric tag _r used for all three wrapper types so V8 can use hidden-class
+// fixed-offset reads instead of the slower `'key' in obj` property-existence check.
+
+// A residual sub-expression — a reconstructed Input fragment.
+// Wrapped in an object so we can distinguish it from concrete Result[] arrays.
+
+// Accumulated XOR state during chained binary XOR evaluation.
+// Tracks residual operands and how many concrete-true values were seen.
+
+// Union of all slot object wrapper types (distinguishable via _r discriminant).
+
+// Arrays on the stack carry no _r property. Declaring _r?: undefined here exposes
+// the discriminant on the full "non-null object Slot" union so that needsReconstruct
+// and slotVal can read ._r directly — without Array.isArray — in their hot paths.
+// For arrays, ._r resolves to undefined, which naturally fails the === 2/3/1 checks.
+
+// A stack slot is a concrete value (primitives, arrays, SlotObject wrappers).
+// Record<string,unknown> values can be pushed directly from OP_PUSH_VALUE
+// (object literals in expressions), and are returned as-is by slotVal.
+
+// Type guard: checks if a slot is a SlotObject (has _r as an own property).
+// This distinguishes SlotObject types from plain Record<string,unknown> objects.
+function isSlotObject(v) {
+  return typeof v === 'object' && v !== null && Object.prototype.hasOwnProperty.call(v, '_r');
+}
+function isXorState(v) {
+  return isSlotObject(v) && v._r === 3;
+}
+function isResidual(v) {
+  return isSlotObject(v) && v._r === 2;
+}
+function isDivByZeroMarker(v) {
+  return isSlotObject(v) && v._r === 4;
+}
+
+// True if the slot needs to be reconstructed rather than computed.
+// Hot path — booleans/numbers/strings short-circuit at the first typeof check.
+// Unknown refs are always wrapped in Residual (_r === 2), never pushed as raw strings,
+// so no reference-predicate check is needed here.
+// No Array.isArray needed: arrays have _r === undefined, failing the 2/3/4 check.
+function needsReconstruct(v) {
+  if (typeof v !== 'object' || v === null) {
+    return false;
+  }
+  // v is ArraySlot | SlotObject | Record<string, unknown>; _r is undefined|1|2|3|4
+  return v._r === 2 || v._r === 3 || v._r === 4;
+}
+
+// Extract the concrete Result from a slot (unwrap Resolved if needed).
+// Hot path — no Array.isArray needed: for non-Resolved objects (arrays, Residual,
+// XorState, DivByZeroMarker), the _r === 1 check is false and they
+// fall through to the primitive branch or return the value as appropriate.
+function slotVal(v) {
+  if (typeof v !== 'object' || v === null) {
+    return v; // primitives: boolean, number, string, null, undefined
+  }
+  // v is ArraySlot | SlotObject | Record<string,unknown>
+  if (isSlotObject(v)) {
+    // v is a SlotObject — discriminate via _r
+    if (v._r === 1) {
+      return v.val; // Resolved — unwrap the concrete value
+    }
+    if (v._r === 4) {
+      // DivByZeroMarker — unwrap as Infinity
+      return v._val;
+    }
+    // v._r is 2 or 3 (Residual/XorState) — no concrete value to extract
+    return undefined;
+  }
+  // v is ArraySlot or Record<string,unknown> — both are valid Results
+  if (Array.isArray(v)) {
+    return v; // ArraySlot — the array is itself a Result
+  }
+  return v; // Plain object literal — Record<string,unknown> is a valid Result
+}
+
+// Module-level op name references for XorState finalization.
+// Set at the start of each interpretSimplify call.
+let _xorOpName = 'XOR';
+let _notOpName = 'NOT';
+let _norOpName = 'NOR';
+
+// Type guard: checks whether a Result value is also a valid Input.
+// Input = string | number | boolean | null | Input[] | Record<string, unknown>.
+function isInput(v) {
+  if (v === undefined) {
+    return false;
+  }
+  if (v === null) {
+    return true;
+  }
+  if (Array.isArray(v)) {
+    return v.every(isInput);
+  }
+  if (typeof v === 'object') {
+    return Object.values(v).every(isInput);
+  }
+  return true;
+}
+
+// Extract the serialized Input form of a slot for residual reconstruction.
+function slotSrc(v) {
+  if (typeof v !== 'object' || v === null) {
+    // v is a primitive: undefined | null | string | number | boolean
+    // In residual paths this should always be a valid Input — guard against null/undefined.
+    if (!isInput(v)) {
+      throw new Error(`slotSrc: invariant violated — non-Input value in residual path: ${typeof v}`);
+    }
+    return v; // v narrowed to Input by the type guard above
+  }
+  // v is ArraySlot | SlotObject | Record<string,unknown>
+  if (Array.isArray(v)) {
+    // v is ArraySlot — a concrete collection used as an operand
+    if (!isInput(v)) {
+      throw new Error(`slotSrc: invariant violated — non-Input array in residual path`);
+    }
+    return v;
+  }
+  // v is a plain object — use isSlotObject to distinguish SlotObject types
+  // (which have _r as an own property) from plain Record<string,unknown> objects.
+  if (isSlotObject(v)) {
+    // v is a SlotObject — discriminate via _r
+    if (v._r === 3) {
+      // XorState — finalize accumulated XOR state into an expression
+      const {
+        xorResiduals: residuals,
+        xorTrueCount: trueCount
+      } = v;
+      // "One-hot" XOR: if more than one true was seen, result is false
+      if (trueCount > 1) {
+        return false;
+      }
+      const effectiveTrueCount = trueCount % 2;
+      if (residuals.length === 1) {
+        return effectiveTrueCount === 1 ? [_notOpName, residuals[0]] : residuals[0];
+      }
+      return effectiveTrueCount === 1 ? [_norOpName, ...residuals] : [_xorOpName, ...residuals];
+    }
+    if (v._r === 2) {
+      // Residual — return the reconstructed expression
+      return v.expr;
+    }
+    if (v._r === 4) {
+      // DivByZeroMarker — reconstruct as a DIVIDE expression
+      return ['/', v.left, v.right];
+    }
+    if (v._r === 1) {
+      // Resolved — return original ref key
+      return v.src;
+    }
+  }
+  // Plain object literal — return as-is (valid Input)
+  return v;
+}
+
+// Wrap a reconstructed expression as a Residual slot.
+// expr should be an Input array (sub-expression) like ['EQ', '$ref', 5].
+function makeResidual(expr) {
+  return {
+    _r: 2,
+    expr
+  };
+}
+
+// Create a Resolved slot wrapping a known ref value.
+function makeResolved(val, src) {
+  return {
+    _r: 1,
+    val,
+    src
+  };
+}
+
+// Create a XorState slot accumulating XOR operands.
+function makeXorState(xorResiduals, xorTrueCount) {
+  return {
+    _r: 3,
+    xorResiduals,
+    xorTrueCount
+  };
+}
+
+// Pre-allocated stack — same as evaluate interpreter
+const MAX_STACK = 512;
+const stack = new Array(MAX_STACK);
+let stackTop = -1;
+
+// Pre-allocated locals for CSE collection caching
+const MAX_LOCALS = 64;
+const locals = new Array(MAX_LOCALS);
+
+// Pre-resolved ref cache — populated lazily per interpretSimplify call.
+// Indexed by ref index; avoids repeated resolveCompactRef() calls when the same
+// ref appears in multiple opcodes (e.g. multiple OVERLAP_SCAN_REFS_CONST in one expression).
+// resolvedRefDirty[i] = true means resolvedRefCache[i] holds a valid (possibly undefined) result.
+const MAX_REFS = 512;
+const resolvedRefCache = new Array(MAX_REFS);
+const resolvedRefDirty = new Array(MAX_REFS).fill(false);
+// Tracks which indices were populated this call so we can reset only those.
+const resolvedRefUsed = new Array(MAX_REFS);
+let resolvedRefUsedCount = 0;
+
+// Residual spill buffer: when OP_POP discards a residual/unknown-ref slot that
+// is part of a short-circuit AND/OR sequence, we save it here so OP_AND/OR/NOR
+// can include it in the reconstructed expression.
+const spillBuf = new Array(MAX_STACK);
+let spillTop = -1;
+// Track the last jump opcode type to detect transitions between short-circuit
+// sequences. Different jump opcodes (41=JUMP_IF_FALSE vs 42=JUMP_IF_TRUE) indicate
+// different short-circuit sequences (AND vs OR/NOR).
+let lastJumpOp = 0;
+function relationalCompare(left, right, op) {
+  if (isNumber(left) && isNumber(right)) {
+    if (op === OP_GT) {
+      return left > right;
+    }
+    if (op === OP_GE) {
+      return left >= right;
+    }
+    if (op === OP_LT) {
+      return left < right;
+    }
+    return left <= right;
+  }
+  const ld = toDateNumber(left);
+  const rd = toDateNumber(right);
+  if (!isNaN(ld) && !isNaN(rd)) {
+    if (op === OP_GT) {
+      return ld > rd;
+    }
+    if (op === OP_GE) {
+      return ld >= rd;
+    }
+    if (op === OP_LT) {
+      return ld < rd;
+    }
+    return ld <= rd;
+  }
+  return false;
+}
+function arithmeticReduce(values, op) {
+  if (op === OP_SUM) {
+    return values.reduce(addDecimals);
+  }
+  if (op === OP_SUBTRACT) {
+    return values.reduce(subtractDecimals);
+  }
+  if (op === OP_MULTIPLY) {
+    return values.reduce(multiplyDecimals);
+  }
+  return values.reduce(divideDecimals);
+}
+function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
+  const {
+    bytecode,
+    refs,
+    opNames,
+    refKeys,
+    refRawKeys,
+    refFirstCtxKeys
+  } = compiled;
+  stackTop = -1;
+  spillTop = -1;
+  lastJumpOp = 0;
+  let overlapRefsResiduals = overlapRefsResidualsCache.get(compiled);
+  if (overlapRefsResiduals === undefined) {
+    overlapRefsResiduals = new Map(compiled.overlapRefsResiduals);
+    overlapRefsResidualsCache.set(compiled, overlapRefsResiduals);
+  }
+  let directionMap = directionMapCache.get(compiled);
+  if (directionMap === undefined) {
+    directionMap = new Map(compiled.directionMap);
+    directionMapCache.set(compiled, directionMap);
+  }
+
+  // Reset the ref cache (only clear slots used in the previous call)
+  for (let r = 0; r < resolvedRefUsedCount; r++) {
+    resolvedRefDirty[resolvedRefUsed[r]] = false;
+  }
+  resolvedRefUsedCount = 0;
+
+  // Set module-level op names for XorState finalization
+  _xorOpName = opNames[OP_XOR] ?? 'XOR';
+  _notOpName = opNames[OP_NOT] ?? 'NOT';
+  _norOpName = opNames[OP_NOR] ?? 'NOR';
+  let i = 0;
+  const len = bytecode.length;
+
+  // Normalise key sets for O(1) lookup
+  const strictSet = strictKeys instanceof Set ? strictKeys : strictKeys ? new Set(strictKeys) : undefined;
+  const optionalSet = optionalKeys instanceof Set ? optionalKeys : optionalKeys ? new Set(optionalKeys) : undefined;
+  while (i < len) {
+    const op = numAt(bytecode[i++]);
+    switch (op) {
+      // ---------------------------------------------------------------------
+      // Push
+      // ---------------------------------------------------------------------
+      case OP_PUSH_VALUE:
+        {
+          const lit = bytecode[i++];
+          // OP_PUSH_VALUE stores parsed Input literals, including object literals.
+          // No guard needed — the compiler guarantees valid Input values.
+          stack[++stackTop] = lit;
+          break;
+        }
+      case OP_PUSH_REF_KEY:
+      case OP_PUSH_REF_KEYS:
+      case OP_PUSH_REF_TOKENS:
+      case OP_PUSH_REF_DYNAMIC:
+        {
+          const idx = numAt(bytecode[i++]);
+          const rawKey = refRawKeys[idx];
+          let val;
+          if (resolvedRefDirty[idx]) {
+            val = resolvedRefCache[idx];
+          } else {
+            val = resolveCompactRef(refs[idx], ctx);
+            resolvedRefCache[idx] = val;
+            resolvedRefDirty[idx] = true;
+            resolvedRefUsed[resolvedRefUsedCount++] = idx;
+          }
+          if (val !== undefined) {
+            // Ref is in context — always resolve (strictKeys/optionalKeys only affect absent keys)
+            stack[++stackTop] = makeResolved(val, refKeys[idx]);
+            break;
+          }
+
+          // Ref is absent from context.
+          // Check if it should be treated as a concrete undefined (evaluated as undefined)
+          // or as a residual expression (preserved for later simplification).
+          if (strictSet?.has(rawKey)) {
+            // strictKeys: force-evaluate as undefined (not a residual)
+            stack[++stackTop] = undefined;
+            break;
+          }
+          if (optionalSet && !optionalSet.has(rawKey)) {
+            // Key not in optionalKeys: treat as definitely-present but absent → undefined
+            stack[++stackTop] = undefined;
+            break;
+          }
+
+          // First-key heuristic: match OOP Reference.simplify() behavior.
+          // If the top-level context key exists, the ref's parent object is known — treat the
+          // (absent) sub-field as concrete undefined rather than preserving it as an unknown.
+          // This only applies to multi-key refs (refFirstCtxKeys[idx] is undefined for single-key).
+          const firstCtxKey = refFirstCtxKeys[idx];
+          if (firstCtxKey !== undefined && ctx[firstCtxKey] !== undefined) {
+            stack[++stackTop] = undefined;
+            break;
+          }
+
+          // Key is genuinely unknown — wrap as Residual so detection does not depend
+          // on the reference character (respects custom referencePredicate/referenceSerialization).
+          stack[++stackTop] = makeResidual(refKeys[idx]);
+          break;
+        }
+      case OP_MAKE_COLLECTION:
+        {
+          const n = numAt(bytecode[i++]);
+          // Check for unknown items first
+          let hasUnknown = false;
+          for (let j = 0; j < n; j++) {
+            if (needsReconstruct(stack[stackTop - j])) {
+              hasUnknown = true;
+              break;
+            }
+          }
+          if (hasUnknown) {
+            // Keep serialized form (ref keys or sub-expressions) for residual reconstruction
+            const items = new Array(n);
+            for (let j = n - 1; j >= 0; j--) {
+              items[j] = slotSrc(stack[stackTop--]);
+            }
+            stack[++stackTop] = makeResidual(items);
+          } else {
+            // All concrete — use actual values
+            const items = new Array(n);
+            for (let j = n - 1; j >= 0; j--) {
+              items[j] = slotVal(stack[stackTop--]);
+            }
+            stack[++stackTop] = items;
+          }
+          break;
+        }
+      case OP_PUSH_CONST:
+        stack[++stackTop] = compiled.consts[numAt(bytecode[i++])];
+        break;
+      case OP_OVERLAP_CONST:
+        {
+          const opcodePos = i - 1; // position of OP_OVERLAP_CONST in bytecode
+          const constArr = compiled.consts[numAt(bytecode[i++])];
+          const constOnLeft = directionMap.get(opcodePos) === 0;
+          const dynamic = stack[stackTop--];
+          if (needsReconstruct(dynamic)) {
+            // Dynamic side is unknown — reconstruct as OVERLAP expression preserving original order
+            const constInput = constArr;
+            const dynamicInput = slotSrc(dynamic);
+            stack[++stackTop] = makeResidual([opNames[OP_OVERLAP], constOnLeft ? constInput : dynamicInput, constOnLeft ? dynamicInput : constInput]);
+            break;
+          }
+          const dynamicVal = slotVal(dynamic);
+          if (dynamicVal === null || dynamicVal === undefined || !Array.isArray(dynamicVal)) {
+            stack[++stackTop] = false;
+            break;
+          }
+          if (constArr.length === 0 && dynamicVal.length === 0) {
+            stack[++stackTop] = true;
+            break;
+          }
+          let found = false;
+          if (constArr.length === 1) {
+            const constVal = constArr[0];
+            for (let j = 0; j < dynamicVal.length; j++) {
+              if (dynamicVal[j] === constVal) {
+                found = true;
+                break;
+              }
+            }
+          } else {
+            let s = overlapSetCache.get(constArr);
+            if (s === undefined) {
+              s = new Set(constArr);
+              overlapSetCache.set(constArr, s);
+            }
+            for (let j = 0; j < dynamicVal.length; j++) {
+              if (s.has(dynamicVal[j])) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stack[++stackTop] = found;
+          break;
+        }
+      case OP_OVERLAP_SCAN_REFS_CONST:
+        {
+          // bytecode layout: N, ref0..refN-1, constIdx
+          const opcodePos = i - 1; // position of OP_OVERLAP_SCAN_REFS_CONST in bytecode
+          const n = numAt(bytecode[i++]);
+          const refStart = i;
+          i += n; // advance past all ref indices
+          const constIdx = numAt(bytecode[i++]);
+          const constArr = compiled.consts[constIdx];
+          const constOnLeft = directionMap.get(opcodePos) === 0;
+
+          // First pass: check whether any ref is genuinely unknown.
+          // Uses the per-call ref cache to avoid redundant resolveCompactRef calls.
+          let hasUnknown = false;
+          for (let j = 0; j < n; j++) {
+            const refIdx = numAt(bytecode[refStart + j]);
+            const rawKey = refRawKeys[refIdx];
+            let val;
+            if (resolvedRefDirty[refIdx]) {
+              val = resolvedRefCache[refIdx];
+            } else {
+              val = resolveCompactRef(refs[refIdx], ctx);
+              resolvedRefCache[refIdx] = val;
+              resolvedRefDirty[refIdx] = true;
+              resolvedRefUsed[resolvedRefUsedCount++] = refIdx;
+            }
+            if (val === undefined) {
+              if (strictSet?.has(rawKey)) {
+                continue;
+              }
+              if (optionalSet && !optionalSet.has(rawKey)) {
+                continue;
+              }
+              // First-key heuristic: if parent object is in context, treat undefined sub-field as concrete
+              const firstCtxKey = refFirstCtxKeys[refIdx];
+              if (firstCtxKey !== undefined && ctx[firstCtxKey] !== undefined) {
+                continue;
+              }
+              hasUnknown = true;
+              break;
+            }
+          }
+          if (hasUnknown) {
+            // Use pre-built residual array from compile time — no allocation here
+            const refInputs = requireMapEntry(overlapRefsResiduals, opcodePos);
+            const constInput = constArr;
+            const dynamicInput = refInputs;
+            stack[++stackTop] = makeResidual([opNames[OP_OVERLAP], constOnLeft ? constInput : dynamicInput, constOnLeft ? dynamicInput : constInput]);
+            break;
+          }
+          let found = false;
+          if (constArr.length === 1) {
+            // Fast path: single-element const — direct equality, no Set needed
+            const constVal = constArr[0];
+            for (let j = 0; j < n; j++) {
+              const val = resolvedRefCache[numAt(bytecode[refStart + j])];
+              if (val !== undefined && val === constVal) {
+                found = true;
+                break;
+              }
+            }
+          } else {
+            let s = overlapSetCache.get(constArr);
+            if (s === undefined) {
+              s = new Set(constArr);
+              overlapSetCache.set(constArr, s);
+            }
+            for (let j = 0; j < n; j++) {
+              const val = resolvedRefCache[numAt(bytecode[refStart + j])];
+              if (val !== undefined && s.has(val)) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stack[++stackTop] = found;
+          break;
+        }
+      case OP_IN_SCAN_REFS_CONST:
+      case OP_NOT_IN_SCAN_REFS_CONST:
+        {
+          // bytecode layout: N, ref0..refN-1, constIdx
+          // const at constIdx is a 1-element array [scalar]
+          const opcodePos = i - 1;
+          const n = numAt(bytecode[i++]);
+          const refStart = i;
+          i += n;
+          const constIdx = numAt(bytecode[i++]);
+          const constArr = compiled.consts[constIdx];
+          // dir=0: refs on left, scalar on right → scalar (constInput) is on right
+          // dir=1: scalar on left, refs on right → scalar (constInput) is on left
+          const constOnLeft = directionMap.get(opcodePos) === 1;
+          let hasUnknown = false;
+          for (let j = 0; j < n; j++) {
+            const refIdx = numAt(bytecode[refStart + j]);
+            const rawKey = refRawKeys[refIdx];
+            let val;
+            if (resolvedRefDirty[refIdx]) {
+              val = resolvedRefCache[refIdx];
+            } else {
+              val = resolveCompactRef(refs[refIdx], ctx);
+              resolvedRefCache[refIdx] = val;
+              resolvedRefDirty[refIdx] = true;
+              resolvedRefUsed[resolvedRefUsedCount++] = refIdx;
+            }
+            if (val === undefined) {
+              if (strictSet?.has(rawKey)) {
+                continue;
+              }
+              if (optionalSet && !optionalSet.has(rawKey)) {
+                continue;
+              }
+              // First-key heuristic: if parent object is in context, treat undefined sub-field as concrete
+              const firstCtxKey = refFirstCtxKeys[refIdx];
+              if (firstCtxKey !== undefined && ctx[firstCtxKey] !== undefined) {
+                continue;
+              }
+              hasUnknown = true;
+              break;
+            }
+          }
+          if (hasUnknown) {
+            const refInputs = requireMapEntry(overlapRefsResiduals, opcodePos);
+            // constArr is a 1-element array [scalar]; use the scalar as the const operand
+            const constInput = constArr[0];
+            const dynamicInput = refInputs;
+            stack[++stackTop] = makeResidual([opNames[op], constOnLeft ? constInput : dynamicInput, constOnLeft ? dynamicInput : constInput]);
+            break;
+          }
+          const target = constArr[0];
+          let found = false;
+          if (target !== null && target !== undefined) {
+            for (let j = 0; j < n; j++) {
+              const val = resolvedRefCache[numAt(bytecode[refStart + j])];
+              if (val === target) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stack[++stackTop] = op === OP_IN_SCAN_REFS_CONST ? found : !found;
+          break;
+        }
+      case OP_STORE_LOCAL:
+        // Peek top (don't pop) and store into locals slot
+        locals[numAt(bytecode[i++])] = stack[stackTop];
+        break;
+      case OP_LOAD_LOCAL:
+        stack[++stackTop] = locals[numAt(bytecode[i++])];
+        break;
+
+      // ---------------------------------------------------------------------
+      // Equality
+      // ---------------------------------------------------------------------
+      case OP_EQ:
+      case OP_NE:
+        {
+          const right = stack[stackTop--];
+          const left = stack[stackTop--];
+          if (needsReconstruct(left) || needsReconstruct(right)) {
+            stack[++stackTop] = makeResidual([opNames[op], slotSrc(left), slotSrc(right)]);
+          } else {
+            const lv = slotVal(left);
+            const rv = slotVal(right);
+            stack[++stackTop] = op === OP_EQ ? lv === rv : lv !== rv;
+          }
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // Relational
+      // ---------------------------------------------------------------------
+      case OP_GT:
+      case OP_GE:
+      case OP_LT:
+      case OP_LE:
+        {
+          const right = stack[stackTop--];
+          const left = stack[stackTop--];
+          // Check for DivByZeroMarker on either side
+          const leftIsDivZero = isDivByZeroMarker(left);
+          const rightIsDivZero = isDivByZeroMarker(right);
+          if (leftIsDivZero) {
+            // Left is a division-by-zero result.
+            // Match OOP isInfinite guard: preserve expression only if right
+            // is a residual. If right is concrete, evaluate directly.
+            if (needsReconstruct(right) && !rightIsDivZero) {
+              stack[++stackTop] = makeResidual([opNames[op], ['/', left.left, left.right], slotSrc(right)]);
+            } else {
+              // Both concrete — evaluate directly (OOP: 10000 > Infinity = false)
+              stack[++stackTop] = relationalCompare(left._val, slotVal(right), op);
+            }
+          } else if (rightIsDivZero) {
+            // Right is a division-by-zero result.
+            // If left is a residual, preserve expression. Otherwise evaluate directly.
+            if (needsReconstruct(left)) {
+              stack[++stackTop] = makeResidual([opNames[op], slotSrc(left), ['/', right.left, right.right]]);
+            } else {
+              // Both concrete — evaluate directly (OOP: 10000 > Infinity = false)
+              stack[++stackTop] = relationalCompare(slotVal(left), right._val, op);
+            }
+          } else if (needsReconstruct(left) || needsReconstruct(right)) {
+            stack[++stackTop] = makeResidual([opNames[op], slotSrc(left), slotSrc(right)]);
+          } else {
+            stack[++stackTop] = relationalCompare(slotVal(left), slotVal(right), op);
+          }
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // Containment — dynamic fallback (both sides are refs)
+      // ---------------------------------------------------------------------
+      case OP_IN:
+      case OP_NOT_IN:
+        {
+          const right = stack[stackTop--];
+          const left = stack[stackTop--];
+          if (needsReconstruct(left) || needsReconstruct(right)) {
+            stack[++stackTop] = makeResidual([opNames[op], slotSrc(left), slotSrc(right)]);
+          } else {
+            const l = slotVal(left);
+            const r = slotVal(right);
+            if (l === null || l === undefined || r === null || r === undefined) {
+              stack[++stackTop] = op === OP_IN ? false : true;
+            } else if (Array.isArray(l)) {
+              if (Array.isArray(r)) {
+                throw new Error(op === OP_IN ? 'IN: both operands are arrays' : 'NOT IN: both operands are arrays');
+              }
+              const found = l.indexOf(r) > -1;
+              stack[++stackTop] = op === OP_IN ? found : !found;
+            } else if (Array.isArray(r)) {
+              const found = r.indexOf(l) > -1;
+              stack[++stackTop] = op === OP_IN ? found : !found;
+            } else {
+              throw new Error(op === OP_IN ? 'IN: neither operand is an array' : 'NOT IN: neither operand is an array');
+            }
+          }
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // Inline collection scan
+      // ---------------------------------------------------------------------
+      case OP_IN_COLLECTION:
+      case OP_NOT_IN_COLLECTION:
+        {
+          const opcodePos = i - 1; // position of the opcode in bytecode
+          const n = numAt(bytecode[i++]);
+          const collectionOnLeft = directionMap.get(opcodePos) === 0;
+          const scalarSlot = stack[stackTop--];
+          const scalarIsUnknown = needsReconstruct(scalarSlot);
+          // Check if any collection item needs reconstruction
+          let hasUnknownItem = false;
+          for (let j = 0; j < n; j++) {
+            if (needsReconstruct(stack[stackTop - j])) {
+              hasUnknownItem = true;
+              break;
+            }
+          }
+          if (scalarIsUnknown || hasUnknownItem) {
+            const items = new Array(n);
+            for (let j = 0; j < n; j++) {
+              items[j] = slotSrc(stack[stackTop - (n - 1 - j)]);
+            }
+            stackTop -= n;
+            // Reconstruct preserving original operand order
+            const itemsInput = items;
+            const reconstructed = collectionOnLeft ? [opNames[op], itemsInput, slotSrc(scalarSlot)] : [opNames[op], slotSrc(scalarSlot), itemsInput];
+            stack[++stackTop] = makeResidual(reconstructed);
+            break;
+          }
+          // All concrete — inline scan using slotVal to unwrap Resolved
+          const scalar = slotVal(scalarSlot);
+          let found = false;
+          if (scalar !== null && scalar !== undefined) {
+            for (let j = 0; j < n; j++) {
+              if (slotVal(stack[stackTop - j]) === scalar) {
+                found = true;
+                break;
+              }
+            }
+          }
+          stackTop -= n;
+          stack[++stackTop] = op === OP_IN_COLLECTION ? found : !found;
+          break;
+        }
+      case OP_IN_CONST:
+      case OP_NOT_IN_CONST:
+        {
+          const opcodePos = i - 1; // position of the opcode in bytecode
+          const constArr = compiled.consts[numAt(bytecode[i++])];
+          const collectionOnLeft = directionMap.get(opcodePos) === 0;
+          const scalarSlot = stack[stackTop--];
+          if (needsReconstruct(scalarSlot)) {
+            const scalarInput = slotSrc(scalarSlot);
+            const constInput = constArr;
+            stack[++stackTop] = makeResidual([opNames[op], collectionOnLeft ? constInput : scalarInput, collectionOnLeft ? scalarInput : constInput]);
+            break;
+          }
+          const scalar = slotVal(scalarSlot);
+          if (scalar === null || scalar === undefined) {
+            stack[++stackTop] = op === OP_IN_CONST ? false : true;
+            break;
+          }
+          let s = overlapSetCache.get(constArr);
+          if (s === undefined) {
+            s = new Set(constArr);
+            overlapSetCache.set(constArr, s);
+          }
+          const found = s.has(scalar);
+          stack[++stackTop] = op === OP_IN_CONST ? found : !found;
+          break;
+        }
+      case OP_OR_AND_IN_CONST_2:
+        {
+          // bytecode layout: ref1Idx, ref2Idx, M, aVal0, setBIdx0, aVal1, setBIdx1, ..., aValM-1, setBIdxM-1
+          // aVal_j is a literal value; setBIdx_j is a constIdx for the merged setB.
+          const ref1Idx = numAt(bytecode[i++]);
+          const ref2Idx = numAt(bytecode[i++]);
+          const n = numAt(bytecode[i++]);
+          const pairsStart = i;
+          i += n * 2;
+          const rawKey1 = refRawKeys[ref1Idx];
+          const rawKey2 = refRawKeys[ref2Idx];
+          const v1 = resolveCompactRef(refs[ref1Idx], ctx);
+          const v2 = resolveCompactRef(refs[ref2Idx], ctx);
+          const unknown1 = v1 === undefined && !strictSet?.has(rawKey1) && (!optionalSet || optionalSet.has(rawKey1));
+          const unknown2 = v2 === undefined && !strictSet?.has(rawKey2) && (!optionalSet || optionalSet.has(rawKey2));
+          if (unknown1 || unknown2) {
+            // Reconstruct the original complex expression tree
+            const branches = [opNames[OP_OR]];
+            const andOp = opNames[OP_AND];
+            const eqOp = opNames[OP_EQ];
+            const inOp = opNames[OP_IN];
+            const r1 = refKeys[ref1Idx];
+            const r2 = refKeys[ref2Idx];
+            for (let j = 0; j < n; j++) {
+              const aVal = literalAt(bytecode[pairsStart + j * 2]);
+              const setB = compiled.consts[numAt(bytecode[pairsStart + j * 2 + 1])];
+              const setInput = setB;
+              branches.push([andOp, [eqOp, r1, aVal], [inOp, r2, setInput]]);
+            }
+            stack[++stackTop] = makeResidual(branches);
+            break;
+          }
+
+          // Both refs known — evaluate normally
+          let found = false;
+          if (v1 !== null && v1 !== undefined && v2 !== null && v2 !== undefined) {
+            for (let j = 0; j < n; j++) {
+              if (bytecode[pairsStart + j * 2] === v1) {
+                const setB = compiled.consts[numAt(bytecode[pairsStart + j * 2 + 1])];
+                let s = overlapSetCache.get(setB);
+                if (s === undefined) {
+                  s = new Set(setB);
+                  overlapSetCache.set(setB, s);
+                }
+                found = s.has(v2);
+                break;
+              }
+            }
+          }
+          stack[++stackTop] = found;
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // String
+      // ---------------------------------------------------------------------
+      case OP_PREFIX:
+      case OP_SUFFIX:
+        {
+          const right = stack[stackTop--];
+          const left = stack[stackTop--];
+          if (needsReconstruct(left) || needsReconstruct(right)) {
+            stack[++stackTop] = makeResidual([opNames[op], slotSrc(left), slotSrc(right)]);
+          } else {
+            const lv = slotVal(left);
+            const rv = slotVal(right);
+            stack[++stackTop] = op === OP_PREFIX ? isString(lv) && isString(rv) ? rv.startsWith(lv) : false : isString(lv) && isString(rv) ? lv.endsWith(rv) : false;
+          }
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // Array
+      // ---------------------------------------------------------------------
+      case OP_OVERLAP:
+        {
+          const right = stack[stackTop--];
+          const left = stack[stackTop--];
+          if (needsReconstruct(left) || needsReconstruct(right)) {
+            stack[++stackTop] = makeResidual([opNames[op], slotSrc(left), slotSrc(right)]);
+          } else {
+            const l = slotVal(left);
+            const r = slotVal(right);
+            if (l === null || l === undefined || r === null || r === undefined) {
+              stack[++stackTop] = false;
+            } else if (!Array.isArray(l) || !Array.isArray(r)) {
+              throw new Error('OVERLAP: both operands must be arrays');
+            } else if (l.length === 0 && r.length === 0) {
+              stack[++stackTop] = true;
+            } else {
+              stack[++stackTop] = l.some(el => r.includes(el));
+            }
+          }
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // Presence
+      // ---------------------------------------------------------------------
+      case OP_PRESENT:
+        {
+          const val = stack[stackTop];
+          if (needsReconstruct(val)) {
+            stack[stackTop] = makeResidual([opNames[op], slotSrc(val)]);
+          } else {
+            const v = slotVal(val);
+            stack[stackTop] = v !== undefined && v !== null;
+          }
+          break;
+        }
+      case OP_UNDEFINED:
+        {
+          const val = stack[stackTop];
+          if (needsReconstruct(val)) {
+            stack[stackTop] = makeResidual([opNames[op], slotSrc(val)]);
+          } else {
+            const v = slotVal(val);
+            stack[stackTop] = v === undefined;
+          }
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // Arithmetic
+      // ---------------------------------------------------------------------
+      case OP_SUM:
+      case OP_SUBTRACT:
+      case OP_MULTIPLY:
+      case OP_DIVIDE:
+        {
+          const n = numAt(bytecode[i++]);
+          // Check for any unknown operand
+          let hasUnknown = false;
+          for (let j = 0; j < n; j++) {
+            if (needsReconstruct(stack[stackTop - j])) {
+              hasUnknown = true;
+              break;
+            }
+          }
+          if (hasUnknown) {
+            const items = new Array(n);
+            for (let j = n - 1; j >= 0; j--) {
+              items[j] = slotSrc(stack[stackTop--]);
+            }
+            stack[++stackTop] = makeResidual([opNames[op], ...items]);
+            break;
+          }
+          // Fast path: 2 operands, all concrete
+          if (n === 2) {
+            const bVal = slotVal(stack[stackTop--]);
+            const aVal = slotVal(stack[stackTop--]);
+            if (aVal === null || aVal === undefined || bVal === null || bVal === undefined) {
+              stack[++stackTop] = false;
+              break;
+            }
+            if (!isNumber(aVal) || !isNumber(bVal)) {
+              throw new Error(`arithmetic operand is not a number: ${!isNumber(aVal) ? aVal : bVal}`);
+            }
+            // After the throw above, aVal and bVal are narrowed to number
+            if (op === OP_SUM) {
+              stack[++stackTop] = addDecimals(aVal, bVal);
+            } else if (op === OP_SUBTRACT) {
+              stack[++stackTop] = subtractDecimals(aVal, bVal);
+            } else if (op === OP_MULTIPLY) {
+              stack[++stackTop] = multiplyDecimals(aVal, bVal);
+            } else {
+              // Division — match OOP isInfinite guard: use a marker so
+              // comparisons can decide whether to preserve the expression.
+              const result = divideDecimals(aVal, bVal);
+              if (isUnusableResult(result)) {
+                // Push marker with original operands for reconstruction
+                const marker = {
+                  _r: 4,
+                  _val: result,
+                  left: aVal,
+                  right: bVal
+                };
+                stack[++stackTop] = marker;
+              } else {
+                stack[++stackTop] = result;
+              }
+            }
+            break;
+          }
+          // N-operand path
+          const values = new Array(n);
+          let hasNull = false;
+          for (let j = n - 1; j >= 0; j--) {
+            const v = slotVal(stack[stackTop--]);
+            if (v === null || v === undefined) {
+              hasNull = true;
+              break;
+            }
+            if (!isNumber(v)) {
+              throw new Error(`arithmetic operand is not a number: ${v}`);
+            }
+            // After the throw above, v is narrowed to number
+            values[j] = v;
+          }
+          const reduced = hasNull ? false : arithmeticReduce(values, op);
+          if (hasNull) {
+            stack[++stackTop] = false;
+          } else if (op === OP_DIVIDE && reduced !== false && isUnusableResult(reduced)) {
+            // N-operand division producing Infinity/NaN — create marker
+            const result = reduced;
+            const marker = {
+              _r: 4,
+              _val: result,
+              left: values[0],
+              right: values[1]
+            };
+            stack[++stackTop] = marker;
+          } else if (reduced !== false && isUnusableResult(reduced)) {
+            // Other arithmetic producing Infinity/NaN — preserve expression
+            stack[++stackTop] = makeResidual([opNames[op], ...values]);
+          } else {
+            stack[++stackTop] = reduced;
+          }
+          break;
+        }
+
+      // ---------------------------------------------------------------------
+      // Logical
+      // ---------------------------------------------------------------------
+      case OP_NOT:
+        {
+          const val = stack[stackTop];
+          if (needsReconstruct(val)) {
+            const src = slotSrc(val);
+            // If this NOT follows a NOR that already applied its simplification
+            // (multi-residual NOR pushes a NOR expression), pass it through unchanged.
+            if (Array.isArray(src) && src[0] === opNames[OP_NOR]) {
+              // Already a NOR expression — leave it as-is
+              break;
+            }
+            stack[stackTop] = makeResidual([opNames[op], src]);
+          } else {
+            const v = slotVal(val);
+            if (typeof v !== 'boolean') {
+              throw new Error('NOT: operand must be boolean');
+            }
+            stack[stackTop] = !v;
+          }
+          break;
+        }
+      case OP_JUMP_IF_FALSE:
+        {
+          const offset = numAt(bytecode[i++]);
+          const top = stack[stackTop];
+          if (!needsReconstruct(top) && slotVal(top) === false) {
+            i += offset;
+          }
+          // Clear spill buffer when transitioning between short-circuit sequences.
+          // Different jump opcodes (41=JUMP_IF_FALSE for AND vs 42=JUMP_IF_TRUE for OR/NOR)
+          // indicate different short-circuit sequences.
+          if (lastJumpOp !== 41) {
+            spillTop = -1;
+          }
+          lastJumpOp = 41;
+          break;
+        }
+      case OP_JUMP_IF_TRUE:
+        {
+          const offset = numAt(bytecode[i++]);
+          const top = stack[stackTop];
+          if (!needsReconstruct(top) && slotVal(top) === true) {
+            i += offset;
+          }
+          // Clear spill buffer when transitioning between short-circuit sequences.
+          if (lastJumpOp !== 42) {
+            spillTop = -1;
+          }
+          lastJumpOp = 42;
+          break;
+        }
+      case OP_POP:
+        {
+          const popped = stack[stackTop--];
+          // If this residual is being discarded in a short-circuit sequence,
+          // save it so OP_AND/OR/NOR can include it in the reconstructed expression.
+          if (needsReconstruct(popped)) {
+            spillBuf[++spillTop] = popped;
+          }
+          break;
+        }
+
+      // AND/OR/NOR markers — collect the current stack top plus any residuals
+      // that were spilled by OP_POP during the short-circuit sequence, then
+      // apply the simplification logic.
+      case OP_AND:
+        {
+          i++; // consume the operand count byte (unused — we use the spill buffer)
+          const top = stack[stackTop--];
+          // Fast path: nothing was spilled — all non-top operands were concrete.
+          // The top is either a short-circuit false, the last true, or a lone residual.
+          // Push top directly — slotVal unwrapping happens at the final return point.
+          if (spillTop < 0) {
+            spillTop = -1;
+            if (!needsReconstruct(top)) {
+              stack[++stackTop] = top;
+            } else {
+              stack[++stackTop] = makeResidual(slotSrc(top));
+            }
+            break;
+          }
+          const residuals = [];
+          // Drain spill buffer (residuals from earlier operands that were POP'd)
+          // Check if any spilled operand was false (dominates AND)
+          let andDominated = false;
+          for (let j = 0; j <= spillTop; j++) {
+            const v = spillBuf[j];
+            if (!needsReconstruct(v) && slotVal(v) === false) {
+              andDominated = true;
+              break;
+            }
+            if (needsReconstruct(v)) {
+              residuals.push(slotSrc(v));
+            }
+          }
+          spillTop = -1; // clear spill buffer
+          // Include the stack top (last operand result)
+          if (!andDominated) {
+            if (!needsReconstruct(top) && slotVal(top) === false) {
+              andDominated = true;
+            } else if (needsReconstruct(top)) {
+              residuals.push(slotSrc(top));
+            }
+          }
+          if (andDominated) {
+            stack[++stackTop] = false;
+          } else if (residuals.length === 0) {
+            stack[++stackTop] = true;
+          } else if (residuals.length === 1) {
+            stack[++stackTop] = makeResidual(residuals[0]);
+          } else {
+            stack[++stackTop] = makeResidual([opNames[op], ...residuals]);
+          }
+          break;
+        }
+      case OP_OR:
+        {
+          i++; // consume the operand count byte
+          const top = stack[stackTop--];
+          // Fast path: nothing was spilled — all non-top operands were concrete.
+          // Push top directly — slotVal unwrapping happens at the final return point.
+          if (spillTop < 0) {
+            spillTop = -1;
+            if (!needsReconstruct(top)) {
+              stack[++stackTop] = top;
+            } else {
+              stack[++stackTop] = makeResidual(slotSrc(top));
+            }
+            break;
+          }
+          const residuals = [];
+          let orDominated = false;
+          for (let j = 0; j <= spillTop; j++) {
+            const v = spillBuf[j];
+            if (!needsReconstruct(v) && slotVal(v) === true) {
+              orDominated = true;
+              break;
+            }
+            if (needsReconstruct(v)) {
+              residuals.push(slotSrc(v));
+            }
+          }
+          spillTop = -1;
+          if (!orDominated) {
+            if (!needsReconstruct(top) && slotVal(top) === true) {
+              orDominated = true;
+            } else if (needsReconstruct(top)) {
+              residuals.push(slotSrc(top));
+            }
+          }
+          if (orDominated) {
+            stack[++stackTop] = true;
+          } else if (residuals.length === 0) {
+            stack[++stackTop] = false;
+          } else if (residuals.length === 1) {
+            stack[++stackTop] = makeResidual(residuals[0]);
+          } else {
+            stack[++stackTop] = makeResidual([opNames[op], ...residuals]);
+          }
+          break;
+        }
+      case OP_NOR:
+        {
+          // Semantics: NOR = NOT OR. OP_NOT follows in bytecode.
+          // For concrete booleans, we push the OR result so OP_NOT negates it.
+          // For residuals with >1 terms, we apply NOR simplification directly
+          // (returning a NOR expression) and push a "NOR_DONE" residual that
+          // OP_NOT will pass through unchanged.
+          i++; // consume the operand count byte
+          const top = stack[stackTop--];
+          const residuals = [];
+          let dominated = false;
+          for (let j = 0; j <= spillTop; j++) {
+            const v = spillBuf[j];
+            if (!needsReconstruct(v) && slotVal(v) === true) {
+              dominated = true;
+              break;
+            }
+            if (needsReconstruct(v)) {
+              residuals.push(slotSrc(v));
+            }
+          }
+          spillTop = -1;
+          if (!dominated) {
+            if (!needsReconstruct(top) && slotVal(top) === true) {
+              dominated = true;
+            } else if (needsReconstruct(top)) {
+              residuals.push(slotSrc(top));
+            }
+          }
+          if (dominated) {
+            // OR was true → push true so OP_NOT yields false (= NOR false)
+            stack[++stackTop] = true;
+          } else if (residuals.length === 0) {
+            // All false → push false so OP_NOT yields true (= NOR true)
+            stack[++stackTop] = false;
+          } else if (residuals.length === 1) {
+            // Single residual — OP_NOT will wrap in NOT(residual) ✓
+            stack[++stackTop] = makeResidual(residuals[0]);
+          } else {
+            // Multiple residuals — push NOR expression directly.
+            // OP_NOT must pass it through unchanged (handled in OP_NOT case).
+            stack[++stackTop] = makeResidual([opNames[op], ...residuals]);
+          }
+          break;
+        }
+      case OP_XOR:
+        {
+          // XOR is compiled as chained binary: (((A XOR B) XOR C) XOR D).
+          // We accumulate residuals + trueCount into a XorState to defer finalization
+          // until we know all operands. The XorState is finalized when used by another
+          // operator or at the return point.
+          const b = stack[stackTop--];
+          const a = stack[stackTop--];
+
+          // If neither has unknowns, compute the binary XOR directly (no state needed)
+          // But for "one-hot" XOR semantics, if both are true, we need XorState(trueCount=2)
+          // so subsequent chained XORs also see trueCount > 1.
+          if (!needsReconstruct(a) && !needsReconstruct(b)) {
+            const av = slotVal(a) === true;
+            const bv = slotVal(b) === true;
+            const trueCount = (av ? 1 : 0) + (bv ? 1 : 0);
+            if (trueCount > 1) {
+              // Both true → "one-hot" XOR is false, but track trueCount for chained XORs
+              stack[++stackTop] = makeXorState([], trueCount);
+            } else {
+              stack[++stackTop] = (av || bv) && !(av && bv);
+            }
+            break;
+          }
+
+          // Accumulate into a XorState
+          let residuals;
+          let trueCount;
+          if (isXorState(a)) {
+            residuals = a.xorResiduals.slice();
+            trueCount = a.xorTrueCount;
+          } else if (!needsReconstruct(a)) {
+            residuals = [];
+            trueCount = slotVal(a) ? 1 : 0;
+          } else {
+            residuals = [slotSrc(a)];
+            trueCount = 0;
+          }
+          if (isXorState(b)) {
+            for (const r of b.xorResiduals) {
+              residuals.push(r);
+            }
+            trueCount += b.xorTrueCount;
+          } else if (!needsReconstruct(b)) {
+            if (slotVal(b)) {
+              trueCount++;
+            }
+          } else {
+            residuals.push(slotSrc(b));
+          }
+
+          // If no residuals, resolve immediately
+          // "One-hot" XOR: exactly one true → true, otherwise false
+          // This matches the OOP evaluator's behavior.
+          // Use XorState so subsequent chained XORs also see trueCount > 1.
+          if (trueCount > 1) {
+            stack[++stackTop] = makeXorState([], trueCount);
+            break;
+          }
+          if (residuals.length === 0) {
+            stack[++stackTop] = trueCount % 2 === 1;
+            break;
+          }
+
+          // Push accumulated state — finalized by slotSrc() when consumed by another op
+          stack[++stackTop] = makeXorState(residuals, trueCount);
+          break;
+        }
+      default:
+        throw new Error(`unknown opcode: ${op}`);
+    }
+  }
+
+  // Unwrap the top slot to a plain Result | Input
+  const top = stack[stackTop];
+  if (isXorState(top) || isResidual(top)) {
+    return slotSrc(top);
+  }
+  const result = slotVal(top);
+  if (result === undefined) {
+    throw new Error('simplify: unexpected undefined top-level result');
+  }
+  if (!isInput(result)) {
+    throw new Error('simplify: unexpected non-Input result');
+  }
+  return result;
+}
+
+class BytecodeEvaluable {
+  constructor(compiled, delegate) {
+    this.compiled = compiled;
+    this.delegate = delegate;
+    _defineProperty(this, "type", EvaluableType.Expression);
+  }
+  evaluate(ctx) {
+    return interpret(this.compiled, ctx);
+  }
+  simplify(ctx, strictKeys, optionalKeys) {
+    return interpretSimplify(this.compiled, ctx, strictKeys, optionalKeys);
+  }
+  serialize(options) {
+    return this.delegate.serialize(options);
+  }
+  toString() {
+    return this.delegate.toString();
+  }
+}
+
+/**
+ * Collection operand resolved containing mixture of value and references.
+ */
+class Collection extends Operand {
+  /**
+   * Get the items in the collection.
+   * @returns {Array<Value | Reference>}
+   */
+  getItems() {
+    return this.items;
+  }
+
+  /**
+   * @constructor
+   * @param {Operand[]} items Collection of operands.
+   */
+  constructor(items) {
+    super();
+    _defineProperty(this, "items", void 0);
+    this.items = items;
+  }
+
+  /**
+   * Evaluate in the given context.
+   * @param {Context} ctx
+   * @return {boolean}
+   */
+  evaluate(ctx) {
+    return this.items.map(item => item.evaluate(ctx));
+  }
+
+  /**
+   * {@link Evaluable.simplify}
+   */
+  simplify(...args) {
+    const values = [];
+    for (const item of this.items) {
+      const simplifiedItem = item.simplify(...args);
+      if (isEvaluable(simplifiedItem)) {
+        return this;
+      }
+      values.push(simplifiedItem);
+    }
+    return values;
+  }
+
+  /**
+   * {@link Evaluable.serialize}
+   */
+  serialize(options) {
+    return this.items.map(item => isEvaluable(item) ? item.serialize(options) : item);
+  }
+
+  /**
+   * Get the strict representation of the operand.
+   * @return {string}
+   */
+  toString() {
+    return '[' + this.items.map(item => item.toString()).join(', ') + ']';
+  }
+}
+
+// Option value whitelist
+
+/**
+ * Engine evaluator mode.
+ * - `'oop'` (default): evaluates expressions using the classic OOP evaluable tree.
+ * - `'bytecode'`: compiles expressions to bytecode and interprets them.
+ */
+
+// Parser options
+
+/**
+ * Default reference predicate.
+ * The "$" symbol at the begging of the operand is used
+ * to predicate the reference type.
+ * E.g. "$State", "$Country"
+ * @param {string} key
+ * @return {boolean}
+ */
+function defaultReferencePredicate(key) {
+  return typeof key === 'string' && key[0] === '$';
+}
+
+/**
+ * Default reference transform.
+ * It removes the "$" symbol at the begging of the operand name.
+ * @param {string} key
+ * @return {string}
+ */
+function defaultReferenceTransform(key) {
+  return key.slice(1);
+}
+function defaultReferenceSerialization(key) {
+  return `$${key}`;
+}
+
+// Default operator mapping
+// Unique operator key <-> raw expression key
+const defaultOperatorMapping = new Map([
+// Comparison
+[OPERATOR$h, '=='], [OPERATOR$b, '!='], [OPERATOR$f, '>'], [OPERATOR$g, '>='], [OPERATOR$c, '<'], [OPERATOR$d, '<='], [OPERATOR$e, 'IN'], [OPERATOR$a, 'NOT IN'], [OPERATOR$8, 'PREFIX'], [OPERATOR$6, 'SUFFIX'], [OPERATOR$9, 'OVERLAP'], [OPERATOR$5, 'UNDEFINED'], [OPERATOR$7, 'PRESENT'],
+// Logical
+[OPERATOR$4, 'AND'], [OPERATOR$1, 'OR'], [OPERATOR$2, 'NOR'], [OPERATOR, 'XOR'], [OPERATOR$3, 'NOT'],
+// Arithmetic
+[OPERATOR$i, '+'], [OPERATOR$j, '-'], [OPERATOR$k, '*'], [OPERATOR$l, '/']]);
+
+/**
+ * Default parser options
+ */
+const defaultOptions = {
+  referencePredicate: defaultReferencePredicate,
+  referenceTransform: defaultReferenceTransform,
+  referenceSerialization: defaultReferenceSerialization,
+  operatorMapping: defaultOperatorMapping
+};
+
+// Input types
+
+const invalidExpression = 'invalid expression';
+const logicalIfValidOperands = (operands, logical) => {
+  if (operands.every(operand => operand instanceof Logical || operand instanceof Comparison)) {
+    return logical;
+  }
+  throw new Error(invalidExpression);
+};
+
+/**
+ * Parser of raw expressions into Evaluable expression
+ */
+class Parser {
+  /**
+   * @constructor
+   * @param {Options?} options Parser options.
+   */
+  constructor(options) {
+    _defineProperty(this, "opts", void 0);
+    _defineProperty(this, "expectedRootOperators", void 0);
+    _defineProperty(this, "unexpectedRootSymbols", new Set([OPERATOR$i, OPERATOR$j, OPERATOR$k, OPERATOR$l]));
+    _defineProperty(this, "referenceCache", new Map());
+    this.opts = {
+      ...defaultOptions
+    };
+    // Apply exclusive options overrides
+    if (options) {
+      for (const key of Object.keys(options)) {
+        if (key in this.opts) {
+          Reflect.set(this.opts, key, Reflect.get(options, key));
         }
       }
     }
@@ -1809,6 +4778,9 @@ class Parser {
     let expression;
     let operandParser = this.getOperand;
     const operator = raw[0];
+    if (typeof operator !== 'string') {
+      return this.getOperand(raw);
+    }
     const operands = raw.slice(1);
 
     /**
@@ -1961,7 +4933,19 @@ class Engine {
    */
   constructor(options) {
     _defineProperty(this, "parser", void 0);
+    _defineProperty(this, "evaluator", void 0);
+    _defineProperty(this, "bytecodeCache", new WeakMap());
     this.parser = new Parser(options);
+    this.evaluator = options?.evaluator ?? 'oop';
+  }
+  getCompiled(exp) {
+    let compiled = this.bytecodeCache.get(exp);
+    if (compiled === undefined) {
+      this.parser.parse(exp); // validates root operator and expression structure
+      compiled = compile(exp, this.parser.options);
+      this.bytecodeCache.set(exp, compiled);
+    }
+    return compiled;
   }
 
   /**
@@ -1971,7 +4955,7 @@ class Engine {
    * @return {boolean}
    */
   evaluate(exp, ctx) {
-    const result = this.parse(exp).evaluate(ctx);
+    const result = this.evaluator === 'oop' ? this.parser.parse(exp).evaluate(ctx) : interpret(this.getCompiled(exp), ctx);
     if (isBoolean(result)) {
       return result;
     }
@@ -1993,7 +4977,10 @@ class Engine {
    * @return {Evaluable}
    */
   parse(exp) {
-    return this.parser.parse(exp);
+    if (this.evaluator === 'oop') {
+      return this.parser.parse(exp);
+    }
+    return new BytecodeEvaluable(this.getCompiled(exp), this.parser.parse(exp));
   }
 
   /**
@@ -2014,7 +5001,10 @@ class Engine {
    * @returns {Inpunt | boolean}
    */
   simplify(exp, context, strictKeys, optionalKeys) {
-    const result = this.parse(exp).simplify(context, strictKeys, optionalKeys);
+    if (this.evaluator === 'bytecode') {
+      return interpretSimplify(this.getCompiled(exp), context, strictKeys, optionalKeys);
+    }
+    const result = this.parser.parse(exp).simplify(context, strictKeys, optionalKeys);
     if (isEvaluable(result)) {
       return result.serialize(this.parser.options);
     }