eyeling 1.25.3 → 1.25.5

package/lib/engine.js

@@ -484,6 +484,158 @@ function __varOccursElsewhereInPremise(premise, name, idx, field) {
   return false;
 }
 
+
+function __scopedPriorityForTerm(t) {
+  if (t instanceof GraphTerm) return 0;
+  const p0 = __logNaturalPriorityFromTerm(t);
+  return p0 !== null && p0 >= 1 ? p0 : 1;
+}
+
+function __pushScopedQueryTriplesFromGraph(term, out) {
+  if (!(term instanceof GraphTerm)) return;
+  for (const tr of term.triples) out.push(tr);
+}
+
+function __analyzeForwardRuleScopedUse(rule) {
+  const out = {
+    needsSnap: false,
+    baseLevel: 0,
+    queryTriples: [],
+    hasScopedAggregate: false,
+  };
+
+  if (!rule || !Array.isArray(rule.premise)) return out;
+
+  for (let i = 0; i < rule.premise.length; i++) {
+    const tr = rule.premise[i];
+    if (!(tr && tr.p instanceof Iri)) continue;
+    const pv = tr.p.value;
+
+    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
+      // Explicit quoted scopes are local formulas, not snapshots of the global closure.
+      if (tr.s instanceof GraphTerm) continue;
+
+      // A scope variable that is bound by another premise may become an explicit GraphTerm.
+      // Still, if it remains unbound at runtime the builtin treats it as priority 1.
+      // We therefore record the scoped use, but only use quoted object triples for
+      // dependency analysis; variables inside the quoted object do not bind the scope.
+      out.needsSnap = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.s));
+      __pushScopedQueryTriplesFromGraph(tr.o, out.queryTriples);
+      continue;
+    }
+
+    if (pv === LOG_NS + 'collectAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 3) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+      continue;
+    }
+
+    if (pv === LOG_NS + 'forAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 2) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[0], out.queryTriples);
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+    }
+  }
+
+  return out;
+}
+
+function __triplePatternsMayOverlap(a, b) {
+  return unifyTriple(a, b, __emptySubst()) !== null || unifyTriple(b, a, __emptySubst()) !== null;
+}
+
+function __ruleConclusionsMayFeedScopedQueries(producer, consumerMeta) {
+  if (!consumerMeta || !consumerMeta.queryTriples || consumerMeta.queryTriples.length === 0) return false;
+
+  // Dynamic conclusions are only known after a proof solution. Conservatively
+  // assume they can feed any scoped query if the producing rule is scoped.
+  if (producer && producer.__dynamicConclusionTerm) return true;
+
+  if (!producer || !Array.isArray(producer.conclusion) || producer.conclusion.length === 0) return false;
+  for (const q of consumerMeta.queryTriples) {
+    for (const h of producer.conclusion) {
+      if (__triplePatternsMayOverlap(q, h)) return true;
+    }
+  }
+  return false;
+}
+
+function __setForwardRuleScopedStratumInfo(rule, level) {
+  const value =
+    level > 0
+      ? { needsSnap: true, requiredLevel: level, exactLevel: true }
+      : { needsSnap: false, requiredLevel: 0, exactLevel: false };
+
+  if (!hasOwn.call(rule, '__scopedStratumInfo')) {
+    Object.defineProperty(rule, '__scopedStratumInfo', {
+      value,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+  } else {
+    rule.__scopedStratumInfo = value;
+  }
+}
+
+function __computeForwardRuleScopedStrata(forwardRules) {
+  if (!Array.isArray(forwardRules) || forwardRules.length === 0) return 0;
+
+  const metas = forwardRules.map((r) => __analyzeForwardRuleScopedUse(r));
+  const levels = metas.map((m) => (m.needsSnap ? Math.max(1, m.baseLevel || 1) : 0));
+
+  let maxLevel = 0;
+  for (const lvl of levels) if (lvl > maxLevel) maxLevel = lvl;
+
+  // Stratify scoped rules by data dependency: if a scoped query can read facts
+  // produced by another scoped rule, the reader must run against a later frozen
+  // snapshot. This prevents non-monotonic scoped builtins such as collectAllIn
+  // from emitting an early result before lower strata have derived their facts.
+  const passLimit = Math.max(1, forwardRules.length) + maxLevel + 1;
+  for (let pass = 0; pass < passLimit; pass++) {
+    let changed = false;
+    for (let ci = 0; ci < forwardRules.length; ci++) {
+      if (!metas[ci].needsSnap || !metas[ci].hasScopedAggregate) continue;
+      let needed = levels[ci];
+      for (let pi = 0; pi < forwardRules.length; pi++) {
+        if (pi === ci) continue;
+        if (levels[pi] <= 0) continue;
+        if (metas[pi].hasScopedAggregate) continue;
+        if (!__ruleConclusionsMayFeedScopedQueries(forwardRules[pi], metas[ci])) continue;
+        needed = Math.max(needed, levels[pi] + 1);
+      }
+      if (needed !== levels[ci]) {
+        levels[ci] = needed;
+        if (needed > maxLevel) maxLevel = needed;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+
+
+  maxLevel = 0;
+  for (let i = 0; i < forwardRules.length; i++) {
+    __setForwardRuleScopedStratumInfo(forwardRules[i], levels[i]);
+    if (levels[i] > maxLevel) maxLevel = levels[i];
+  }
+
+  return maxLevel;
+}
+
 function __computeForwardRuleScopedSkipInfo(rule) {
   let needsSnap = false;
   let requiredLevel = 0;
@@ -1034,6 +1186,12 @@ function alphaEqGraphTriples(xs, ys, opts) {
 //   - __byPred: Map<predicateId, number[]>   (indices into facts array)
 //   - __byPS:   Map<predicateId, Map<subjectId, number[]>>
 //   - __byPO:   Map<predicateId, Map<objectId, number[]>>
+//   - __byPNonFastS / __byPNonFastO: Map<predicateId, number[]>
+//       IRI-predicate facts whose subject/object cannot be indexed by fast key.
+//       These are the fallback clauses for a constrained subject/object, just
+//       like a Prolog clause index keeps variable-headed clauses as fallback.
+//   - __varPred* indexes: facts whose predicate is a Var.  Only these non-IRI
+//       predicate facts can unify with a ground IRI predicate goal.
 //   - __keySet: Set<"S\tP\tO"> for Iri/Literal/Blank-only triples (fast dup check)
 //
 // Backward rules:
@@ -1049,6 +1207,8 @@ const __compoundKeyToTid = new Map();
 // Use a negative id space so we never collide with __tid (which is positive).
 let __nextCompoundTid = -1;
 
+const EMPTY_FACT_INDEX_BUCKET = Object.freeze([]);
+
 function __internCompoundTid(key) {
   const hit = __compoundKeyToTid.get(key);
   if (hit !== undefined) return hit;
@@ -1100,6 +1260,71 @@ function termFastKey(t) {
   return null;
 }
 
+function encodeLookupKeyPart(k) {
+  if (typeof k === 'number') return 'T' + k;
+  const s = String(k);
+  return 'K' + s.length + ':' + s;
+}
+
+function literalLookupKey(t) {
+  const boolInfo = parseBooleanLiteralInfo(t);
+  if (boolInfo) return '\u0000B' + (boolInfo.value ? '1' : '0');
+
+  const numInfo = parseNumericLiteralInfo(t);
+  if (numInfo) {
+    if (numInfo.kind === 'bigint') return '\u0000N' + numInfo.dt + '\u0000' + numInfo.value.toString();
+
+    const n = numInfo.value;
+    // Normal unification intentionally does not make NaN value-equal to NaN;
+    // only identical lexical literals match through the ordinary __tid path.
+    if (!Number.isNaN(n)) return '\u0000N' + numInfo.dt + '\u0000' + String(n);
+  }
+
+  // Covers exact literals plus plain string / xsd:string canonicalization, which
+  // Literal construction already normalizes into a shared __tid.
+  return termFastKey(t);
+}
+
+function termLookupKey(t) {
+  // Lookup keys summarize the equality accepted by ordinary unifyTerm(), not
+  // merely object identity.  This keeps literal-index pruning complete for
+  // value-equivalent booleans/numerics such as true/"1"^^xsd:boolean and
+  // 1.0/1.00, while preserving exact fast ids for IRIs, blanks, and strings.
+  if (t instanceof Iri) {
+    if (t.value === RDF_NIL_IRI) return '\u0000L0';
+    return t.__tid;
+  }
+  if (t instanceof Blank) return t.__tid;
+  if (t instanceof Literal) return literalLookupKey(t);
+
+  if (t instanceof ListTerm) {
+    const cached = t.__lookupKey;
+    if (cached !== undefined) return cached === false ? null : cached;
+
+    const xs = t.elems;
+    if (xs.length === 0) {
+      Object.defineProperty(t, '__lookupKey', { value: '\u0000L0', enumerable: false });
+      return '\u0000L0';
+    }
+
+    const parts = new Array(xs.length);
+    for (let i = 0; i < xs.length; i++) {
+      const k = termLookupKey(xs[i]);
+      if (k === null) {
+        Object.defineProperty(t, '__lookupKey', { value: false, enumerable: false });
+        return null;
+      }
+      parts[i] = encodeLookupKeyPart(k);
+    }
+
+    const key = '\u0000L' + xs.length + '\u0001' + parts.join('\u0001');
+    Object.defineProperty(t, '__lookupKey', { value: key, enumerable: false });
+    return key;
+  }
+
+  return null;
+}
+
 function tripleFastKey(tr) {
   const ks = termFastKey(tr.s);
   const kp = termFastKey(tr.p);
@@ -1113,9 +1338,13 @@ function ensureFactIndexes(facts) {
     facts.__byPred &&
     facts.__byPS &&
     facts.__byPO &&
-    facts.__wildPred &&
-    facts.__wildPS &&
-    facts.__wildPO &&
+    facts.__byPNonFastS &&
+    facts.__byPNonFastO &&
+    facts.__varPred &&
+    facts.__varPredPS &&
+    facts.__varPredPO &&
+    facts.__varPredNonFastS &&
+    facts.__varPredNonFastO &&
     facts.__keySet
   )
     return;
@@ -1135,21 +1364,41 @@ function ensureFactIndexes(facts) {
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPred', {
+  Object.defineProperty(facts, '__byPNonFastS', {
+    value: new Map(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__byPNonFastO', {
+    value: new Map(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__varPred', {
     value: [],
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPS', {
+  Object.defineProperty(facts, '__varPredPS', {
     value: new Map(),
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPO', {
+  Object.defineProperty(facts, '__varPredPO', {
     value: new Map(),
     enumerable: false,
     writable: true,
   });
+  Object.defineProperty(facts, '__varPredNonFastS', {
+    value: [],
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__varPredNonFastO', {
+    value: [],
+    enumerable: false,
+    writable: true,
+  });
   Object.defineProperty(facts, '__keySet', {
     value: new Set(),
     enumerable: false,
@@ -1190,16 +1439,53 @@ function cloneFactIndexesForSnapshot(src, dest) {
   Object.defineProperty(dest, '__byPred', { value: cloneArrayMap(src.__byPred), enumerable: false, writable: true });
   Object.defineProperty(dest, '__byPS', { value: cloneNestedArrayMap(src.__byPS), enumerable: false, writable: true });
   Object.defineProperty(dest, '__byPO', { value: cloneNestedArrayMap(src.__byPO), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPred', { value: src.__wildPred.slice(), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPS', { value: cloneArrayMap(src.__wildPS), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPO', { value: cloneArrayMap(src.__wildPO), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__byPNonFastS', {
+    value: cloneArrayMap(src.__byPNonFastS),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__byPNonFastO', {
+    value: cloneArrayMap(src.__byPNonFastO),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPred', { value: src.__varPred.slice(), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__varPredPS', {
+    value: cloneArrayMap(src.__varPredPS),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredPO', {
+    value: cloneArrayMap(src.__varPredPO),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredNonFastS', {
+    value: src.__varPredNonFastS.slice(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredNonFastO', {
+    value: src.__varPredNonFastO.slice(),
+    enumerable: false,
+    writable: true,
+  });
   Object.defineProperty(dest, '__keySet', { value: new Set(src.__keySet), enumerable: false, writable: true });
   Object.defineProperty(dest, '__keySetComplete', { value: !!src.__keySetComplete, enumerable: false, writable: true });
 }
 
+function addToIndexArrayMap(map, key, value) {
+  let bucket = map.get(key);
+  if (!bucket) {
+    bucket = [];
+    map.set(key, bucket);
+  }
+  bucket.push(value);
+}
+
 function indexFact(facts, tr, idx, addKeySet = true) {
-  const sk = termFastKey(tr.s);
-  const ok = termFastKey(tr.o);
+  const sk = termLookupKey(tr.s);
+  const ok = termLookupKey(tr.o);
   let pkForKey = null;
 
   if (tr.p instanceof Iri) {
@@ -1220,12 +1506,9 @@ function indexFact(facts, tr, idx, addKeySet = true) {
         ps = new Map();
         facts.__byPS.set(pk, ps);
       }
-      let psb = ps.get(sk);
-      if (!psb) {
-        psb = [];
-        ps.set(sk, psb);
-      }
-      psb.push(idx);
+      addToIndexArrayMap(ps, sk, idx);
+    } else {
+      addToIndexArrayMap(facts.__byPNonFastS, pk, idx);
     }
 
     if (ok !== null) {
@@ -1234,32 +1517,23 @@ function indexFact(facts, tr, idx, addKeySet = true) {
         po = new Map();
         facts.__byPO.set(pk, po);
       }
-      let pob = po.get(ok);
-      if (!pob) {
-        pob = [];
-        po.set(ok, pob);
-      }
-      pob.push(idx);
+      addToIndexArrayMap(po, ok, idx);
+    } else {
+      addToIndexArrayMap(facts.__byPNonFastO, pk, idx);
     }
-  } else {
-    facts.__wildPred.push(idx);
+  } else if (tr.p instanceof Var) {
+    facts.__varPred.push(idx);
 
     if (sk !== null) {
-      let psb = facts.__wildPS.get(sk);
-      if (!psb) {
-        psb = [];
-        facts.__wildPS.set(sk, psb);
-      }
-      psb.push(idx);
+      addToIndexArrayMap(facts.__varPredPS, sk, idx);
+    } else {
+      facts.__varPredNonFastS.push(idx);
     }
 
     if (ok !== null) {
-      let pob = facts.__wildPO.get(ok);
-      if (!pob) {
-        pob = [];
-        facts.__wildPO.set(ok, pob);
-      }
-      pob.push(idx);
+      addToIndexArrayMap(facts.__varPredPO, ok, idx);
+    } else {
+      facts.__varPredNonFastO.push(idx);
     }
   }
 
@@ -1269,55 +1543,86 @@ function indexFact(facts, tr, idx, addKeySet = true) {
   }
 }
 
+function mergeIndexBuckets(primary, fallback) {
+  const a = primary && primary.length ? primary : null;
+  const b = fallback && fallback.length ? fallback : null;
+  if (!a && !b) return EMPTY_FACT_INDEX_BUCKET;
+  if (!a) return b;
+  if (!b) return a;
+  const out = new Array(a.length + b.length);
+  for (let i = 0; i < a.length; i++) out[i] = a[i];
+  for (let i = 0; i < b.length; i++) out[a.length + i] = b[i];
+  return out;
+}
+
+function selectPositionIndexedCandidates(all, exactByS, fallbackS, sk, exactByO, fallbackO, ok) {
+  if (sk === null && ok === null) return all && all.length ? all : EMPTY_FACT_INDEX_BUCKET;
+
+  let sBucket = null;
+  if (sk !== null) sBucket = mergeIndexBuckets(exactByS || null, fallbackS || null);
+
+  let oBucket = null;
+  if (ok !== null) oBucket = mergeIndexBuckets(exactByO || null, fallbackO || null);
+
+  if (sk !== null && ok !== null) return sBucket.length <= oBucket.length ? sBucket : oBucket;
+  return sk !== null ? sBucket : oBucket;
+}
+
 function candidateFacts(facts, goal) {
   ensureFactIndexes(facts);
 
   if (goal.p instanceof Iri) {
     const pk = goal.p.__tid;
 
-    const sk = termFastKey(goal.s);
-    const ok = termFastKey(goal.o);
+    const sk = termLookupKey(goal.s);
+    const ok = termLookupKey(goal.o);
 
-    /** @type {number[] | null} */
     let byPS = null;
     if (sk !== null) {
       const ps = facts.__byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
     }
+    const byPNonFastS = sk !== null ? facts.__byPNonFastS.get(pk) || null : null;
 
-    /** @type {number[] | null} */
     let byPO = null;
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
       if (po) byPO = po.get(ok) || null;
     }
+    const byPNonFastO = ok !== null ? facts.__byPNonFastO.get(pk) || null : null;
+
+    const exact = selectPositionIndexedCandidates(
+      facts.__byPred.get(pk) || null,
+      byPS,
+      byPNonFastS,
+      sk,
+      byPO,
+      byPNonFastO,
+      ok,
+    );
 
-    let exact = null;
-    if (byPS && byPO) exact = byPS.length <= byPO.length ? byPS : byPO;
-    else if (byPS) exact = byPS;
-    else if (byPO) exact = byPO;
-    else exact = facts.__byPred.get(pk) || null;
-
-    /** @type {number[] | null} */
-    let wildPS = null;
-    if (sk !== null) wildPS = facts.__wildPS.get(sk) || null;
+    let varPredPS = null;
+    if (sk !== null) varPredPS = facts.__varPredPS.get(sk) || null;
 
-    /** @type {number[] | null} */
-    let wildPO = null;
-    if (ok !== null) wildPO = facts.__wildPO.get(ok) || null;
+    let varPredPO = null;
+    if (ok !== null) varPredPO = facts.__varPredPO.get(ok) || null;
 
-    let wild = null;
-    if (wildPS && wildPO) wild = wildPS.length <= wildPO.length ? wildPS : wildPO;
-    else if (wildPS) wild = wildPS;
-    else if (wildPO) wild = wildPO;
-    else wild = facts.__wildPred.length ? facts.__wildPred : null;
+    const wild = selectPositionIndexedCandidates(
+      facts.__varPred,
+      varPredPS,
+      sk !== null ? facts.__varPredNonFastS : null,
+      sk,
+      varPredPO,
+      ok !== null ? facts.__varPredNonFastO : null,
+      ok,
+    );
 
     return {
-      exact: exact || null,
-      wild: wild || null,
-      exactLen: exact ? exact.length : 0,
-      wildLen: wild ? wild.length : 0,
-      totalLen: (exact ? exact.length : 0) + (wild ? wild.length : 0),
+      exact,
+      wild,
+      exactLen: exact.length,
+      wildLen: wild.length,
+      totalLen: exact.length + wild.length,
     };
   }
 
@@ -1335,20 +1640,28 @@ function hasFactIndexed(facts, tr) {
 
   if (tr.p instanceof Iri) {
     const pk = tr.p.__tid;
+    const sk = termLookupKey(tr.s);
+    let best = null;
+
+    if (sk !== null) {
+      const ps = facts.__byPS.get(pk);
+      if (!ps) return false;
+      const psb = ps.get(sk);
+      if (!psb || psb.length === 0) return false;
+      best = psb;
+    }
 
-    const ok = termFastKey(tr.o);
+    const ok = termLookupKey(tr.o);
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
-      if (po) {
-        const pob = po.get(ok) || [];
-        // Facts are all in the same graph. Different blank node labels represent
-        // different existentials unless explicitly connected. Do NOT treat
-        // triples as duplicates modulo blank renaming, or you'll incorrectly
-        // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
-        return pob.some((i) => triplesEqual(facts[i], tr));
-      }
+      if (!po) return false;
+      const pob = po.get(ok);
+      if (!pob || pob.length === 0) return false;
+      if (!best || pob.length < best.length) best = pob;
     }
 
+    if (best) return best.some((i) => triplesEqual(facts[i], tr));
+
     const pb = facts.__byPred.get(pk) || [];
     return pb.some((i) => triplesEqual(facts[i], tr));
   }
@@ -1457,11 +1770,25 @@ function mergeSinglePremiseAgendaBuckets() {
   return out;
 }
 
+function termContainsVarForAgenda(t) {
+  if (t instanceof Var) return true;
+  if (t instanceof ListTerm) return t.elems.some(termContainsVarForAgenda);
+  if (t instanceof OpenListTerm) return true;
+  if (t instanceof GraphTerm)
+    return t.triples.some(
+      (tr) =>
+        termContainsVarForAgenda(tr.s) || termContainsVarForAgenda(tr.p) || termContainsVarForAgenda(tr.o),
+    );
+  return false;
+}
+
 function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
   const index = {
     byPred: new Map(),
+    byPredAll: new Map(),
     byPS: new Map(),
     byPO: new Map(),
+    allIriPred: [],
     wildPred: [],
     wildPS: new Map(),
     wildPO: new Map(),
@@ -1483,8 +1810,8 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     if (!isSinglePremiseAgendaRuleSafe(r, backRules)) continue;
 
     const goal = r.premise[0];
-    const goalSKey = termFastKey(goal.s);
-    const goalOKey = termFastKey(goal.o);
+    const goalSKey = termLookupKey(goal.s);
+    const goalOKey = termLookupKey(goal.o);
     const fastSubjectVar = goal.p instanceof Iri && goal.s instanceof Var && goalOKey !== null ? goal.s.name : null;
     const fastObjectVar = goal.p instanceof Iri && goal.o instanceof Var && goalSKey !== null ? goal.o.name : null;
     const entry = {
@@ -1494,7 +1821,7 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
       goalPredTid: goal.p instanceof Iri ? goal.p.__tid : null,
       goalSKey,
       goalOKey,
-      needsSkipCheck: !!r.__needsForwardSkipCheck,
+      needsSkipCheck: !!(r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)),
       fastSubjectVar,
       fastObjectVar,
     };
@@ -1503,6 +1830,8 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     index.size += 1;
 
     if (entry.goalPredTid !== null) {
+      addToMapArray(index.byPredAll, entry.goalPredTid, entry);
+      index.allIriPred.push(entry);
       if (entry.goalSKey === null && entry.goalOKey === null) addToMapArray(index.byPred, entry.goalPredTid, entry);
       if (entry.goalSKey !== null) {
         let ps = index.byPS.get(entry.goalPredTid);
@@ -1533,25 +1862,37 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
 function getSinglePremiseAgendaCandidates(index, fact) {
   if (!index || index.size === 0) return null;
 
-  const sk = termFastKey(fact.s);
-  const ok = termFastKey(fact.o);
+  const sk = termLookupKey(fact.s);
+  const ok = termLookupKey(fact.o);
 
   let exact = null;
   if (fact.p instanceof Iri) {
     const pk = fact.p.__tid;
-    const byPred = index.byPred.get(pk) || null;
-    let byPS = null;
-    if (sk !== null) {
+    if ((sk === null && termContainsVarForAgenda(fact.s)) || (ok === null && termContainsVarForAgenda(fact.o))) {
+      // A fact with a variable-bearing subject/object (most importantly a
+      // top-level variable fact such as `?S :p ?O.`) can match rules whose
+      // premise is fixed in that position. The ordinary `(p,s)` / `(p,o)` lookup
+      // would miss those rules, so fall back to all agenda-indexed rules for
+      // this predicate. Do not do this merely for non-fast quoted formulas:
+      // they are not wildcards, and broad fallback would over-fire rules that
+      // rely on protected blank-node/formula unification semantics.
+      exact = index.byPredAll.get(pk) || null;
+    } else {
+      const byPred = index.byPred.get(pk) || null;
+      let byPS = null;
       const ps = index.byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
-    }
-    let byPO = null;
-    if (ok !== null) {
+      let byPO = null;
       const po = index.byPO.get(pk);
       if (po) byPO = po.get(ok) || null;
-    }
 
-    exact = mergeSinglePremiseAgendaBuckets(byPred, byPS, byPO);
+      exact = mergeSinglePremiseAgendaBuckets(byPred, byPS, byPO);
+    }
+  } else if (fact.p instanceof Var) {
+    // A variable-predicate fact can match any IRI-predicate agenda rule.
+    // This is deliberately broad and relies on final unification below; such
+    // facts are uncommon and correctness matters more than over-indexing them.
+    exact = index.allIriPred.length ? index.allIriPred : null;
   }
 
   const wildPred = index.wildPred.length ? index.wildPred : null;
@@ -2928,7 +3269,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     let scopedClosureLevel = 0;
 
     // Scan known rules for the maximum requested closure priority in scoped log:* goals.
-    let maxScopedClosurePriorityNeeded = __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules);
+    let maxScopedClosurePriorityNeeded = Math.max(
+      __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+      __computeForwardRuleScopedStrata(forwardRules),
+    );
 
     // Conservative fast-skip for forward rules that cannot possibly succeed
     // until a scoped snapshot exists (or a given closure level is reached).
@@ -2982,12 +3326,16 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // until a snapshot exists (and a certain closure level is reached).
       // This prevents expensive proofs that will definitely fail in Phase A
       // and in early closure levels.
-      const info = r.__scopedSkipInfo;
+      const info = r.__scopedStratumInfo || r.__scopedSkipInfo;
       if (info && info.needsSnap) {
         const snapHere = facts.__scopedSnapshot || null;
         const lvlHere = (facts && typeof facts.__scopedClosureLevel === 'number' && facts.__scopedClosureLevel) || 0;
         if (!snapHere) return true;
-        if (lvlHere < info.requiredLevel) return true;
+        if (info.exactLevel) {
+          if (lvlHere !== info.requiredLevel) return true;
+        } else if (lvlHere < info.requiredLevel) {
+          return true;
+        }
       }
 
       // Optimization: if the rule head is **structurally ground** (no vars anywhere, even inside
@@ -3187,6 +3535,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
             const outcome = __emitForwardRuleSolution(r, entry.ruleIndex, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -3200,7 +3552,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         for (let i = 0; i < forwardRules.length; i++) {
           const r = forwardRules[i];
           if (agendaIndex.indexed.has(r)) continue;
-          if (r.__needsForwardSkipCheck && __skipForwardRuleNow(r)) continue;
+          if ((r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)) && __skipForwardRuleNow(r)) continue;
 
           const headIsStrictGround = r.__headIsStrictGround;
           const maxSols = r.isFuse || headIsStrictGround ? 1 : undefined;
@@ -3221,6 +3573,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           for (const s of sols) {
             const outcome = __emitForwardRuleSolution(r, i, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -3248,8 +3604,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // Rules may have been added dynamically (rule-producing triples), possibly
       // introducing scoped builtins and/or higher closure priorities.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       // If there are no scoped builtins in the entire program, Phase B is pure
@@ -3267,8 +3623,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
       // Phase B can also derive rule-producing triples.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       if (!changedA && !changedB && scopedClosureLevel >= maxScopedClosurePriorityNeeded) break;