eyeleng 1.1.0 → 1.1.2

package/src/backward.js

@@ -130,10 +130,7 @@ class BackwardProver {
     const entry = this.memo.get(key);
     if (entry && entry.complete) {
       this.stats.memoHits += 1;
-      for (const answer of entry.answers) {
-        const next = unifyTriples(pattern, answer, binding);
-        if (next) yield next;
-      }
+      yield* this.replayAnswers(pattern, binding, entry.answers);
       return;
     }
     if (this.active.has(key)) return;
@@ -147,7 +144,6 @@ class BackwardProver {
         if (!next) continue;
         rememberAnswer(answers, answerKeys, pattern, next);
         this.stats.facts += 1;
-        yield next;
       }
 
       for (const item of this.ruleCandidates(resolvedPattern)) {
@@ -159,7 +155,6 @@ class BackwardProver {
         for (const solved of this.solveBody(freshBody, next, depth + 1, 0)) {
           rememberAnswer(answers, answerKeys, pattern, solved);
           this.stats.rules += 1;
-          yield solved;
         }
       }
     } finally {
@@ -168,6 +163,14 @@ class BackwardProver {
 
     this.memo.set(key, { complete: true, answers });
     this.stats.memoStores += 1;
+    yield* this.replayAnswers(pattern, binding, answers);
+  }
+
+  *replayAnswers(pattern, binding, answers) {
+    for (const answer of answers) {
+      const next = unifyTriples(pattern, answer, binding);
+      if (next) yield next;
+    }
   }
 
   factCandidates(pattern, binding) {
@@ -447,15 +450,57 @@ function preferredBackwardPredicates(program, options = {}) {
   if (explicit) return supportedBackwardPredicates(program, { ...options, hybridPredicates: explicit });
   const supported = supportedBackwardPredicates(program, options);
   const preferred = new Set();
+  const force = options.hybrid === true || options.hybridMode === 'force';
+  const demanded = force ? null : demandedBodyPredicates(program);
   for (const rule of program.rules || []) {
     if (!ruleIsFunctionLike(rule)) continue;
+    if (!force && ruleCreatesHeadTerms(rule)) continue;
     for (const head of rule.head || []) {
-      if (head && head.p && head.p.type === 'iri' && supported.has(head.p.value)) preferred.add(head.p.value);
+      if (!head || !head.p || head.p.type !== 'iri' || !supported.has(head.p.value)) continue;
+      if (force || demanded.has(head.p.value)) preferred.add(head.p.value);
     }
   }
   return preferred;
 }
 
+function demandedBodyPredicates(program) {
+  const out = new Set();
+  for (const rule of program.rules || []) {
+    for (const predicate of bodyPredicateDemands(rule.body || [])) if (predicate) out.add(predicate);
+  }
+  return out;
+}
+
+
+function ruleCreatesHeadTerms(rule) {
+  const headVars = new Set();
+  for (const triple of rule.head || []) {
+    for (const term of [triple.s, triple.p, triple.o]) {
+      if (!term) continue;
+      if (term.type === 'blank') return true;
+      if (term.type === 'var') headVars.add(term.value);
+    }
+  }
+  if (headVars.size === 0) return false;
+  for (const clause of rule.body || []) {
+    if ((clause.type === 'set' || clause.type === 'bind') && headVars.has(clause.variable) && expressionCreatesTerm(clause.expr)) return true;
+  }
+  return false;
+}
+
+function expressionCreatesTerm(expr) {
+  if (!expr) return false;
+  if (expr.type === 'call') {
+    const name = String(expr.name || '').toUpperCase();
+    if (name === 'BNODE' || name === 'IRI' || name === 'URI' || name === 'TRIPLE' || name === 'UUID' || name === 'STRUUID') return true;
+    return (expr.args || []).some(expressionCreatesTerm);
+  }
+  if (expr.type === 'binary') return expressionCreatesTerm(expr.left) || expressionCreatesTerm(expr.right);
+  if (expr.type === 'unary') return expressionCreatesTerm(expr.expr);
+  if (expr.type === 'in') return expressionCreatesTerm(expr.left) || (expr.values || []).some(expressionCreatesTerm);
+  return false;
+}
+
 function ruleIsFunctionLike(rule) {
   return (rule.body || []).some((clause) => clause.type === 'set' || clause.type === 'bind');
 }

package/src/cli.js

@@ -36,7 +36,7 @@ function readPackageVersion() {
 const VERSION = readPackageVersion();
 
 function help() {
-  return `eyeleng ${VERSION}\n\nA dependency-free JavaScript implementation experiment for the SHACL 1.2 Rules draft, including SRL and RDF Rules syntax front-ends.\n\nUsage:\n  eyeleng [options] [file ...]\n\nOptions:\n  --all                 Print the full closure, including input facts\n  --json                Print JSON instead of compact triples/bindings\n  --trace               Print derivation trace to stderr, or include it in JSON\n  --stats               Print iteration and triple counts to stderr\n  --check               Parse and analyze only; do not run rules\n  --strict              Treat static warnings as errors, including recursive term generation\n  --deps                Print rule dependency edges during --check\n  --query TEXT          Run a raw SRL body pattern over the closure or backward planner\n  --query-file FILE     Read a raw SRL body pattern from a file\n  --query-mode MODE     Use auto, forward, or backward query planning (default auto)\n  --hybrid              Orient function-like rules backward during forward execution and queries\n  --max-iterations N    Stop after N fixpoint iterations within a recursive layer\n  --no-imports          Parse IMPORTS/owl:imports but do not load imported rule sets\n  --rdf-messages        Parse input as an RDF Message Log\n  --include-message-facts Include payload facts while parsing RDF Message Logs\n  --syntax MODE         Use srl, rdf, or auto syntax detection (default auto)\n  --ruleset TERM        In RDF syntax, run only the selected srl:RuleSet\n  --version             Print version\n  -h, --help            Print this help\n\nWith no file arguments, eyeleng reads from stdin.\n`;
+  return `eyeleng ${VERSION}\n\nA dependency-free JavaScript implementation experiment for the SHACL 1.2 Rules draft, including SRL and RDF Rules syntax front-ends.\n\nUsage:\n  eyeleng [options] [file ...]\n\nOptions:\n  --all                 Print the full closure, including input facts\n  --json                Print JSON instead of compact triples/bindings\n  --trace               Print derivation trace to stderr, or include it in JSON\n  --stats               Print iteration and triple counts to stderr\n  --check               Parse and analyze only; do not run rules\n  --strict              Treat static warnings as errors, including recursive term generation\n  --deps                Print rule dependency edges during --check\n  --query TEXT          Run a raw SRL body pattern over the closure or backward planner\n  --query-file FILE     Read a raw SRL body pattern from a file\n  --query-mode MODE     Use auto, forward, or backward query planning (default auto)\n  --hybrid              Force aggressive hybrid orientation for function-like rules\n  --no-hybrid           Disable automatic hybrid forward/backward execution\n  --max-iterations N    Stop after N fixpoint iterations within a recursive layer\n  --no-imports          Parse IMPORTS/owl:imports but do not load imported rule sets\n  --rdf-messages        Parse input as an RDF Message Log\n  --include-message-facts Include payload facts while parsing RDF Message Logs\n  --syntax MODE         Use srl, rdf, or auto syntax detection (default auto)\n  --ruleset TERM        In RDF syntax, run only the selected srl:RuleSet\n  --version             Print version\n  -h, --help            Print this help\n\nWith no file arguments, eyeleng reads from stdin.\n`;
 }
 
 function parseArgs(argv) {
@@ -51,7 +51,7 @@ function parseArgs(argv) {
     query: null,
     queryFile: null,
     queryMode: 'auto',
-    hybrid: false,
+    hybrid: 'auto',
     maxIterations: 10000,
     imports: true,
     syntax: 'auto',
@@ -71,6 +71,7 @@ function parseArgs(argv) {
     else if (arg === '--deps') options.deps = true;
     else if (arg === '--no-imports') options.imports = false;
     else if (arg === '--hybrid') options.hybrid = true;
+    else if (arg === '--no-hybrid') options.hybrid = false;
     else if (arg === '--rdf-messages') options.rdfMessages = true;
     else if (arg === '--include-message-facts') options.includeMessageFacts = true;
     else if (arg === '--syntax') {

package/src/engine.js

@@ -37,7 +37,8 @@ function evaluate(program, options = {}) {
   const relaxedRecursiveRunOnce = options.relaxedRecursion === false
     ? new Set()
     : recursiveTermGenerationRuleIndexes(analysis);
-  const hybridBackwardPredicates = options.hybrid || options.backwardBodyCalls
+  const useHybrid = options.hybrid !== false && !options.shacl12Conformance;
+  const hybridBackwardPredicates = useHybrid || options.backwardBodyCalls
     ? preferredBackwardPredicates(program, options)
     : new Set();
   const hybridBackwardRules = new Set();

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/query.js

@@ -14,7 +14,7 @@ function queryResult(result, querySpec, options = {}) {
     prefixes: result.prefixes,
     select,
     bindings: projectBindings(bindings, select),
-    mode: options.queryMode === 'hybrid' || options.hybrid ? 'hybrid' : 'forward',
+    mode: result.hybridStats ? 'hybrid' : 'forward',
   };
 }
 
@@ -80,13 +80,16 @@ function runQuery(source, querySource = null, options = {}) {
 }
 
 function queryRunOptions(program, querySpec, options = {}) {
-  if (shouldUseHybridForQuery(program, querySpec, options)) return { ...options, hybrid: true };
+  const mode = options.queryMode || 'auto';
+  if (mode === 'forward') return { ...options, hybrid: false };
+  if (shouldUseHybridForQuery(program, querySpec, options)) return { ...options, hybrid: options.hybrid ?? 'auto' };
   return options;
 }
 
 function shouldUseHybridForQuery(program, querySpec, options = {}) {
   const mode = options.queryMode || 'auto';
-  if (options.hybrid || mode === 'hybrid') return true;
+  if (options.hybrid === false) return false;
+  if (options.hybrid === true) return true;
   if (mode !== 'auto') return false;
   if (!querySpec) return false;
   return preferredBackwardPredicates(program, options).size > 0;

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

@@ -219,6 +219,60 @@ RULE { ?x :ready true } WHERE { ?x :nextScore 42 }
   assert.ok(result.hybridStats.rules > 0);
 });
 
+
+
+test('hybrid backward tabling completes sibling recursive goals before replaying answers', () => {
+  const result = run(`
+PREFIX : <http://example/fib/>
+DATA {
+  :n0 :index 0 ; :fibPairF 0 ; :fibPairG 1 .
+  :n1 :index 1 .
+  :n2 :index 2 .
+  :n5 :index 5 .
+  :n10 a :FibCase ; :index 10 .
+}
+RULE { ?node :fibPairF ?c ; :fibPairG ?d }
+WHERE {
+  ?node :index ?n .
+  FILTER(?n > 0)
+  SET(?half := FLOOR(?n / 2))
+  SET(?halfNode := IRI(CONCAT("http://example/fib/n", STR(?half))))
+  ?halfNode :fibPairF ?a ; :fibPairG ?b .
+  SET(?twob := ?b * 2)
+  SET(?twobminusa := ?twob - ?a)
+  SET(?c := ?a * ?twobminusa)
+  SET(?aa := ?a * ?a)
+  SET(?bb := ?b * ?b)
+  SET(?d := ?aa + ?bb)
+  SET(?parity := ?n - (?half * 2))
+  FILTER(?parity = 0)
+}
+RULE { ?node :fibPairF ?d ; :fibPairG ?next }
+WHERE {
+  ?node :index ?n .
+  FILTER(?n > 0)
+  SET(?half := FLOOR(?n / 2))
+  SET(?halfNode := IRI(CONCAT("http://example/fib/n", STR(?half))))
+  ?halfNode :fibPairF ?a ; :fibPairG ?b .
+  SET(?twob := ?b * 2)
+  SET(?twobminusa := ?twob - ?a)
+  SET(?c := ?a * ?twobminusa)
+  SET(?aa := ?a * ?a)
+  SET(?bb := ?b * ?b)
+  SET(?d := ?aa + ?bb)
+  SET(?parity := ?n - (?half * 2))
+  FILTER(?parity = 1)
+  SET(?next := ?c + ?d)
+}
+RULE { ?node :fib ?value } WHERE { ?node a :FibCase ; :fibPairF ?value }
+`, { hybrid: true });
+  const keys = result.closure.map(tripleKey).join('\n');
+  assert.match(keys, /I:http:\/\/example\/fib\/n10 I:http:\/\/example\/fib\/fib L:55\^\^http:\/\/www\.w3\.org\/2001\/XMLSchema#integer@--/);
+  assert.equal(result.perRule[0].backward, true);
+  assert.equal(result.perRule[1].backward, true);
+  assert.ok(result.hybridStats.memoHits > 0);
+});
+
 test('hybrid query mode runs forward rules with backward body calls', () => {
   const { runQuery, formatBindings } = require('../src/index.js');
   const result = runQuery(`
@@ -692,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(`

package/test/cli.test.js

@@ -41,7 +41,9 @@ test('query mode flag is accepted by parseArgs', () => {
   assert.equal(parseArgs(['--query-mode', 'auto']).options.queryMode, 'auto');
   assert.equal(parseArgs(['--query-mode', 'forward']).options.queryMode, 'forward');
   assert.equal(parseArgs(['--query-mode', 'backward']).options.queryMode, 'backward');
+  assert.equal(parseArgs([]).options.hybrid, 'auto');
   assert.equal(parseArgs(['--hybrid']).options.hybrid, true);
+  assert.equal(parseArgs(['--no-hybrid']).options.hybrid, false);
   assert.throws(() => parseArgs(['--query-mode', 'hybrid']), /--query-mode requires auto, forward, or backward/);
   assert.throws(() => parseArgs(['--query-mode', 'sideways']), /--query-mode requires auto, forward, or backward/);
   assert.throws(() => parseArgs(['--stream-messages']), /Unknown option --stream-messages/);

package/test/perf-baseline.json

@@ -11,28 +11,28 @@
       "name": "deep-taxonomy-100000.srl",
       "file": "examples/deep-taxonomy-100000.srl",
       "repeat": 1,
-      "baselineMs": 5427.8,
+      "baselineMs": 12316.7,
       "outputBytes": 5068161
     },
     {
       "name": "fibonacci.srl",
       "file": "examples/fibonacci.srl",
       "repeat": 1,
-      "baselineMs": 1409.4,
-      "outputBytes": 10810713
+      "baselineMs": 124.0,
+      "outputBytes": 2405
     },
     {
       "name": "fft32-numeric.srl",
       "file": "examples/fft32-numeric.srl",
-      "repeat": 3,
-      "baselineMs": 182.2,
+      "repeat": 1,
+      "baselineMs": 607.8,
       "outputBytes": 466351
     },
     {
       "name": "path-discovery.srl",
       "file": "examples/path-discovery.srl",
-      "repeat": 5,
-      "baselineMs": 1317.7,
+      "repeat": 1,
+      "baselineMs": 3054.6,
       "outputBytes": 736870
     }
   ]