@briza/illogical 2.2.2 → 2.2.4

package/lib/illogical.cjs

@@ -1304,7 +1304,7 @@ class Present extends Comparison {
 }
 
 // Operator key
-const OPERATOR$6 = Symbol('PREFIX');
+const OPERATOR$6 = Symbol('SUFFIX');
 
 /**
  * Suffix comparison expression
@@ -2293,7 +2293,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: right
+      vals: right,
+      operator: 'in'
     };
   }
 
@@ -2309,7 +2310,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: [right]
+      vals: [right],
+      operator: 'eq'
     };
   }
   return null;
@@ -2341,6 +2343,10 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Inverted index: each distinct setA value → merged setB values across all branches containing it
   const setBValsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref1 operand reconstruction)
+  const ref1OpsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref2 operand reconstruction)
+  const ref2OpsByAValue = new Map();
   for (let b = 1; b <= nBranches; b++) {
     const branch = arr[b];
     if (!Array.isArray(branch)) {
@@ -2396,6 +2402,20 @@ function detectOrAndIn2Pattern(arr, state) {
         setBVals = new Set();
         setBValsByAValue.set(aVal, setBVals);
       }
+      // Track ref1 operator
+      let r1Ops = ref1OpsByAValue.get(aVal);
+      if (r1Ops === undefined) {
+        r1Ops = new Set();
+        ref1OpsByAValue.set(aVal, r1Ops);
+      }
+      r1Ops.add(extA.operator);
+      // Track ref2 operator
+      let r2Ops = ref2OpsByAValue.get(aVal);
+      if (r2Ops === undefined) {
+        r2Ops = new Set();
+        ref2OpsByAValue.set(aVal, r2Ops);
+      }
+      r2Ops.add(extB.operator);
       for (const bVal of extB.vals) {
         setBVals.add(bVal);
       }
@@ -2407,14 +2427,25 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Build entries: one (literal aVal, mergedSetBIdx) per distinct setA value
   const entries = [];
+  // Track operators per entry: [ref1Op, ref2Op]
+  const entryOperators = [];
   for (const [aVal, setBVals] of setBValsByAValue) {
     const mergedSetB = [...setBVals].filter(v => v !== undefined);
-    entries.push([aVal, internConst(mergedSetB, state)]);
+    const constIdx = internConst(mergedSetB, state);
+    entries.push([aVal, constIdx]);
+    // Determine ref1 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r1Ops = ref1OpsByAValue.get(aVal);
+    const ref1Op = r1Ops !== undefined && r1Ops.size === 1 && r1Ops.has('eq') ? 'eq' : 'in';
+    // Determine ref2 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r2Ops = ref2OpsByAValue.get(aVal);
+    const ref2Op = r2Ops !== undefined && r2Ops.size === 1 && r2Ops.has('eq') ? 'eq' : 'in';
+    entryOperators.push([ref1Op, ref2Op]);
   }
   return {
     ref1Raw,
     ref2Raw,
-    entries
+    entries,
+    entryOperators
   };
 }
 
@@ -2467,23 +2498,29 @@ function emitExpression(raw, state) {
     return;
   }
   if (operator === maps.orOp) {
-    const orAnd2 = detectOrAndIn2Pattern(arr, state);
+    // Skip the merge when compiling for simplify so the nested structure can
+    // be reconstructed verbatim (the merge collapses branches by ref1 value).
+    const orAnd2 = state.simplify ? null : detectOrAndIn2Pattern(arr, state);
     if (orAnd2 !== null) {
       const {
         ref1Raw,
         ref2Raw,
-        entries
+        entries,
+        entryOperators
       } = 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
+      // Emit: OP_OR_AND_IN_CONST_2 ref1Idx ref2Idx M (aVal0 setBIdx0 ref1Op0 ref2Op0) ...
       // M is the number of distinct setA values across all branches (after inverted-index merge).
+      // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
       bytecode.push(OP_OR_AND_IN_CONST_2, ref1Idx, ref2Idx, entries.length);
-      for (const [aVal, mergedSetBIdx] of entries) {
-        bytecode.push(aVal, mergedSetBIdx);
+      for (let j = 0; j < entries.length; j++) {
+        const [aVal, mergedSetBIdx] = entries[j];
+        const [ref1Op, ref2Op] = entryOperators[j];
+        bytecode.push(aVal, mergedSetBIdx, ref1Op === 'in' ? 1 : 0, ref2Op === 'in' ? 1 : 0);
       }
       return;
     }
@@ -2740,7 +2777,7 @@ function emitExpression(raw, state) {
  * Compile a raw ExpressionInput into bytecode.
  * The result should be cached and reused across evaluate() calls.
  */
-function compile(raw, opts) {
+function compile(raw, opts, simplify = false) {
   const maps = buildOperatorMaps(opts);
   const state = {
     bytecode: [],
@@ -2755,7 +2792,8 @@ function compile(raw, opts) {
     consts: [],
     constIndex: new Map(),
     overlapRefsEntries: [],
-    directionEntries: []
+    directionEntries: [],
+    simplify
   };
   emitExpression(raw, state);
 
@@ -3215,20 +3253,22 @@ function interpret(compiled, ctx) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, v0, setBIdx0, v1, setBIdx1, ..., vM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M,
+          //   (aVal0, setBIdx0, ref1Op0, ref2Op0), (aVal1, setBIdx1, ref1Op1, ref2Op1), ...
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in' (unused at runtime, kept for simplifier)
           // 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;
+          i += m * 4;
           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);
+              if (bytecode[entriesStart + j * 4] === v1) {
+                found = constSets[numAt$1(bytecode[entriesStart + j * 4 + 1])].has(v2);
                 break;
               }
             }
@@ -3333,8 +3373,14 @@ function interpret(compiled, ctx) {
             break;
           }
           const values = new Array(n);
+          // Fixed destination slot for the single result value: the bottom-most
+          // operand slot. The operands occupy [stackTop - n + 1 .. stackTop].
+          // Writing here (instead of to stack[++stackTop]) keeps the result in a
+          // stable slot even when the loop below breaks early on a missing
+          // operand, so the next opcode never reads a stale operand value.
+          const resultSlot = stackTop$1 - n + 1;
           let hasNull = false;
-          const isDateArithmetic = !isNaN(toDateNumber(stack$1[stackTop$1 - n + 1])) && (op === OP_SUM || op === OP_SUBTRACT);
+          const isDateArithmetic = !isNaN(toDateNumber(stack$1[resultSlot])) && (op === OP_SUM || op === OP_SUBTRACT);
           for (let j = n - 1; j >= 0; j--) {
             const v = stack$1[stackTop$1--];
             if (v === null || v === undefined) {
@@ -3355,7 +3401,9 @@ function interpret(compiled, ctx) {
               values[j] = v;
             }
           }
-          stack$1[++stackTop$1] = hasNull ? false : isDateArithmetic && (op === OP_SUM || op === OP_SUBTRACT) && values.every(v => isString(v)) ? dateArithmeticReduce$1(values, op) : values.every(v => isNumber(v)) ? arithmeticReduce$1(values, op) : false;
+          const result = hasNull ? false : isDateArithmetic && (op === OP_SUM || op === OP_SUBTRACT) && values.every(v => isString(v)) ? dateArithmeticReduce$1(values, op) : values.every(v => isNumber(v)) ? arithmeticReduce$1(values, op) : false;
+          stack$1[resultSlot] = result;
+          stackTop$1 = resultSlot;
           break;
         }
 
@@ -4235,13 +4283,15 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, aVal0, setBIdx0, aVal1, setBIdx1, ..., aValM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M, (aVal0, setBIdx0, ref1Op0, ref2Op0),
+          //   (aVal1, setBIdx1, ref1Op1, ref2Op1), ...
           // aVal_j is a literal value; setBIdx_j is a constIdx for the merged setB.
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
           const ref1Idx = numAt(bytecode[i++]);
           const ref2Idx = numAt(bytecode[i++]);
           const n = numAt(bytecode[i++]);
-          const pairsStart = i;
-          i += n * 2;
+          const quadsStart = i;
+          i += n * 4;
           const rawKey1 = refRawKeys[ref1Idx];
           const rawKey2 = refRawKeys[ref2Idx];
           const v1 = resolveCompactRef(refs[ref1Idx], ctx);
@@ -4250,6 +4300,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           const unknown2 = v2 === undefined && !strictSet?.has(rawKey2) && (!optionalSet || optionalSet.has(rawKey2));
           if (unknown1 || unknown2) {
             // Reconstruct the original complex expression tree
+            // When one ref is known, only include entries where the known ref matches
             const branches = [opNames[OP_OR]];
             const andOp = opNames[OP_AND];
             const eqOp = opNames[OP_EQ];
@@ -4257,12 +4308,71 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
             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]]);
+              const aVal = literalAt(bytecode[quadsStart + j * 4]);
+              const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
+              const ref1OpByte = numAt(bytecode[quadsStart + j * 4 + 2]);
+              const ref2OpByte = numAt(bytecode[quadsStart + j * 4 + 3]);
+              // Use the original operators for both operands
+              const op1 = ref1OpByte === 1 ? inOp : eqOp;
+              const op2 = ref2OpByte === 1 ? inOp : eqOp;
+              // When reconstructing == with a scalar, use the scalar value
+              // When reconstructing IN with a scalar, wrap it in an array
+              const r1Val = op1 === eqOp ? aVal : [aVal];
+              let r2Val = setB;
+              if (op2 === eqOp && Array.isArray(setB) && setB.length === 1) {
+                r2Val = setB[0];
+              }
+              // Skip entries where the known ref doesn't match
+              if (!unknown1 && v1 !== undefined && v1 !== null) {
+                // ref1 is known — only include matching entries
+                // For ==, check exact match; for IN, check if value is in set
+                let matches = false;
+                if (op1 === eqOp) {
+                  matches = v1 === aVal;
+                } else {
+                  matches = Array.isArray(v1) ? v1.includes(aVal) : v1 === aVal;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              if (!unknown2 && v2 !== undefined && v2 !== null) {
+                // ref2 is known — only include matching entries
+                let matches = false;
+                if (op2 === eqOp) {
+                  matches = v2 === r2Val;
+                } else {
+                  // setB is always an array here (it's a compiled const)
+                  matches = Array.isArray(v2) ? setB.some(item => item === v2) : v2 === r2Val;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              // Build the AND branch, omitting known refs that already matched
+              const branchOperands = [];
+              if (unknown1) {
+                branchOperands.push([op1, r1, r1Val]);
+              }
+              if (unknown2) {
+                branchOperands.push([op2, r2, r2Val]);
+              }
+              if (branchOperands.length === 1) {
+                branches.push(branchOperands[0]);
+              } else {
+                branches.push([andOp, ...branchOperands]);
+              }
+            }
+            // Handle edge cases: no matches → false, single match → unwrap OR
+            if (branches.length === 1) {
+              // No entries matched
+              stack[++stackTop] = false;
+            } else if (branches.length === 2) {
+              // Only one entry matched — unwrap the OR
+              stack[++stackTop] = branches[1];
+            } else {
+              stack[++stackTop] = makeResidual(branches);
             }
-            stack[++stackTop] = makeResidual(branches);
             break;
           }
 
@@ -4270,8 +4380,8 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           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])];
+              if (bytecode[quadsStart + j * 4] === v1) {
+                const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
                 let s = overlapSetCache.get(setB);
                 if (s === undefined) {
                   s = new Set(setB);
@@ -5147,6 +5257,11 @@ class Engine {
     _defineProperty(this, "parser", void 0);
     _defineProperty(this, "evaluator", void 0);
     _defineProperty(this, "bytecodeCache", new WeakMap());
+    // Separate cache for the simplify compiler output. Simplify must preserve the
+    // nested structure verbatim, so it compiles with the OR_AND_IN merge disabled
+    // (see `compile`'s `simplify` flag), which yields different bytecode than the
+    // evaluate path and therefore cannot share `bytecodeCache`.
+    _defineProperty(this, "simplifyCache", new WeakMap());
     this.parser = new Parser(options);
     this.evaluator = options?.evaluator ?? 'oop';
   }
@@ -5160,6 +5275,20 @@ class Engine {
     return compiled;
   }
 
+  /**
+   * Compile for simplify: preserves the original nested structure so the
+   * simplify interpreter can reproduce the input verbatim (no OR_AND_IN merge).
+   */
+  getSimplifiedCompiled(exp) {
+    let compiled = this.simplifyCache.get(exp);
+    if (compiled === undefined) {
+      this.parser.parse(exp); // validates root operator and expression structure
+      compiled = compile(exp, this.parser.options, true);
+      this.simplifyCache.set(exp, compiled);
+    }
+    return compiled;
+  }
+
   /**
    * Evaluate the expression.
    * @param {ExpressionInput} exp Raw expression.
@@ -5214,7 +5343,7 @@ class Engine {
    */
   simplify(exp, context, strictKeys, optionalKeys) {
     if (this.evaluator === 'bytecode') {
-      return interpretSimplify(this.getCompiled(exp), context, strictKeys, optionalKeys);
+      return interpretSimplify(this.getSimplifiedCompiled(exp), context, strictKeys, optionalKeys);
     }
     const result = this.parser.parse(exp).simplify(context, strictKeys, optionalKeys);
     if (isEvaluable(result)) {

package/lib/illogical.esm.js

@@ -1300,7 +1300,7 @@ class Present extends Comparison {
 }
 
 // Operator key
-const OPERATOR$6 = Symbol('PREFIX');
+const OPERATOR$6 = Symbol('SUFFIX');
 
 /**
  * Suffix comparison expression
@@ -2289,7 +2289,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: right
+      vals: right,
+      operator: 'in'
     };
   }
 
@@ -2305,7 +2306,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: [right]
+      vals: [right],
+      operator: 'eq'
     };
   }
   return null;
@@ -2337,6 +2339,10 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Inverted index: each distinct setA value → merged setB values across all branches containing it
   const setBValsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref1 operand reconstruction)
+  const ref1OpsByAValue = new Map();
+  // Track which operators were used for each setA value (for ref2 operand reconstruction)
+  const ref2OpsByAValue = new Map();
   for (let b = 1; b <= nBranches; b++) {
     const branch = arr[b];
     if (!Array.isArray(branch)) {
@@ -2392,6 +2398,20 @@ function detectOrAndIn2Pattern(arr, state) {
         setBVals = new Set();
         setBValsByAValue.set(aVal, setBVals);
       }
+      // Track ref1 operator
+      let r1Ops = ref1OpsByAValue.get(aVal);
+      if (r1Ops === undefined) {
+        r1Ops = new Set();
+        ref1OpsByAValue.set(aVal, r1Ops);
+      }
+      r1Ops.add(extA.operator);
+      // Track ref2 operator
+      let r2Ops = ref2OpsByAValue.get(aVal);
+      if (r2Ops === undefined) {
+        r2Ops = new Set();
+        ref2OpsByAValue.set(aVal, r2Ops);
+      }
+      r2Ops.add(extB.operator);
       for (const bVal of extB.vals) {
         setBVals.add(bVal);
       }
@@ -2403,14 +2423,25 @@ function detectOrAndIn2Pattern(arr, state) {
 
   // Build entries: one (literal aVal, mergedSetBIdx) per distinct setA value
   const entries = [];
+  // Track operators per entry: [ref1Op, ref2Op]
+  const entryOperators = [];
   for (const [aVal, setBVals] of setBValsByAValue) {
     const mergedSetB = [...setBVals].filter(v => v !== undefined);
-    entries.push([aVal, internConst(mergedSetB, state)]);
+    const constIdx = internConst(mergedSetB, state);
+    entries.push([aVal, constIdx]);
+    // Determine ref1 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r1Ops = ref1OpsByAValue.get(aVal);
+    const ref1Op = r1Ops !== undefined && r1Ops.size === 1 && r1Ops.has('eq') ? 'eq' : 'in';
+    // Determine ref2 operator: if all branches used 'eq', preserve 'eq'; otherwise use 'in'
+    const r2Ops = ref2OpsByAValue.get(aVal);
+    const ref2Op = r2Ops !== undefined && r2Ops.size === 1 && r2Ops.has('eq') ? 'eq' : 'in';
+    entryOperators.push([ref1Op, ref2Op]);
   }
   return {
     ref1Raw,
     ref2Raw,
-    entries
+    entries,
+    entryOperators
   };
 }
 
@@ -2463,23 +2494,29 @@ function emitExpression(raw, state) {
     return;
   }
   if (operator === maps.orOp) {
-    const orAnd2 = detectOrAndIn2Pattern(arr, state);
+    // Skip the merge when compiling for simplify so the nested structure can
+    // be reconstructed verbatim (the merge collapses branches by ref1 value).
+    const orAnd2 = state.simplify ? null : detectOrAndIn2Pattern(arr, state);
     if (orAnd2 !== null) {
       const {
         ref1Raw,
         ref2Raw,
-        entries
+        entries,
+        entryOperators
       } = 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
+      // Emit: OP_OR_AND_IN_CONST_2 ref1Idx ref2Idx M (aVal0 setBIdx0 ref1Op0 ref2Op0) ...
       // M is the number of distinct setA values across all branches (after inverted-index merge).
+      // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
       bytecode.push(OP_OR_AND_IN_CONST_2, ref1Idx, ref2Idx, entries.length);
-      for (const [aVal, mergedSetBIdx] of entries) {
-        bytecode.push(aVal, mergedSetBIdx);
+      for (let j = 0; j < entries.length; j++) {
+        const [aVal, mergedSetBIdx] = entries[j];
+        const [ref1Op, ref2Op] = entryOperators[j];
+        bytecode.push(aVal, mergedSetBIdx, ref1Op === 'in' ? 1 : 0, ref2Op === 'in' ? 1 : 0);
       }
       return;
     }
@@ -2736,7 +2773,7 @@ function emitExpression(raw, state) {
  * Compile a raw ExpressionInput into bytecode.
  * The result should be cached and reused across evaluate() calls.
  */
-function compile(raw, opts) {
+function compile(raw, opts, simplify = false) {
   const maps = buildOperatorMaps(opts);
   const state = {
     bytecode: [],
@@ -2751,7 +2788,8 @@ function compile(raw, opts) {
     consts: [],
     constIndex: new Map(),
     overlapRefsEntries: [],
-    directionEntries: []
+    directionEntries: [],
+    simplify
   };
   emitExpression(raw, state);
 
@@ -3211,20 +3249,22 @@ function interpret(compiled, ctx) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, v0, setBIdx0, v1, setBIdx1, ..., vM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M,
+          //   (aVal0, setBIdx0, ref1Op0, ref2Op0), (aVal1, setBIdx1, ref1Op1, ref2Op1), ...
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in' (unused at runtime, kept for simplifier)
           // 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;
+          i += m * 4;
           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);
+              if (bytecode[entriesStart + j * 4] === v1) {
+                found = constSets[numAt$1(bytecode[entriesStart + j * 4 + 1])].has(v2);
                 break;
               }
             }
@@ -3329,8 +3369,14 @@ function interpret(compiled, ctx) {
             break;
           }
           const values = new Array(n);
+          // Fixed destination slot for the single result value: the bottom-most
+          // operand slot. The operands occupy [stackTop - n + 1 .. stackTop].
+          // Writing here (instead of to stack[++stackTop]) keeps the result in a
+          // stable slot even when the loop below breaks early on a missing
+          // operand, so the next opcode never reads a stale operand value.
+          const resultSlot = stackTop$1 - n + 1;
           let hasNull = false;
-          const isDateArithmetic = !isNaN(toDateNumber(stack$1[stackTop$1 - n + 1])) && (op === OP_SUM || op === OP_SUBTRACT);
+          const isDateArithmetic = !isNaN(toDateNumber(stack$1[resultSlot])) && (op === OP_SUM || op === OP_SUBTRACT);
           for (let j = n - 1; j >= 0; j--) {
             const v = stack$1[stackTop$1--];
             if (v === null || v === undefined) {
@@ -3351,7 +3397,9 @@ function interpret(compiled, ctx) {
               values[j] = v;
             }
           }
-          stack$1[++stackTop$1] = hasNull ? false : isDateArithmetic && (op === OP_SUM || op === OP_SUBTRACT) && values.every(v => isString(v)) ? dateArithmeticReduce$1(values, op) : values.every(v => isNumber(v)) ? arithmeticReduce$1(values, op) : false;
+          const result = hasNull ? false : isDateArithmetic && (op === OP_SUM || op === OP_SUBTRACT) && values.every(v => isString(v)) ? dateArithmeticReduce$1(values, op) : values.every(v => isNumber(v)) ? arithmeticReduce$1(values, op) : false;
+          stack$1[resultSlot] = result;
+          stackTop$1 = resultSlot;
           break;
         }
 
@@ -4231,13 +4279,15 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
         }
       case OP_OR_AND_IN_CONST_2:
         {
-          // bytecode layout: ref1Idx, ref2Idx, M, aVal0, setBIdx0, aVal1, setBIdx1, ..., aValM-1, setBIdxM-1
+          // bytecode layout: ref1Idx, ref2Idx, M, (aVal0, setBIdx0, ref1Op0, ref2Op0),
+          //   (aVal1, setBIdx1, ref1Op1, ref2Op1), ...
           // aVal_j is a literal value; setBIdx_j is a constIdx for the merged setB.
+          // ref1Op/ref2Op: 0 for 'eq', 1 for 'in'
           const ref1Idx = numAt(bytecode[i++]);
           const ref2Idx = numAt(bytecode[i++]);
           const n = numAt(bytecode[i++]);
-          const pairsStart = i;
-          i += n * 2;
+          const quadsStart = i;
+          i += n * 4;
           const rawKey1 = refRawKeys[ref1Idx];
           const rawKey2 = refRawKeys[ref2Idx];
           const v1 = resolveCompactRef(refs[ref1Idx], ctx);
@@ -4246,6 +4296,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           const unknown2 = v2 === undefined && !strictSet?.has(rawKey2) && (!optionalSet || optionalSet.has(rawKey2));
           if (unknown1 || unknown2) {
             // Reconstruct the original complex expression tree
+            // When one ref is known, only include entries where the known ref matches
             const branches = [opNames[OP_OR]];
             const andOp = opNames[OP_AND];
             const eqOp = opNames[OP_EQ];
@@ -4253,12 +4304,71 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
             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]]);
+              const aVal = literalAt(bytecode[quadsStart + j * 4]);
+              const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
+              const ref1OpByte = numAt(bytecode[quadsStart + j * 4 + 2]);
+              const ref2OpByte = numAt(bytecode[quadsStart + j * 4 + 3]);
+              // Use the original operators for both operands
+              const op1 = ref1OpByte === 1 ? inOp : eqOp;
+              const op2 = ref2OpByte === 1 ? inOp : eqOp;
+              // When reconstructing == with a scalar, use the scalar value
+              // When reconstructing IN with a scalar, wrap it in an array
+              const r1Val = op1 === eqOp ? aVal : [aVal];
+              let r2Val = setB;
+              if (op2 === eqOp && Array.isArray(setB) && setB.length === 1) {
+                r2Val = setB[0];
+              }
+              // Skip entries where the known ref doesn't match
+              if (!unknown1 && v1 !== undefined && v1 !== null) {
+                // ref1 is known — only include matching entries
+                // For ==, check exact match; for IN, check if value is in set
+                let matches = false;
+                if (op1 === eqOp) {
+                  matches = v1 === aVal;
+                } else {
+                  matches = Array.isArray(v1) ? v1.includes(aVal) : v1 === aVal;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              if (!unknown2 && v2 !== undefined && v2 !== null) {
+                // ref2 is known — only include matching entries
+                let matches = false;
+                if (op2 === eqOp) {
+                  matches = v2 === r2Val;
+                } else {
+                  // setB is always an array here (it's a compiled const)
+                  matches = Array.isArray(v2) ? setB.some(item => item === v2) : v2 === r2Val;
+                }
+                if (!matches) {
+                  continue;
+                }
+              }
+              // Build the AND branch, omitting known refs that already matched
+              const branchOperands = [];
+              if (unknown1) {
+                branchOperands.push([op1, r1, r1Val]);
+              }
+              if (unknown2) {
+                branchOperands.push([op2, r2, r2Val]);
+              }
+              if (branchOperands.length === 1) {
+                branches.push(branchOperands[0]);
+              } else {
+                branches.push([andOp, ...branchOperands]);
+              }
+            }
+            // Handle edge cases: no matches → false, single match → unwrap OR
+            if (branches.length === 1) {
+              // No entries matched
+              stack[++stackTop] = false;
+            } else if (branches.length === 2) {
+              // Only one entry matched — unwrap the OR
+              stack[++stackTop] = branches[1];
+            } else {
+              stack[++stackTop] = makeResidual(branches);
             }
-            stack[++stackTop] = makeResidual(branches);
             break;
           }
 
@@ -4266,8 +4376,8 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           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])];
+              if (bytecode[quadsStart + j * 4] === v1) {
+                const setB = compiled.consts[numAt(bytecode[quadsStart + j * 4 + 1])];
                 let s = overlapSetCache.get(setB);
                 if (s === undefined) {
                   s = new Set(setB);
@@ -5143,6 +5253,11 @@ class Engine {
     _defineProperty(this, "parser", void 0);
     _defineProperty(this, "evaluator", void 0);
     _defineProperty(this, "bytecodeCache", new WeakMap());
+    // Separate cache for the simplify compiler output. Simplify must preserve the
+    // nested structure verbatim, so it compiles with the OR_AND_IN merge disabled
+    // (see `compile`'s `simplify` flag), which yields different bytecode than the
+    // evaluate path and therefore cannot share `bytecodeCache`.
+    _defineProperty(this, "simplifyCache", new WeakMap());
     this.parser = new Parser(options);
     this.evaluator = options?.evaluator ?? 'oop';
   }
@@ -5156,6 +5271,20 @@ class Engine {
     return compiled;
   }
 
+  /**
+   * Compile for simplify: preserves the original nested structure so the
+   * simplify interpreter can reproduce the input verbatim (no OR_AND_IN merge).
+   */
+  getSimplifiedCompiled(exp) {
+    let compiled = this.simplifyCache.get(exp);
+    if (compiled === undefined) {
+      this.parser.parse(exp); // validates root operator and expression structure
+      compiled = compile(exp, this.parser.options, true);
+      this.simplifyCache.set(exp, compiled);
+    }
+    return compiled;
+  }
+
   /**
    * Evaluate the expression.
    * @param {ExpressionInput} exp Raw expression.
@@ -5210,7 +5339,7 @@ class Engine {
    */
   simplify(exp, context, strictKeys, optionalKeys) {
     if (this.evaluator === 'bytecode') {
-      return interpretSimplify(this.getCompiled(exp), context, strictKeys, optionalKeys);
+      return interpretSimplify(this.getSimplifiedCompiled(exp), context, strictKeys, optionalKeys);
     }
     const result = this.parser.parse(exp).simplify(context, strictKeys, optionalKeys);
     if (isEvaluable(result)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "2.2.2",
+  "version": "2.2.4",
   "description": "A micro conditional javascript engine used to parse the raw logical and comparison expressions, evaluate the expression in the given data context, and provide access to a text form of the given expressions.",
   "type": "module",
   "main": "./lib/illogical.cjs",
@@ -24,10 +24,9 @@
     "build:types": "tsc --project tsconfig.build.json --emitDeclarationOnly",
     "build:js": "rollup -c",
     "build": "rm -rf lib types && npm run build:types && npm run build:js",
-    "docs": "typedoc src && git checkout docs/.nojekyll",
-    "test": "node --import tsx --test \"src/**/*.test.ts\"",
+    "test": "bash -c 'node --import tsx --test \"${@:-src/__test__/unit/**/*.test.ts}\"' --",
     "test:sample-conditions": "node --import tsx --test --test-reporter=spec \"src/__test__/unit/sample-conditions.test.ts\"",
-    "test:coverage": "node --import tsx --test --experimental-test-coverage --test-reporter=spec --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=coverage.lcov \"src/**/*.test.ts\"",
+    "test:coverage": "node --import tsx --test --experimental-test-coverage --test-reporter=spec --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=coverage.lcov \"src/__test__/unit/**/*.test.ts\"",
     "lint": "eslint --max-warnings 0 \"src/**/*.{ts,js}\"",
     "lint:fix": "eslint --max-warnings 0 \"src/**/*.{ts,js}\" --fix",
     "prepublishOnly": "npm run test && npm run build",
@@ -53,8 +52,11 @@
     "bench:synthetic:report:simplify": "node --import tsx src/benchmark/report.ts benchmark/results-synthetic-simplify-oop.json benchmark/results-synthetic-simplify-bytecode.json --op simplify --out benchmark/report-synthetic-simplify.md",
     "bench:sample:report:full:simplify": "node --import tsx src/benchmark/report.ts benchmark/results-sample-simplify-oop.json    benchmark/results-sample-simplify-bytecode.json    --op simplify --full --out benchmark/report-sample-simplify-full.md",
     "bench:synthetic:report:full:simplify": "node --import tsx src/benchmark/report.ts benchmark/results-synthetic-simplify-oop.json benchmark/results-synthetic-simplify-bytecode.json --op simplify --full --out benchmark/report-synthetic-simplify-full.md",
+    "bench:full:report:test-case": "sh -c 'FILTER=$(echo \"$@\" | sed -n \"s/.*--filter \\([^ ]*\\).*/\\1/p\"); if [ -z \"$FILTER\" ]; then FILTER=\"tmp\"; fi; node --import tsx src/benchmark/simplify.ts --cases conditions/sample-conditions \"$@\" --out benchmark/results-simplify-${FILTER}-oop.json && node --import tsx src/benchmark/simplify.ts --cases conditions/sample-conditions \"$@\" --options '\\''{\"evaluator\":\"bytecode\"}'\\'' --out benchmark/results-simplify-${FILTER}-bytecode.json && node --import tsx src/benchmark/report.ts benchmark/results-simplify-${FILTER}-oop.json benchmark/results-simplify-${FILTER}-bytecode.json --op simplify --out benchmark/report-simplify-${FILTER}.md && echo \"\\nReport written to benchmark/report-simplify-${FILTER}.md\" && node --import tsx src/benchmark/evaluate.ts --cases conditions/sample-conditions \"$@\" --out benchmark/results-evaluate-${FILTER}-oop.json && node --import tsx src/benchmark/evaluate.ts --cases conditions/sample-conditions \"$@\" --options '\\''{\"evaluator\":\"bytecode\"}'\\'' --out benchmark/results-evaluate-${FILTER}-bytecode.json && node --import tsx src/benchmark/report.ts benchmark/results-evaluate-${FILTER}-oop.json benchmark/results-evaluate-${FILTER}-bytecode.json --op evaluate --out benchmark/report-evaluate-${FILTER}.md && echo \"\\nReport written to benchmark/report-evaluate-${FILTER}.md\"' -- ",
     "get-bytecode": "node --import tsx src/bytecode/get-bytecode.ts",
-    "debug-bytecode": "node --import tsx src/tools/debugger.ts"
+    "debug-bytecode": "node --import tsx src/tools/debugger.ts",
+    "test:fuzz": "node --import tsx src/tools/fuzz-runner.ts",
+    "test:fuzz:deep": "FUZZ_RUNS=100000 npm run test:fuzz"
   },
   "repository": {
     "type": "git",
@@ -92,12 +94,12 @@
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",
+    "fast-check": "^4.8.0",
     "license-checker": "^25.0.1",
     "prettier": "^3.6.2",
     "rollup": "^4.52.5",
     "tinybench": "^6.0.0",
     "tsx": "^4.19.1",
-    "typedoc": "^0.28.18",
     "typescript": "^6.0.2"
   }
 }

package/readme.md

@@ -13,11 +13,13 @@
   <strong>illogical</strong> is a JSON DSL (domain-specific language) for expressing and evaluating business rules in the insurance industry. Underwriters use illogical to model business rules for their question sets, enabling distributors to render great user experiences.
   </p>
 
-  [![build status](https://github.com/briza-insurance/illogical/actions/workflows/test.yml/badge.svg)](https://github.com/briza-insurance/illogical/actions?branch=master)
-  [![npm version](https://badge.fury.io/js/@briza%2Fillogical.svg?icon=si%3Anpm)](https://badge.fury.io/js/@briza%2Fillogical)
-  [![install size](https://packagephobia.com/badge?p=@briza/illogical)](https://packagephobia.com/result?p=@briza/illogical)
-  ![zero dependencies](https://img.shields.io/badge/0-dependencies-green)
-  ![npm downloads](https://img.shields.io/npm/dm/%40briza%2Fillogical)
+[![build status](https://github.com/briza-insurance/illogical/actions/workflows/test.yml/badge.svg)](https://github.com/briza-insurance/illogical/actions?branch=master)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/briza-insurance/illogical/badge)](https://scorecard.dev/viewer/?uri=github.com/briza-insurance/illogical)
+[![npm version](https://badge.fury.io/js/@briza%2Fillogical.svg?icon=si%3Anpm)](https://badge.fury.io/js/@briza%2Fillogical)
+[![install size](https://packagephobia.com/badge?p=@briza/illogical)](https://packagephobia.com/result?p=@briza/illogical)
+![zero dependencies](https://img.shields.io/badge/0-dependencies-green)
+![npm downloads](https://img.shields.io/npm/dm/%40briza%2Fillogical)
+
 </div>
 
 ---
@@ -26,6 +28,8 @@
 
 Get up and running with illogical in just a few steps.
 
+Read the [Background](#background) section to quickly understand what illogical is and why it exists. 
+
 ### Installation
 
 ```sh
@@ -67,6 +71,18 @@ engine.evaluate(['AND', ['>', '$age', 20], ['==', '$name', 'peter']]) // true
 
 ## 📚 Documentation
 
+### Background
+
+**illogical** is a JSON DSL (domain-specific language) for expressing and evaluating business rules in the insurance industry.
+
+Domain-specific languages exist to streamline work in a given domain by providing the means of performing tasks in a way that is quicker to learn and implement. This lets you optimize your custom solution and tailor it for use by distinct user groups or within unique contexts.
+
+Developers of software for insurance underwriters can enable illogical quickly and easily to make the underwriter's task of writing question sets for programmatic use more efficient by eliminating the need to learn and understand the programming language(s) in use.
+
+The way it works is that underwriters use the illogical JSON DSL to express their underwriting models, specifically their question sets and business rules. Then, the JavaScript functions in illogical parse what has been written for use within an application.
+
+Another way to think about this is that illogical is used to define machine-readable business rules for underwriting models and question sets that brokers and distribution partners can easily consume. This is much more efficient than the traditional use of spreadsheets, documents, PDFs, email exchanges, and other non-machine-readable formats that then must be translated before being used. illogical speeds up the integration process, gets your rules to market faster, and does so with significantly reduced submission errors and a lower total cost of ownership.
+
 ### Core Concepts
 
 Explore the supported expressions and their usage:
@@ -88,10 +104,7 @@ Learn how to use the engine and its methods:
 
 ### Customization
 
-Customize the engine and the documentation:
-
-- [Engine Options](./specs/engine.md)
-- [Code Documentation](https://briza-insurance.github.io/illogical/index.html)
+Customize the [engine options](./specs/engine.md).
 
 ### Development Tools
 

package/types/bytecode/compiler.d.ts

@@ -10,6 +10,63 @@ import { ArrayInput, ExpressionInput, Input } from '../parser/index.js';
 import { Options } from '../parser/options.js';
 import { CompactRef } from './refs.js';
 export type Bytecode = (number | Result)[];
+interface OperatorMaps {
+    binary: Record<string, number>;
+    arithmetic: Record<string, number>;
+    presentOp: string;
+    undefinedOp: string;
+    andOp: string;
+    orOp: string;
+    norOp: string;
+    notOp: string;
+    xorOp: string;
+    inOp: string;
+    notInOp: string;
+    overlapOp: string;
+    eqOp: string;
+}
+export interface CompilerState {
+    bytecode: Bytecode;
+    refs: CompactRef[];
+    refIndex: Map<string, number>;
+    refRawKeys: string[];
+    refKeys: string[];
+    opts: Options;
+    maps: OperatorMaps;
+    collectionCse: Map<string, number>;
+    numLocals: number;
+    consts: ArrayInput[];
+    constIndex: Map<string, number>;
+    overlapRefsEntries: Array<{
+        pos: number;
+        refIdxs: number[];
+    }>;
+    directionEntries: Array<{
+        pos: number;
+        dir: 0 | 1;
+    }>;
+    simplify: boolean;
+}
+/**
+ * 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.
+ */
+export declare function detectOrAndIn2Pattern(arr: ArrayInput, state: CompilerState): {
+    ref1Raw: string;
+    ref2Raw: string;
+    entries: Array<[Result, number]>;
+    entryOperators: Array<['eq' | 'in', 'eq' | 'in']>;
+} | null;
 export interface CompiledExpression {
     bytecode: Bytecode;
     refs: CompactRef[];
@@ -26,4 +83,5 @@ export interface CompiledExpression {
  * Compile a raw ExpressionInput into bytecode.
  * The result should be cached and reused across evaluate() calls.
  */
-export declare function compile(raw: ExpressionInput, opts: Options): CompiledExpression;
+export declare function compile(raw: ExpressionInput, opts: Options, simplify?: boolean): CompiledExpression;
+export {};

package/types/common/evaluable.d.ts

@@ -3,7 +3,7 @@ import { Options } from '../parser/options.js';
 /**
  * Valid types for context members
  */
-type ContextValue = Record<string, unknown> | string | number | boolean | null | undefined | ContextValue[];
+export type ContextValue = Record<string, unknown> | string | number | boolean | null | undefined | ContextValue[];
 /**
  * Evaluation Context
  * Holds references used during the evaluation process.
@@ -56,4 +56,3 @@ export interface Evaluable {
     toString(): string;
 }
 export type SimplifyArgs = Parameters<Evaluable['simplify']>;
-export {};

package/types/index.d.ts

@@ -39,12 +39,18 @@ declare class Engine {
     private readonly parser;
     private readonly evaluator;
     private readonly bytecodeCache;
+    private readonly simplifyCache;
     /**
      * @constructor
      * @param {Options?} options Parser options.
      */
     constructor(options?: Partial<Options>);
     private getCompiled;
+    /**
+     * Compile for simplify: preserves the original nested structure so the
+     * simplify interpreter can reproduce the input verbatim (no OR_AND_IN merge).
+     */
+    private getSimplifiedCompiled;
     /**
      * Evaluate the expression.
      * @param {ExpressionInput} exp Raw expression.