eyeling 1.6.15 → 1.6.17

package/eyeling.js

@@ -1993,6 +1993,10 @@ function applySubstTriple(tr, s) {
   return new Triple(applySubstTerm(tr.s, s), applySubstTerm(tr.p, s), applySubstTerm(tr.o, s));
 }
 
+function iriValue(t) {
+  return t instanceof Iri ? t.value : null;
+}
+
 function unifyOpenWithList(prefix, tailv, ys, subst) {
   if (ys.length < prefix.length) return null;
   let s2 = { ...subst };
@@ -2041,6 +2045,16 @@ function unifyFormulaTriples(xs, ys, subst) {
 }
 
 function unifyTerm(a, b, subst) {
+  return unifyTermWithOptions(a, b, subst, { boolValueEq: true, intDecimalEq: false });
+}
+
+function unifyTermListAppend(a, b, subst) {
+  // Keep list:append behavior: allow integer<->decimal exact equality,
+  // but do NOT add boolean-value equivalence (preserves current semantics).
+  return unifyTermWithOptions(a, b, subst, { boolValueEq: false, intDecimalEq: true });
+}
+
+function unifyTermWithOptions(a, b, subst, opts) {
   a = applySubstTerm(a, subst);
   b = applySubstTerm(b, subst);
 
@@ -2054,9 +2068,8 @@ function unifyTerm(a, b, subst) {
     s2[v] = t;
     return s2;
   }
-
   if (b instanceof Var) {
-    return unifyTerm(b, a, subst);
+    return unifyTermWithOptions(b, a, subst, opts);
   }
 
   // Exact matches
@@ -2064,25 +2077,25 @@ function unifyTerm(a, b, subst) {
   if (a instanceof Literal && b instanceof Literal && a.value === b.value) return { ...subst };
   if (a instanceof Blank && b instanceof Blank && a.label === b.label) return { ...subst };
 
-  // String-literal match (RDF 1.1): treat plain strings and xsd:string as equal (but not @lang)
+  // Plain string vs xsd:string equivalence
   if (a instanceof Literal && b instanceof Literal) {
     if (literalsEquivalentAsXsdString(a.value, b.value)) return { ...subst };
   }
 
-  // Boolean-value match: treat untyped true/false tokens and xsd:boolean as equal.
-  if (a instanceof Literal && b instanceof Literal) {
+  // Boolean-value equivalence (ONLY for normal unifyTerm)
+  if (opts.boolValueEq && a instanceof Literal && b instanceof Literal) {
     const ai = parseBooleanLiteralInfo(a);
     const bi = parseBooleanLiteralInfo(b);
     if (ai && bi && ai.value === bi.value) return { ...subst };
   }
 
-  // Numeric-value match for literals, BUT ONLY when datatypes agree (or infer to agree)
+  // Numeric-value match:
+  // - always allow equality when datatype matches (existing behavior)
+  // - optionally allow integer<->decimal exact equality (list:append only)
   if (a instanceof Literal && b instanceof Literal) {
     const ai = parseNumericLiteralInfo(a);
     const bi = parseNumericLiteralInfo(b);
-
     if (ai && bi) {
-      // same datatype: keep existing behavior
       if (ai.dt === bi.dt) {
         if (ai.kind === 'bigint' && bi.kind === 'bigint') {
           if (ai.value === bi.value) return { ...subst };
@@ -2092,101 +2105,18 @@ function unifyTerm(a, b, subst) {
           if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn) return { ...subst };
         }
       }
-    }
-  }
-
-  // Open list vs concrete list
-  if (a instanceof OpenListTerm && b instanceof ListTerm) {
-    return unifyOpenWithList(a.prefix, a.tailVar, b.elems, subst);
-  }
-  if (a instanceof ListTerm && b instanceof OpenListTerm) {
-    return unifyOpenWithList(b.prefix, b.tailVar, a.elems, subst);
-  }
 
-  // Open list vs open list (same tail var)
-  if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
-    if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length) return null;
-    let s2 = { ...subst };
-    for (let i = 0; i < a.prefix.length; i++) {
-      s2 = unifyTerm(a.prefix[i], b.prefix[i], s2);
-      if (s2 === null) return null;
-    }
-    return s2;
-  }
-
-  // List terms
-  if (a instanceof ListTerm && b instanceof ListTerm) {
-    if (a.elems.length !== b.elems.length) return null;
-    let s2 = { ...subst };
-    for (let i = 0; i < a.elems.length; i++) {
-      s2 = unifyTerm(a.elems[i], b.elems[i], s2);
-      if (s2 === null) return null;
-    }
-    return s2;
-  }
-
-  // Formulas:
-  // 1) If they are alpha-equivalent, succeed without leaking internal bindings.
-  // 2) Otherwise fall back to full unification (may bind vars).
-  if (a instanceof FormulaTerm && b instanceof FormulaTerm) {
-    if (alphaEqFormulaTriples(a.triples, b.triples)) return { ...subst };
-    return unifyFormulaTriples(a.triples, b.triples, subst);
-  }
-  return null;
-}
-
-function unifyTermListAppend(a, b, subst) {
-  a = applySubstTerm(a, subst);
-  b = applySubstTerm(b, subst);
-
-  // Variable binding (same as unifyTerm)
-  if (a instanceof Var) {
-    const v = a.name;
-    const t = b;
-    if (t instanceof Var && t.name === v) return { ...subst };
-    if (containsVarTerm(t, v)) return null;
-    const s2 = { ...subst };
-    s2[v] = t;
-    return s2;
-  }
-  if (b instanceof Var) return unifyTermListAppend(b, a, subst);
-
-  // Exact matches
-  if (a instanceof Iri && b instanceof Iri && a.value === b.value) return { ...subst };
-  if (a instanceof Literal && b instanceof Literal && a.value === b.value) return { ...subst };
-  if (a instanceof Blank && b instanceof Blank && a.label === b.label) return { ...subst };
-
-  // Plain string vs xsd:string equivalence
-  if (a instanceof Literal && b instanceof Literal) {
-    if (literalsEquivalentAsXsdString(a.value, b.value)) return { ...subst };
-  }
-
-  // Numeric match: same-dt OR integer<->decimal exact equality (for list:append only)
-  if (a instanceof Literal && b instanceof Literal) {
-    const ai = parseNumericLiteralInfo(a);
-    const bi = parseNumericLiteralInfo(b);
-    if (ai && bi) {
-      // same datatype
-      if (ai.dt === bi.dt) {
-        if (ai.kind === 'bigint' && bi.kind === 'bigint') {
-          if (ai.value === bi.value) return { ...subst };
-        } else {
-          const an = ai.kind === 'bigint' ? Number(ai.value) : ai.value;
-          const bn = bi.kind === 'bigint' ? Number(bi.value) : bi.value;
-          if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn) return { ...subst };
-        }
-      }
-
-      // integer <-> decimal exact equality
-      const intDt = XSD_NS + 'integer';
-      const decDt = XSD_NS + 'decimal';
-      if ((ai.dt === intDt && bi.dt === decDt) || (ai.dt === decDt && bi.dt === intDt)) {
-        const intInfo = ai.dt === intDt ? ai : bi;
-        const decInfo = ai.dt === decDt ? ai : bi;
-        const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
-        if (dec) {
-          const scaledInt = intInfo.value * pow10n(dec.scale);
-          if (scaledInt === dec.num) return { ...subst };
+      if (opts.intDecimalEq) {
+        const intDt = XSD_NS + 'integer';
+        const decDt = XSD_NS + 'decimal';
+        if ((ai.dt === intDt && bi.dt === decDt) || (ai.dt === decDt && bi.dt === intDt)) {
+          const intInfo = ai.dt === intDt ? ai : bi; // bigint
+          const decInfo = ai.dt === decDt ? ai : bi; // number + lexStr
+          const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
+          if (dec) {
+            const scaledInt = intInfo.value * pow10n(dec.scale);
+            if (scaledInt === dec.num) return { ...subst };
+          }
         }
       }
     }
@@ -2205,7 +2135,7 @@ function unifyTermListAppend(a, b, subst) {
     if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length) return null;
     let s2 = { ...subst };
     for (let i = 0; i < a.prefix.length; i++) {
-      s2 = unifyTermListAppend(a.prefix[i], b.prefix[i], s2);
+      s2 = unifyTermWithOptions(a.prefix[i], b.prefix[i], s2, opts);
       if (s2 === null) return null;
     }
     return s2;
@@ -2216,7 +2146,7 @@ function unifyTermListAppend(a, b, subst) {
     if (a.elems.length !== b.elems.length) return null;
     let s2 = { ...subst };
     for (let i = 0; i < a.elems.length; i++) {
-      s2 = unifyTermListAppend(a.elems[i], b.elems[i], s2);
+      s2 = unifyTermWithOptions(a.elems[i], b.elems[i], s2, opts);
       if (s2 === null) return null;
     }
     return s2;
@@ -2598,6 +2528,10 @@ function parseXsdFloatSpecialLex(s) {
   return null;
 }
 
+// ============================================================================
+// Math builtin helpers
+// ============================================================================
+
 function formatXsdFloatSpecialLex(n) {
   if (n === Infinity) return 'INF';
   if (n === -Infinity) return '-INF';
@@ -2752,6 +2686,10 @@ function pow10n(k) {
   return 10n ** BigInt(k);
 }
 
+// ============================================================================
+// Time & duration builtin helpers
+// ============================================================================
+
 function parseXsdDateTerm(t) {
   if (!(t instanceof Literal)) return null;
   const [lex, dt] = literalParts(t.value);
@@ -2833,7 +2771,7 @@ function parseNumericForCompareTerm(t) {
 }
 
 function cmpNumericInfo(aInfo, bInfo, op) {
-  // op is one of ">", "<", ">=", "<="
+  // op is one of ">", "<", ">=", "<=", "==", "!="
   if (!aInfo || !bInfo) return false;
 
   if (aInfo.kind === 'bigint' && bInfo.kind === 'bigint') {
@@ -2858,6 +2796,19 @@ function cmpNumericInfo(aInfo, bInfo, op) {
   return false;
 }
 
+function evalNumericComparisonBuiltin(g, subst, op) {
+  const aInfo = parseNumericForCompareTerm(g.s);
+  const bInfo = parseNumericForCompareTerm(g.o);
+  if (aInfo && bInfo && cmpNumericInfo(aInfo, bInfo, op)) return [{ ...subst }];
+
+  if (g.s instanceof ListTerm && g.s.elems.length === 2) {
+    const a2 = parseNumericForCompareTerm(g.s.elems[0]);
+    const b2 = parseNumericForCompareTerm(g.s.elems[1]);
+    if (a2 && b2 && cmpNumericInfo(a2, b2, op)) return [{ ...subst }];
+  }
+  return [];
+}
+
 function parseNumOrDuration(t) {
   const n = parseNum(t);
   if (n !== null) return n;
@@ -2886,35 +2837,10 @@ function parseNumOrDuration(t) {
 
 function formatDurationLiteralFromSeconds(secs) {
   const neg = secs < 0;
-  const absSecs = Math.abs(secs);
-  const days = Math.round(absSecs / 86400.0);
-  const lex = neg ? `" -P${days}D"` : `"P${days}D"`;
-  const cleanLex = neg ? `" -P${days}D"` : `"P${days}D"`; // minor detail; we just follow shape
-  const lex2 = neg ? `" -P${days}D"` : `"P${days}D"`;
-  const actualLex = neg ? `" -P${days}D"` : `"P${days}D"`;
-  // keep simpler, no spaces:
-  const finalLex = neg ? `" -P${days}D"` : `"P${days}D"`;
+  const days = Math.round(Math.abs(secs) / 86400.0);
   const literalLex = neg ? `"-P${days}D"` : `"P${days}D"`;
   return new Literal(`${literalLex}^^<${XSD_NS}duration>`);
 }
-
-function listAppendSplit(parts, resElems, subst) {
-  if (!parts.length) {
-    if (!resElems.length) return [{ ...subst }];
-    return [];
-  }
-  const out = [];
-  const n = resElems.length;
-  for (let k = 0; k <= n; k++) {
-    const left = new ListTerm(resElems.slice(0, k));
-    let s1 = unifyTermListAppend(parts[0], left, subst);
-    if (s1 === null) continue;
-    const restElems = resElems.slice(k);
-    out.push(...listAppendSplit(parts.slice(1), restElems, s1));
-  }
-  return out;
-}
-
 function numEqualTerm(t, n, eps = 1e-9) {
   const v = parseNum(t);
   if (v === null) return false;
@@ -3092,174 +3018,138 @@ function evalUnaryMathRel(g, subst, forwardFn, inverseFn /* may be null */) {
 }
 
 // ============================================================================
-// Backward proof & builtins mutual recursion — declarations first
+// List builtin helpers
 // ============================================================================
 
-function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
-  const g = applySubstTriple(goal, subst);
-
-  function hashLiteral(t, algo) {
-    // Accept only literals, interpret lexical form as UTF-8 string
-    if (!(t instanceof Literal)) return null;
-    const [lex, _dt] = literalParts(t.value);
-    const input = stripQuotes(lex);
-    try {
-      const digest = nodeCrypto.createHash(algo).update(input, 'utf8').digest('hex');
-      // plain string literal with the hex digest
-      return new Literal(JSON.stringify(digest));
-    } catch (e) {
-      return null;
-    }
+function listAppendSplit(parts, resElems, subst) {
+  if (!parts.length) {
+    if (!resElems.length) return [{ ...subst }];
+    return [];
   }
-
-  // -----------------------------------------------------------------
-  // 4.1 crypto: builtins
-  // -----------------------------------------------------------------
-
-  // crypto:sha
-  // true iff ?o is the SHA-1 hash of the subject string.
-  if (g.p instanceof Iri && g.p.value === CRYPTO_NS + 'sha') {
-    const lit = hashLiteral(g.s, 'sha1');
-    if (!lit) return [];
-    if (g.o instanceof Var) {
-      const s2 = { ...subst };
-      s2[g.o.name] = lit;
-      return [s2];
-    }
-    const s2 = unifyTerm(g.o, lit, subst);
-    return s2 !== null ? [s2] : [];
+  const out = [];
+  const n = resElems.length;
+  for (let k = 0; k <= n; k++) {
+    const left = new ListTerm(resElems.slice(0, k));
+    let s1 = unifyTermListAppend(parts[0], left, subst);
+    if (s1 === null) continue;
+    const restElems = resElems.slice(k);
+    out.push(...listAppendSplit(parts.slice(1), restElems, s1));
   }
+  return out;
+}
 
-  // crypto:md5
-  if (g.p instanceof Iri && g.p.value === CRYPTO_NS + 'md5') {
-    const lit = hashLiteral(g.s, 'md5');
-    if (!lit) return [];
-    if (g.o instanceof Var) {
-      const s2 = { ...subst };
-      s2[g.o.name] = lit;
-      return [s2];
-    }
-    const s2 = unifyTerm(g.o, lit, subst);
-    return s2 !== null ? [s2] : [];
-  }
+function evalListFirstLikeBuiltin(sTerm, oTerm, subst) {
+  if (!(sTerm instanceof ListTerm)) return [];
+  if (!sTerm.elems.length) return [];
+  const first = sTerm.elems[0];
+  const s2 = unifyTerm(oTerm, first, subst);
+  return s2 !== null ? [s2] : [];
+}
 
-  // crypto:sha256
-  if (g.p instanceof Iri && g.p.value === CRYPTO_NS + 'sha256') {
-    const lit = hashLiteral(g.s, 'sha256');
-    if (!lit) return [];
-    if (g.o instanceof Var) {
-      const s2 = { ...subst };
-      s2[g.o.name] = lit;
-      return [s2];
-    }
-    const s2 = unifyTerm(g.o, lit, subst);
+function evalListRestLikeBuiltin(sTerm, oTerm, subst) {
+  // Closed list: (a b c) -> (b c)
+  if (sTerm instanceof ListTerm) {
+    if (!sTerm.elems.length) return [];
+    const rest = new ListTerm(sTerm.elems.slice(1));
+    const s2 = unifyTerm(oTerm, rest, subst);
     return s2 !== null ? [s2] : [];
   }
 
-  // crypto:sha512
-  if (g.p instanceof Iri && g.p.value === CRYPTO_NS + 'sha512') {
-    const lit = hashLiteral(g.s, 'sha512');
-    if (!lit) return [];
-    if (g.o instanceof Var) {
-      const s2 = { ...subst };
-      s2[g.o.name] = lit;
-      return [s2];
+  // Open list: (a b ... ?T) -> (b ... ?T)
+  if (sTerm instanceof OpenListTerm) {
+    if (!sTerm.prefix.length) return [];
+    if (sTerm.prefix.length === 1) {
+      const s2 = unifyTerm(oTerm, new Var(sTerm.tailVar), subst);
+      return s2 !== null ? [s2] : [];
     }
-    const s2 = unifyTerm(g.o, lit, subst);
+    const rest = new OpenListTerm(sTerm.prefix.slice(1), sTerm.tailVar);
+    const s2 = unifyTerm(oTerm, rest, subst);
     return s2 !== null ? [s2] : [];
   }
 
-  // -----------------------------------------------------------------
-  // 4.2 math: builtins
-  // -----------------------------------------------------------------
-
-  // math:greaterThan
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'greaterThan') {
-    const aInfo = parseNumericForCompareTerm(g.s);
-    const bInfo = parseNumericForCompareTerm(g.o);
-    if (aInfo && bInfo && cmpNumericInfo(aInfo, bInfo, '>')) return [{ ...subst }];
-
-    if (g.s instanceof ListTerm && g.s.elems.length === 2) {
-      const a2 = parseNumericForCompareTerm(g.s.elems[0]);
-      const b2 = parseNumericForCompareTerm(g.s.elems[1]);
-      if (a2 && b2 && cmpNumericInfo(a2, b2, '>')) return [{ ...subst }];
-    }
-    return [];
-  }
+  return [];
+}
 
-  // math:lessThan
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'lessThan') {
-    const aInfo = parseNumericForCompareTerm(g.s);
-    const bInfo = parseNumericForCompareTerm(g.o);
-    if (aInfo && bInfo && cmpNumericInfo(aInfo, bInfo, '<')) return [{ ...subst }];
+// ============================================================================
+// Crypto builtin helpers
+// ============================================================================
 
-    if (g.s instanceof ListTerm && g.s.elems.length === 2) {
-      const a2 = parseNumericForCompareTerm(g.s.elems[0]);
-      const b2 = parseNumericForCompareTerm(g.s.elems[1]);
-      if (a2 && b2 && cmpNumericInfo(a2, b2, '<')) return [{ ...subst }];
-    }
-    return [];
+function hashLiteralTerm(t, algo) {
+  if (!(t instanceof Literal)) return null;
+  const [lex] = literalParts(t.value);
+  const input = stripQuotes(lex);
+  try {
+    const digest = nodeCrypto.createHash(algo).update(input, 'utf8').digest('hex');
+    return new Literal(JSON.stringify(digest));
+  } catch (e) {
+    return null;
   }
+}
 
-  // math:notLessThan
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'notLessThan') {
-    const aInfo = parseNumericForCompareTerm(g.s);
-    const bInfo = parseNumericForCompareTerm(g.o);
-    if (aInfo && bInfo && cmpNumericInfo(aInfo, bInfo, '>=')) return [{ ...subst }];
-
-    if (g.s instanceof ListTerm && g.s.elems.length === 2) {
-      const a2 = parseNumericForCompareTerm(g.s.elems[0]);
-      const b2 = parseNumericForCompareTerm(g.s.elems[1]);
-      if (a2 && b2 && cmpNumericInfo(a2, b2, '>=')) return [{ ...subst }];
-    }
-    return [];
+function evalCryptoHashBuiltin(g, subst, algo) {
+  const lit = hashLiteralTerm(g.s, algo);
+  if (!lit) return [];
+  if (g.o instanceof Var) {
+    const s2 = { ...subst };
+    s2[g.o.name] = lit;
+    return [s2];
   }
+  const s2 = unifyTerm(g.o, lit, subst);
+  return s2 !== null ? [s2] : [];
+}
 
-  // math:notGreaterThan
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'notGreaterThan') {
-    const aInfo = parseNumericForCompareTerm(g.s);
-    const bInfo = parseNumericForCompareTerm(g.o);
-    if (aInfo && bInfo && cmpNumericInfo(aInfo, bInfo, '<=')) return [{ ...subst }];
+// ============================================================================
+// Builtin evaluation
+// ============================================================================
+// Backward proof & builtins mutual recursion — declarations first
 
-    if (g.s instanceof ListTerm && g.s.elems.length === 2) {
-      const a2 = parseNumericForCompareTerm(g.s.elems[0]);
-      const b2 = parseNumericForCompareTerm(g.s.elems[1]);
-      if (a2 && b2 && cmpNumericInfo(a2, b2, '<=')) return [{ ...subst }];
-    }
-    return [];
-  }
+function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
+  const g = applySubstTriple(goal, subst);
+  const pv = iriValue(g.p);
+  if (pv === null) return null;
 
-  // math:equalTo
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'equalTo') {
-    const aInfo = parseNumericForCompareTerm(g.s);
-    const bInfo = parseNumericForCompareTerm(g.o);
-    if (aInfo && bInfo && cmpNumericInfo(aInfo, bInfo, '==')) return [{ ...subst }];
+  // -----------------------------------------------------------------
+  // 4.1 crypto: builtins
+  // -----------------------------------------------------------------
 
-    if (g.s instanceof ListTerm && g.s.elems.length === 2) {
-      const a2 = parseNumericForCompareTerm(g.s.elems[0]);
-      const b2 = parseNumericForCompareTerm(g.s.elems[1]);
-      if (a2 && b2 && cmpNumericInfo(a2, b2, '==')) return [{ ...subst }];
-    }
-    return [];
-  }
+  // crypto:sha, crypto:md5, crypto:sha256, crypto:sha512
+  // Digest builtins. crypto:sha uses SHA-1 per the N3/crypto convention.
+  const cryptoAlgo =
+    pv === CRYPTO_NS + 'sha'
+      ? 'sha1'
+      : pv === CRYPTO_NS + 'md5'
+        ? 'md5'
+        : pv === CRYPTO_NS + 'sha256'
+          ? 'sha256'
+          : pv === CRYPTO_NS + 'sha512'
+            ? 'sha512'
+            : null;
+  if (cryptoAlgo) return evalCryptoHashBuiltin(g, subst, cryptoAlgo);
 
-  // math:notEqualTo
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'notEqualTo') {
-    const aInfo = parseNumericForCompareTerm(g.s);
-    const bInfo = parseNumericForCompareTerm(g.o);
-    if (aInfo && bInfo && cmpNumericInfo(aInfo, bInfo, '!=')) return [{ ...subst }];
+  // -----------------------------------------------------------------
+  // 4.2 math: builtins
+  // -----------------------------------------------------------------
 
-    if (g.s instanceof ListTerm && g.s.elems.length === 2) {
-      const a2 = parseNumericForCompareTerm(g.s.elems[0]);
-      const b2 = parseNumericForCompareTerm(g.s.elems[1]);
-      if (a2 && b2 && cmpNumericInfo(a2, b2, '!=')) return [{ ...subst }];
-    }
-    return [];
-  }
+  // math:greaterThan / lessThan / notLessThan / notGreaterThan / equalTo / notEqualTo
+  const mathCmpOp =
+    pv === MATH_NS + 'greaterThan'
+      ? '>'
+      : pv === MATH_NS + 'lessThan'
+        ? '<'
+        : pv === MATH_NS + 'notLessThan'
+          ? '>='
+          : pv === MATH_NS + 'notGreaterThan'
+            ? '<='
+            : pv === MATH_NS + 'equalTo'
+              ? '=='
+              : pv === MATH_NS + 'notEqualTo'
+                ? '!='
+                : null;
+  if (mathCmpOp) return evalNumericComparisonBuiltin(g, subst, mathCmpOp);
 
   // math:sum
   // Schema: ( $s.i+ )+ math:sum $o-
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'sum') {
+  if (pv === MATH_NS + 'sum') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length < 2) return [];
     const xs = g.s.elems;
 
@@ -3313,7 +3203,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
   // math:product
   // Schema: ( $s.i+ )+ math:product $o-
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'product') {
+  if (pv === MATH_NS + 'product') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length < 2) return [];
     const xs = g.s.elems;
 
@@ -3365,7 +3255,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
   // math:difference
   // Schema: ( $s.1+ $s.2+ )+ math:difference $o-
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'difference') {
+  if (pv === MATH_NS + 'difference') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [a0, b0] = g.s.elems;
 
@@ -3453,7 +3343,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
   // math:quotient
   // Schema: ( $s.1+ $s.2+ )+ math:quotient $o-
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'quotient') {
+  if (pv === MATH_NS + 'quotient') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [a0, b0] = g.s.elems;
 
@@ -3482,7 +3372,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // math:integerQuotient
   // Schema: ( $a $b ) math:integerQuotient $q
   // Cwm: divide first integer by second integer, ignoring remainder. :contentReference[oaicite:1]{index=1}
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'integerQuotient') {
+  if (pv === MATH_NS + 'integerQuotient') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [a0, b0] = g.s.elems;
 
@@ -3536,7 +3426,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // math:exponentiation
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'exponentiation') {
+  if (pv === MATH_NS + 'exponentiation') {
     if (g.s instanceof ListTerm && g.s.elems.length === 2) {
       const baseTerm = g.s.elems[0];
       const expTerm = g.s.elems[1];
@@ -3583,7 +3473,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // math:absoluteValue
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'absoluteValue') {
+  if (pv === MATH_NS + 'absoluteValue') {
     const a = parseNum(g.s);
     if (a === null) return [];
 
@@ -3604,58 +3494,58 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // math:acos
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'acos') {
+  if (pv === MATH_NS + 'acos') {
     return evalUnaryMathRel(g, subst, Math.acos, Math.cos);
   }
 
   // math:asin
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'asin') {
+  if (pv === MATH_NS + 'asin') {
     return evalUnaryMathRel(g, subst, Math.asin, Math.sin);
   }
 
   // math:atan
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'atan') {
+  if (pv === MATH_NS + 'atan') {
     return evalUnaryMathRel(g, subst, Math.atan, Math.tan);
   }
 
   // math:sin  (inverse uses principal asin)
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'sin') {
+  if (pv === MATH_NS + 'sin') {
     return evalUnaryMathRel(g, subst, Math.sin, Math.asin);
   }
 
   // math:cos  (inverse uses principal acos)
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'cos') {
+  if (pv === MATH_NS + 'cos') {
     return evalUnaryMathRel(g, subst, Math.cos, Math.acos);
   }
 
   // math:tan  (inverse uses principal atan)
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'tan') {
+  if (pv === MATH_NS + 'tan') {
     return evalUnaryMathRel(g, subst, Math.tan, Math.atan);
   }
 
   // math:sinh / cosh / tanh (guard for JS availability)
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'sinh') {
+  if (pv === MATH_NS + 'sinh') {
     if (typeof Math.sinh !== 'function' || typeof Math.asinh !== 'function') return [];
     return evalUnaryMathRel(g, subst, Math.sinh, Math.asinh);
   }
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'cosh') {
+  if (pv === MATH_NS + 'cosh') {
     if (typeof Math.cosh !== 'function' || typeof Math.acosh !== 'function') return [];
     return evalUnaryMathRel(g, subst, Math.cosh, Math.acosh);
   }
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'tanh') {
+  if (pv === MATH_NS + 'tanh') {
     if (typeof Math.tanh !== 'function' || typeof Math.atanh !== 'function') return [];
     return evalUnaryMathRel(g, subst, Math.tanh, Math.atanh);
   }
 
   // math:degrees (inverse is radians)
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'degrees') {
+  if (pv === MATH_NS + 'degrees') {
     const toDeg = (rad) => (rad * 180.0) / Math.PI;
     const toRad = (deg) => (deg * Math.PI) / 180.0;
     return evalUnaryMathRel(g, subst, toDeg, toRad);
   }
 
   // math:negation (inverse is itself)
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'negation') {
+  if (pv === MATH_NS + 'negation') {
     const neg = (x) => -x;
     return evalUnaryMathRel(g, subst, neg, neg);
   }
@@ -3663,7 +3553,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // math:remainder
   // Subject is a list (dividend divisor); object is the remainder.
   // Schema: ( $a $b ) math:remainder $r
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'remainder') {
+  if (pv === MATH_NS + 'remainder') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [a0, b0] = g.s.elems;
 
@@ -3713,7 +3603,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // If there are two such numbers, then the one closest to positive infinity is returned.
   // Schema: $s+ math:rounded $o-
   // Note: spec says $o is xsd:integer, but we also accept any numeric $o that equals the rounded value.
-  if (g.p instanceof Iri && g.p.value === MATH_NS + 'rounded') {
+  if (pv === MATH_NS + 'rounded') {
     const a = parseNum(g.s);
     if (a === null) return [];
     if (Number.isNaN(a)) return [];
@@ -3742,7 +3632,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
   // time:localTime
   // "" time:localTime ?D.  binds ?D to “now” as xsd:dateTime.
-  if (g.p instanceof Iri && g.p.value === TIME_NS + 'localTime') {
+  if (pv === TIME_NS + 'localTime') {
     const now = getNowLex();
 
     if (g.o instanceof Var) {
@@ -3764,7 +3654,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // list:append
   // true if and only if $o is the concatenation of all lists $s.i.
   // Schema: ( $s.i?[*] )+ list:append $o?
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'append') {
+  if (pv === LIST_NS + 'append') {
     if (!(g.s instanceof ListTerm)) return [];
     const parts = g.s.elems;
     if (g.o instanceof ListTerm) {
@@ -3785,86 +3675,25 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return [];
   }
 
-  // list:first
+  // list:first and rdf:first
   // true iff $s is a list and $o is the first member of that list.
   // Schema: $s+ list:first $o-
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'first') {
-    if (!(g.s instanceof ListTerm)) return [];
-    if (!g.s.elems.length) return [];
-    const first = g.s.elems[0];
-    const s2 = unifyTerm(g.o, first, subst);
-    return s2 !== null ? [s2] : [];
+  if (pv === LIST_NS + 'first' || pv === RDF_NS + 'first') {
+    return evalListFirstLikeBuiltin(g.s, g.o, subst);
   }
 
-  // list:rest
+  // list:rest and rdf:rest
   // true iff $s is a (non-empty) list and $o is the rest (tail) of that list.
   // Schema: $s+ list:rest $o-
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'rest') {
-    // Closed list: (a b c) -> (b c)
-    if (g.s instanceof ListTerm) {
-      if (!g.s.elems.length) return [];
-      const rest = new ListTerm(g.s.elems.slice(1));
-      const s2 = unifyTerm(g.o, rest, subst);
-      return s2 !== null ? [s2] : [];
-    }
-
-    // Open list: (a b ... ?T) -> (b ... ?T)
-    if (g.s instanceof OpenListTerm) {
-      if (!g.s.prefix.length) return []; // can't compute rest without a known head
-
-      if (g.s.prefix.length === 1) {
-        // (a ... ?T) rest is exactly ?T
-        const s2 = unifyTerm(g.o, new Var(g.s.tailVar), subst);
-        return s2 !== null ? [s2] : [];
-      }
-
-      const rest = new OpenListTerm(g.s.prefix.slice(1), g.s.tailVar);
-      const s2 = unifyTerm(g.o, rest, subst);
-      return s2 !== null ? [s2] : [];
-    }
-
-    return [];
-  }
-
-  // rdf:first (alias of list:first)
-  // Schema: $s+ rdf:first $o-
-  if (g.p instanceof Iri && g.p.value === RDF_NS + 'first') {
-    if (!(g.s instanceof ListTerm)) return [];
-    if (!g.s.elems.length) return [];
-    const first = g.s.elems[0];
-    const s2 = unifyTerm(g.o, first, subst);
-    return s2 !== null ? [s2] : [];
-  }
-
-  // rdf:rest (alias of list:rest)
-  // Schema: $s+ rdf:rest $o-
-  if (g.p instanceof Iri && g.p.value === RDF_NS + 'rest') {
-    // Closed list: (a b c) -> (b c)
-    if (g.s instanceof ListTerm) {
-      if (!g.s.elems.length) return [];
-      const rest = new ListTerm(g.s.elems.slice(1));
-      const s2 = unifyTerm(g.o, rest, subst);
-      return s2 !== null ? [s2] : [];
-    }
-    // Open list: (a b ... ?T) -> (b ... ?T)
-    if (g.s instanceof OpenListTerm) {
-      if (!g.s.prefix.length) return [];
-      if (g.s.prefix.length === 1) {
-        const s2 = unifyTerm(g.o, new Var(g.s.tailVar), subst);
-        return s2 !== null ? [s2] : [];
-      }
-      const rest = new OpenListTerm(g.s.prefix.slice(1), g.s.tailVar);
-      const s2 = unifyTerm(g.o, rest, subst);
-      return s2 !== null ? [s2] : [];
-    }
-    return [];
+  if (pv === LIST_NS + 'rest' || pv === RDF_NS + 'rest') {
+    return evalListRestLikeBuiltin(g.s, g.o, subst);
   }
 
   // list:iterate
   // Multi-solution builtin:
   // For a list subject $s, generate solutions by unifying $o with (index value).
   // This allows $o to be a variable (e.g., ?Y) or a pattern (e.g., (?i "Dewey")).
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'iterate') {
+  if (pv === LIST_NS + 'iterate') {
     if (!(g.s instanceof ListTerm)) return [];
     const xs = g.s.elems;
     const outs = [];
@@ -3905,7 +3734,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // list:last
   // true iff $s is a list and $o is the last member of that list.
   // Schema: $s+ list:last $o-
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'last') {
+  if (pv === LIST_NS + 'last') {
     if (!(g.s instanceof ListTerm)) return [];
     const xs = g.s.elems;
     if (!xs.length) return [];
@@ -3917,7 +3746,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // list:memberAt
   // true iff $s.1 is a list, $s.2 is a valid index, and $o is the member at that index.
   // Schema: ( $s.1+ $s.2?[*] )+ list:memberAt $o?[*]
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'memberAt') {
+  if (pv === LIST_NS + 'memberAt') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [listTerm, indexTerm] = g.s.elems;
     if (!(listTerm instanceof ListTerm)) return [];
@@ -3956,7 +3785,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // list:remove
   // true iff $s.1 is a list and $o is that list with all occurrences of $s.2 removed.
   // Schema: ( $s.1+ $s.2+ )+ list:remove $o-
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'remove') {
+  if (pv === LIST_NS + 'remove') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [listTerm, itemTerm] = g.s.elems;
     if (!(listTerm instanceof ListTerm)) return [];
@@ -3978,7 +3807,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:member
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'member') {
+  if (pv === LIST_NS + 'member') {
     if (!(g.s instanceof ListTerm)) return [];
     const outs = [];
     for (const x of g.s.elems) {
@@ -3989,7 +3818,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:in
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'in') {
+  if (pv === LIST_NS + 'in') {
     if (!(g.o instanceof ListTerm)) return [];
     const outs = [];
     for (const x of g.o.elems) {
@@ -4000,7 +3829,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:length  (strict: do not accept integer<->decimal matches for a ground object)
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'length') {
+  if (pv === LIST_NS + 'length') {
     if (!(g.s instanceof ListTerm)) return [];
     const nTerm = new Literal(String(g.s.elems.length));
 
@@ -4014,7 +3843,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:notMember
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'notMember') {
+  if (pv === LIST_NS + 'notMember') {
     if (!(g.s instanceof ListTerm)) return [];
     for (const el of g.s.elems) {
       if (unifyTerm(g.o, el, subst) !== null) return [];
@@ -4023,7 +3852,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:reverse
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'reverse') {
+  if (pv === LIST_NS + 'reverse') {
     if (g.s instanceof ListTerm) {
       const rev = [...g.s.elems].reverse();
       const rterm = new ListTerm(rev);
@@ -4040,7 +3869,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:sort
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'sort') {
+  if (pv === LIST_NS + 'sort') {
     function cmpTermForSort(a, b) {
       if (a instanceof Literal && b instanceof Literal) {
         const [lexA] = literalParts(a.value);
@@ -4108,7 +3937,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:map
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'map') {
+  if (pv === LIST_NS + 'map') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [inputTerm, predTerm] = g.s.elems;
     if (!(inputTerm instanceof ListTerm)) return [];
@@ -4134,7 +3963,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // list:firstRest
-  if (g.p instanceof Iri && g.p.value === LIST_NS + 'firstRest') {
+  if (pv === LIST_NS + 'firstRest') {
     if (g.s instanceof ListTerm) {
       if (!g.s.elems.length) return [];
       const first = g.s.elems[0];
@@ -4172,13 +4001,13 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // -----------------------------------------------------------------
 
   // log:equalTo
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'equalTo') {
+  if (pv === LOG_NS + 'equalTo') {
     const s2 = unifyTerm(goal.s, goal.o, subst);
     return s2 !== null ? [s2] : [];
   }
 
   // log:notEqualTo
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'notEqualTo') {
+  if (pv === LOG_NS + 'notEqualTo') {
     const s2 = unifyTerm(goal.s, goal.o, subst);
     if (s2 !== null) return [];
     return [{ ...subst }];
@@ -4187,7 +4016,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // log:dtlit
   // Schema: ( $s.1? $s.2? )? log:dtlit $o?
   // true iff $o is a datatyped literal with string value $s.1 and datatype IRI $s.2
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'dtlit') {
+  if (pv === LOG_NS + 'dtlit') {
     // Fully unbound (both arguments '?'-mode): treat as satisfiable, succeed once.
     // Required by notation3tests "success-fullUnbound-*".
     if (g.s instanceof Var && g.o instanceof Var) return [{ ...subst }];
@@ -4240,7 +4069,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // log:langlit
   // Schema: ( $s.1? $s.2? )? log:langlit $o?
   // true iff $o is a language-tagged literal with string value $s.1 and language tag $s.2
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'langlit') {
+  if (pv === LOG_NS + 'langlit') {
     // Fully unbound (both arguments '?'-mode): treat as satisfiable, succeed once.
     if (g.s instanceof Var && g.o instanceof Var) return [{ ...subst }];
     const results = [];
@@ -4294,7 +4123,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // log:implies — expose internal forward rules as data
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'implies') {
+  if (pv === LOG_NS + 'implies') {
     const allFw = backRules.__allForwardRules || [];
     const results = [];
 
@@ -4322,7 +4151,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // log:impliedBy — expose internal backward rules as data
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'impliedBy') {
+  if (pv === LOG_NS + 'impliedBy') {
     const allBw = backRules.__allBackwardRules || backRules;
     const results = [];
 
@@ -4352,7 +4181,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
   // log:notIncludes (EYE-style: "not provable in scope")
   // Delay until we have a frozen scope snapshot to avoid early success.
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'notIncludes') {
+  if (pv === LOG_NS + 'notIncludes') {
     if (!(g.o instanceof FormulaTerm)) return [];
 
     let scopeFacts = null;
@@ -4375,7 +4204,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // log:collectAllIn (scoped)
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'collectAllIn') {
+  if (pv === LOG_NS + 'collectAllIn') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 3) return [];
     const [valueTempl, clauseTerm, listTerm] = g.s.elems;
     if (!(clauseTerm instanceof FormulaTerm)) return [];
@@ -4404,7 +4233,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // log:forAllIn (scoped)
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'forAllIn') {
+  if (pv === LOG_NS + 'forAllIn') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [whereClause, thenClause] = g.s.elems;
     if (!(whereClause instanceof FormulaTerm) || !(thenClause instanceof FormulaTerm)) return [];
@@ -4434,7 +4263,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // log:skolem
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'skolem') {
+  if (pv === LOG_NS + 'skolem') {
     // Subject must be ground; commonly a list, but we allow any ground term.
     if (!isGroundTerm(g.s)) return [];
 
@@ -4451,7 +4280,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // log:uri
-  if (g.p instanceof Iri && g.p.value === LOG_NS + 'uri') {
+  if (pv === LOG_NS + 'uri') {
     // Direction 1: subject is an IRI -> object is its string representation
     if (g.s instanceof Iri) {
       const uriStr = g.s.value; // raw IRI string, e.g. "https://www.w3.org"
@@ -4480,7 +4309,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // -----------------------------------------------------------------
 
   // string:concatenation
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'concatenation') {
+  if (pv === STRING_NS + 'concatenation') {
     if (!(g.s instanceof ListTerm)) return [];
     const parts = [];
     for (const t of g.s.elems) {
@@ -4500,7 +4329,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:contains
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'contains') {
+  if (pv === STRING_NS + 'contains') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4508,7 +4337,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:containsIgnoringCase
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'containsIgnoringCase') {
+  if (pv === STRING_NS + 'containsIgnoringCase') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4516,7 +4345,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:endsWith
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'endsWith') {
+  if (pv === STRING_NS + 'endsWith') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4524,7 +4353,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:equalIgnoringCase
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'equalIgnoringCase') {
+  if (pv === STRING_NS + 'equalIgnoringCase') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4533,7 +4362,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
   // string:format
   // (limited: only %s and %% are supported, anything else ⇒ builtin fails)
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'format') {
+  if (pv === STRING_NS + 'format') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length < 1) return [];
     const fmtStr = termToJsString(g.s.elems[0]);
     if (fmtStr === null) return [];
@@ -4560,10 +4389,10 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
   // string:jsonPointer
   // Schema: ( $jsonText $pointer ) string:jsonPointer $value
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'jsonPointer') {
+  if (pv === STRING_NS + 'jsonPointer') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
 
-    const jsonText = termToJsonText(g.s.elems[0]); // <-- changed
+    const jsonText = termToJsonText(g.s.elems[0]);
     const ptr = termToJsStringDecoded(g.s.elems[1]);
     if (jsonText === null || ptr === null) return [];
 
@@ -4575,7 +4404,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:greaterThan
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'greaterThan') {
+  if (pv === STRING_NS + 'greaterThan') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4583,7 +4412,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:lessThan
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'lessThan') {
+  if (pv === STRING_NS + 'lessThan') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4591,7 +4420,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:matches
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'matches') {
+  if (pv === STRING_NS + 'matches') {
     const sStr = termToJsString(g.s);
     const pattern = termToJsString(g.o);
     if (sStr === null || pattern === null) return [];
@@ -4606,7 +4435,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:notEqualIgnoringCase
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'notEqualIgnoringCase') {
+  if (pv === STRING_NS + 'notEqualIgnoringCase') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4614,7 +4443,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:notGreaterThan  (≤ in Unicode code order)
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'notGreaterThan') {
+  if (pv === STRING_NS + 'notGreaterThan') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4622,7 +4451,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:notLessThan  (≥ in Unicode code order)
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'notLessThan') {
+  if (pv === STRING_NS + 'notLessThan') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -4630,7 +4459,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:notMatches
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'notMatches') {
+  if (pv === STRING_NS + 'notMatches') {
     const sStr = termToJsString(g.s);
     const pattern = termToJsString(g.o);
     if (sStr === null || pattern === null) return [];
@@ -4644,7 +4473,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:replace
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'replace') {
+  if (pv === STRING_NS + 'replace') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 3) return [];
     const dataStr = termToJsString(g.s.elems[0]);
     const searchStr = termToJsString(g.s.elems[1]);
@@ -4672,7 +4501,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:scrape
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'scrape') {
+  if (pv === STRING_NS + 'scrape') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const dataStr = termToJsString(g.s.elems[0]);
     const pattern = termToJsString(g.s.elems[1]);
@@ -4701,7 +4530,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   }
 
   // string:startsWith
-  if (g.p instanceof Iri && g.p.value === STRING_NS + 'startsWith') {
+  if (pv === STRING_NS + 'startsWith') {
     const sStr = termToJsString(g.s);
     const oStr = termToJsString(g.o);
     if (sStr === null || oStr === null) return [];
@@ -5065,134 +4894,121 @@ function forwardChain(facts, forwardRules, backRules) {
 
   function runFixpoint() {
     let anyChange = false;
+
     while (true) {
       let changed = false;
 
-      while (true) {
-        let changed = false;
+      for (let i = 0; i < forwardRules.length; i++) {
+        const r = forwardRules[i];
+        const empty = {};
+        const visited = [];
+        const sols = proveGoals(r.premise.slice(), empty, facts, backRules, 0, visited, varGen);
 
-        for (let i = 0; i < forwardRules.length; i++) {
-          const r = forwardRules[i];
-          const empty = {};
-          const visited = [];
-
-          const sols = proveGoals(r.premise.slice(), empty, facts, backRules, 0, visited, varGen);
+        // Inference fuse
+        if (r.isFuse && sols.length) {
+          console.log('# Inference fuse triggered: a { ... } => false. rule fired.');
+          process.exit(2);
+        }
 
-          // Inference fuse
-          if (r.isFuse && sols.length) {
-            console.log('# Inference fuse triggered: a { ... } => false. rule fired.');
-            process.exit(2);
-          }
+        for (const s of sols) {
+          // IMPORTANT: one skolem map per *rule firing*
+          const skMap = {};
+          const instantiatedPremises = r.premise.map((b) => applySubstTriple(b, s));
+          const fireKey = firingKey(i, instantiatedPremises);
+
+          for (const cpat of r.conclusion) {
+            const instantiated = applySubstTriple(cpat, s);
+
+            const isFwRuleTriple =
+              isLogImplies(instantiated.p) &&
+              ((instantiated.s instanceof FormulaTerm && instantiated.o instanceof FormulaTerm) ||
+                (instantiated.s instanceof Literal && instantiated.s.value === 'true' && instantiated.o instanceof FormulaTerm) ||
+                (instantiated.s instanceof FormulaTerm && instantiated.o instanceof Literal && instantiated.o.value === 'true'));
+
+            const isBwRuleTriple =
+              isLogImpliedBy(instantiated.p) &&
+              ((instantiated.s instanceof FormulaTerm && instantiated.o instanceof FormulaTerm) ||
+                (instantiated.s instanceof FormulaTerm && instantiated.o instanceof Literal && instantiated.o.value === 'true') ||
+                (instantiated.s instanceof Literal && instantiated.s.value === 'true' && instantiated.o instanceof FormulaTerm));
+
+            if (isFwRuleTriple || isBwRuleTriple) {
+              if (!hasFactIndexed(facts, instantiated)) {
+                factList.push(instantiated);
+                pushFactIndexed(facts, instantiated);
+                derivedForward.push(new DerivedFact(instantiated, r, instantiatedPremises.slice(), { ...s }));
+                changed = true;
+              }
 
-          for (const s of sols) {
-            // IMPORTANT: one skolem map per *rule firing* so head blank nodes
-            // (e.g., from [ :p ... ; :q ... ]) stay connected across all head triples.
-            const skMap = {};
-            const instantiatedPremises = r.premise.map((b) => applySubstTriple(b, s));
-            const fireKey = firingKey(i, instantiatedPremises);
-
-            for (const cpat of r.conclusion) {
-              const instantiated = applySubstTriple(cpat, s);
-
-              const isFwRuleTriple =
-                isLogImplies(instantiated.p) &&
-                ((instantiated.s instanceof FormulaTerm && instantiated.o instanceof FormulaTerm) ||
-                  (instantiated.s instanceof Literal && instantiated.s.value === 'true' && instantiated.o instanceof FormulaTerm) ||
-                  (instantiated.s instanceof FormulaTerm && instantiated.o instanceof Literal && instantiated.o.value === 'true'));
-
-              const isBwRuleTriple =
-                isLogImpliedBy(instantiated.p) &&
-                ((instantiated.s instanceof FormulaTerm && instantiated.o instanceof FormulaTerm) ||
-                  (instantiated.s instanceof FormulaTerm && instantiated.o instanceof Literal && instantiated.o.value === 'true') ||
-                  (instantiated.s instanceof Literal && instantiated.s.value === 'true' && instantiated.o instanceof FormulaTerm));
-
-              if (isFwRuleTriple || isBwRuleTriple) {
-                if (!hasFactIndexed(facts, instantiated)) {
-                  factList.push(instantiated);
-                  pushFactIndexed(facts, instantiated);
-                  derivedForward.push(
-                    new DerivedFact(instantiated, r, instantiatedPremises.slice(), {
-                      ...s,
-                    }),
+              // Promote rule-producing triples to live rules, treating literal true as {}.
+              const left =
+                instantiated.s instanceof FormulaTerm
+                  ? instantiated.s.triples
+                  : instantiated.s instanceof Literal && instantiated.s.value === 'true'
+                    ? []
+                    : null;
+
+              const right =
+                instantiated.o instanceof FormulaTerm
+                  ? instantiated.o.triples
+                  : instantiated.o instanceof Literal && instantiated.o.value === 'true'
+                    ? []
+                    : null;
+
+              if (left !== null && right !== null) {
+                if (isFwRuleTriple) {
+                  const [premise0, conclusion] = liftBlankRuleVars(left, right);
+                  const premise = reorderPremiseForConstraints(premise0);
+                  const headBlankLabels = collectBlankLabelsInTriples(conclusion);
+                  const newRule = new Rule(premise, conclusion, true, false, headBlankLabels);
+
+                  const already = forwardRules.some(
+                    (rr) =>
+                      rr.isForward === newRule.isForward &&
+                      rr.isFuse === newRule.isFuse &&
+                      triplesListEqual(rr.premise, newRule.premise) &&
+                      triplesListEqual(rr.conclusion, newRule.conclusion),
                   );
-                  changed = true;
-                }
-
-                // Promote rule-producing triples to live rules, treating literal true as {}.
-                const left =
-                  instantiated.s instanceof FormulaTerm
-                    ? instantiated.s.triples
-                    : instantiated.s instanceof Literal && instantiated.s.value === 'true'
-                      ? []
-                      : null;
-
-                const right =
-                  instantiated.o instanceof FormulaTerm
-                    ? instantiated.o.triples
-                    : instantiated.o instanceof Literal && instantiated.o.value === 'true'
-                      ? []
-                      : null;
-
-                if (left !== null && right !== null) {
-                  if (isFwRuleTriple) {
-                    const [premise0, conclusion] = liftBlankRuleVars(left, right);
-                    const premise = reorderPremiseForConstraints(premise0);
-
-                    const headBlankLabels = collectBlankLabelsInTriples(conclusion);
-                    const newRule = new Rule(premise, conclusion, true, false, headBlankLabels);
-
-                    const already = forwardRules.some(
-                      (rr) =>
-                        rr.isForward === newRule.isForward &&
-                        rr.isFuse === newRule.isFuse &&
-                        triplesListEqual(rr.premise, newRule.premise) &&
-                        triplesListEqual(rr.conclusion, newRule.conclusion),
-                    );
-                    if (!already) forwardRules.push(newRule);
-                  } else if (isBwRuleTriple) {
-                    const [premise, conclusion] = liftBlankRuleVars(right, left);
-
-                    const headBlankLabels = collectBlankLabelsInTriples(conclusion);
-                    const newRule = new Rule(premise, conclusion, false, false, headBlankLabels);
-
-                    const already = backRules.some(
-                      (rr) =>
-                        rr.isForward === newRule.isForward &&
-                        rr.isFuse === newRule.isFuse &&
-                        triplesListEqual(rr.premise, newRule.premise) &&
-                        triplesListEqual(rr.conclusion, newRule.conclusion),
-                    );
-                    if (!already) {
-                      backRules.push(newRule);
-                      indexBackRule(backRules, newRule);
-                    }
+                  if (!already) forwardRules.push(newRule);
+                } else if (isBwRuleTriple) {
+                  const [premise, conclusion] = liftBlankRuleVars(right, left);
+                  const headBlankLabels = collectBlankLabelsInTriples(conclusion);
+                  const newRule = new Rule(premise, conclusion, false, false, headBlankLabels);
+
+                  const already = backRules.some(
+                    (rr) =>
+                      rr.isForward === newRule.isForward &&
+                      rr.isFuse === newRule.isFuse &&
+                      triplesListEqual(rr.premise, newRule.premise) &&
+                      triplesListEqual(rr.conclusion, newRule.conclusion),
+                  );
+                  if (!already) {
+                    backRules.push(newRule);
+                    indexBackRule(backRules, newRule);
                   }
                 }
-
-                continue; // skip normal fact handling
               }
 
-              // Only skolemize blank nodes that occur explicitly in the rule head
-              const inst = skolemizeTripleForHeadBlanks(instantiated, r.headBlankLabels, skMap, skCounter, fireKey, headSkolemCache);
+              continue; // skip normal fact handling
+            }
 
-              if (!isGroundTriple(inst)) continue;
-              if (hasFactIndexed(facts, inst)) continue;
+            // Only skolemize blank nodes that occur explicitly in the rule head
+            const inst = skolemizeTripleForHeadBlanks(instantiated, r.headBlankLabels, skMap, skCounter, fireKey, headSkolemCache);
 
-              factList.push(inst);
-              pushFactIndexed(facts, inst);
+            if (!isGroundTriple(inst)) continue;
+            if (hasFactIndexed(facts, inst)) continue;
 
-              derivedForward.push(new DerivedFact(inst, r, instantiatedPremises.slice(), { ...s }));
-              changed = true;
-            }
+            factList.push(inst);
+            pushFactIndexed(facts, inst);
+            derivedForward.push(new DerivedFact(inst, r, instantiatedPremises.slice(), { ...s }));
+            changed = true;
           }
         }
-
-        if (!changed) break;
       }
 
-      if (changed) anyChange = true;
       if (!changed) break;
+      anyChange = true;
     }
+
     return anyChange;
   }