eyeling 1.7.1 → 1.7.3

package/eyeling.js

@@ -4638,6 +4638,58 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return [{ ...subst }];
   }
 
+  // log:conjunction
+  // Schema: ( $s.i+ )+ log:conjunction $o?
+  // $o is a formula containing a copy of each formula in the subject list.
+  // Duplicates are removed.
+  if (pv === LOG_NS + 'conjunction') {
+    if (!(g.s instanceof ListTerm)) return [];
+
+    const parts = g.s.elems;
+    if (!parts.length) return [];
+
+    /** @type {Triple[]} */
+    const merged = [];
+
+    // Fast-path dedup for IRI/Literal-only triples.
+    const fastKeySet = new Set();
+
+    for (const part of parts) {
+      // Support the empty formula token `true`.
+      if (part instanceof Literal && part.value === 'true') continue;
+
+      if (!(part instanceof GraphTerm)) return [];
+
+      for (const tr of part.triples) {
+        const k = tripleFastKey(tr);
+        if (k !== null) {
+          if (fastKeySet.has(k)) continue;
+          fastKeySet.add(k);
+          merged.push(tr);
+          continue;
+        }
+
+        // Fallback: structural equality (still respects plain-string == xsd:string).
+        let dup = false;
+        for (const ex of merged) {
+          if (triplesEqual(tr, ex)) {
+            dup = true;
+            break;
+          }
+        }
+        if (!dup) merged.push(tr);
+      }
+    }
+
+    const outFormula = new GraphTerm(merged);
+
+    // Allow blank nodes as a don't-care output (common in builtin schemas).
+    if (g.o instanceof Blank) return [{ ...subst }];
+
+    const s2 = unifyTerm(g.o, outFormula, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
   // 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
@@ -4804,6 +4856,41 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return results;
   }
 
+  // log:includes (provable in scope)
+  // Schema: $s+ log:includes $o+
+  // When the subject is a formula, the scope is that concrete formula (syntactic containment).
+  // Otherwise, the scope is the current document scope (facts + backward rules).
+  if (pv === LOG_NS + 'includes') {
+    // Empty formula is always included.
+    if (g.o instanceof Literal && g.o.value === 'true') return [{ ...subst }];
+    if (!(g.o instanceof GraphTerm)) return [];
+
+    /** @type {Triple[] | null} */
+    let scopeFacts = null;
+    /** @type {Rule[]} */
+    let scopeBackRules = backRules;
+
+    // If the subject is a formula, treat it as a concrete scope graph.
+    // Also support `true` as the empty formula.
+    if (g.s instanceof GraphTerm) {
+      scopeFacts = g.s.triples.slice();
+      ensureFactIndexes(scopeFacts);
+      Object.defineProperty(scopeFacts, '__scopedSnapshot', { value: scopeFacts, enumerable: false, writable: true });
+      scopeBackRules = []; // concrete scope = syntactic containment (no extra rules)
+    } else if (g.s instanceof Literal && g.s.value === 'true') {
+      scopeFacts = [];
+      ensureFactIndexes(scopeFacts);
+      Object.defineProperty(scopeFacts, '__scopedSnapshot', { value: scopeFacts, enumerable: false, writable: true });
+      scopeBackRules = [];
+    } else {
+      scopeFacts = facts; // dynamic scope
+    }
+
+    const visited2 = [];
+    // Start from the incoming substitution so bindings flow outward.
+    return proveGoals(Array.from(g.o.triples), { ...subst }, scopeFacts, scopeBackRules, depth + 1, visited2, varGen);
+  }
+
   // log:notIncludes (not provable in scope)
   // Delay until we have a frozen scope snapshot to avoid early success.
   if (pv === LOG_NS + 'notIncludes') {
@@ -4847,6 +4934,11 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
       if (!scopeFacts) return []; // DELAY until snapshot exists
     }
 
+    // If sols is a blank node succeed without collecting/binding.
+    if (listTerm instanceof Blank) {
+      return [{ ...subst }];
+    }
+
     const visited2 = [];
     const sols = proveGoals(Array.from(clauseTerm.triples), {}, scopeFacts, scopeBackRules, depth + 1, visited2, varGen);
 
@@ -4908,8 +5000,8 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   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"
-      const lit = makeStringLiteral(uriStr); // "https://www.w3.org"
+      const uriStr = g.s.value; // raw IRI string
+      const lit = makeStringLiteral(uriStr); // "..."
       const s2 = unifyTerm(goal.o, lit, subst);
       return s2 !== null ? [s2] : [];
     }
@@ -4918,6 +5010,14 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     if (g.o instanceof Literal) {
       const uriStr = termToJsString(g.o); // JS string from the literal
       if (uriStr === null) return [];
+
+      // Reject strings that cannot be safely serialized as <...> in Turtle/N3.
+      // Turtle IRIREF forbids control/space and these characters: < > " { } | ^ ` \
+      // (and eyeling also prints IRIs starting with "_:" as blank-node labels)
+      if (uriStr.startsWith('_:') || /[\u0000-\u0020<>"{}|^`\\]/.test(uriStr)) {
+        return [];
+      }
+
       const iri = internIri(uriStr);
       const s2 = unifyTerm(goal.s, iri, subst);
       return s2 !== null ? [s2] : [];
@@ -5819,7 +5919,6 @@ function printExplanation(df, prefixes) {
   console.log('# ----------------------------------------------------------------------\n');
 }
 
-
 function offsetToLineCol(text, offset) {
   const chars = Array.from(text);
   const n = Math.max(0, Math.min(typeof offset === 'number' ? offset : 0, chars.length));

package/package.json

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