eyeling 1.11.9 → 1.11.10

package/HANDBOOK.md

@@ -365,11 +365,23 @@ A substitution is a plain JS object:
 { X: Term, Y: Term, ... }
 ```
 
-When applying substitutions, Eyeling follows chains:
+When applying substitutions, Eyeling follows **chains**:
 
 * if `X → Var(Y)` and `Y → Iri(...)`, applying to `X` yields the IRI.
 
-This matters because unification can bind variables to variables; it’s normal in logic programming, and you want `applySubst` to “chase the link” until it reaches a stable term.
+Chains arise naturally during unification (e.g. when variables unify with other variables) and during rule firing. Eyeling treats substitutions as *persistent maps*: when a new binding is added, the engine makes a shallow copy and records only the new binding.
+
+Implementation details (and why they matter):
+
+* **`applySubstTerm` is the only “chain chaser”.** It follows `Var → Term` links until it reaches a stable term.
+  * Unification’s occurs-check prevents most cycles, but `applySubstTerm` still defends against accidental cyclic chains.
+  * The cycle guard is written to avoid allocating a `Set` in the common case (short chains).
+* **Structural sharing is deliberate.** Applying a substitution often changes nothing:
+  * `applySubstTerm` returns the original term when it is unaffected.
+  * list/open-list/graph terms are only rebuilt if at least one component changes (lazy copy-on-change).
+  * `applySubstTriple` returns the original `Triple` when `s/p/o` are unchanged.
+
+These “no-op returns” are one of the biggest practical performance wins in the engine: backward chaining and forward rule instantiation apply substitutions constantly, so avoiding allocations reduces GC pressure without changing semantics.
 
 ### 6.4 Unification: the core operation
 
@@ -480,6 +492,9 @@ for delta in deltas:
   composed = composeSubst(currentSubst, delta)
 ```
 
+**Implementation note (performance):** `composeSubst` has a fast path — if `delta` is empty (or only repeats bindings already present in `currentSubst`), it returns the original substitution object instead of cloning. This makes constraint-style builtins that often yield `{}` much cheaper, but it does **not** change the search-space: a vacuous solution can still amplify later branching.
+
+
 So built-ins behave like relations that can generate zero, one, or many possible bindings. A list generator might yield many deltas; a numeric test yields zero or one.
 
 #### 8.3.1 Builtin deferral and “vacuous” solutions
@@ -579,6 +594,8 @@ But it does something subtle and important: it caches skolemization per (rule fi
 
 The “firing instance” is keyed by a deterministic string derived from the instantiated body (“firingKey”). This stabilizes the closure and prevents “existential churn.”
 
+**Implementation note (performance):** the firing-instance key is computed in a hot loop, so `firingKey(...)` builds a compact string via concatenation rather than `JSON.stringify`. If you change what counts as a distinct “firing instance”, update the key format and the skolem cache together.
+
 Implementation: deterministic Skolem IDs live in `lib/skolem.js`; the per-firing cache and head-blank rewriting are implemented in `lib/engine.js`.
 
 ### 9.4 Inference fuses: `{ ... } => false`
@@ -1878,4 +1895,3 @@ Logic & reasoning background (Wikipedia):
 - [https://en.wikipedia.org/wiki/Prolog](https://en.wikipedia.org/wiki/Prolog)
 - [https://en.wikipedia.org/wiki/Datalog](https://en.wikipedia.org/wiki/Datalog)
 - [https://en.wikipedia.org/wiki/Skolem_normal_form](https://en.wikipedia.org/wiki/Skolem_normal_form)
-

package/eyeling.js

@@ -5226,64 +5226,123 @@ function skolemIriFromGroundTerm(t) {
 function applySubstTerm(t, s) {
   // Common case: variable
   if (t instanceof Var) {
-    // Fast path: unbound variable → no change
     const first = s[t.name];
-    if (first === undefined) {
-      return t;
-    }
+    if (first === undefined) return t;
 
     // Follow chains X -> Y -> ... until we hit a non-var or a cycle.
+    // Avoid allocating a Set in the common case (short chains).
     let cur = first;
-    const seen = new Set([t.name]);
+    let seen0 = t.name;
+    let seen1 = null;
+    let seen2 = null;
+    let seenSet = null;
+    let steps = 0;
+
     while (cur instanceof Var) {
       const name = cur.name;
-      if (seen.has(name)) break; // cycle
-      seen.add(name);
+
+      // Cycle check
+      if (name === seen0 || name === seen1 || name === seen2 || (seenSet && seenSet.has(name))) {
+        return cur;
+      }
+
+      if (steps == 0) {
+        seen1 = name;
+      } else if (steps == 1) {
+        seen2 = name;
+      } else if (steps == 2) {
+        seenSet = new Set([seen0, seen1, seen2]);
+        seenSet.add(name);
+      } else if (seenSet) {
+        seenSet.add(name);
+      }
+
       const nxt = s[name];
-      if (!nxt) break;
+      if (nxt === undefined) break;
       cur = nxt;
-    }
 
-    if (cur instanceof Var) {
-      // Still a var: keep it as is (no need to clone)
-      return cur;
+      steps += 1;
+      // Safety guard against pathological substitutions
+      if (steps > 1024) break;
     }
-    // Bound to a non-var term: apply substitution recursively in case it
-    // contains variables inside.
+
+    if (cur instanceof Var) return cur;
+    // Bound to a non-var term: apply substitution recursively in case it contains variables inside.
     return applySubstTerm(cur, s);
   }
 
   // Non-variable terms
   if (t instanceof ListTerm) {
-    return new ListTerm(t.elems.map((e) => applySubstTerm(e, s)));
+    const xs = t.elems;
+    let out = null;
+    for (let i = 0; i < xs.length; i++) {
+      const v = applySubstTerm(xs[i], s);
+      if (out) {
+        out.push(v);
+      } else if (v !== xs[i]) {
+        out = xs.slice(0, i);
+        out.push(v);
+      }
+    }
+    return out ? new ListTerm(out) : t;
   }
 
   if (t instanceof OpenListTerm) {
-    const newPrefix = t.prefix.map((e) => applySubstTerm(e, s));
-    const tailTerm = s[t.tailVar];
-    if (tailTerm !== undefined) {
-      const tailApplied = applySubstTerm(tailTerm, s);
-      if (tailApplied instanceof ListTerm) {
-        return new ListTerm(newPrefix.concat(tailApplied.elems));
-      } else if (tailApplied instanceof OpenListTerm) {
-        return new OpenListTerm(newPrefix.concat(tailApplied.prefix), tailApplied.tailVar);
-      } else {
-        return new OpenListTerm(newPrefix, t.tailVar);
+    const xs = t.prefix;
+    let newPrefix = null;
+    for (let i = 0; i < xs.length; i++) {
+      const v = applySubstTerm(xs[i], s);
+      if (newPrefix) {
+        newPrefix.push(v);
+      } else if (v !== xs[i]) {
+        newPrefix = xs.slice(0, i);
+        newPrefix.push(v);
       }
+    }
+    const prefixApplied = newPrefix || xs;
+
+    const tailTerm = s[t.tailVar];
+    if (tailTerm === undefined) {
+      return prefixApplied === xs ? t : new OpenListTerm(prefixApplied, t.tailVar);
+    }
+
+    const tailApplied = applySubstTerm(tailTerm, s);
+    if (tailApplied instanceof ListTerm) {
+      if (prefixApplied.length === 0) return tailApplied;
+      return new ListTerm(prefixApplied.concat(tailApplied.elems));
+    } else if (tailApplied instanceof OpenListTerm) {
+      if (prefixApplied.length === 0) return tailApplied;
+      return new OpenListTerm(prefixApplied.concat(tailApplied.prefix), tailApplied.tailVar);
     } else {
-      return new OpenListTerm(newPrefix, t.tailVar);
+      // Non-list tail binding: keep as open list (matches existing behavior).
+      return prefixApplied === xs ? t : new OpenListTerm(prefixApplied, t.tailVar);
     }
   }
 
   if (t instanceof GraphTerm) {
-    return new GraphTerm(t.triples.map((tr) => applySubstTriple(tr, s)));
+    const xs = t.triples;
+    let out = null;
+    for (let i = 0; i < xs.length; i++) {
+      const v = applySubstTriple(xs[i], s);
+      if (out) {
+        out.push(v);
+      } else if (v !== xs[i]) {
+        out = xs.slice(0, i);
+        out.push(v);
+      }
+    }
+    return out ? new GraphTerm(out) : t;
   }
 
   return t;
 }
 
 function applySubstTriple(tr, s) {
-  return new Triple(applySubstTerm(tr.s, s), applySubstTerm(tr.p, s), applySubstTerm(tr.o, s));
+  const s2 = applySubstTerm(tr.s, s);
+  const p2 = applySubstTerm(tr.p, s);
+  const o2 = applySubstTerm(tr.o, s);
+  if (s2 === tr.s && p2 === tr.p && o2 === tr.o) return tr;
+  return new Triple(s2, p2, o2);
 }
 
 function iriValue(t) {
@@ -5292,7 +5351,7 @@ function iriValue(t) {
 
 function unifyOpenWithList(prefix, tailv, ys, subst) {
   if (ys.length < prefix.length) return null;
-  let s2 = { ...subst };
+  let s2 = subst;
   for (let i = 0; i < prefix.length; i++) {
     s2 = unifyTerm(prefix[i], ys[i], s2);
     if (s2 === null) return null;
@@ -5307,7 +5366,7 @@ function unifyGraphTriples(xs, ys, subst) {
   if (xs.length !== ys.length) return null;
 
   // Fast path: exact same sequence.
-  if (triplesListEqual(xs, ys)) return { ...subst };
+  if (triplesListEqual(xs, ys)) return subst;
 
   // Backtracking match (order-insensitive), *threading* the substitution through.
   const used = new Array(ys.length).fill(false);
@@ -5334,7 +5393,7 @@ function unifyGraphTriples(xs, ys, subst) {
     return null;
   }
 
-  return step(0, { ...subst }); // IMPORTANT: start from the incoming subst
+  return step(0, subst); // IMPORTANT: start from the incoming subst
 }
 
 function unifyTerm(a, b, subst) {
@@ -5361,7 +5420,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
   if (a instanceof Var) {
     const v = a.name;
     const t = b;
-    if (t instanceof Var && t.name === v) return { ...subst };
+    if (t instanceof Var && t.name === v) return subst;
     if (containsVarTerm(t, v)) return null;
     const s2 = { ...subst };
     s2[v] = t;
@@ -5372,20 +5431,20 @@ function unifyTermWithOptions(a, b, subst, opts) {
   }
 
   // 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 };
+  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 };
+    if (literalsEquivalentAsXsdString(a.value, b.value)) return subst;
   }
 
   // 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 };
+    if (ai && bi && ai.value === bi.value) return subst;
   }
 
   // Numeric-value match:
@@ -5397,11 +5456,11 @@ function unifyTermWithOptions(a, b, subst, opts) {
     if (ai && bi) {
       if (ai.dt === bi.dt) {
         if (ai.kind === 'bigint' && bi.kind === 'bigint') {
-          if (ai.value === bi.value) return { ...subst };
+          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 };
+          if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn) return subst;
         }
       }
 
@@ -5414,7 +5473,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
           const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
           if (dec) {
             const scaledInt = intInfo.value * pow10n(dec.scale);
-            if (scaledInt === dec.num) return { ...subst };
+            if (scaledInt === dec.num) return subst;
           }
         }
       }
@@ -5432,7 +5491,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
   // Open list vs open list
   if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
     if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length) return null;
-    let s2 = { ...subst };
+    let s2 = subst;
     for (let i = 0; i < a.prefix.length; i++) {
       s2 = unifyTermWithOptions(a.prefix[i], b.prefix[i], s2, opts);
       if (s2 === null) return null;
@@ -5443,7 +5502,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
   // List terms
   if (a instanceof ListTerm && b instanceof ListTerm) {
     if (a.elems.length !== b.elems.length) return null;
-    let s2 = { ...subst };
+    let s2 = subst;
     for (let i = 0; i < a.elems.length; i++) {
       s2 = unifyTermWithOptions(a.elems[i], b.elems[i], s2, opts);
       if (s2 === null) return null;
@@ -5453,7 +5512,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
 
   // Graphs
   if (a instanceof GraphTerm && b instanceof GraphTerm) {
-    if (alphaEqGraphTriples(a.triples, b.triples)) return { ...subst };
+    if (alphaEqGraphTriples(a.triples, b.triples)) return subst;
     return unifyGraphTriples(a.triples, b.triples, subst);
   }
 
@@ -5473,18 +5532,25 @@ function unifyTriple(pat, fact, subst) {
 }
 
 function composeSubst(outer, delta) {
-  if (!delta || Object.keys(delta).length === 0) {
-    return { ...outer };
-  }
-  const out = { ...outer };
-  for (const [k, v] of Object.entries(delta)) {
-    if (Object.prototype.hasOwnProperty.call(out, k)) {
-      if (!termsEqual(out[k], v)) return null;
-    } else {
-      out[k] = v;
+  if (!delta) return outer;
+
+  // Fast path: avoid copying `outer` when `delta` is empty or only repeats existing bindings.
+  let out = null;
+
+  for (const k in delta) {
+    if (!Object.prototype.hasOwnProperty.call(delta, k)) continue;
+    const v = delta[k];
+
+    if (Object.prototype.hasOwnProperty.call(outer, k)) {
+      if (!termsEqual(outer[k], v)) return null;
+      continue;
     }
+
+    if (!out) out = { ...outer };
+    out[k] = v;
   }
-  return out;
+
+  return out || outer;
 }
 
 
@@ -5863,11 +5929,14 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
 
   function firingKey(ruleIndex, instantiatedPremises) {
     // Deterministic key derived from the instantiated body (ground per substitution).
-    const parts = [];
-    for (const tr of instantiatedPremises) {
-      parts.push(JSON.stringify([skolemKeyFromTerm(tr.s), skolemKeyFromTerm(tr.p), skolemKeyFromTerm(tr.o)]));
+    // Avoid repeated JSON.stringify of arrays-of-strings (hot path).
+    let out = `R${ruleIndex}|`;
+    for (let i = 0; i < instantiatedPremises.length; i++) {
+      const tr = instantiatedPremises[i];
+      if (i) out += '\n';
+      out += skolemKeyFromTerm(tr.s) + '	' + skolemKeyFromTerm(tr.p) + '	' + skolemKeyFromTerm(tr.o);
     }
-    return `R${ruleIndex}|` + parts.join('\\n');
+    return out;
   }
 
   // Make rules visible to introspection builtins

package/lib/engine.js

@@ -859,64 +859,123 @@ function skolemIriFromGroundTerm(t) {
 function applySubstTerm(t, s) {
   // Common case: variable
   if (t instanceof Var) {
-    // Fast path: unbound variable → no change
     const first = s[t.name];
-    if (first === undefined) {
-      return t;
-    }
+    if (first === undefined) return t;
 
     // Follow chains X -> Y -> ... until we hit a non-var or a cycle.
+    // Avoid allocating a Set in the common case (short chains).
     let cur = first;
-    const seen = new Set([t.name]);
+    let seen0 = t.name;
+    let seen1 = null;
+    let seen2 = null;
+    let seenSet = null;
+    let steps = 0;
+
     while (cur instanceof Var) {
       const name = cur.name;
-      if (seen.has(name)) break; // cycle
-      seen.add(name);
+
+      // Cycle check
+      if (name === seen0 || name === seen1 || name === seen2 || (seenSet && seenSet.has(name))) {
+        return cur;
+      }
+
+      if (steps == 0) {
+        seen1 = name;
+      } else if (steps == 1) {
+        seen2 = name;
+      } else if (steps == 2) {
+        seenSet = new Set([seen0, seen1, seen2]);
+        seenSet.add(name);
+      } else if (seenSet) {
+        seenSet.add(name);
+      }
+
       const nxt = s[name];
-      if (!nxt) break;
+      if (nxt === undefined) break;
       cur = nxt;
-    }
 
-    if (cur instanceof Var) {
-      // Still a var: keep it as is (no need to clone)
-      return cur;
+      steps += 1;
+      // Safety guard against pathological substitutions
+      if (steps > 1024) break;
     }
-    // Bound to a non-var term: apply substitution recursively in case it
-    // contains variables inside.
+
+    if (cur instanceof Var) return cur;
+    // Bound to a non-var term: apply substitution recursively in case it contains variables inside.
     return applySubstTerm(cur, s);
   }
 
   // Non-variable terms
   if (t instanceof ListTerm) {
-    return new ListTerm(t.elems.map((e) => applySubstTerm(e, s)));
+    const xs = t.elems;
+    let out = null;
+    for (let i = 0; i < xs.length; i++) {
+      const v = applySubstTerm(xs[i], s);
+      if (out) {
+        out.push(v);
+      } else if (v !== xs[i]) {
+        out = xs.slice(0, i);
+        out.push(v);
+      }
+    }
+    return out ? new ListTerm(out) : t;
   }
 
   if (t instanceof OpenListTerm) {
-    const newPrefix = t.prefix.map((e) => applySubstTerm(e, s));
-    const tailTerm = s[t.tailVar];
-    if (tailTerm !== undefined) {
-      const tailApplied = applySubstTerm(tailTerm, s);
-      if (tailApplied instanceof ListTerm) {
-        return new ListTerm(newPrefix.concat(tailApplied.elems));
-      } else if (tailApplied instanceof OpenListTerm) {
-        return new OpenListTerm(newPrefix.concat(tailApplied.prefix), tailApplied.tailVar);
-      } else {
-        return new OpenListTerm(newPrefix, t.tailVar);
+    const xs = t.prefix;
+    let newPrefix = null;
+    for (let i = 0; i < xs.length; i++) {
+      const v = applySubstTerm(xs[i], s);
+      if (newPrefix) {
+        newPrefix.push(v);
+      } else if (v !== xs[i]) {
+        newPrefix = xs.slice(0, i);
+        newPrefix.push(v);
       }
+    }
+    const prefixApplied = newPrefix || xs;
+
+    const tailTerm = s[t.tailVar];
+    if (tailTerm === undefined) {
+      return prefixApplied === xs ? t : new OpenListTerm(prefixApplied, t.tailVar);
+    }
+
+    const tailApplied = applySubstTerm(tailTerm, s);
+    if (tailApplied instanceof ListTerm) {
+      if (prefixApplied.length === 0) return tailApplied;
+      return new ListTerm(prefixApplied.concat(tailApplied.elems));
+    } else if (tailApplied instanceof OpenListTerm) {
+      if (prefixApplied.length === 0) return tailApplied;
+      return new OpenListTerm(prefixApplied.concat(tailApplied.prefix), tailApplied.tailVar);
     } else {
-      return new OpenListTerm(newPrefix, t.tailVar);
+      // Non-list tail binding: keep as open list (matches existing behavior).
+      return prefixApplied === xs ? t : new OpenListTerm(prefixApplied, t.tailVar);
     }
   }
 
   if (t instanceof GraphTerm) {
-    return new GraphTerm(t.triples.map((tr) => applySubstTriple(tr, s)));
+    const xs = t.triples;
+    let out = null;
+    for (let i = 0; i < xs.length; i++) {
+      const v = applySubstTriple(xs[i], s);
+      if (out) {
+        out.push(v);
+      } else if (v !== xs[i]) {
+        out = xs.slice(0, i);
+        out.push(v);
+      }
+    }
+    return out ? new GraphTerm(out) : t;
   }
 
   return t;
 }
 
 function applySubstTriple(tr, s) {
-  return new Triple(applySubstTerm(tr.s, s), applySubstTerm(tr.p, s), applySubstTerm(tr.o, s));
+  const s2 = applySubstTerm(tr.s, s);
+  const p2 = applySubstTerm(tr.p, s);
+  const o2 = applySubstTerm(tr.o, s);
+  if (s2 === tr.s && p2 === tr.p && o2 === tr.o) return tr;
+  return new Triple(s2, p2, o2);
 }
 
 function iriValue(t) {
@@ -925,7 +984,7 @@ function iriValue(t) {
 
 function unifyOpenWithList(prefix, tailv, ys, subst) {
   if (ys.length < prefix.length) return null;
-  let s2 = { ...subst };
+  let s2 = subst;
   for (let i = 0; i < prefix.length; i++) {
     s2 = unifyTerm(prefix[i], ys[i], s2);
     if (s2 === null) return null;
@@ -940,7 +999,7 @@ function unifyGraphTriples(xs, ys, subst) {
   if (xs.length !== ys.length) return null;
 
   // Fast path: exact same sequence.
-  if (triplesListEqual(xs, ys)) return { ...subst };
+  if (triplesListEqual(xs, ys)) return subst;
 
   // Backtracking match (order-insensitive), *threading* the substitution through.
   const used = new Array(ys.length).fill(false);
@@ -967,7 +1026,7 @@ function unifyGraphTriples(xs, ys, subst) {
     return null;
   }
 
-  return step(0, { ...subst }); // IMPORTANT: start from the incoming subst
+  return step(0, subst); // IMPORTANT: start from the incoming subst
 }
 
 function unifyTerm(a, b, subst) {
@@ -994,7 +1053,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
   if (a instanceof Var) {
     const v = a.name;
     const t = b;
-    if (t instanceof Var && t.name === v) return { ...subst };
+    if (t instanceof Var && t.name === v) return subst;
     if (containsVarTerm(t, v)) return null;
     const s2 = { ...subst };
     s2[v] = t;
@@ -1005,20 +1064,20 @@ function unifyTermWithOptions(a, b, subst, opts) {
   }
 
   // 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 };
+  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 };
+    if (literalsEquivalentAsXsdString(a.value, b.value)) return subst;
   }
 
   // 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 };
+    if (ai && bi && ai.value === bi.value) return subst;
   }
 
   // Numeric-value match:
@@ -1030,11 +1089,11 @@ function unifyTermWithOptions(a, b, subst, opts) {
     if (ai && bi) {
       if (ai.dt === bi.dt) {
         if (ai.kind === 'bigint' && bi.kind === 'bigint') {
-          if (ai.value === bi.value) return { ...subst };
+          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 };
+          if (!Number.isNaN(an) && !Number.isNaN(bn) && an === bn) return subst;
         }
       }
 
@@ -1047,7 +1106,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
           const dec = parseXsdDecimalToBigIntScale(decInfo.lexStr);
           if (dec) {
             const scaledInt = intInfo.value * pow10n(dec.scale);
-            if (scaledInt === dec.num) return { ...subst };
+            if (scaledInt === dec.num) return subst;
           }
         }
       }
@@ -1065,7 +1124,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
   // Open list vs open list
   if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
     if (a.tailVar !== b.tailVar || a.prefix.length !== b.prefix.length) return null;
-    let s2 = { ...subst };
+    let s2 = subst;
     for (let i = 0; i < a.prefix.length; i++) {
       s2 = unifyTermWithOptions(a.prefix[i], b.prefix[i], s2, opts);
       if (s2 === null) return null;
@@ -1076,7 +1135,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
   // List terms
   if (a instanceof ListTerm && b instanceof ListTerm) {
     if (a.elems.length !== b.elems.length) return null;
-    let s2 = { ...subst };
+    let s2 = subst;
     for (let i = 0; i < a.elems.length; i++) {
       s2 = unifyTermWithOptions(a.elems[i], b.elems[i], s2, opts);
       if (s2 === null) return null;
@@ -1086,7 +1145,7 @@ function unifyTermWithOptions(a, b, subst, opts) {
 
   // Graphs
   if (a instanceof GraphTerm && b instanceof GraphTerm) {
-    if (alphaEqGraphTriples(a.triples, b.triples)) return { ...subst };
+    if (alphaEqGraphTriples(a.triples, b.triples)) return subst;
     return unifyGraphTriples(a.triples, b.triples, subst);
   }
 
@@ -1106,18 +1165,25 @@ function unifyTriple(pat, fact, subst) {
 }
 
 function composeSubst(outer, delta) {
-  if (!delta || Object.keys(delta).length === 0) {
-    return { ...outer };
-  }
-  const out = { ...outer };
-  for (const [k, v] of Object.entries(delta)) {
-    if (Object.prototype.hasOwnProperty.call(out, k)) {
-      if (!termsEqual(out[k], v)) return null;
-    } else {
-      out[k] = v;
+  if (!delta) return outer;
+
+  // Fast path: avoid copying `outer` when `delta` is empty or only repeats existing bindings.
+  let out = null;
+
+  for (const k in delta) {
+    if (!Object.prototype.hasOwnProperty.call(delta, k)) continue;
+    const v = delta[k];
+
+    if (Object.prototype.hasOwnProperty.call(outer, k)) {
+      if (!termsEqual(outer[k], v)) return null;
+      continue;
     }
+
+    if (!out) out = { ...outer };
+    out[k] = v;
   }
-  return out;
+
+  return out || outer;
 }
 
 
@@ -1496,11 +1562,14 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
 
   function firingKey(ruleIndex, instantiatedPremises) {
     // Deterministic key derived from the instantiated body (ground per substitution).
-    const parts = [];
-    for (const tr of instantiatedPremises) {
-      parts.push(JSON.stringify([skolemKeyFromTerm(tr.s), skolemKeyFromTerm(tr.p), skolemKeyFromTerm(tr.o)]));
+    // Avoid repeated JSON.stringify of arrays-of-strings (hot path).
+    let out = `R${ruleIndex}|`;
+    for (let i = 0; i < instantiatedPremises.length; i++) {
+      const tr = instantiatedPremises[i];
+      if (i) out += '\n';
+      out += skolemKeyFromTerm(tr.s) + '	' + skolemKeyFromTerm(tr.p) + '	' + skolemKeyFromTerm(tr.o);
     }
-    return `R${ruleIndex}|` + parts.join('\\n');
+    return out;
   }
 
   // Make rules visible to introspection builtins

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.11.9",
+  "version": "1.11.10",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [