eyeling 1.25.4 → 1.26.0

package/index.d.ts

@@ -151,6 +151,7 @@ declare module 'eyeling' {
   }
 
   export interface ReasonOptions {
+    proof?: boolean;
     proofComments?: boolean;
     noProofComments?: boolean;
     args?: string[];

package/index.js

@@ -19,21 +19,24 @@ function reason(opt = {}, input = '') {
 
   const args = [];
 
-  // default: proof comments OFF for API output (machine-friendly)
-  // set { proofComments: true } to keep them
-  const proofCommentsSpecified = typeof opt.proofComments === 'boolean' || typeof opt.noProofComments === 'boolean';
-
-  const proofComments =
-    typeof opt.proofComments === 'boolean'
-      ? opt.proofComments
-      : typeof opt.noProofComments === 'boolean'
-        ? !opt.noProofComments
-        : false;
+  // default: proof output OFF for API output (machine-friendly)
+  // set { proof: true } to include N3 proof explanations.
+  // proofComments/noProofComments are accepted as legacy aliases.
+  const proofSpecified =
+    typeof opt.proof === 'boolean' || typeof opt.proofComments === 'boolean' || typeof opt.noProofComments === 'boolean';
+
+  const proof =
+    typeof opt.proof === 'boolean'
+      ? opt.proof
+      : typeof opt.proofComments === 'boolean'
+        ? opt.proofComments
+        : typeof opt.noProofComments === 'boolean'
+          ? !opt.noProofComments
+          : false;
 
   // Only pass a flag when the caller explicitly asked.
-  // (CLI default is now: no proof comments.)
-  if (proofCommentsSpecified) {
-    if (proofComments) args.push('--proof-comments');
+  if (proofSpecified) {
+    if (proof) args.push('--proof');
     else args.push('--no-proof-comments');
   }
 

package/lib/cli.js

@@ -106,7 +106,7 @@ function main() {
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +
-      `  -p, --proof-comments         Enable proof explanations.\n` +
+      `  -p, --proof                  Enable proof explanations.\n` +
       `  -r, --rdf                    Enable RDF/TriG input/output compatibility.\n` +
       `  -s, --super-restricted       Disable all builtins except => and <=.\n` +
       `  -t, --stream                 Stream derived triples as soon as they are derived.\n` +
@@ -161,8 +161,8 @@ function main() {
     if (typeof engine.setDeterministicSkolemEnabled === 'function') engine.setDeterministicSkolemEnabled(true);
   }
 
-  // --proof-comments / -p: enable proof explanations
-  if (argv.includes('--proof-comments') || argv.includes('-p')) {
+  // --proof / -p: enable proof explanations as N3 proof graphs
+  if (argv.includes('--proof') || argv.includes('--proof-comments') || argv.includes('-p')) {
     engine.setProofCommentsEnabled(true);
   }
 
@@ -211,6 +211,7 @@ function main() {
           baseIri: __sourceLabelToBaseIri(sourceLabel),
           label: sourceLabel,
           collectUsedPrefixes: streamMode,
+          collectSourceLocations: engine.getProofCommentsEnabled(),
           keepSourceArtifacts: false,
           rdf: rdfMode,
         }),
@@ -301,7 +302,7 @@ function main() {
   const hasQueries = Array.isArray(qrules) && qrules.length;
   const mayAutoRenderOutputStrings = programMayProduceOutputStrings(triples, frules, qrules);
 
-  if (streamMode && !hasQueries && !mayAutoRenderOutputStrings) {
+  if (streamMode && !hasQueries && !mayAutoRenderOutputStrings && !engine.getProofCommentsEnabled()) {
     const usedInInput = mergedDocument.usedPrefixes instanceof Set ? new Set(mergedDocument.usedPrefixes) : new Set();
     const outPrefixes = restrictPrefixEnv(prefixes, usedInInput);
 
@@ -366,6 +367,11 @@ function main() {
     return;
   }
 
+  if (engine.getProofCommentsEnabled()) {
+    process.stdout.write(engine.renderProofDocument(outDerived, derived, triples, prefixes, brules));
+    return;
+  }
+
   let bodyText = '';
   if (rdfMode && !engine.getProofCommentsEnabled()) {
     bodyText = outTriples.map((tr) => engine.tripleToRdfCompatible(tr, prefixes)).join('\n');

package/lib/engine.js

@@ -484,6 +484,158 @@ function __varOccursElsewhereInPremise(premise, name, idx, field) {
   return false;
 }
 
+
+function __scopedPriorityForTerm(t) {
+  if (t instanceof GraphTerm) return 0;
+  const p0 = __logNaturalPriorityFromTerm(t);
+  return p0 !== null && p0 >= 1 ? p0 : 1;
+}
+
+function __pushScopedQueryTriplesFromGraph(term, out) {
+  if (!(term instanceof GraphTerm)) return;
+  for (const tr of term.triples) out.push(tr);
+}
+
+function __analyzeForwardRuleScopedUse(rule) {
+  const out = {
+    needsSnap: false,
+    baseLevel: 0,
+    queryTriples: [],
+    hasScopedAggregate: false,
+  };
+
+  if (!rule || !Array.isArray(rule.premise)) return out;
+
+  for (let i = 0; i < rule.premise.length; i++) {
+    const tr = rule.premise[i];
+    if (!(tr && tr.p instanceof Iri)) continue;
+    const pv = tr.p.value;
+
+    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
+      // Explicit quoted scopes are local formulas, not snapshots of the global closure.
+      if (tr.s instanceof GraphTerm) continue;
+
+      // A scope variable that is bound by another premise may become an explicit GraphTerm.
+      // Still, if it remains unbound at runtime the builtin treats it as priority 1.
+      // We therefore record the scoped use, but only use quoted object triples for
+      // dependency analysis; variables inside the quoted object do not bind the scope.
+      out.needsSnap = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.s));
+      __pushScopedQueryTriplesFromGraph(tr.o, out.queryTriples);
+      continue;
+    }
+
+    if (pv === LOG_NS + 'collectAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 3) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+      continue;
+    }
+
+    if (pv === LOG_NS + 'forAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 2) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[0], out.queryTriples);
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+    }
+  }
+
+  return out;
+}
+
+function __triplePatternsMayOverlap(a, b) {
+  return unifyTriple(a, b, __emptySubst()) !== null || unifyTriple(b, a, __emptySubst()) !== null;
+}
+
+function __ruleConclusionsMayFeedScopedQueries(producer, consumerMeta) {
+  if (!consumerMeta || !consumerMeta.queryTriples || consumerMeta.queryTriples.length === 0) return false;
+
+  // Dynamic conclusions are only known after a proof solution. Conservatively
+  // assume they can feed any scoped query if the producing rule is scoped.
+  if (producer && producer.__dynamicConclusionTerm) return true;
+
+  if (!producer || !Array.isArray(producer.conclusion) || producer.conclusion.length === 0) return false;
+  for (const q of consumerMeta.queryTriples) {
+    for (const h of producer.conclusion) {
+      if (__triplePatternsMayOverlap(q, h)) return true;
+    }
+  }
+  return false;
+}
+
+function __setForwardRuleScopedStratumInfo(rule, level) {
+  const value =
+    level > 0
+      ? { needsSnap: true, requiredLevel: level, exactLevel: true }
+      : { needsSnap: false, requiredLevel: 0, exactLevel: false };
+
+  if (!hasOwn.call(rule, '__scopedStratumInfo')) {
+    Object.defineProperty(rule, '__scopedStratumInfo', {
+      value,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+  } else {
+    rule.__scopedStratumInfo = value;
+  }
+}
+
+function __computeForwardRuleScopedStrata(forwardRules) {
+  if (!Array.isArray(forwardRules) || forwardRules.length === 0) return 0;
+
+  const metas = forwardRules.map((r) => __analyzeForwardRuleScopedUse(r));
+  const levels = metas.map((m) => (m.needsSnap ? Math.max(1, m.baseLevel || 1) : 0));
+
+  let maxLevel = 0;
+  for (const lvl of levels) if (lvl > maxLevel) maxLevel = lvl;
+
+  // Stratify scoped rules by data dependency: if a scoped query can read facts
+  // produced by another scoped rule, the reader must run against a later frozen
+  // snapshot. This prevents non-monotonic scoped builtins such as collectAllIn
+  // from emitting an early result before lower strata have derived their facts.
+  const passLimit = Math.max(1, forwardRules.length) + maxLevel + 1;
+  for (let pass = 0; pass < passLimit; pass++) {
+    let changed = false;
+    for (let ci = 0; ci < forwardRules.length; ci++) {
+      if (!metas[ci].needsSnap || !metas[ci].hasScopedAggregate) continue;
+      let needed = levels[ci];
+      for (let pi = 0; pi < forwardRules.length; pi++) {
+        if (pi === ci) continue;
+        if (levels[pi] <= 0) continue;
+        if (metas[pi].hasScopedAggregate) continue;
+        if (!__ruleConclusionsMayFeedScopedQueries(forwardRules[pi], metas[ci])) continue;
+        needed = Math.max(needed, levels[pi] + 1);
+      }
+      if (needed !== levels[ci]) {
+        levels[ci] = needed;
+        if (needed > maxLevel) maxLevel = needed;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+
+
+  maxLevel = 0;
+  for (let i = 0; i < forwardRules.length; i++) {
+    __setForwardRuleScopedStratumInfo(forwardRules[i], levels[i]);
+    if (levels[i] > maxLevel) maxLevel = levels[i];
+  }
+
+  return maxLevel;
+}
+
 function __computeForwardRuleScopedSkipInfo(rule) {
   let needsSnap = false;
   let requiredLevel = 0;
@@ -628,9 +780,11 @@ const { evalBuiltin, isBuiltinPred } = makeBuiltins({
 });
 
 // Initialize proof/output helpers (implemented in lib/explain.js).
-const { printExplanation, collectOutputStringsFromFacts } = makeExplain({
+const { printExplanation, renderProofDocument, collectOutputStringsFromFacts } = makeExplain({
   applySubstTerm,
   skolemKeyFromTerm,
+  isBuiltinPred,
+  findBackwardProofForGoal,
 });
 
 function skolemizeTermForHeadBlanks(t, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
@@ -1669,7 +1823,7 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
       goalPredTid: goal.p instanceof Iri ? goal.p.__tid : null,
       goalSKey,
       goalOKey,
-      needsSkipCheck: !!r.__needsForwardSkipCheck,
+      needsSkipCheck: !!(r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)),
       fastSubjectVar,
       fastObjectVar,
     };
@@ -2281,6 +2435,217 @@ function unifyTriple(pat, fact, subst) {
   return s3;
 }
 
+
+function __copyProofSourceMetadata(from, to) {
+  if (!from || !to) return to;
+  for (const key of ['__sourceOffset', '__source']) {
+    if (hasOwn.call(from, key)) {
+      Object.defineProperty(to, key, {
+        value: from[key],
+        enumerable: false,
+        writable: false,
+        configurable: true,
+      });
+    }
+  }
+  return to;
+}
+
+function __standardizeRuleForProof(rule, gen) {
+  const proofVarNames = Object.create(null);
+
+  function renameTerm(t, vmapName, vmapVar, genArr) {
+    if (t instanceof Var) {
+      if (!hasOwn.call(vmapVar, t.name)) {
+        const name = `${t.name}__proof_${genArr[0]}`;
+        genArr[0] += 1;
+        vmapName[t.name] = name;
+        vmapVar[t.name] = new Var(name);
+        proofVarNames[name] = t.name;
+      }
+      return vmapVar[t.name];
+    }
+    if (t instanceof ListTerm) {
+      let changed = false;
+      const elems2 = t.elems.map((e) => {
+        const e2 = renameTerm(e, vmapName, vmapVar, genArr);
+        if (e2 !== e) changed = true;
+        return e2;
+      });
+      return changed ? new ListTerm(elems2) : t;
+    }
+    if (t instanceof OpenListTerm) {
+      let changed = false;
+      const newXs = t.prefix.map((e) => {
+        const e2 = renameTerm(e, vmapName, vmapVar, genArr);
+        if (e2 !== e) changed = true;
+        return e2;
+      });
+      if (!hasOwn.call(vmapName, t.tailVar)) {
+        const name = `${t.tailVar}__proof_${genArr[0]}`;
+        genArr[0] += 1;
+        vmapName[t.tailVar] = name;
+        vmapVar[t.tailVar] = new Var(name);
+        proofVarNames[name] = t.tailVar;
+      }
+      const newTail = vmapName[t.tailVar];
+      if (newTail !== t.tailVar) changed = true;
+      return changed ? new OpenListTerm(newXs, newTail) : t;
+    }
+    if (t instanceof GraphTerm) {
+      let changed = false;
+      const triples2 = t.triples.map((tr) => {
+        const s2 = renameTerm(tr.s, vmapName, vmapVar, genArr);
+        const p2 = renameTerm(tr.p, vmapName, vmapVar, genArr);
+        const o2 = renameTerm(tr.o, vmapName, vmapVar, genArr);
+        if (s2 !== tr.s || p2 !== tr.p || o2 !== tr.o) changed = true;
+        return s2 === tr.s && p2 === tr.p && o2 === tr.o ? tr : new Triple(s2, p2, o2);
+      });
+      return changed ? copyQuotedGraphMetadata(t, new GraphTerm(triples2)) : t;
+    }
+    return t;
+  }
+
+  const vmapName = Object.create(null);
+  const vmapVar = Object.create(null);
+  const premise = rule.premise.map((tr) => {
+    const s2 = renameTerm(tr.s, vmapName, vmapVar, gen);
+    const p2 = renameTerm(tr.p, vmapName, vmapVar, gen);
+    const o2 = renameTerm(tr.o, vmapName, vmapVar, gen);
+    return s2 === tr.s && p2 === tr.p && o2 === tr.o ? tr : new Triple(s2, p2, o2);
+  });
+  const conclusion = rule.conclusion.map((tr) => {
+    const s2 = renameTerm(tr.s, vmapName, vmapVar, gen);
+    const p2 = renameTerm(tr.p, vmapName, vmapVar, gen);
+    const o2 = renameTerm(tr.o, vmapName, vmapVar, gen);
+    return s2 === tr.s && p2 === tr.p && o2 === tr.o ? tr : new Triple(s2, p2, o2);
+  });
+  const out = new Rule(premise, conclusion, rule.isForward, rule.isFuse, rule.headBlankLabels);
+  Object.defineProperty(out, '__proofVarSourceNames', {
+    value: proofVarNames,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return __copyProofSourceMetadata(rule, out);
+}
+
+function __mergeProofSubst(base, delta) {
+  const out = __cloneSubst(base);
+  for (const k in delta || {}) {
+    if (!hasOwn.call(delta, k)) continue;
+    const v = applySubstTerm(delta[k], out);
+    if (hasOwn.call(out, k)) {
+      if (!termsEqual(applySubstTerm(out[k], out), v)) return null;
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+function __sourceSortKey(obj) {
+  const src = obj && obj.__source;
+  const label = src && typeof src.label === 'string' ? src.label : '';
+  const line = src && Number.isInteger(src.line) ? src.line : 0;
+  return `${label}\t${line}`;
+}
+
+function __candidateFactsForProof(facts, goal) {
+  if (!Array.isArray(facts)) return [];
+  ensureFactIndexes(facts);
+  const candidates = candidateFacts(facts, goal);
+  if (!candidates) return facts;
+  const out = [];
+  for (let i = 0; i < candidates.exactLen; i++) out.push(facts[candidates.exact[i]]);
+  for (let i = 0; i < candidates.wildLen; i++) out.push(facts[candidates.wild[i]]);
+  return out;
+}
+
+function findBackwardProofForGoal(goal, facts, backRules, opts = {}) {
+  const maxDepth = Number.isInteger(opts.maxDepth) && opts.maxDepth > 0 ? opts.maxDepth : 64;
+  const varGen = [0];
+
+  function proofKey(tr) {
+    return `${skolemKeyFromTerm(tr.s)}\t${skolemKeyFromTerm(tr.p)}\t${skolemKeyFromTerm(tr.o)}`;
+  }
+
+  function proveGoal(goal0, subst, depth, visited) {
+    if (depth > maxDepth) return [];
+    const g = applySubstTriple(goal0, subst);
+    const key = proofKey(g);
+    if (visited.has(key)) return [];
+
+    if (isBuiltinPred(g.p)) {
+      const builtinGoalForEval = g.p instanceof Iri && g.p.value === LOG_NS + 'rawType' ? goal0 : g;
+      const builtinSubstForEval = g.p instanceof Iri && g.p.value === LOG_NS + 'rawType' ? subst : __emptySubst();
+      const deltas = evalBuiltin(builtinGoalForEval, builtinSubstForEval, facts, backRules, depth, varGen, 1) || [];
+      const out = [];
+      for (const delta of deltas) {
+        const subst2 = __mergeProofSubst(subst, delta);
+        if (subst2 === null) continue;
+        const fact = applySubstTriple(g, subst2);
+        out.push({ subst: subst2, proof: { kind: 'builtin', fact, builtin: fact.p } });
+        break;
+      }
+      return out;
+    }
+
+    const factResults = [];
+    for (const f of __candidateFactsForProof(facts, g)) {
+      const subst2 = unifyTriple(g, f, subst);
+      if (subst2 === null) continue;
+      factResults.push({ subst: subst2, proof: { kind: 'fact', fact: applySubstTriple(f, subst2), source: f.__source } });
+      break;
+    }
+    if (factResults.length) return factResults;
+
+    if (!(g.p instanceof Iri)) return [];
+    ensureBackRuleIndexes(backRules);
+    const rules = (backRules.__byHeadPred.get(g.p.__tid) || []).concat(backRules.__wildHeadPred || []);
+    rules.sort((a, b) => (__sourceSortKey(a) < __sourceSortKey(b) ? -1 : __sourceSortKey(a) > __sourceSortKey(b) ? 1 : 0));
+
+    const visited2 = new Set(visited);
+    visited2.add(key);
+
+    for (const r of rules) {
+      if (!r || !Array.isArray(r.conclusion) || r.conclusion.length !== 1) continue;
+      const rStd = __standardizeRuleForProof(r, varGen);
+      const head = rStd.conclusion[0];
+      if (head.p instanceof Iri && head.p.__tid !== g.p.__tid) continue;
+      const subst1 = unifyTriple(head, g, subst);
+      if (subst1 === null) continue;
+      const bodyProof = proveGoalList(rStd.premise || [], subst1, depth + 1, visited2);
+      if (!bodyProof) continue;
+      const fact = applySubstTriple(g, bodyProof.subst);
+      const premises = (rStd.premise || []).map((prem) => applySubstTriple(prem, bodyProof.subst));
+      const df = new DerivedFact(fact, rStd, premises, bodyProof.subst);
+      return [{ subst: bodyProof.subst, proof: { kind: 'rule', df, children: bodyProof.proofs } }];
+    }
+
+    return [];
+  }
+
+  function proveGoalList(goals, subst, depth, visited) {
+    let states = [{ subst, proofs: [] }];
+    for (const goal1 of goals || []) {
+      const next = [];
+      for (const state of states) {
+        const proofs = proveGoal(goal1, state.subst, depth, visited);
+        for (const pr of proofs) next.push({ subst: pr.subst, proofs: state.proofs.concat([pr.proof]) });
+      }
+      if (!next.length) return null;
+      // Keep proof reconstruction deterministic and cheap: one proof is enough
+      // for an explanation of the already-derived enclosing fact.
+      states = [next[0]];
+    }
+    return states[0] || { subst, proofs: [] };
+  }
+
+  const found = proveGoal(goal, __emptySubst(), 0, new Set());
+  return found.length ? found[0].proof : null;
+}
+
 // Strategy: when the substitution is "large" or search depth is high,
 // keep only bindings that are still relevant to:
 //   - variables appearing in the remaining goals
@@ -3117,7 +3482,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     let scopedClosureLevel = 0;
 
     // Scan known rules for the maximum requested closure priority in scoped log:* goals.
-    let maxScopedClosurePriorityNeeded = __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules);
+    let maxScopedClosurePriorityNeeded = Math.max(
+      __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+      __computeForwardRuleScopedStrata(forwardRules),
+    );
 
     // Conservative fast-skip for forward rules that cannot possibly succeed
     // until a scoped snapshot exists (or a given closure level is reached).
@@ -3171,12 +3539,16 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // until a snapshot exists (and a certain closure level is reached).
       // This prevents expensive proofs that will definitely fail in Phase A
       // and in early closure levels.
-      const info = r.__scopedSkipInfo;
+      const info = r.__scopedStratumInfo || r.__scopedSkipInfo;
       if (info && info.needsSnap) {
         const snapHere = facts.__scopedSnapshot || null;
         const lvlHere = (facts && typeof facts.__scopedClosureLevel === 'number' && facts.__scopedClosureLevel) || 0;
         if (!snapHere) return true;
-        if (lvlHere < info.requiredLevel) return true;
+        if (info.exactLevel) {
+          if (lvlHere !== info.requiredLevel) return true;
+        } else if (lvlHere < info.requiredLevel) {
+          return true;
+        }
       }
 
       // Optimization: if the rule head is **structurally ground** (no vars anywhere, even inside
@@ -3376,6 +3748,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
             const outcome = __emitForwardRuleSolution(r, entry.ruleIndex, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -3389,7 +3765,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         for (let i = 0; i < forwardRules.length; i++) {
           const r = forwardRules[i];
           if (agendaIndex.indexed.has(r)) continue;
-          if (r.__needsForwardSkipCheck && __skipForwardRuleNow(r)) continue;
+          if ((r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)) && __skipForwardRuleNow(r)) continue;
 
           const headIsStrictGround = r.__headIsStrictGround;
           const maxSols = r.isFuse || headIsStrictGround ? 1 : undefined;
@@ -3410,6 +3786,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           for (const s of sols) {
             const outcome = __emitForwardRuleSolution(r, i, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -3437,8 +3817,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // Rules may have been added dynamically (rule-producing triples), possibly
       // introducing scoped builtins and/or higher closure priorities.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       // If there are no scoped builtins in the entire program, Phase B is pure
@@ -3456,8 +3836,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
       // Phase B can also derive rule-producing triples.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       if (!changedA && !changedB && scopedClosureLevel >= maxScopedClosurePriorityNeeded) break;
@@ -3780,11 +4160,19 @@ function reasonStream(input, opts = {}) {
         ? facts
         : derived.map((d) => d.fact);
 
-  const closureN3 = useRdfCompatibility
-    ? closureTriples.map((t) => tripleToRdfCompatible(t, prefixes)).join('\n')
-    : Array.isArray(logQueryRules) && logQueryRules.length && !proof
-      ? prettyPrintQueryTriples(closureTriples, prefixes)
-      : closureTriples.map((t) => tripleToN3(t, prefixes)).join('\n');
+  const closureN3 = proof
+    ? renderProofDocument(
+        Array.isArray(logQueryRules) && logQueryRules.length ? queryDerived : derived,
+        derived,
+        triples,
+        prefixes,
+        brules,
+      ).replace(/\n$/g, '')
+    : useRdfCompatibility
+      ? closureTriples.map((t) => tripleToRdfCompatible(t, prefixes)).join('\n')
+      : Array.isArray(logQueryRules) && logQueryRules.length
+        ? prettyPrintQueryTriples(closureTriples, prefixes)
+        : closureTriples.map((t) => tripleToN3(t, prefixes)).join('\n');
 
   const __out = {
     prefixes,
@@ -3911,6 +4299,7 @@ module.exports = {
   collectLogQueryConclusions,
   forwardChainAndCollectLogQueryConclusions,
   collectOutputStringsFromFacts,
+  renderProofDocument,
   main,
   version,
   N3SyntaxError,

package/lib/entry.js

@@ -32,6 +32,7 @@ module.exports = {
   materializeRdfLists: engine.materializeRdfLists,
   isGroundTriple: engine.isGroundTriple,
   printExplanation: engine.printExplanation,
+  renderProofDocument: engine.renderProofDocument,
   tripleToN3: engine.tripleToN3,
   collectOutputStringsFromFacts: engine.collectOutputStringsFromFacts,
   prettyPrintQueryTriples: engine.prettyPrintQueryTriples,