eyeling 1.26.2 → 1.26.4

package/eyeling.js

@@ -5535,6 +5535,27 @@ const INFERENCE_FUSE_EXIT_CODE = 65;
 const RDF_NIL_IRI = RDF_NS + 'nil';
 const EMPTY_LIST_TERM = new ListTerm([]);
 
+const LOG_COLLECT_ALL_IN_IRI = LOG_NS + 'collectAllIn';
+const LOG_FOR_ALL_IN_IRI = LOG_NS + 'forAllIn';
+const LOG_INCLUDES_IRI = LOG_NS + 'includes';
+const LOG_NOT_INCLUDES_IRI = LOG_NS + 'notIncludes';
+const LOG_IMPLIES_IRI = LOG_NS + 'implies';
+const LOG_IMPLIED_BY_IRI = LOG_NS + 'impliedBy';
+
+const MATH_BUILTINS_SATISFIABLE_WHEN_FULLY_UNBOUND = new Set([
+  MATH_NS + 'sin',
+  MATH_NS + 'cos',
+  MATH_NS + 'tan',
+  MATH_NS + 'asin',
+  MATH_NS + 'acos',
+  MATH_NS + 'atan',
+  MATH_NS + 'sinh',
+  MATH_NS + 'cosh',
+  MATH_NS + 'tanh',
+  MATH_NS + 'degrees',
+  MATH_NS + 'negation',
+]);
+
 const { lex, N3SyntaxError } = require('./lexer');
 const { Parser } = require('./parser');
 const { liftBlankRuleVars } = require('./rules');
@@ -5595,6 +5616,29 @@ function __cloneSubst(subst) {
   return out;
 }
 
+function __defineHidden(obj, name, value, writable) {
+  Object.defineProperty(obj, name, { value, enumerable: false, writable, configurable: true });
+}
+
+function __defineHiddenValue(obj, name, value) {
+  __defineHidden(obj, name, value, false);
+}
+
+function __defineHiddenWritable(obj, name, value) {
+  __defineHidden(obj, name, value, true);
+}
+
+function __setHiddenWritable(obj, name, value) {
+  if (hasOwn.call(obj, name)) obj[name] = value;
+  else __defineHiddenWritable(obj, name, value);
+}
+
+const FACT_INDEX_ARRAY_FIELDS = ['__varPred', '__varPredNonFastS', '__varPredNonFastO'];
+const FACT_INDEX_ARRAY_MAP_FIELDS = ['__byPred', '__byPNonFastS', '__byPNonFastO', '__varPredPS', '__varPredPO'];
+const FACT_INDEX_NESTED_ARRAY_MAP_FIELDS = ['__byPS', '__byPO'];
+const FACT_INDEX_MAP_FIELDS = FACT_INDEX_ARRAY_MAP_FIELDS.concat(FACT_INDEX_NESTED_ARRAY_MAP_FIELDS);
+const FACT_INDEX_REQUIRED_FIELDS = FACT_INDEX_ARRAY_FIELDS.concat(FACT_INDEX_MAP_FIELDS, ['__keySet']);
+
 let version = 'dev';
 try {
   // Node: keep package.json version if available
@@ -5818,14 +5862,13 @@ function __firingKey(ruleIndex, instantiatedPremises) {
 // -----------------------------------------------------------------------------
 function __ensureRuleKeySet(rules) {
   if (!hasOwn.call(rules, '__ruleKeySet')) {
-    Object.defineProperty(rules, '__ruleKeySet', {
-      value: new Set(
+    __defineHiddenValue(
+      rules,
+      '__ruleKeySet',
+      new Set(
         rules.map((r) => __ruleKey(r.isForward, r.isFuse, r.premise, r.conclusion, r.__dynamicConclusionTerm || null)),
       ),
-      enumerable: false,
-      writable: false,
-      configurable: true,
-    });
+    );
   }
   return rules.__ruleKeySet;
 }
@@ -5843,28 +5886,13 @@ function __computeHeadIsStrictGround(r) {
 function __prepareForwardRule(r) {
   if (!hasOwn.call(r, '__scopedSkipInfo')) {
     const info = __computeForwardRuleScopedSkipInfo(r);
-    Object.defineProperty(r, '__scopedSkipInfo', {
-      value: info,
-      enumerable: false,
-      writable: false,
-      configurable: true,
-    });
+    __defineHiddenValue(r, '__scopedSkipInfo', info);
   }
   if (!hasOwn.call(r, '__headIsStrictGround')) {
-    Object.defineProperty(r, '__headIsStrictGround', {
-      value: __computeHeadIsStrictGround(r),
-      enumerable: false,
-      writable: false,
-      configurable: true,
-    });
+    __defineHiddenValue(r, '__headIsStrictGround', __computeHeadIsStrictGround(r));
   }
   if (!hasOwn.call(r, '__needsForwardSkipCheck')) {
-    Object.defineProperty(r, '__needsForwardSkipCheck', {
-      value: !!(r.__headIsStrictGround || (r.__scopedSkipInfo && r.__scopedSkipInfo.needsSnap)),
-      enumerable: false,
-      writable: false,
-      configurable: true,
-    });
+    __defineHiddenValue(r, '__needsForwardSkipCheck', !!(r.__headIsStrictGround || (r.__scopedSkipInfo && r.__scopedSkipInfo.needsSnap)));
   }
 }
 
@@ -5906,44 +5934,29 @@ function __logNaturalPriorityFromTerm(t) {
 function __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules) {
   let maxP = 0;
 
+  function bumpMaxPriority(term) {
+    if (term instanceof GraphTerm) return;
+    if (term instanceof Var) {
+      if (maxP < 1) maxP = 1;
+      return;
+    }
+    const p0 = __logNaturalPriorityFromTerm(term);
+    const priority = p0 !== null ? p0 : 1;
+    if (priority > maxP) maxP = priority;
+  }
+
   function scanTriple(tr) {
     if (!(tr && tr.p instanceof Iri)) return;
     const pv = tr.p.value;
 
     // log:collectAllIn / log:forAllIn use the object position for the priority.
-    if (pv === LOG_NS + 'collectAllIn' || pv === LOG_NS + 'forAllIn') {
-      // Explicit scope graphs are immediate and do not require a closure.
-      if (tr.o instanceof GraphTerm) return;
-      // Variable or non-numeric object => default priority 1 (if used).
-      if (tr.o instanceof Var) {
-        if (maxP < 1) maxP = 1;
-        return;
-      }
-      const p0 = __logNaturalPriorityFromTerm(tr.o);
-      if (p0 !== null) {
-        if (p0 > maxP) maxP = p0;
-      } else {
-        if (maxP < 1) maxP = 1;
-      }
+    if (pv === LOG_COLLECT_ALL_IN_IRI || pv === LOG_FOR_ALL_IN_IRI) {
+      bumpMaxPriority(tr.o);
       return;
     }
 
     // log:includes / log:notIncludes use the subject position for the priority.
-    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
-      // Explicit scope graphs are immediate and do not require a closure.
-      if (tr.s instanceof GraphTerm) return;
-      // Variable or non-numeric subject => default priority 1 (if used).
-      if (tr.s instanceof Var) {
-        if (maxP < 1) maxP = 1;
-        return;
-      }
-      const p0 = __logNaturalPriorityFromTerm(tr.s);
-      if (p0 !== null) {
-        if (p0 > maxP) maxP = p0;
-      } else {
-        if (maxP < 1) maxP = 1;
-      }
-    }
+    if (pv === LOG_INCLUDES_IRI || pv === LOG_NOT_INCLUDES_IRI) bumpMaxPriority(tr.s);
   }
 
   for (const r of forwardRules) {
@@ -5955,17 +5968,6 @@ function __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules) {
   return maxP;
 }
 
-function __termContainsVarName(t, name) {
-  if (t instanceof Var) return t.name === name;
-  if (t instanceof ListTerm) return t.elems.some((e) => __termContainsVarName(e, name));
-  if (t instanceof OpenListTerm) return t.tailVar === name || t.prefix.some((e) => __termContainsVarName(e, name));
-  if (t instanceof GraphTerm)
-    return t.triples.some(
-      (tr) =>
-        __termContainsVarName(tr.s, name) || __termContainsVarName(tr.p, name) || __termContainsVarName(tr.o, name),
-    );
-  return false;
-}
 
 function __varOccursElsewhereInPremise(premise, name, idx, field) {
   for (let i = 0; i < premise.length; i++) {
@@ -5973,14 +5975,13 @@ function __varOccursElsewhereInPremise(premise, name, idx, field) {
     if (!(tr && tr.s && tr.p && tr.o)) continue;
 
     // Skip the specific scope/priority occurrence we are analyzing.
-    if (!(i === idx && field === 's') && __termContainsVarName(tr.s, name)) return true;
-    if (!(i === idx && field === 'p') && __termContainsVarName(tr.p, name)) return true;
-    if (!(i === idx && field === 'o') && __termContainsVarName(tr.o, name)) return true;
+    if (!(i === idx && field === 's') && containsVarTerm(tr.s, name)) return true;
+    if (!(i === idx && field === 'p') && containsVarTerm(tr.p, name)) return true;
+    if (!(i === idx && field === 'o') && containsVarTerm(tr.o, name)) return true;
   }
   return false;
 }
 
-
 function __scopedPriorityForTerm(t) {
   if (t instanceof GraphTerm) return 0;
   const p0 = __logNaturalPriorityFromTerm(t);
@@ -6007,7 +6008,7 @@ function __analyzeForwardRuleScopedUse(rule) {
     if (!(tr && tr.p instanceof Iri)) continue;
     const pv = tr.p.value;
 
-    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
+    if (pv === LOG_INCLUDES_IRI || pv === LOG_NOT_INCLUDES_IRI) {
       // Explicit quoted scopes are local formulas, not snapshots of the global closure.
       if (tr.s instanceof GraphTerm) continue;
 
@@ -6021,7 +6022,7 @@ function __analyzeForwardRuleScopedUse(rule) {
       continue;
     }
 
-    if (pv === LOG_NS + 'collectAllIn') {
+    if (pv === LOG_COLLECT_ALL_IN_IRI) {
       if (tr.o instanceof GraphTerm) continue;
 
       out.needsSnap = true;
@@ -6033,7 +6034,7 @@ function __analyzeForwardRuleScopedUse(rule) {
       continue;
     }
 
-    if (pv === LOG_NS + 'forAllIn') {
+    if (pv === LOG_FOR_ALL_IN_IRI) {
       if (tr.o instanceof GraphTerm) continue;
 
       out.needsSnap = true;
@@ -6075,16 +6076,7 @@ function __setForwardRuleScopedStratumInfo(rule, level) {
       ? { 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;
-  }
+  __setHiddenWritable(rule, '__scopedStratumInfo', value);
 }
 
 function __computeForwardRuleScopedStrata(forwardRules) {
@@ -6122,7 +6114,6 @@ function __computeForwardRuleScopedStrata(forwardRules) {
     if (!changed) break;
   }
 
-
   maxLevel = 0;
   for (let i = 0; i < forwardRules.length; i++) {
     __setForwardRuleScopedStratumInfo(forwardRules[i], levels[i]);
@@ -6136,42 +6127,33 @@ function __computeForwardRuleScopedSkipInfo(rule) {
   let needsSnap = false;
   let requiredLevel = 0;
 
+  function addScopedUse(scopeTerm, idx, field) {
+    if (scopeTerm instanceof GraphTerm) return true; // explicit scope
+
+    // If scope term is a Var that appears elsewhere, it might be bound to a GraphTerm.
+    // Be conservative and do not skip in that case.
+    if (scopeTerm instanceof Var) {
+      if (__varOccursElsewhereInPremise(rule.premise, scopeTerm.name, idx, field)) return false;
+      needsSnap = true;
+      requiredLevel = Math.max(requiredLevel, 1);
+      return true;
+    }
+
+    needsSnap = true;
+    const p0 = __logNaturalPriorityFromTerm(scopeTerm);
+    requiredLevel = Math.max(requiredLevel, p0 !== null ? p0 : 1);
+    return true;
+  }
+
   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 + 'collectAllIn' || pv === LOG_NS + 'forAllIn') {
-      if (tr.o instanceof GraphTerm) continue; // explicit scope
-      // If scope term is a Var that appears elsewhere, it might be bound to a GraphTerm.
-      // Be conservative and do not skip in that case.
-      if (tr.o instanceof Var) {
-        if (__varOccursElsewhereInPremise(rule.premise, tr.o.name, i, 'o')) return null;
-        needsSnap = true;
-        requiredLevel = Math.max(requiredLevel, 1);
-      } else {
-        needsSnap = true;
-        let prio = 1;
-        const p0 = __logNaturalPriorityFromTerm(tr.o);
-        if (p0 !== null) prio = p0;
-        requiredLevel = Math.max(requiredLevel, prio);
-      }
-      continue;
-    }
-
-    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
-      if (tr.s instanceof GraphTerm) continue; // explicit scope
-      if (tr.s instanceof Var) {
-        if (__varOccursElsewhereInPremise(rule.premise, tr.s.name, i, 's')) return null;
-        needsSnap = true;
-        requiredLevel = Math.max(requiredLevel, 1);
-      } else {
-        needsSnap = true;
-        let prio = 1;
-        const p0 = __logNaturalPriorityFromTerm(tr.s);
-        if (p0 !== null) prio = p0;
-        requiredLevel = Math.max(requiredLevel, prio);
-      }
+    if (pv === LOG_COLLECT_ALL_IN_IRI || pv === LOG_FOR_ALL_IN_IRI) {
+      if (!addScopedUse(tr.o, i, 'o')) return null;
+    } else if (pv === LOG_INCLUDES_IRI || pv === LOG_NOT_INCLUDES_IRI) {
+      if (!addScopedUse(tr.s, i, 's')) return null;
     }
   }
 
@@ -6354,140 +6336,70 @@ function skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, f
 // Alpha equivalence helpers
 // ===========================================================================
 
-function termsEqual(a, b) {
-  if (a === b) return true;
-  if (!a || !b) return false;
-  if (a.__tid && b.__tid && a.__tid === b.__tid) return true;
-
-  // rdf:nil is equivalent to the empty list ()
-  if (a instanceof Iri && a.value === RDF_NIL_IRI && b instanceof ListTerm && b.elems.length === 0) return true;
-  if (b instanceof Iri && b.value === RDF_NIL_IRI && a instanceof ListTerm && a.elems.length === 0) return true;
-  if (a.constructor !== b.constructor) return false;
-
-  if (a instanceof Iri) return a.value === b.value;
-
-  if (a instanceof Literal) {
-    if (a.value === b.value) return true;
-
-    // Plain "abc" == "abc"^^xsd:string (but not language-tagged strings)
-    if (literalsEquivalentAsXsdString(a.value, b.value)) return true;
+function __isRdfNilEmptyListPair(a, b) {
+  return a instanceof Iri && a.value === RDF_NIL_IRI && b instanceof ListTerm && b.elems.length === 0;
+}
 
-    // Keep in sync with unifyTerm(): numeric-value equality, datatype-aware.
-    const ai = parseNumericLiteralInfo(a);
-    const bi = parseNumericLiteralInfo(b);
+function __numericInfosSameDatatypeEqual(ai, bi, exactDecimal) {
+  if (!ai || !bi || ai.dt !== bi.dt) return false;
+  if (ai.kind === 'bigint' && bi.kind === 'bigint') return ai.value === bi.value;
 
-    if (ai && bi) {
-      // Same datatype => compare values
-      if (ai.dt === bi.dt) {
-        if (ai.kind === 'bigint' && bi.kind === 'bigint') return ai.value === bi.value;
-
-        const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
-        const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
-        return !Number.isNaN(an) && !Number.isNaN(bn) && an === bn;
-      }
+  if (exactDecimal && ai.dt === XSD_NS + 'decimal') {
+    const da = parseXsdDecimalToBigIntScale(ai.lexStr);
+    const db = parseXsdDecimalToBigIntScale(bi.lexStr);
+    if (da && db) {
+      const scale = Math.max(da.scale, db.scale);
+      return da.num * pow10n(scale - da.scale) === db.num * pow10n(scale - db.scale);
     }
-
-    return false;
   }
 
-  if (a instanceof Var) return a.name === b.name;
-  if (a instanceof Blank) return a.label === b.label;
-
-  if (a instanceof ListTerm) {
-    if (a.elems.length !== b.elems.length) return false;
-    for (let i = 0; i < a.elems.length; i++) {
-      if (!termsEqual(a.elems[i], b.elems[i])) return false;
-    }
-    return true;
-  }
+  const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
+  const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
+  return !Number.isNaN(an) && !Number.isNaN(bn) && an === bn;
+}
 
-  if (a instanceof OpenListTerm) {
-    if (a.tailVar !== b.tailVar) return false;
-    if (a.prefix.length !== b.prefix.length) return false;
-    for (let i = 0; i < a.prefix.length; i++) {
-      if (!termsEqual(a.prefix[i], b.prefix[i])) return false;
-    }
-    return true;
-  }
+function __literalsEqual(a, b, exactDecimal) {
+  if (a.value === b.value) return true;
+  if (literalsEquivalentAsXsdString(a.value, b.value)) return true;
+  return __numericInfosSameDatatypeEqual(parseNumericLiteralInfo(a), parseNumericLiteralInfo(b), exactDecimal);
+}
 
-  if (a instanceof GraphTerm) {
-    return alphaEqGraphTriples(a.triples, b.triples);
+function __termArraysEqual(xs, ys, eq) {
+  if (xs.length !== ys.length) return false;
+  for (let i = 0; i < xs.length; i++) {
+    if (!eq(xs[i], ys[i])) return false;
   }
-
-  return false;
+  return true;
 }
 
-function termsEqualNoIntDecimal(a, b) {
+function __termsEqual(a, b, exactDecimal) {
   if (a === b) return true;
   if (!a || !b) return false;
   if (a.__tid && b.__tid && a.__tid === b.__tid) return true;
 
   // rdf:nil is equivalent to the empty list ()
-  if (a instanceof Iri && a.value === RDF_NIL_IRI && b instanceof ListTerm && b.elems.length === 0) return true;
-  if (b instanceof Iri && b.value === RDF_NIL_IRI && a instanceof ListTerm && a.elems.length === 0) return true;
+  if (__isRdfNilEmptyListPair(a, b) || __isRdfNilEmptyListPair(b, a)) return true;
   if (a.constructor !== b.constructor) return false;
 
   if (a instanceof Iri) return a.value === b.value;
-
-  if (a instanceof Literal) {
-    if (a.value === b.value) return true;
-
-    // Plain "abc" == "abc"^^xsd:string (but not language-tagged)
-    if (literalsEquivalentAsXsdString(a.value, b.value)) return true;
-
-    // Numeric equality ONLY when datatypes agree (no integer<->decimal here)
-    const ai = parseNumericLiteralInfo(a);
-    const bi = parseNumericLiteralInfo(b);
-    if (ai && bi && ai.dt === bi.dt) {
-      // integer: exact bigint
-      if (ai.kind === 'bigint' && bi.kind === 'bigint') return ai.value === bi.value;
-
-      // decimal: compare exactly via num/scale if possible
-      if (ai.dt === XSD_NS + 'decimal') {
-        const da = parseXsdDecimalToBigIntScale(ai.lexStr);
-        const db = parseXsdDecimalToBigIntScale(bi.lexStr);
-        if (da && db) {
-          const scale = Math.max(da.scale, db.scale);
-          const na = da.num * pow10n(scale - da.scale);
-          const nb = db.num * pow10n(scale - db.scale);
-          return na === nb;
-        }
-      }
-
-      // double/float-ish: JS number (same as your normal same-dt path)
-      const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
-      const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
-      return !Number.isNaN(an) && !Number.isNaN(bn) && an === bn;
-    }
-
-    return false;
-  }
-
+  if (a instanceof Literal) return __literalsEqual(a, b, exactDecimal);
   if (a instanceof Var) return a.name === b.name;
   if (a instanceof Blank) return a.label === b.label;
+  if (a instanceof ListTerm) return __termArraysEqual(a.elems, b.elems, (x, y) => __termsEqual(x, y, exactDecimal));
+  if (a instanceof OpenListTerm)
+    return a.tailVar === b.tailVar && __termArraysEqual(a.prefix, b.prefix, (x, y) => __termsEqual(x, y, exactDecimal));
+  if (a instanceof GraphTerm) return alphaEqGraphTriples(a.triples, b.triples);
+  return false;
+}
 
-  if (a instanceof ListTerm) {
-    if (a.elems.length !== b.elems.length) return false;
-    for (let i = 0; i < a.elems.length; i++) {
-      if (!termsEqualNoIntDecimal(a.elems[i], b.elems[i])) return false;
-    }
-    return true;
-  }
-
-  if (a instanceof OpenListTerm) {
-    if (a.tailVar !== b.tailVar) return false;
-    if (a.prefix.length !== b.prefix.length) return false;
-    for (let i = 0; i < a.prefix.length; i++) {
-      if (!termsEqualNoIntDecimal(a.prefix[i], b.prefix[i])) return false;
-    }
-    return true;
-  }
-
-  if (a instanceof GraphTerm) {
-    return alphaEqGraphTriples(a.triples, b.triples);
-  }
+function termsEqual(a, b) {
+  // Keep in sync with unifyTerm(): numeric-value equality, datatype-aware.
+  return __termsEqual(a, b, false);
+}
 
-  return false;
+function termsEqualNoIntDecimal(a, b) {
+  // Numeric equality ONLY when datatypes agree; decimals are compared exactly.
+  return __termsEqual(a, b, true);
 }
 
 function triplesEqual(a, b) {
@@ -6832,81 +6744,12 @@ function tripleFastKey(tr) {
 }
 
 function ensureFactIndexes(facts) {
-  if (
-    facts.__byPred &&
-    facts.__byPS &&
-    facts.__byPO &&
-    facts.__byPNonFastS &&
-    facts.__byPNonFastO &&
-    facts.__varPred &&
-    facts.__varPredPS &&
-    facts.__varPredPO &&
-    facts.__varPredNonFastS &&
-    facts.__varPredNonFastO &&
-    facts.__keySet
-  )
-    return;
+  if (FACT_INDEX_REQUIRED_FIELDS.every((name) => facts[name])) return;
 
-  Object.defineProperty(facts, '__byPred', {
-    value: new Map(),
-    enumerable: false,
-    writable: true,
-  });
-  Object.defineProperty(facts, '__byPS', {
-    value: new Map(),
-    enumerable: false,
-    writable: true,
-  });
-  Object.defineProperty(facts, '__byPO', {
-    value: new Map(),
-    enumerable: false,
-    writable: true,
-  });
-  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, '__varPredPS', {
-    value: new Map(),
-    enumerable: false,
-    writable: true,
-  });
-  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,
-    writable: true,
-  });
-  Object.defineProperty(facts, '__keySetComplete', {
-    value: false,
-    enumerable: false,
-    writable: true,
-  });
+  for (const name of FACT_INDEX_MAP_FIELDS) __defineHiddenWritable(facts, name, new Map());
+  for (const name of FACT_INDEX_ARRAY_FIELDS) __defineHiddenWritable(facts, name, []);
+  __defineHiddenWritable(facts, '__keySet', new Set());
+  __defineHiddenWritable(facts, '__keySetComplete', false);
 
   // Build lookup indexes eagerly, but do not populate the duplicate-detection
   // string Set for every input fact.  The predicate/subject/object indexes are
@@ -6934,45 +6777,14 @@ function cloneFactIndexesForSnapshot(src, dest) {
     return out;
   }
 
-  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, '__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 });
+  for (const name of FACT_INDEX_ARRAY_MAP_FIELDS) __defineHiddenWritable(dest, name, cloneArrayMap(src[name]));
+  for (const name of FACT_INDEX_NESTED_ARRAY_MAP_FIELDS) __defineHiddenWritable(dest, name, cloneNestedArrayMap(src[name]));
+  for (const name of FACT_INDEX_ARRAY_FIELDS) __defineHiddenWritable(dest, name, src[name].slice());
+  __defineHiddenWritable(dest, '__keySet', new Set(src.__keySet));
+  __defineHiddenWritable(dest, '__keySetComplete', !!src.__keySetComplete);
 }
 
-function addToIndexArrayMap(map, key, value) {
+function pushMapArray(map, key, value) {
   let bucket = map.get(key);
   if (!bucket) {
     bucket = [];
@@ -6981,6 +6793,15 @@ function addToIndexArrayMap(map, key, value) {
   bucket.push(value);
 }
 
+function getOrCreateMap(map, key) {
+  let inner = map.get(key);
+  if (!inner) {
+    inner = new Map();
+    map.set(key, inner);
+  }
+  return inner;
+}
+
 function indexFact(facts, tr, idx, addKeySet = true) {
   const sk = termLookupKey(tr.s);
   const ok = termLookupKey(tr.o);
@@ -6991,45 +6812,30 @@ function indexFact(facts, tr, idx, addKeySet = true) {
     const pk = tr.p.__tid;
     pkForKey = pk;
 
-    let pb = facts.__byPred.get(pk);
-    if (!pb) {
-      pb = [];
-      facts.__byPred.set(pk, pb);
-    }
-    pb.push(idx);
+    pushMapArray(facts.__byPred, pk, idx);
 
     if (sk !== null) {
-      let ps = facts.__byPS.get(pk);
-      if (!ps) {
-        ps = new Map();
-        facts.__byPS.set(pk, ps);
-      }
-      addToIndexArrayMap(ps, sk, idx);
+      pushMapArray(getOrCreateMap(facts.__byPS, pk), sk, idx);
     } else {
-      addToIndexArrayMap(facts.__byPNonFastS, pk, idx);
+      pushMapArray(facts.__byPNonFastS, pk, idx);
     }
 
     if (ok !== null) {
-      let po = facts.__byPO.get(pk);
-      if (!po) {
-        po = new Map();
-        facts.__byPO.set(pk, po);
-      }
-      addToIndexArrayMap(po, ok, idx);
+      pushMapArray(getOrCreateMap(facts.__byPO, pk), ok, idx);
     } else {
-      addToIndexArrayMap(facts.__byPNonFastO, pk, idx);
+      pushMapArray(facts.__byPNonFastO, pk, idx);
     }
   } else if (tr.p instanceof Var) {
     facts.__varPred.push(idx);
 
     if (sk !== null) {
-      addToIndexArrayMap(facts.__varPredPS, sk, idx);
+      pushMapArray(facts.__varPredPS, sk, idx);
     } else {
       facts.__varPredNonFastS.push(idx);
     }
 
     if (ok !== null) {
-      addToIndexArrayMap(facts.__varPredPO, ok, idx);
+      pushMapArray(facts.__varPredPO, ok, idx);
     } else {
       facts.__varPredNonFastO.push(idx);
     }
@@ -7183,16 +6989,8 @@ function makeDerivedRecord(fact, rule, premises, subst, captureExplanations) {
 function ensureBackRuleIndexes(backRules) {
   if (backRules.__byHeadPred && backRules.__wildHeadPred) return;
 
-  Object.defineProperty(backRules, '__byHeadPred', {
-    value: new Map(),
-    enumerable: false,
-    writable: true,
-  });
-  Object.defineProperty(backRules, '__wildHeadPred', {
-    value: [],
-    enumerable: false,
-    writable: true,
-  });
+  __defineHiddenWritable(backRules, '__byHeadPred', new Map());
+  __defineHiddenWritable(backRules, '__wildHeadPred', []);
 
   for (const r of backRules) indexBackRule(backRules, r);
 }
@@ -7201,13 +6999,7 @@ function indexBackRule(backRules, r) {
   if (!r || !r.conclusion || r.conclusion.length !== 1) return;
   const head = r.conclusion[0];
   if (head && head.p instanceof Iri) {
-    const k = head.p.__tid;
-    let bucket = backRules.__byHeadPred.get(k);
-    if (!bucket) {
-      bucket = [];
-      backRules.__byHeadPred.set(k, bucket);
-    }
-    bucket.push(r);
+    pushMapArray(backRules.__byHeadPred, head.p.__tid, r);
   } else {
     backRules.__wildHeadPred.push(r);
   }
@@ -7242,12 +7034,11 @@ function isSinglePremiseAgendaRuleSafe(r, backRules) {
   return backRules.__wildHeadPred.length === 0;
 }
 
-function mergeSinglePremiseAgendaBuckets() {
+function mergeSinglePremiseAgendaBuckets(...buckets) {
   let out = null;
   let seen = null;
 
-  for (let i = 0; i < arguments.length; i++) {
-    const bucket = arguments[i];
+  for (const bucket of buckets) {
     if (!bucket || bucket.length === 0) continue;
 
     if (out === null) {
@@ -7257,8 +7048,7 @@ function mergeSinglePremiseAgendaBuckets() {
     }
 
     if (!seen) seen = new Set(out);
-    for (let j = 0; j < bucket.length; j++) {
-      const entry = bucket[j];
+    for (const entry of bucket) {
       if (seen.has(entry)) continue;
       seen.add(entry);
       out.push(entry);
@@ -7268,18 +7058,6 @@ 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(),
@@ -7294,15 +7072,6 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     size: 0,
   };
 
-  function addToMapArray(m, k, v) {
-    let bucket = m.get(k);
-    if (!bucket) {
-      bucket = [];
-      m.set(k, bucket);
-    }
-    bucket.push(v);
-  }
-
   for (let i = 0; i < forwardRules.length; i++) {
     const r = forwardRules[i];
     if (!isSinglePremiseAgendaRuleSafe(r, backRules)) continue;
@@ -7328,29 +7097,15 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     index.size += 1;
 
     if (entry.goalPredTid !== null) {
-      addToMapArray(index.byPredAll, entry.goalPredTid, entry);
+      pushMapArray(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);
-        if (!ps) {
-          ps = new Map();
-          index.byPS.set(entry.goalPredTid, ps);
-        }
-        addToMapArray(ps, entry.goalSKey, entry);
-      }
-      if (entry.goalOKey !== null) {
-        let po = index.byPO.get(entry.goalPredTid);
-        if (!po) {
-          po = new Map();
-          index.byPO.set(entry.goalPredTid, po);
-        }
-        addToMapArray(po, entry.goalOKey, entry);
-      }
+      if (entry.goalSKey === null && entry.goalOKey === null) pushMapArray(index.byPred, entry.goalPredTid, entry);
+      if (entry.goalSKey !== null) pushMapArray(getOrCreateMap(index.byPS, entry.goalPredTid), entry.goalSKey, entry);
+      if (entry.goalOKey !== null) pushMapArray(getOrCreateMap(index.byPO, entry.goalPredTid), entry.goalOKey, entry);
     } else {
       if (entry.goalSKey === null && entry.goalOKey === null) index.wildPred.push(entry);
-      if (entry.goalSKey !== null) addToMapArray(index.wildPS, entry.goalSKey, entry);
-      if (entry.goalOKey !== null) addToMapArray(index.wildPO, entry.goalOKey, entry);
+      if (entry.goalSKey !== null) pushMapArray(index.wildPS, entry.goalSKey, entry);
+      if (entry.goalOKey !== null) pushMapArray(index.wildPO, entry.goalOKey, entry);
     }
   }
 
@@ -7366,7 +7121,7 @@ function getSinglePremiseAgendaCandidates(index, fact) {
   let exact = null;
   if (fact.p instanceof Iri) {
     const pk = fact.p.__tid;
-    if ((sk === null && termContainsVarForAgenda(fact.s)) || (ok === null && termContainsVarForAgenda(fact.o))) {
+    if ((sk === null && containsVarTerm(fact.s)) || (ok === null && containsVarTerm(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
@@ -7411,11 +7166,11 @@ function getSinglePremiseAgendaCandidates(index, fact) {
 // ===========================================================================
 
 function isLogImplies(p) {
-  return p instanceof Iri && p.value === LOG_NS + 'implies';
+  return p instanceof Iri && p.value === LOG_IMPLIES_IRI;
 }
 
 function isLogImpliedBy(p) {
-  return p instanceof Iri && p.value === LOG_NS + 'impliedBy';
+  return p instanceof Iri && p.value === LOG_IMPLIED_BY_IRI;
 }
 
 // ===========================================================================
@@ -7448,16 +7203,7 @@ function __makeGoalTable() {
 
 function __attachGoalTable(scopeCarrier, goalTable) {
   if (!scopeCarrier) return goalTable;
-  if (!hasOwn.call(scopeCarrier, 'goalTable')) {
-    Object.defineProperty(scopeCarrier, 'goalTable', {
-      value: goalTable,
-      enumerable: false,
-      writable: true,
-      configurable: true,
-    });
-  } else {
-    scopeCarrier.goalTable = goalTable;
-  }
+  __setHiddenWritable(scopeCarrier, 'goalTable', goalTable);
   return goalTable;
 }
 
@@ -7512,11 +7258,10 @@ function __canStoreGoalMemo(visited, maxResults) {
 // Unification + substitution
 // ===========================================================================
 
-function containsVarTerm(t, v) {
-  if (t instanceof Iri || t instanceof Literal || t instanceof Blank) return false;
-  if (t instanceof Var) return t.name === v;
+function containsVarTerm(t, v = null) {
+  if (t instanceof Var) return v === null || t.name === v;
   if (t instanceof ListTerm) return t.elems.some((e) => containsVarTerm(e, v));
-  if (t instanceof OpenListTerm) return t.prefix.some((e) => containsVarTerm(e, v)) || t.tailVar === v;
+  if (t instanceof OpenListTerm) return t.prefix.some((e) => containsVarTerm(e, v)) || v === null || t.tailVar === v;
   if (t instanceof GraphTerm)
     return t.triples.some((tr) => containsVarTerm(tr.s, v) || containsVarTerm(tr.p, v) || containsVarTerm(tr.o, v));
   return false;
@@ -7721,16 +7466,8 @@ function unifyOpenWithList(prefix, tailv, ys, subst) {
 }
 
 function graphTriplesContainVars(triples) {
-  function termHasVar(t) {
-    if (t instanceof Var) return true;
-    if (t instanceof ListTerm) return t.elems.some(termHasVar);
-    if (t instanceof OpenListTerm) return t.prefix.some(termHasVar) || true;
-    if (t instanceof GraphTerm) return t.triples.some((tr) => termHasVar(tr.s) || termHasVar(tr.p) || termHasVar(tr.o));
-    return false;
-  }
-
   for (const tr of triples) {
-    if (termHasVar(tr.s) || termHasVar(tr.p) || termHasVar(tr.o)) return true;
+    if (containsVarTerm(tr.s) || containsVarTerm(tr.p) || containsVarTerm(tr.o)) return true;
   }
   return false;
 }
@@ -8015,19 +7752,7 @@ function __tripleHasVarOrBlank(tr) {
 }
 
 function __builtinIsSatisfiableWhenFullyUnbound(pIriVal) {
-  return (
-    pIriVal === MATH_NS + 'sin' ||
-    pIriVal === MATH_NS + 'cos' ||
-    pIriVal === MATH_NS + 'tan' ||
-    pIriVal === MATH_NS + 'asin' ||
-    pIriVal === MATH_NS + 'acos' ||
-    pIriVal === MATH_NS + 'atan' ||
-    pIriVal === MATH_NS + 'sinh' ||
-    pIriVal === MATH_NS + 'cosh' ||
-    pIriVal === MATH_NS + 'tanh' ||
-    pIriVal === MATH_NS + 'degrees' ||
-    pIriVal === MATH_NS + 'negation'
-  );
+  return MATH_BUILTINS_SATISFIABLE_WHEN_FULLY_UNBOUND.has(pIriVal);
 }
 
 function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxResults, opts) {
@@ -8662,12 +8387,7 @@ function __proofTripleKey(tr) {
 
 function __copyProofSource(from, to) {
   if (from && to && Object.prototype.hasOwnProperty.call(from, '__source')) {
-    Object.defineProperty(to, '__source', {
-      value: from.__source,
-      enumerable: false,
-      writable: false,
-      configurable: true,
-    });
+    __defineHiddenValue(to, '__source', from.__source);
   }
   return to;
 }
@@ -8679,12 +8399,7 @@ function __annotateProofVarSourceNames(rule) {
     const m = /^(.*)__\d+$/.exec(name);
     sourceNames[name] = m ? m[1] : name;
   }
-  Object.defineProperty(rule, '__proofVarSourceNames', {
-    value: sourceNames,
-    enumerable: false,
-    writable: false,
-    configurable: true,
-  });
+  __defineHiddenValue(rule, '__proofVarSourceNames', sourceNames);
   return rule;
 }
 
@@ -8890,45 +8605,16 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     // until a scoped snapshot exists (or a given closure level is reached).
     // Helper functions are module-scoped: __computeForwardRuleScopedSkipInfo, etc.
     function setScopedSnapshot(snap, level) {
-      if (!hasOwn.call(facts, '__scopedSnapshot')) {
-        Object.defineProperty(facts, '__scopedSnapshot', {
-          value: snap,
-          enumerable: false,
-          writable: true,
-          configurable: true,
-        });
-      } else {
-        facts.__scopedSnapshot = snap;
-      }
-
-      if (!hasOwn.call(facts, '__scopedClosureLevel')) {
-        Object.defineProperty(facts, '__scopedClosureLevel', {
-          value: level,
-          enumerable: false,
-          writable: true,
-          configurable: true,
-        });
-      } else {
-        facts.__scopedClosureLevel = level;
-      }
+      __setHiddenWritable(facts, '__scopedSnapshot', snap);
+      __setHiddenWritable(facts, '__scopedClosureLevel', level);
     }
 
     function makeScopedSnapshot() {
       const snap = facts.slice();
       cloneFactIndexesForSnapshot(facts, snap);
-      Object.defineProperty(snap, '__scopedSnapshot', {
-        value: snap,
-        enumerable: false,
-        writable: true,
-        configurable: true,
-      });
+      __defineHiddenWritable(snap, '__scopedSnapshot', snap);
       // Propagate closure level so nested scoped builtins can see it.
-      Object.defineProperty(snap, '__scopedClosureLevel', {
-        value: scopedClosureLevel,
-        enumerable: false,
-        writable: true,
-        configurable: true,
-      });
+      __defineHiddenWritable(snap, '__scopedClosureLevel', scopedClosureLevel);
       return snap;
     }
 
@@ -9276,36 +8962,12 @@ function __withScopedSnapshotForQueries(facts, fn) {
   // Create a frozen snapshot of the saturated closure.
   const snap = facts.slice();
   ensureFactIndexes(snap);
-  Object.defineProperty(snap, '__scopedSnapshot', {
-    value: snap,
-    enumerable: false,
-    writable: true,
-    configurable: true,
-  });
-  Object.defineProperty(snap, '__scopedClosureLevel', {
-    value: Number.MAX_SAFE_INTEGER,
-    enumerable: false,
-    writable: true,
-    configurable: true,
-  });
+  __defineHiddenWritable(snap, '__scopedSnapshot', snap);
+  __defineHiddenWritable(snap, '__scopedClosureLevel', Number.MAX_SAFE_INTEGER);
 
   // Ensure the live facts array exposes the snapshot/level for builtins.
-  if (!hasOwn.call(facts, '__scopedSnapshot')) {
-    Object.defineProperty(facts, '__scopedSnapshot', {
-      value: null,
-      enumerable: false,
-      writable: true,
-      configurable: true,
-    });
-  }
-  if (!hasOwn.call(facts, '__scopedClosureLevel')) {
-    Object.defineProperty(facts, '__scopedClosureLevel', {
-      value: 0,
-      enumerable: false,
-      writable: true,
-      configurable: true,
-    });
-  }
+  __setHiddenWritable(facts, '__scopedSnapshot', null);
+  __setHiddenWritable(facts, '__scopedClosureLevel', 0);
 
   facts.__scopedSnapshot = snap;
   facts.__scopedClosureLevel = Number.MAX_SAFE_INTEGER;