@briza/illogical 2.2.1 → 2.2.3

package/lib/illogical.cjs

@@ -1810,6 +1810,12 @@ const OP_NOR = 55; // next: N — marker for NOR with N operands
 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;
+// Marks the entry of a short-circuit AND/OR/NOR scope.
+// Emitted by the compiler at the start of every emitShortCircuit block.
+// The evaluate interpreter treats it as a no-op.
+// The simplify interpreter uses it to push a spill-buffer scope marker so that
+// nested AND/OR/NOR blocks cannot steal residuals accumulated by an outer scope.
+const OP_ENTER_SCOPE = 58;
 
 /**
  * Reference path descriptors for the bytecode compiler and interpreter.
@@ -2287,7 +2293,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: right
+      vals: right,
+      operator: 'in'
     };
   }
 
@@ -2303,7 +2310,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: [right]
+      vals: [right],
+      operator: 'eq'
     };
   }
   return null;
@@ -2335,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)) {
@@ -2390,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);
       }
@@ -2401,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
   };
 }
 
@@ -2419,6 +2456,7 @@ function emitShortCircuit(arr, jumpOp, markerOp, state) {
   } = state;
   const jumpSlots = [];
   const last = arr.length - 1;
+  bytecode.push(OP_ENTER_SCOPE);
   for (let i = 1; i < last; i++) {
     emitExpression(arr[i], state);
     bytecode.push(jumpOp);
@@ -2465,18 +2503,22 @@ function emitExpression(raw, state) {
       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;
     }
@@ -3208,20 +3250,21 @@ 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, (v0, setBIdx0, ref1Op0, ref2Op0), (v1, 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;
               }
             }
@@ -3393,6 +3436,8 @@ function interpret(compiled, ctx) {
       case OP_POP:
         stackTop$1--;
         break;
+      case OP_ENTER_SCOPE:
+        break;
       case OP_AND:
       case OP_OR:
       case OP_NOR:
@@ -3679,10 +3724,12 @@ let resolvedRefUsedCount = 0;
 // 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;
+// Scope stack for the spill buffer: each OP_ENTER_SCOPE pushes the current
+// spillTop so that OP_AND/OR/NOR can drain only the entries added within their
+// own scope (base+1..spillTop) and restore the outer scope (spillTop = base).
+// This prevents nested AND/OR from stealing residuals accumulated by outer scopes.
+const scopeStack = new Array(MAX_STACK);
+let scopeStackTop = -1;
 function relationalCompare(left, right, op) {
   if (isNumber(left) && isNumber(right)) {
     if (op === OP_GT) {
@@ -3739,7 +3786,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
   } = compiled;
   stackTop = -1;
   spillTop = -1;
-  lastJumpOp = 0;
+  scopeStackTop = -1;
   let overlapRefsResiduals = overlapRefsResidualsCache.get(compiled);
   if (overlapRefsResiduals === undefined) {
     overlapRefsResiduals = new Map(compiled.overlapRefsResiduals);
@@ -4224,13 +4271,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);
@@ -4239,6 +4288,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];
@@ -4246,12 +4296,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;
           }
 
@@ -4259,8 +4368,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);
@@ -4499,13 +4608,6 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           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:
@@ -4515,13 +4617,11 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           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_ENTER_SCOPE:
+        scopeStack[++scopeStackTop] = spillTop;
+        break;
       case OP_POP:
         {
           const popped = stack[stackTop--];
@@ -4536,15 +4636,19 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
       // 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.
+      //
+      // Each of these opcodes pops the scope base that was pushed by the
+      // matching OP_ENTER_SCOPE at the start of the short-circuit block. Only
+      // spill entries above that base (indices base+1..spillTop) belong to this
+      // scope; entries at 0..base belong to outer scopes and are preserved by
+      // restoring spillTop = base after draining.
       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;
+          const base = scopeStack[scopeStackTop--];
+          // Fast path: no entries were spilled in this scope.
+          if (spillTop === base) {
             if (!needsReconstruct(top)) {
               stack[++stackTop] = top;
             } else {
@@ -4553,10 +4657,8 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
             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++) {
+          for (let j = base + 1; j <= spillTop; j++) {
             const v = spillBuf[j];
             if (!needsReconstruct(v) && slotVal(v) === false) {
               andDominated = true;
@@ -4566,8 +4668,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
               residuals.push(slotSrc(v));
             }
           }
-          spillTop = -1; // clear spill buffer
-          // Include the stack top (last operand result)
+          spillTop = base; // restore outer scope
           if (!andDominated) {
             if (!needsReconstruct(top) && slotVal(top) === false) {
               andDominated = true;
@@ -4590,10 +4691,9 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
         {
           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;
+          const base = scopeStack[scopeStackTop--];
+          // Fast path: no entries were spilled in this scope.
+          if (spillTop === base) {
             if (!needsReconstruct(top)) {
               stack[++stackTop] = top;
             } else {
@@ -4603,7 +4703,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           }
           const residuals = [];
           let orDominated = false;
-          for (let j = 0; j <= spillTop; j++) {
+          for (let j = base + 1; j <= spillTop; j++) {
             const v = spillBuf[j];
             if (!needsReconstruct(v) && slotVal(v) === true) {
               orDominated = true;
@@ -4613,7 +4713,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
               residuals.push(slotSrc(v));
             }
           }
-          spillTop = -1;
+          spillTop = base; // restore outer scope
           if (!orDominated) {
             if (!needsReconstruct(top) && slotVal(top) === true) {
               orDominated = true;
@@ -4641,9 +4741,10 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           // OP_NOT will pass through unchanged.
           i++; // consume the operand count byte
           const top = stack[stackTop--];
+          const base = scopeStack[scopeStackTop--];
           const residuals = [];
           let dominated = false;
-          for (let j = 0; j <= spillTop; j++) {
+          for (let j = base + 1; j <= spillTop; j++) {
             const v = spillBuf[j];
             if (!needsReconstruct(v) && slotVal(v) === true) {
               dominated = true;
@@ -4653,7 +4754,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
               residuals.push(slotSrc(v));
             }
           }
-          spillTop = -1;
+          spillTop = base; // restore outer scope
           if (!dominated) {
             if (!needsReconstruct(top) && slotVal(top) === true) {
               dominated = true;

package/lib/illogical.esm.js

@@ -1806,6 +1806,12 @@ const OP_NOR = 55; // next: N — marker for NOR with N operands
 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;
+// Marks the entry of a short-circuit AND/OR/NOR scope.
+// Emitted by the compiler at the start of every emitShortCircuit block.
+// The evaluate interpreter treats it as a no-op.
+// The simplify interpreter uses it to push a spill-buffer scope marker so that
+// nested AND/OR/NOR blocks cannot steal residuals accumulated by an outer scope.
+const OP_ENTER_SCOPE = 58;
 
 /**
  * Reference path descriptors for the bytecode compiler and interpreter.
@@ -2283,7 +2289,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: right
+      vals: right,
+      operator: 'in'
     };
   }
 
@@ -2299,7 +2306,8 @@ function extractInLikeChild(ca, state) {
     return {
       rawRef,
       refKey,
-      vals: [right]
+      vals: [right],
+      operator: 'eq'
     };
   }
   return null;
@@ -2331,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)) {
@@ -2386,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);
       }
@@ -2397,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
   };
 }
 
@@ -2415,6 +2452,7 @@ function emitShortCircuit(arr, jumpOp, markerOp, state) {
   } = state;
   const jumpSlots = [];
   const last = arr.length - 1;
+  bytecode.push(OP_ENTER_SCOPE);
   for (let i = 1; i < last; i++) {
     emitExpression(arr[i], state);
     bytecode.push(jumpOp);
@@ -2461,18 +2499,22 @@ function emitExpression(raw, state) {
       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;
     }
@@ -3204,20 +3246,21 @@ 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, (v0, setBIdx0, ref1Op0, ref2Op0), (v1, 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;
               }
             }
@@ -3389,6 +3432,8 @@ function interpret(compiled, ctx) {
       case OP_POP:
         stackTop$1--;
         break;
+      case OP_ENTER_SCOPE:
+        break;
       case OP_AND:
       case OP_OR:
       case OP_NOR:
@@ -3675,10 +3720,12 @@ let resolvedRefUsedCount = 0;
 // 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;
+// Scope stack for the spill buffer: each OP_ENTER_SCOPE pushes the current
+// spillTop so that OP_AND/OR/NOR can drain only the entries added within their
+// own scope (base+1..spillTop) and restore the outer scope (spillTop = base).
+// This prevents nested AND/OR from stealing residuals accumulated by outer scopes.
+const scopeStack = new Array(MAX_STACK);
+let scopeStackTop = -1;
 function relationalCompare(left, right, op) {
   if (isNumber(left) && isNumber(right)) {
     if (op === OP_GT) {
@@ -3735,7 +3782,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
   } = compiled;
   stackTop = -1;
   spillTop = -1;
-  lastJumpOp = 0;
+  scopeStackTop = -1;
   let overlapRefsResiduals = overlapRefsResidualsCache.get(compiled);
   if (overlapRefsResiduals === undefined) {
     overlapRefsResiduals = new Map(compiled.overlapRefsResiduals);
@@ -4220,13 +4267,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);
@@ -4235,6 +4284,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];
@@ -4242,12 +4292,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;
           }
 
@@ -4255,8 +4364,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);
@@ -4495,13 +4604,6 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           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:
@@ -4511,13 +4613,11 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           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_ENTER_SCOPE:
+        scopeStack[++scopeStackTop] = spillTop;
+        break;
       case OP_POP:
         {
           const popped = stack[stackTop--];
@@ -4532,15 +4632,19 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
       // 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.
+      //
+      // Each of these opcodes pops the scope base that was pushed by the
+      // matching OP_ENTER_SCOPE at the start of the short-circuit block. Only
+      // spill entries above that base (indices base+1..spillTop) belong to this
+      // scope; entries at 0..base belong to outer scopes and are preserved by
+      // restoring spillTop = base after draining.
       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;
+          const base = scopeStack[scopeStackTop--];
+          // Fast path: no entries were spilled in this scope.
+          if (spillTop === base) {
             if (!needsReconstruct(top)) {
               stack[++stackTop] = top;
             } else {
@@ -4549,10 +4653,8 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
             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++) {
+          for (let j = base + 1; j <= spillTop; j++) {
             const v = spillBuf[j];
             if (!needsReconstruct(v) && slotVal(v) === false) {
               andDominated = true;
@@ -4562,8 +4664,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
               residuals.push(slotSrc(v));
             }
           }
-          spillTop = -1; // clear spill buffer
-          // Include the stack top (last operand result)
+          spillTop = base; // restore outer scope
           if (!andDominated) {
             if (!needsReconstruct(top) && slotVal(top) === false) {
               andDominated = true;
@@ -4586,10 +4687,9 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
         {
           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;
+          const base = scopeStack[scopeStackTop--];
+          // Fast path: no entries were spilled in this scope.
+          if (spillTop === base) {
             if (!needsReconstruct(top)) {
               stack[++stackTop] = top;
             } else {
@@ -4599,7 +4699,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           }
           const residuals = [];
           let orDominated = false;
-          for (let j = 0; j <= spillTop; j++) {
+          for (let j = base + 1; j <= spillTop; j++) {
             const v = spillBuf[j];
             if (!needsReconstruct(v) && slotVal(v) === true) {
               orDominated = true;
@@ -4609,7 +4709,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
               residuals.push(slotSrc(v));
             }
           }
-          spillTop = -1;
+          spillTop = base; // restore outer scope
           if (!orDominated) {
             if (!needsReconstruct(top) && slotVal(top) === true) {
               orDominated = true;
@@ -4637,9 +4737,10 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
           // OP_NOT will pass through unchanged.
           i++; // consume the operand count byte
           const top = stack[stackTop--];
+          const base = scopeStack[scopeStackTop--];
           const residuals = [];
           let dominated = false;
-          for (let j = 0; j <= spillTop; j++) {
+          for (let j = base + 1; j <= spillTop; j++) {
             const v = spillBuf[j];
             if (!needsReconstruct(v) && slotVal(v) === true) {
               dominated = true;
@@ -4649,7 +4750,7 @@ function interpretSimplify(compiled, ctx, strictKeys, optionalKeys) {
               residuals.push(slotSrc(v));
             }
           }
-          spillTop = -1;
+          spillTop = base; // restore outer scope
           if (!dominated) {
             if (!needsReconstruct(top) && slotVal(top) === true) {
               dominated = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "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",
@@ -15,8 +15,8 @@
     "types/"
   ],
   "author": {
-    "name": "David Horak",
-    "email": "dhorak@briza.com"
+    "name": "Briza, Inc.",
+    "email": "dev@briza.com"
   },
   "license": "MIT",
   "scripts": {

package/readme.md

@@ -8,20 +8,18 @@
   <div align="center">
     <h3 align="center">illogical</h3>
   </div>
-</div>
 
-<div align="center">
   <p>
-  **illogical** 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.
+  <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>
-</div>
 
-<div align="center">
-  [![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>
 
 ---

package/types/bytecode/opcodes.d.ts

@@ -49,3 +49,4 @@ export declare const OP_OR = 54;
 export declare const OP_NOR = 55;
 export declare const OP_IN_SCAN_REFS_CONST = 56;
 export declare const OP_NOT_IN_SCAN_REFS_CONST = 57;
+export declare const OP_ENTER_SCOPE = 58;