eyeling 1.25.0 → 1.25.2

package/lib/cli.js

@@ -210,7 +210,7 @@ function main() {
         parseN3Text(text, {
           baseIri: __sourceLabelToBaseIri(sourceLabel),
           label: sourceLabel,
-          collectUsedPrefixes: true,
+          collectUsedPrefixes: streamMode,
           keepSourceArtifacts: false,
           rdf: rdfMode,
         }),

package/lib/engine.js

@@ -362,6 +362,14 @@ function __prepareForwardRule(r) {
       configurable: true,
     });
   }
+  if (!hasOwn.call(r, '__needsForwardSkipCheck')) {
+    Object.defineProperty(r, '__needsForwardSkipCheck', {
+      value: !!(r.__headIsStrictGround || (r.__scopedSkipInfo && r.__scopedSkipInfo.needsSnap)),
+      enumerable: false,
+      writable: false,
+      configurable: true,
+    });
+  }
 }
 
 function __graphTriplesOrTrue(term) {
@@ -680,6 +688,11 @@ function skolemizeTermForHeadBlanks(t, headBlankLabels, mapping, skCounter, firi
 }
 
 function skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
+  // Fast path: the common case has no explicit head blanks.  Do not allocate a
+  // replacement Triple or compute a firing key when skolemization cannot change
+  // anything.  This matters for long single-premise chains such as
+  // deep-taxonomy-100000, where every derived head triple is otherwise copied.
+  if (!headBlankLabels || headBlankLabels.size === 0) return tr;
   return new Triple(
     skolemizeTermForHeadBlanks(tr.s, headBlankLabels, mapping, skCounter, firingKey, globalMap),
     skolemizeTermForHeadBlanks(tr.p, headBlankLabels, mapping, skCounter, firingKey, globalMap),
@@ -1049,11 +1062,13 @@ function termFastKey(t) {
   if (t instanceof Iri || t instanceof Blank) return t.__tid;
 
   if (t instanceof Literal) {
-    // Very large literals intentionally skip global interning in prelude.js to
-    // avoid retaining huge strings forever. Their per-object __tid is therefore
-    // not value-stable, so using it here breaks duplicate detection for facts
-    // such as long log:outputString blocks that are re-derived during forward
-    // chaining. Fall back to a value-based key in that case.
+    // Literal construction already computed a value-stable __tid for ordinary
+    // short literals.  Avoid re-running literalParts()/datatype normalization
+    // while building fact indexes; on data-heavy inputs this is a hot path.
+    // Only the rare over-sized literal needs the value-based fallback because
+    // prelude intentionally gives such literals per-object ids to avoid
+    // retaining huge strings in the global interner.
+    if (typeof t.value !== 'string' || t.value.length + 64 <= MAX_LITERAL_TID_LEN) return t.__tid;
     const norm = normalizeLiteralForTid(t.value);
     if (typeof norm === 'string' && norm.length > MAX_LITERAL_TID_LEN) return 'L:' + norm;
     return t.__tid;
@@ -1140,17 +1155,57 @@ function ensureFactIndexes(facts) {
     enumerable: false,
     writable: true,
   });
+  Object.defineProperty(facts, '__keySetComplete', {
+    value: false,
+    enumerable: false,
+    writable: true,
+  });
+
+  // Build lookup indexes eagerly, but do not populate the duplicate-detection
+  // string Set for every input fact.  The predicate/subject/object indexes are
+  // enough to verify duplicates when needed; avoiding 100k+ joined string keys
+  // saves substantial time and GC on data-heavy query workloads.
+  for (let i = 0; i < facts.length; i++) indexFact(facts, facts[i], i, false);
+}
+
+function cloneFactIndexesForSnapshot(src, dest) {
+  ensureFactIndexes(src);
+
+  function cloneArrayMap(map) {
+    const out = new Map();
+    for (const [k, arr] of map) out.set(k, arr.slice());
+    return out;
+  }
 
-  for (let i = 0; i < facts.length; i++) indexFact(facts, facts[i], i);
+  function cloneNestedArrayMap(map) {
+    const out = new Map();
+    for (const [k, inner] of map) {
+      const innerOut = new Map();
+      for (const [k2, arr] of inner) innerOut.set(k2, arr.slice());
+      out.set(k, innerOut);
+    }
+    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, '__wildPred', { value: src.__wildPred.slice(), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__wildPS', { value: cloneArrayMap(src.__wildPS), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__wildPO', { value: cloneArrayMap(src.__wildPO), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__keySet', { value: new Set(src.__keySet), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__keySetComplete', { value: !!src.__keySetComplete, enumerable: false, writable: true });
 }
 
-function indexFact(facts, tr, idx) {
+function indexFact(facts, tr, idx, addKeySet = true) {
   const sk = termFastKey(tr.s);
   const ok = termFastKey(tr.o);
+  let pkForKey = null;
 
   if (tr.p instanceof Iri) {
     // Use predicate term id as the primary key to avoid hashing long IRI strings.
     const pk = tr.p.__tid;
+    pkForKey = pk;
 
     let pb = facts.__byPred.get(pk);
     if (!pb) {
@@ -1208,8 +1263,10 @@ function indexFact(facts, tr, idx) {
     }
   }
 
-  const key = tripleFastKey(tr);
-  if (key !== null) facts.__keySet.add(key);
+  if (addKeySet && sk !== null && ok !== null) {
+    if (pkForKey === null) pkForKey = termFastKey(tr.p);
+    if (pkForKey !== null) facts.__keySet.add(sk + '\t' + pkForKey + '\t' + ok);
+  }
 }
 
 function candidateFacts(facts, goal) {
@@ -1271,7 +1328,10 @@ function hasFactIndexed(facts, tr) {
   ensureFactIndexes(facts);
 
   const key = tripleFastKey(tr);
-  if (key !== null) return facts.__keySet.has(key);
+  if (key !== null) {
+    if (facts.__keySet.has(key)) return true;
+    if (facts.__keySetComplete) return false;
+  }
 
   if (tr.p instanceof Iri) {
     const pk = tr.p.__tid;
@@ -1301,7 +1361,7 @@ function pushFactIndexed(facts, tr) {
   ensureFactIndexes(facts);
   const idx = facts.length;
   facts.push(tr);
-  indexFact(facts, tr, idx);
+  indexFact(facts, tr, idx, true);
 }
 
 function makeDerivedRecord(fact, rule, premises, subst, captureExplanations) {
@@ -1423,13 +1483,20 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     if (!isSinglePremiseAgendaRuleSafe(r, backRules)) continue;
 
     const goal = r.premise[0];
+    const goalSKey = termFastKey(goal.s);
+    const goalOKey = termFastKey(goal.o);
+    const fastSubjectVar = goal.p instanceof Iri && goal.s instanceof Var && goalOKey !== null ? goal.s.name : null;
+    const fastObjectVar = goal.p instanceof Iri && goal.o instanceof Var && goalSKey !== null ? goal.o.name : null;
     const entry = {
       rule: r,
       ruleIndex: i,
       goal,
       goalPredTid: goal.p instanceof Iri ? goal.p.__tid : null,
-      goalSKey: termFastKey(goal.s),
-      goalOKey: termFastKey(goal.o),
+      goalSKey,
+      goalOKey,
+      needsSkipCheck: !!r.__needsForwardSkipCheck,
+      fastSubjectVar,
+      fastObjectVar,
     };
 
     index.indexed.add(r);
@@ -2838,11 +2905,9 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     const varGen = [0];
     const skCounter = [0];
 
-    // Speed up dynamic rule promotion by maintaining O(1) membership sets.
-    // (Some workloads derive many rule-producing triples.)
-
-    __ensureRuleKeySet(forwardRules);
-    __ensureRuleKeySet(backRules);
+    // Rule-key sets are only needed if a program actually derives rule-producing
+    // triples. Building them eagerly is expensive on large static rule sets, so
+    // dynamic-promotion sites create them lazily before duplicate checks.
 
     // Cache head blank-node skolemization per (rule firing, head blank label).
     // This prevents repeatedly generating fresh _:sk_N blanks for the *same*
@@ -2892,7 +2957,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
     function makeScopedSnapshot() {
       const snap = facts.slice();
-      ensureFactIndexes(snap);
+      cloneFactIndexesForSnapshot(facts, snap);
       Object.defineProperty(snap, '__scopedSnapshot', {
         value: snap,
         enumerable: false,
@@ -2946,10 +3011,21 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       let changedHere = false;
       let rulesChanged = false;
 
-      // IMPORTANT: one skolem map per *rule firing*
+      // IMPORTANT: one skolem map per *rule firing*.  Instantiate premise
+      // triples and build the firing key lazily: normal CLI runs do not capture
+      // proof records, and most rules have no explicit head blanks, so the eager
+      // work was pure allocation on large forward chains.
       const skMap = {};
-      const instantiatedPremises = r.premise.map((b) => applySubstTriple(b, s));
-      const fireKey = __firingKey(ruleIndex, instantiatedPremises);
+      let instantiatedPremises = null;
+      let fireKey = null;
+      function getInstantiatedPremises() {
+        if (instantiatedPremises === null) instantiatedPremises = r.premise.map((b) => applySubstTriple(b, s));
+        return instantiatedPremises;
+      }
+      function getFireKey() {
+        if (fireKey === null) fireKey = __firingKey(ruleIndex, getInstantiatedPremises());
+        return fireKey;
+      }
 
       // Support "dynamic" rule heads where the consequent is a term that
       // (after substitution) evaluates to a quoted formula.
@@ -3002,7 +3078,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         if (isFwRuleTriple || isBwRuleTriple) {
           if (!hasFactIndexed(facts, instantiated)) {
             pushFactIndexed(facts, instantiated);
-            const df = makeDerivedRecord(instantiated, r, instantiatedPremises, s, captureExplanations);
+            const df = makeDerivedRecord(instantiated, r, getInstantiatedPremises(), s, captureExplanations);
             derivedForward.push(df);
             if (typeof onDerived === 'function') onDerived(df);
             changedHere = true;
@@ -3021,8 +3097,9 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
               newRule.conclusion,
               newRule.__dynamicConclusionTerm || null,
             );
-            if (!forwardRules.__ruleKeySet.has(key)) {
-              forwardRules.__ruleKeySet.add(key);
+            const forwardRuleKeySet = __ensureRuleKeySet(forwardRules);
+            if (!forwardRuleKeySet.has(key)) {
+              forwardRuleKeySet.add(key);
               forwardRules.push(newRule);
               rulesChanged = true;
             }
@@ -3036,8 +3113,9 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
               newRule.conclusion,
               newRule.__dynamicConclusionTerm || null,
             );
-            if (!backRules.__ruleKeySet.has(key)) {
-              backRules.__ruleKeySet.add(key);
+            const backRuleKeySet = __ensureRuleKeySet(backRules);
+            if (!backRuleKeySet.has(key)) {
+              backRuleKeySet.add(key);
               backRules.push(newRule);
               indexBackRule(backRules, newRule);
               rulesChanged = true;
@@ -3048,20 +3126,23 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         }
 
         // Only skolemize blank nodes that occur explicitly in the rule head
-        const inst = skolemizeTripleForHeadBlanks(
-          instantiated,
-          headBlankLabelsHere,
-          skMap,
-          skCounter,
-          fireKey,
-          headSkolemCache,
-        );
+        const inst =
+          headBlankLabelsHere && headBlankLabelsHere.size
+            ? skolemizeTripleForHeadBlanks(
+                instantiated,
+                headBlankLabelsHere,
+                skMap,
+                skCounter,
+                getFireKey(),
+                headSkolemCache,
+              )
+            : instantiated;
 
         if (!isGroundTriple(inst)) continue;
         if (hasFactIndexed(facts, inst)) continue;
 
         pushFactIndexed(facts, inst);
-        const df = makeDerivedRecord(inst, r, instantiatedPremises, s, captureExplanations);
+        const df = makeDerivedRecord(inst, r, getInstantiatedPremises(), s, captureExplanations);
         derivedForward.push(df);
         if (typeof onDerived === 'function') onDerived(df);
 
@@ -3088,10 +3169,19 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           for (let ci = 0; ci < total; ci++) {
             const entry = ci < candidates.exactLen ? candidates.exact[ci] : candidates.wild[ci - candidates.exactLen];
             const r = entry.rule;
-            if (__skipForwardRuleNow(r)) continue;
-
-            const s = unifyTriple(entry.goal, fact, __emptySubst());
-            if (s === null) continue;
+            if (entry.needsSkipCheck && __skipForwardRuleNow(r)) continue;
+
+            let s;
+            if (entry.fastSubjectVar !== null) {
+              s = __emptySubst();
+              s[entry.fastSubjectVar] = fact.s;
+            } else if (entry.fastObjectVar !== null) {
+              s = __emptySubst();
+              s[entry.fastObjectVar] = fact.o;
+            } else {
+              s = unifyTriple(entry.goal, fact, __emptySubst());
+              if (s === null) continue;
+            }
 
             const outcome = __emitForwardRuleSolution(r, entry.ruleIndex, s);
             if (outcome.rulesChanged) {
@@ -3108,7 +3198,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 (__skipForwardRuleNow(r)) continue;
+          if (r.__needsForwardSkipCheck && __skipForwardRuleNow(r)) continue;
 
           const headIsStrictGround = r.__headIsStrictGround;
           const maxSols = r.isFuse || headIsStrictGround ? 1 : undefined;