eyeling 1.7.10 → 1.7.12

package/examples/bind.n3

@@ -4,4 +4,4 @@
 
 :phayes a :Person ; :givenName "Pat"; :familyName "Hayes" .
 
-{ ?x a :Person . ?SCOPE log:notIncludes { ?x :name ?someName . } . ?x :givenName ?name1 . ?x :familyName ?name2 . (?name1 " " ?name2) string:concatenation ?FN . } => { ?x :name ?FN } .
+{ ?x a :Person . (1 { ?x :name ?someName . } ()) log:collectAllIn ?SCOPE . ?x :givenName ?name1 . ?x :familyName ?name2 . (?name1 " " ?name2) string:concatenation ?FN . } => { ?x :name ?FN } .

package/examples/snaf.n3

@@ -9,7 +9,7 @@
 :Bob a :Person.
 
 {
-  ?SCOPE log:notIncludes { :Alice :hates ?X }.
+  (1 { :Alice :hates ?X } ()) log:collectAllIn ?SCOPE .
   ?X a :Person.
 }
 =>

package/eyeling.js

@@ -16,8 +16,20 @@
  *  5) Print only newly derived forward facts with explanations.
  */
 
-const { version } = require('./package.json');
-const nodeCrypto = require('crypto');
+// -----------------------------------------------------------------------------
+// Browser/Worker-safe version + crypto wiring
+// -----------------------------------------------------------------------------
+let version = 'dev';
+try {
+  // Node: keep package.json version if available
+  if (typeof require === 'function') version = require('./package.json').version || version;
+} catch (_) {}
+
+let nodeCrypto = null;
+try {
+  // Node: crypto available
+  if (typeof require === 'function') nodeCrypto = require('crypto');
+} catch (_) {}
 
 // ===========================================================================
 // Namespace constants
@@ -5533,62 +5545,40 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return results;
   }
 
-  // log:includes (provable in scope)
+  // log:includes
   // 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).
+  // Object may be a concrete formula or the literal `true` (empty formula).
   if (pv === LOG_NS + 'includes') {
+    if (!(g.s instanceof GraphTerm)) return [];
+
     // 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 scopeFacts = g.s.triples.slice();
+    ensureFactIndexes(scopeFacts);
+    Object.defineProperty(scopeFacts, '__scopedSnapshot', { value: scopeFacts, enumerable: false, writable: true });
 
     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);
+    return proveGoals(Array.from(g.o.triples), { ...subst }, scopeFacts, [], depth + 1, visited2, varGen);
   }
 
-  // log:notIncludes (not provable in scope)
-  // Delay until we have a frozen scope snapshot to avoid early success.
+  // log:notIncludes
+  // Schema: $s+ log:notIncludes $o+
   if (pv === LOG_NS + 'notIncludes') {
-    if (!(g.o instanceof GraphTerm)) return [];
+    if (!(g.s instanceof GraphTerm)) return [];
 
-    let scopeFacts = null;
-    let scopeBackRules = backRules;
+    // Empty formula is always included, so it is never "not included".
+    if (g.o instanceof Literal && g.o.value === 'true') return [];
+    if (!(g.o instanceof GraphTerm)) return [];
 
-    // If the subject is a formula, treat it as the concrete scope graph
-    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 {
-      scopeFacts = facts.__scopedSnapshot || null;
-      if (!scopeFacts) return []; // DELAY until saturation snapshot exists
-    }
+    const scopeFacts = g.s.triples.slice();
+    ensureFactIndexes(scopeFacts);
+    Object.defineProperty(scopeFacts, '__scopedSnapshot', { value: scopeFacts, enumerable: false, writable: true });
 
     const visited2 = [];
-    const sols = proveGoals(Array.from(g.o.triples), {}, scopeFacts, scopeBackRules, depth + 1, visited2, varGen);
+    const sols = proveGoals(Array.from(g.o.triples), { ...subst }, scopeFacts, [], depth + 1, visited2, varGen);
     return sols.length ? [] : [{ ...subst }];
   }
 
@@ -6259,7 +6249,7 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen) {
 // Forward chaining to fixpoint
 // ===========================================================================
 
-function forwardChain(facts, forwardRules, backRules) {
+function forwardChain(facts, forwardRules, backRules, onDerived /* optional */) {
   ensureFactIndexes(facts);
   ensureBackRuleIndexes(backRules);
 
@@ -6344,7 +6334,10 @@ function forwardChain(facts, forwardRules, backRules) {
               if (!hasFactIndexed(facts, instantiated)) {
                 factList.push(instantiated);
                 pushFactIndexed(facts, instantiated);
-                derivedForward.push(new DerivedFact(instantiated, r, instantiatedPremises.slice(), { ...s }));
+                const df = new DerivedFact(instantiated, r, instantiatedPremises.slice(), { ...s });
+                derivedForward.push(df);
+                if (typeof onDerived === 'function') onDerived(df);
+
                 changed = true;
               }
 
@@ -6408,7 +6401,10 @@ function forwardChain(facts, forwardRules, backRules) {
 
             factList.push(inst);
             pushFactIndexed(facts, inst);
-            derivedForward.push(new DerivedFact(inst, r, instantiatedPremises.slice(), { ...s }));
+            const df = new DerivedFact(inst, r, instantiatedPremises.slice(), { ...s });
+            derivedForward.push(df);
+            if (typeof onDerived === 'function') onDerived(df);
+
             changed = true;
           }
         }
@@ -6744,6 +6740,53 @@ function __collectOutputStringsFromFacts(facts, prefixes) {
   return pairs.map((p) => p.text).join('');
 }
 
+function reasonStream(n3Text, opts = {}) {
+  const { baseIri = null, proof = false, onDerived = null, includeInputFactsInClosure = true } = opts;
+
+  proofCommentsEnabled = !!proof;
+
+  const toks = lex(n3Text);
+  const parser = new Parser(toks);
+  if (baseIri) parser.prefixes.setBase(baseIri);
+
+  let prefixes, triples, frules, brules;
+  [prefixes, triples, frules, brules] = parser.parseDocument();
+
+  materializeRdfLists(triples, frules, brules);
+
+  // facts becomes the saturated closure because pushFactIndexed(...) appends into it
+  const facts = triples.filter((tr) => isGroundTriple(tr));
+
+  const derived = forwardChain(facts, frules, brules, (df) => {
+    if (typeof onDerived === 'function') {
+      onDerived({
+        triple: tripleToN3(df.fact, prefixes),
+        df,
+      });
+    }
+  });
+
+  const closureTriples = includeInputFactsInClosure ? facts : derived.map((d) => d.fact);
+
+  return {
+    prefixes,
+    facts, // saturated closure (Triple[])
+    derived, // DerivedFact[]
+    closureN3: closureTriples.map((t) => tripleToN3(t, prefixes)).join('\n'),
+  };
+}
+
+// Minimal export surface for Node + browser/worker
+const EYELING_API = { reasonStream };
+
+try {
+  if (typeof module !== 'undefined' && module.exports) module.exports = EYELING_API;
+} catch (_) {}
+
+try {
+  if (typeof self !== 'undefined') self.eyeling = EYELING_API;
+} catch (_) {}
+
 function main() {
   // Drop "node" and script name; keep only user-provided args
   const argv = process.argv.slice(2);

package/package.json

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