eyeleng 1.1.1 → 1.1.2

package/README.md

@@ -8,7 +8,7 @@
 - **SRL** — the Shape Rules Language syntax used by the SHACL 1.2 Rules draft.
 - **RDF Rules** — a Turtle/RDF syntax for rule sets.
 
-Eyeleng is a forward-chaining reasoner over RDF-style triples. It is deliberately small, dependency-free at runtime, readable as ordinary JavaScript, and usable from the CLI, Node.js, and the browser playground.
+Eyeleng is a compact reasoner over RDF-style triples. It still uses forward chaining for ordinary finite materialization, but the default execution mode now includes conservative auto-hybrid planning: selected function-like predicates can be proved just in time by a tabled backward prover when they are demanded by a query or by another rule body. It is deliberately small, dependency-free at runtime, readable as ordinary JavaScript, and usable from the CLI, Node.js, and the browser playground.
 
 Eyeleng implements the rules/reasoning surface. It is **not** a SHACL validation engine and does not emit SHACL validation reports.
 
@@ -76,6 +76,10 @@ then the body matches with `?parent = :alice` and `?child = :bob`, and the head
 
 Negation is handled by stratified evaluation: rules are grouped into dependency layers, and recursion through negation is rejected so the result stays deterministic.
 
+By default, run mode uses **auto-hybrid reasoning**. Ordinary rules are still materialized forward into the closure. Rules that behave like internal functions can instead be proved backward with tabling when their predicates occur as demanded body goals. For example, a Fibonacci helper predicate can be computed just in time for the public `:fib` results, without printing all intermediate helper triples. Use `--no-hybrid` or `{ hybrid: false }` to force pure forward materialization, and use `--hybrid` or `{ hybrid: true }` to force more aggressive backward orientation.
+
+For explicit `--query` / `--query-file` use, the query body is the top-level goal. Each triple pattern in that body is then a sub-goal that may be answered by the backward prover. If pure backward proving is not safe for the demanded predicates, query mode can run a hybrid plan and finally fall back to ordinary forward closure.
+
 Recursive rules that create new terms through `SET`/`BIND` or head blank nodes run in relaxed mode by default. Relaxed mode can derive useful finite closures, but termination is not guaranteed; use `--max-iterations` as a safety valve. `--strict` rejects these recursive term-generating cycles at analysis time. Head blank nodes are deterministically skolemized per rule and solution mapping, so the same firing reuses the same witness node instead of creating a fresh one each pass.
 
 ## Language surface
@@ -153,7 +157,6 @@ npm run w3c:rules:earl
 npm run w3c:rdf
 npm run w3c:rdf:json
 npm run w3c:rdf:earl
-npm run w3c:all
 ```
 
 `npm test` includes the W3C harnesses. When W3C URLs are reachable, progress is printed test by test. In offline environments, remote W3C checks are reported as unreachable unless `EYELENG_W3C_REQUIRED=1` is set. The `*:earl` scripts also print test progress, but write the EARL Turtle only to `reports/` instead of printing the report to the terminal.
@@ -238,28 +241,30 @@ RULE { ?x a :Mortal } WHERE { ?x a :Man }
 console.log(formatTriples(result.inferred, result.prefixes));
 ```
 
-Query mode:
+Hybrid and query mode:
 
 ```js
-const { runQuery, formatBindings } = require('./src/index.js');
+const { run, runQuery, formatBindings } = require('./src/index.js');
+
+// Normal run mode defaults to conservative auto-hybrid reasoning.
+// Ordinary output rules still materialize forward, while selected
+// function-like helper predicates can be proved backward on demand.
+const resultWithAutoHybrid = run(source);
 
+// Force pure forward closure if you want every derivable helper fact materialized.
+const pureForward = run(source, { hybrid: false });
+
+// For explicit queries, the whole raw body is the top-level goal.
+// Each triple pattern in that body is a sub-goal for the planner.
 const result = runQuery(source, '?x :ancestorOf ?y');
 console.log(formatBindings(result.query.bindings, result.prefixes));
 
-// Query mode defaults to auto. Supported query/rule shapes are proved
-// backward with tabling. If full backward proving is not safe but the
-// ruleset contains function-like derived predicates, auto mode uses a
-// hybrid plan before falling back to plain forward closure.
-const justInTime = runQuery(source, ':alice :computedValue ?value', { queryMode: 'backward' });
-
-// Run mode uses conservative auto-hybrid planning by default. It keeps
-// ordinary rules materialized, but can prove demanded function-like predicates
-// backward with tabling. Pass { hybrid: false } to force pure forward closure,
-// or { hybrid: true } to force aggressive hybrid orientation.
-const resultWithAutoHybrid = run(source);
+// queryMode defaults to auto: try tabled backward proving for demanded
+// predicates, then hybrid execution, then ordinary forward closure.
+const justInTime = runQuery(source, ':alice :computedValue ?value');
 
-// The backward planner is demand-driven: irrelevant unsupported rules do not
-// prevent a query from using tabled backward proving.
+// Force the tabled backward prover for supported query shapes.
+const backwardOnly = runQuery(source, ':alice :computedValue ?value', { queryMode: 'backward' });
 ```
 
 Imports:
@@ -326,6 +331,7 @@ Examples live in [examples/](./examples/):
 - `property-paths.srl` — path matching in bodies
 - `basic-ruleset.ttl` — RDF Rules syntax
 - `rdf-messages.srl` / `rdf-messages.trig` — RDF Message Log replay
+- `fibonacci.srl` — fast-doubling Fibonacci using just-in-time backward helper predicates
 - `deep-taxonomy-*.srl` — generated benchmark programs
 
 ## Known boundaries

package/dist/browser/eyeleng.browser.js

@@ -441,7 +441,7 @@
         }
       
         parseTripleStatement(options = {}) {
-          const subjectNode = this.parseGraphNode(options);
+          const subjectNode = this.parseGraphNode({ ...options, position: 'subject' });
           const triples = [...subjectNode.triples];
           triples.push(...this.parsePropertyListForSubject(subjectNode.term, options));
           return triples;
@@ -455,7 +455,7 @@
             if (terminators.some((value) => this.checkValue(value)) || this.checkValue('.')) break;
             const predicate = options.allowPath ? this.parseVerbPathOrSimple(options) : this.parseVerbTerm(options);
             do {
-              const objectNode = this.parseGraphNode(options);
+              const objectNode = this.parseGraphNode({ ...options, position: 'object' });
               triples.push(...objectNode.triples);
               const baseTriple = { s: subject, p: predicate, o: objectNode.term };
               triples.push(baseTriple);
@@ -522,6 +522,7 @@
               currentReifier = this.parseOptionalReifier(options);
               triples.push({ s: currentReifier, p: iri(RDF_REIFIES), o: reified });
             } else if (this.matchValue('{|')) {
+              if (this.checkValue('|}')) throw this.error('Annotation blocks may not be empty');
               const annotationSubject = currentReifier || this.freshGraphNode(options);
               triples.push({ s: annotationSubject, p: iri(RDF_REIFIES), o: reified });
               triples.push(...this.parsePropertyListForSubject(annotationSubject, options, ['|}']));
@@ -571,7 +572,7 @@
         }
       
         parseVerbTerm(options = {}) {
-          const term = this.parseTerm(options);
+          const term = this.parseTerm({ ...options, position: 'predicate' });
           if (term.type !== 'iri' && term.type !== 'var') throw this.error('Expected IRI or variable as predicate');
           return term;
         }
@@ -694,7 +695,10 @@
           if (token.value === '<<(') return this.parseTripleTermAfterOpen(options);
           if (token.value === '<<') throw this.error('Use << s p o >> as a graph node reifier; use <<( s p o )>> for a triple term', token);
           if (token.type === 'word') {
-            if (token.value === 'a') return iri(RDF_TYPE);
+            if (token.value === 'a') {
+              if (options.position !== 'predicate') throw this.error('a is only allowed as a predicate', token);
+              return iri(RDF_TYPE);
+            }
             if (token.value === 'true') return literal(true, XSD_BOOLEAN);
             if (token.value === 'false') return literal(false, XSD_BOOLEAN);
             if (token.value.startsWith('_:')) return blankNode(token.value.slice(2));
@@ -728,7 +732,13 @@
             return literal(coerceLexicalLiteral(token.value, datatype), datatype, null);
           }
           if (this.checkType('word') && /^@[A-Za-z]+(?:-[A-Za-z0-9]+)*(?:--[A-Za-z]+)?$/.test(this.peek().value)) {
-            const tag = this.advance().value.slice(1).toLowerCase();
+            const tagToken = this.advance();
+            const rawTag = tagToken.value.slice(1);
+            const direction = rawTag.includes('--') ? rawTag.slice(rawTag.lastIndexOf('--') + 2) : null;
+            if (direction && direction !== 'ltr' && direction !== 'rtl') {
+              throw this.error(`Invalid base direction --${direction}; expected --ltr or --rtl`, tagToken);
+            }
+            const tag = rawTag.toLowerCase();
             const [lang, langDir = null] = tag.split('--');
             return literal(token.value, null, lang, langDir);
           }
@@ -2507,6 +2517,7 @@
         const syntaxProfile = String(options.profile || options.profileId || '').toLowerCase();
         const rdf12Surface = syntaxProfile === 'turtle' || syntaxProfile === 'trig';
         const implicitStatementNodes = new Set();
+        function implicitStatementNodeKey(term) { return `${term.kind}:${term.value}`; }
       
         function freshBlank() { bnodeCounter += 1; return blank(`b${bnodeCounter}`); }
         function peek(offset = 0) { return tokens[i + offset]; }
@@ -2657,7 +2668,7 @@
           expect('>>');
           const node = reifier || freshBlank();
           out.push(triple(node, iri(RDF_REIFIES), tripleTerm(s, p, o), graph));
-          if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+          implicitStatementNodes.add(implicitStatementNodeKey(node));
           return node;
         }
       
@@ -2686,7 +2697,7 @@
           if (accept(']')) return node;
           parsePredicateObjectList(node, out, graph);
           expect(']');
-          if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+          if (node.kind === 'blank') implicitStatementNodes.add(implicitStatementNodeKey(node));
           return node;
         }
       
@@ -2764,9 +2775,8 @@
             if (options3.requireDot) expect('.'); else accept('.');
             return;
           }
-          if (peek()?.type === '<<' && peek(1)?.type === '(') throw new Error('Triple term cannot be used as a subject');
-          const subject = parseTerm(out, graph, { noLiteral: true, noA: true });
-          if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && subject.kind === 'blank' && implicitStatementNodes.has(subject.value)) {
+          const subject = parseTerm(out, graph, { noLiteral: !rdf12Surface, noA: true });
+          if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && implicitStatementNodes.has(implicitStatementNodeKey(subject))) {
             if (options3.requireDot) expect('.'); else accept('.');
             return;
           }

package/eyeleng.js

@@ -710,7 +710,7 @@
         }
       
         parseTripleStatement(options = {}) {
-          const subjectNode = this.parseGraphNode(options);
+          const subjectNode = this.parseGraphNode({ ...options, position: 'subject' });
           const triples = [...subjectNode.triples];
           triples.push(...this.parsePropertyListForSubject(subjectNode.term, options));
           return triples;
@@ -724,7 +724,7 @@
             if (terminators.some((value) => this.checkValue(value)) || this.checkValue('.')) break;
             const predicate = options.allowPath ? this.parseVerbPathOrSimple(options) : this.parseVerbTerm(options);
             do {
-              const objectNode = this.parseGraphNode(options);
+              const objectNode = this.parseGraphNode({ ...options, position: 'object' });
               triples.push(...objectNode.triples);
               const baseTriple = { s: subject, p: predicate, o: objectNode.term };
               triples.push(baseTriple);
@@ -791,6 +791,7 @@
               currentReifier = this.parseOptionalReifier(options);
               triples.push({ s: currentReifier, p: iri(RDF_REIFIES), o: reified });
             } else if (this.matchValue('{|')) {
+              if (this.checkValue('|}')) throw this.error('Annotation blocks may not be empty');
               const annotationSubject = currentReifier || this.freshGraphNode(options);
               triples.push({ s: annotationSubject, p: iri(RDF_REIFIES), o: reified });
               triples.push(...this.parsePropertyListForSubject(annotationSubject, options, ['|}']));
@@ -840,7 +841,7 @@
         }
       
         parseVerbTerm(options = {}) {
-          const term = this.parseTerm(options);
+          const term = this.parseTerm({ ...options, position: 'predicate' });
           if (term.type !== 'iri' && term.type !== 'var') throw this.error('Expected IRI or variable as predicate');
           return term;
         }
@@ -963,7 +964,10 @@
           if (token.value === '<<(') return this.parseTripleTermAfterOpen(options);
           if (token.value === '<<') throw this.error('Use << s p o >> as a graph node reifier; use <<( s p o )>> for a triple term', token);
           if (token.type === 'word') {
-            if (token.value === 'a') return iri(RDF_TYPE);
+            if (token.value === 'a') {
+              if (options.position !== 'predicate') throw this.error('a is only allowed as a predicate', token);
+              return iri(RDF_TYPE);
+            }
             if (token.value === 'true') return literal(true, XSD_BOOLEAN);
             if (token.value === 'false') return literal(false, XSD_BOOLEAN);
             if (token.value.startsWith('_:')) return blankNode(token.value.slice(2));
@@ -997,7 +1001,13 @@
             return literal(coerceLexicalLiteral(token.value, datatype), datatype, null);
           }
           if (this.checkType('word') && /^@[A-Za-z]+(?:-[A-Za-z0-9]+)*(?:--[A-Za-z]+)?$/.test(this.peek().value)) {
-            const tag = this.advance().value.slice(1).toLowerCase();
+            const tagToken = this.advance();
+            const rawTag = tagToken.value.slice(1);
+            const direction = rawTag.includes('--') ? rawTag.slice(rawTag.lastIndexOf('--') + 2) : null;
+            if (direction && direction !== 'ltr' && direction !== 'rtl') {
+              throw this.error(`Invalid base direction --${direction}; expected --ltr or --rtl`, tagToken);
+            }
+            const tag = rawTag.toLowerCase();
             const [lang, langDir = null] = tag.split('--');
             return literal(token.value, null, lang, langDir);
           }
@@ -2776,6 +2786,7 @@
         const syntaxProfile = String(options.profile || options.profileId || '').toLowerCase();
         const rdf12Surface = syntaxProfile === 'turtle' || syntaxProfile === 'trig';
         const implicitStatementNodes = new Set();
+        function implicitStatementNodeKey(term) { return `${term.kind}:${term.value}`; }
       
         function freshBlank() { bnodeCounter += 1; return blank(`b${bnodeCounter}`); }
         function peek(offset = 0) { return tokens[i + offset]; }
@@ -2926,7 +2937,7 @@
           expect('>>');
           const node = reifier || freshBlank();
           out.push(triple(node, iri(RDF_REIFIES), tripleTerm(s, p, o), graph));
-          if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+          implicitStatementNodes.add(implicitStatementNodeKey(node));
           return node;
         }
       
@@ -2955,7 +2966,7 @@
           if (accept(']')) return node;
           parsePredicateObjectList(node, out, graph);
           expect(']');
-          if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+          if (node.kind === 'blank') implicitStatementNodes.add(implicitStatementNodeKey(node));
           return node;
         }
       
@@ -3033,9 +3044,8 @@
             if (options3.requireDot) expect('.'); else accept('.');
             return;
           }
-          if (peek()?.type === '<<' && peek(1)?.type === '(') throw new Error('Triple term cannot be used as a subject');
-          const subject = parseTerm(out, graph, { noLiteral: true, noA: true });
-          if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && subject.kind === 'blank' && implicitStatementNodes.has(subject.value)) {
+          const subject = parseTerm(out, graph, { noLiteral: !rdf12Surface, noA: true });
+          if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && implicitStatementNodes.has(implicitStatementNodeKey(subject))) {
             if (options3.requireDot) expect('.'); else accept('.');
             return;
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeleng",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "The EYE Logic Engine: a JavaScript implementation of SHACL Rules, including SRL and RDF Rules syntax front-ends.",
   "keywords": [
     "SRL",

package/src/parser.js

@@ -296,7 +296,7 @@ class Parser {
   }
 
   parseTripleStatement(options = {}) {
-    const subjectNode = this.parseGraphNode(options);
+    const subjectNode = this.parseGraphNode({ ...options, position: 'subject' });
     const triples = [...subjectNode.triples];
     triples.push(...this.parsePropertyListForSubject(subjectNode.term, options));
     return triples;
@@ -310,7 +310,7 @@ class Parser {
       if (terminators.some((value) => this.checkValue(value)) || this.checkValue('.')) break;
       const predicate = options.allowPath ? this.parseVerbPathOrSimple(options) : this.parseVerbTerm(options);
       do {
-        const objectNode = this.parseGraphNode(options);
+        const objectNode = this.parseGraphNode({ ...options, position: 'object' });
         triples.push(...objectNode.triples);
         const baseTriple = { s: subject, p: predicate, o: objectNode.term };
         triples.push(baseTriple);
@@ -377,6 +377,7 @@ class Parser {
         currentReifier = this.parseOptionalReifier(options);
         triples.push({ s: currentReifier, p: iri(RDF_REIFIES), o: reified });
       } else if (this.matchValue('{|')) {
+        if (this.checkValue('|}')) throw this.error('Annotation blocks may not be empty');
         const annotationSubject = currentReifier || this.freshGraphNode(options);
         triples.push({ s: annotationSubject, p: iri(RDF_REIFIES), o: reified });
         triples.push(...this.parsePropertyListForSubject(annotationSubject, options, ['|}']));
@@ -426,7 +427,7 @@ class Parser {
   }
 
   parseVerbTerm(options = {}) {
-    const term = this.parseTerm(options);
+    const term = this.parseTerm({ ...options, position: 'predicate' });
     if (term.type !== 'iri' && term.type !== 'var') throw this.error('Expected IRI or variable as predicate');
     return term;
   }
@@ -549,7 +550,10 @@ class Parser {
     if (token.value === '<<(') return this.parseTripleTermAfterOpen(options);
     if (token.value === '<<') throw this.error('Use << s p o >> as a graph node reifier; use <<( s p o )>> for a triple term', token);
     if (token.type === 'word') {
-      if (token.value === 'a') return iri(RDF_TYPE);
+      if (token.value === 'a') {
+        if (options.position !== 'predicate') throw this.error('a is only allowed as a predicate', token);
+        return iri(RDF_TYPE);
+      }
       if (token.value === 'true') return literal(true, XSD_BOOLEAN);
       if (token.value === 'false') return literal(false, XSD_BOOLEAN);
       if (token.value.startsWith('_:')) return blankNode(token.value.slice(2));
@@ -583,7 +587,13 @@ class Parser {
       return literal(coerceLexicalLiteral(token.value, datatype), datatype, null);
     }
     if (this.checkType('word') && /^@[A-Za-z]+(?:-[A-Za-z0-9]+)*(?:--[A-Za-z]+)?$/.test(this.peek().value)) {
-      const tag = this.advance().value.slice(1).toLowerCase();
+      const tagToken = this.advance();
+      const rawTag = tagToken.value.slice(1);
+      const direction = rawTag.includes('--') ? rawTag.slice(rawTag.lastIndexOf('--') + 2) : null;
+      if (direction && direction !== 'ltr' && direction !== 'rtl') {
+        throw this.error(`Invalid base direction --${direction}; expected --ltr or --rtl`, tagToken);
+      }
+      const tag = rawTag.toLowerCase();
       const [lang, langDir = null] = tag.split('--');
       return literal(token.value, null, lang, langDir);
     }

package/src/rdfSyntax.js

@@ -1160,6 +1160,7 @@ function parseN3(source, options = {}) {
   const syntaxProfile = String(options.profile || options.profileId || '').toLowerCase();
   const rdf12Surface = syntaxProfile === 'turtle' || syntaxProfile === 'trig';
   const implicitStatementNodes = new Set();
+  function implicitStatementNodeKey(term) { return `${term.kind}:${term.value}`; }
 
   function freshBlank() { bnodeCounter += 1; return blank(`b${bnodeCounter}`); }
   function peek(offset = 0) { return tokens[i + offset]; }
@@ -1310,7 +1311,7 @@ function parseN3(source, options = {}) {
     expect('>>');
     const node = reifier || freshBlank();
     out.push(triple(node, iri(RDF_REIFIES), tripleTerm(s, p, o), graph));
-    if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+    implicitStatementNodes.add(implicitStatementNodeKey(node));
     return node;
   }
 
@@ -1339,7 +1340,7 @@ function parseN3(source, options = {}) {
     if (accept(']')) return node;
     parsePredicateObjectList(node, out, graph);
     expect(']');
-    if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+    if (node.kind === 'blank') implicitStatementNodes.add(implicitStatementNodeKey(node));
     return node;
   }
 
@@ -1417,9 +1418,8 @@ function parseN3(source, options = {}) {
       if (options3.requireDot) expect('.'); else accept('.');
       return;
     }
-    if (peek()?.type === '<<' && peek(1)?.type === '(') throw new Error('Triple term cannot be used as a subject');
-    const subject = parseTerm(out, graph, { noLiteral: true, noA: true });
-    if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && subject.kind === 'blank' && implicitStatementNodes.has(subject.value)) {
+    const subject = parseTerm(out, graph, { noLiteral: !rdf12Surface, noA: true });
+    if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && implicitStatementNodes.has(implicitStatementNodeKey(subject))) {
       if (options3.requireDot) expect('.'); else accept('.');
       return;
     }

package/test/api.test.js

@@ -746,6 +746,41 @@ RULE { :test :annotation ?source } WHERE {
   assert.match(output, /:test :annotation :witness \./);
 });
 
+test('DATA blocks accept RDF 1.2 symmetric and standalone reifier syntax', () => {
+  const symmetric = parse(`
+PREFIX : <http://example/>
+DATA {
+  123 :q 456 .
+  <<( :s :p :o )>> :q <<( :s1 :p1 :o1 )>> .
+}
+`);
+  assert.equal(symmetric.data.length, 2);
+  assert.equal(symmetric.data[0].s.type, 'literal');
+  assert.equal(symmetric.data[1].s.type, 'triple');
+
+  const standalone = parse(`
+PREFIX : <http://example/>
+DATA { << :a :b :c ~:r >> . }
+`);
+  assert.equal(standalone.data.length, 1);
+  assert.equal(standalone.data[0].s.value, 'http://example/r');
+  assert.equal(standalone.data[0].p.value, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies');
+});
+
+test('SRL rejects invalid base directions, subject a, and empty annotations', () => {
+  const invalidPatterns = [
+    'RULE { } WHERE { :s :p "abc"@en--LTR }',
+    'RULE { :s :p "abc"@en--LTR } WHERE { ?a ?b ?c }',
+    'RULE { } WHERE { a :p "abc" }',
+    'RULE { a :p "abc" } WHERE { ?a ?b ?c }',
+    'RULE { } WHERE { :s :p :o ~:r {| |} }',
+    'RULE { :s :p :o ~:r {| |} } WHERE { ?a ?b ?c }',
+  ];
+  for (const pattern of invalidPatterns) {
+    assert.throws(() => parse(`PREFIX : <http://example/>\n${pattern}`), Error, pattern);
+  }
+});
+
 
 test('strict conformance allows recursive constant BIND aliases', () => {
   assert.doesNotThrow(() => compile(`