eyeleng 1.0.10 → 1.0.12

package/README.md

@@ -76,6 +76,8 @@ 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.
 
+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
 
 SRL supports the practical rule features used by the SHACL 1.2 Rules tests and examples:
@@ -90,7 +92,7 @@ DATA {
 
 RULE { ?x :grade ?grade } WHERE {
   ?x :score ?score .
-  FILTER(?score >= 5) .
+  FILTER(?score >= 5)
   BIND(concat("pass-", str(?score)) AS ?grade)
 }
 
@@ -197,19 +199,24 @@ Common commands:
 Important options:
 
 ```text
---all               print input and inferred triples
---check             parse and analyze only
---strict            warnings become fatal
---deps              print dependency edges and layers
---trace             show rule firings
---stats             show iteration and rule counts
---json              structured output
---query             run a raw body pattern over the closure
---query-file FILE   read a query body from a file
---max-iterations N  recursive-layer fixpoint safety guard
---no-imports        parse imports but do not load them
---rdf-messages      parse input as an RDF Message Log
---stream-messages   replay RDF Message Log envelopes
+--all                 print the full closure, including input facts
+--json                print JSON instead of compact triples/bindings
+--trace               print derivation trace to stderr, or include it in JSON
+--stats               print iteration and triple counts to stderr
+--check               parse and analyze only; do not run rules
+--strict              treat static warnings as errors, including recursive term generation
+--deps                print rule dependency edges during --check
+--query TEXT          run a raw SRL body pattern over the closure
+--query-file FILE     read a raw SRL body pattern from a file
+--max-iterations N    stop after N fixpoint iterations within a recursive layer
+--no-imports          parse IMPORTS/owl:imports but do not load imported rule sets
+--rdf-messages        parse input as an RDF Message Log
+--stream-messages     replay RDF Message Log envelopes
+--include-message-facts include payload facts while parsing RDF Message Logs
+--syntax MODE         use srl, rdf, or auto syntax detection (default auto)
+--ruleset TERM        in RDF syntax, run only the selected srl:RuleSet
+--version             print version
+-h, --help            print help
 ```
 
 ## Public API

package/dist/browser/eyeleng.browser.js

@@ -4048,8 +4048,8 @@
     "src/engine.js": function (require, module, exports) {
       'use strict';
       
-      const { TripleStore, bindingKey, instantiateTriple } = require('./store.js');
-      const { tripleKey, termEquals } = require('./term.js');
+      const { TripleStore, bindingKey } = require('./store.js');
+      const { tripleKey, termKey, termEquals, blankNode, tripleTerm } = require('./term.js');
       const { evalExpression, booleanValue, asTerm } = require('./builtins.js');
       const { analyze } = require('./analyze.js');
       
@@ -4069,7 +4069,7 @@
           runOnce: !!rule.runOnce,
         }));
       
-        const analysis = options.analysis || analyze(program);
+        const analysis = options.analysis || analyze(program, options);
         if (analysis.errors && analysis.errors.length > 0 && !options.ignoreAnalysisErrors) {
           throw new Error(`Analysis failed: ${analysis.errors.map((error) => error.message).join('; ')}`);
         }
@@ -4080,6 +4080,9 @@
           layerIndexes,
           analysis.dependency ? analysis.dependency.edges : [],
         );
+        const relaxedRecursiveRunOnce = options.relaxedRecursion === false
+          ? new Set()
+          : recursiveTermGenerationRuleIndexes(analysis);
         const baseContext = {
           ...evalOptions,
           maxIterations,
@@ -4095,8 +4098,8 @@
       
         for (let layerIndex = 0; layerIndex < layerIndexes.length; layerIndex += 1) {
           const layer = layerIndexes[layerIndex];
-          const ordinary = layer.filter((ruleIndex) => !program.rules[ruleIndex].runOnce);
-          const runOnce = layer.filter((ruleIndex) => program.rules[ruleIndex].runOnce);
+          const ordinary = layer.filter((ruleIndex) => !program.rules[ruleIndex].runOnce || relaxedRecursiveRunOnce.has(ruleIndex));
+          const runOnce = layer.filter((ruleIndex) => program.rules[ruleIndex].runOnce && !relaxedRecursiveRunOnce.has(ruleIndex));
       
           if (runOnce.length > 0) {
             iterations += 1;
@@ -4196,6 +4199,7 @@
         let added = 0;
         const dedupeBindings = rule.body.some((clause) => clause.type === 'path');
         const seenBindings = dedupeBindings ? new Set() : null;
+        const headBlankLabels = collectHeadBlankLabels(rule.head);
       
         const bodyBindings = rule.body.length === 1 && rule.body[0].type === 'triple'
           ? store.match(rule.body[0].triple, {})
@@ -4210,8 +4214,10 @@
           applications += 1;
           context.perRule[ruleIndex].applications += 1;
       
+          const headBlankMap = headBlankLabels.size > 0 ? new Map() : null;
+          const skolemKey = headBlankMap ? skolemizationKey(ruleIndex, binding) : null;
           for (const head of rule.head) {
-            const triple = instantiateTriple(head, binding);
+            const triple = instantiateHeadTriple(head, binding, headBlankLabels, headBlankMap, skolemKey);
             if (!triple) continue;
             if (store.add(triple)) {
               added += 1;
@@ -4233,6 +4239,94 @@
         return { applications, added };
       }
       
+      function recursiveTermGenerationRuleIndexes(analysis) {
+        const out = new Set();
+        if (!analysis || !analysis.dependency || !analysis.diagnostics) return out;
+        const byName = new Map((analysis.dependency.rules || []).map((rule) => [rule.name, rule.index]));
+        for (const diagnostic of analysis.diagnostics) {
+          if (diagnostic.code !== 'recursive-assignment-rule') continue;
+          if (byName.has(diagnostic.rule)) out.add(byName.get(diagnostic.rule));
+        }
+        return out;
+      }
+      
+      function instantiateHeadTriple(pattern, binding, headBlankLabels, headBlankMap, skolemKey) {
+        const s = instantiateHeadTerm(pattern.s, binding, headBlankLabels, headBlankMap, skolemKey);
+        const p = instantiateHeadTerm(pattern.p, binding, headBlankLabels, headBlankMap, skolemKey);
+        const o = instantiateHeadTerm(pattern.o, binding, headBlankLabels, headBlankMap, skolemKey);
+        if (!s || !p || !o) return null;
+        if (p.type !== 'iri') return null;
+        return { s, p, o };
+      }
+      
+      function instantiateHeadTerm(term, binding, headBlankLabels, headBlankMap, skolemKey) {
+        if (term.type === 'var') return binding[term.value] || null;
+        if (term.type === 'blank' && headBlankLabels.has(term.value)) {
+          let label = headBlankMap.get(term.value);
+          if (!label) {
+            label = `sk_${deterministicSkolemIdFromKey(`${skolemKey}|${term.value}`).replace(/-/g, '_')}`;
+            headBlankMap.set(term.value, label);
+          }
+          return blankNode(label);
+        }
+        if (term.type === 'triple') {
+          const s = instantiateHeadTerm(term.s, binding, headBlankLabels, headBlankMap, skolemKey);
+          const p = instantiateHeadTerm(term.p, binding, headBlankLabels, headBlankMap, skolemKey);
+          const o = instantiateHeadTerm(term.o, binding, headBlankLabels, headBlankMap, skolemKey);
+          if (!s || !p || !o) return null;
+          return tripleTerm(s, p, o);
+        }
+        return term;
+      }
+      
+      function collectHeadBlankLabels(head) {
+        const labels = new Set();
+        for (const triple of head || []) {
+          collectBlankLabelsFromTerm(triple.s, labels);
+          collectBlankLabelsFromTerm(triple.p, labels);
+          collectBlankLabelsFromTerm(triple.o, labels);
+        }
+        return labels;
+      }
+      
+      function collectBlankLabelsFromTerm(term, labels) {
+        if (!term) return;
+        if (term.type === 'blank') {
+          labels.add(term.value);
+          return;
+        }
+        if (term.type === 'triple') {
+          collectBlankLabelsFromTerm(term.s, labels);
+          collectBlankLabelsFromTerm(term.p, labels);
+          collectBlankLabelsFromTerm(term.o, labels);
+        }
+      }
+      
+      function skolemizationKey(ruleIndex, binding) {
+        let out = `rule:${ruleIndex}`;
+        for (const name of Object.keys(binding).sort()) {
+          const value = binding[name];
+          out += `|${name}=${value ? termKey(value) : 'unbound'}`;
+        }
+        return out;
+      }
+      
+      function deterministicSkolemIdFromKey(key) {
+        let h1 = 0x811c9dc5;
+        let h2 = 0x811c9dc5;
+        let h3 = 0x811c9dc5;
+        let h4 = 0x811c9dc5;
+        for (let i = 0; i < key.length; i += 1) {
+          const c = key.charCodeAt(i);
+          h1 ^= c; h1 = Math.imul(h1, 0x01000193) >>> 0;
+          h2 ^= c + 1; h2 = Math.imul(h2, 0x01000193) >>> 0;
+          h3 ^= c + 2; h3 = Math.imul(h3, 0x01000193) >>> 0;
+          h4 ^= c + 3; h4 = Math.imul(h4, 0x01000193) >>> 0;
+        }
+        return [h1, h2, h3, h4].map((h) => h.toString(16).padStart(8, '0')).join('');
+      }
+      
+      
       function evaluateBody(clauses, store, initialBinding = {}, options = {}) {
         const bindings = [];
         const seen = new Set();
@@ -4589,8 +4683,8 @@
       function analyze(program, options = {}) {
         const diagnostics = [];
         const dependency = dependencyGraph(program, options);
-        const hasRunOnceRules = program.rules.some((rule) => rule.runOnce);
-        const recursiveIndexes = hasRunOnceRules ? recursiveRuleIndexes(dependency) : new Set();
+        const hasTermGeneratingRules = dependency.rules.some((rule) => rule.createsTerms);
+        const recursiveIndexes = hasTermGeneratingRules ? recursiveRuleIndexes(dependency) : new Set();
       
         program.rules.forEach((rule, index) => {
           const name = ruleName(rule, index);
@@ -4622,12 +4716,13 @@
       
           diagnostics.push(...sequentialWellFormednessDiagnostics(rule.body, name, program.prefixes || {}));
       
-          if (rule.runOnce && recursiveIndexes.has(index)) {
+          const depRule = dependency.rules[index] || {};
+          if (depRule.createsTerms && recursiveIndexes.has(index)) {
             diagnostics.push({
               code: 'recursive-assignment-rule',
               severity: 'warning',
               rule: name,
-              message: `${displayRuleName(name, program.prefixes || {})} is a run-once rule in a recursive dependency cycle`,
+              message: `${displayRuleName(name, program.prefixes || {})} creates terms in a recursive dependency cycle; relaxed mode allows this but termination is not guaranteed (use --strict to reject it)`,
             });
           }
       
@@ -4674,34 +4769,47 @@
             negativePredicates: new Set(negativePatterns.flatMap((triple) => predicateIRIs(triple))),
             runOnce: !!rule.runOnce,
             hasAssignment: ruleHasAssignment(rule, options),
+            hasTermGeneratingAssignment: ruleHasTermGeneratingAssignment(rule, options),
             headHasBlankNode: ruleHeadHasBlankNode(rule),
+            createsTerms: ruleCreatesTerms(rule, options),
           };
         });
       
         const edgeMap = new Map();
-        function addEdge(from, to, negative, predicate) {
+        function addEdge(from, to, kind, predicate) {
           const label = predicate || '*';
           const key = `${from.index}->${to.index}:${label}`;
+          const negated = kind === 'negated';
+          const termGeneration = kind === 'term-generation';
           const existing = edgeMap.get(key);
           if (existing) {
-            existing.negative = existing.negative || negative;
+            existing.negated = existing.negated || negated;
+            existing.termGeneration = existing.termGeneration || termGeneration;
+            existing.negative = existing.negated || existing.termGeneration;
             return;
           }
-          edgeMap.set(key, { from: from.index, to: to.index, negative, predicate });
+          edgeMap.set(key, {
+            from: from.index,
+            to: to.index,
+            negative: negated || termGeneration,
+            negated,
+            termGeneration,
+            predicate,
+          });
         }
       
         const headIndex = buildHeadTemplateIndex(rules);
       
         for (const from of rules) {
-          const forceClosed = from.hasAssignment || from.headHasBlankNode;
+          const forceClosed = from.createsTerms;
           for (const pattern of from.positivePatterns) {
             for (const candidate of candidateHeadTemplates(headIndex, pattern)) {
-              if (canPossiblyGenerate(candidate.template, pattern)) addEdge(from, rules[candidate.ruleIndex], forceClosed, dependencyPredicateLabel(pattern));
+              if (canPossiblyGenerate(candidate.template, pattern)) addEdge(from, rules[candidate.ruleIndex], forceClosed ? 'term-generation' : 'positive', dependencyPredicateLabel(pattern));
             }
           }
           for (const pattern of from.negativePatterns) {
             for (const candidate of candidateHeadTemplates(headIndex, pattern)) {
-              if (canPossiblyGenerate(candidate.template, pattern)) addEdge(from, rules[candidate.ruleIndex], true, dependencyPredicateLabel(pattern));
+              if (canPossiblyGenerate(candidate.template, pattern)) addEdge(from, rules[candidate.ruleIndex], 'negated', dependencyPredicateLabel(pattern));
             }
           }
         }
@@ -4717,7 +4825,7 @@
         const unstratifiedCycles = [];
         const seen = new Set();
         for (const edge of edges) {
-          if (!edge.negative) continue;
+          if (!edge.negated) continue;
           if (edge.from === edge.to && rules[edge.from].runOnce && !rules[edge.from].headHasBlankNode) continue;
           if (componentOf.get(edge.from) !== componentOf.get(edge.to)) continue;
           const component = components[componentOf.get(edge.from)];
@@ -4740,7 +4848,10 @@
             positivePredicates: Array.from(rule.positivePredicates),
             negativePredicates: Array.from(rule.negativePredicates),
             runOnce: rule.runOnce,
+            hasAssignment: rule.hasAssignment,
+            hasTermGeneratingAssignment: rule.hasTermGeneratingAssignment,
             headHasBlankNode: rule.headHasBlankNode,
+            createsTerms: rule.createsTerms,
           })),
           edges,
           components: components.map((component) => component.map((ruleIndex) => rules[ruleIndex].name)),
@@ -4910,7 +5021,14 @@
       function recursiveRuleIndexes(dependency) {
         const out = new Set();
         const ruleByName = new Map(dependency.rules.map((rule) => [rule.name, rule]));
-        const ruleByIndex = new Map(dependency.rules.map((rule) => [rule.index, rule]));
+        const componentOf = new Map();
+      
+        dependency.components.forEach((component, componentIndex) => {
+          for (const name of component) {
+            const rule = ruleByName.get(name);
+            if (rule) componentOf.set(rule.index, componentIndex);
+          }
+        });
       
         for (const component of dependency.components) {
           if (component.length <= 1) continue;
@@ -4921,9 +5039,9 @@
         }
       
         for (const edge of dependency.edges) {
-          const rule = ruleByIndex.get(edge.from);
-          if (edge.from === edge.to && edge.negative && rule && rule.runOnce && !rule.headHasBlankNode) continue;
-          out.add(edge.from);
+          const rule = (dependency.rules || []).find((candidate) => candidate.index === edge.from);
+          if (edge.from === edge.to && edge.negated && rule && rule.runOnce && !rule.headHasBlankNode) continue;
+          if (edge.from === edge.to || componentOf.get(edge.from) === componentOf.get(edge.to)) out.add(edge.from);
         }
         return out;
       }
@@ -5196,7 +5314,26 @@
       }
       
       function ruleHasAssignment(rule, options = {}) {
-        return !!options.shacl12Conformance && (rule.body || []).some((clause) => clause.type === 'set' || clause.type === 'bind');
+        return (rule.body || []).some((clause) => clause.type === 'set' || clause.type === 'bind');
+      }
+      
+      function ruleHasTermGeneratingAssignment(rule, options = {}) {
+        return (rule.body || []).some((clause) => (clause.type === 'set' || clause.type === 'bind') && assignmentMayCreateNewTerm(clause.expr));
+      }
+      
+      function ruleCreatesTerms(rule, options = {}) {
+        return ruleHeadHasBlankNode(rule) || ruleHasTermGeneratingAssignment(rule, options);
+      }
+      
+      function assignmentMayCreateNewTerm(expr) {
+        // Simple aliases and constants are not term generators: they select from a
+        // fixed term or from already-bound terms.  Expressions that compute values
+        // through operators or functions may create an unbounded sequence when used
+        // recursively, e.g. SET(?v1 := ?v + 1), so they remain part of the strict
+        // recursive-new-terms check.
+        if (!expr) return false;
+        if (expr.type === 'var' || expr.type === 'term' || expr.type === 'literal') return false;
+        return true;
       }
       
       function ruleHeadHasBlankNode(rule) {

package/examples/assignment.srl

@@ -7,6 +7,6 @@ DATA {
 
 RULE { ?x :grade ?grade } WHERE {
   ?x :score ?score .
-  FILTER(?score >= 5) .
+  FILTER(?score >= 5)
   SET(?grade := concat("pass-", str(?score)))
 }

package/examples/base-and-literals.srl

@@ -15,6 +15,6 @@ RULE {
 } WHERE {
   ?person :name ?name ;
           :age ?age .
-  FILTER(datatype(?age) = xsd:integer && ?age >= 18 && lang(?name) = "en") .
+  FILTER(datatype(?age) = xsd:integer && ?age >= 18 && lang(?name) = "en")
   SET(?slug := REPLACE(LCASE(STR(?name)), " ", "-"))
 }

package/examples/output/cat-koko.trig

@@ -1,3 +1,3 @@
-_:bsh a :BritishShortHair .
-_:cat a :Cat .
+_:sk_319b8a2f709c2e2189803dc77b3d3e85 a :BritishShortHair .
+_:sk_bb32b39908778273d11a8e49e72b9547 a :Cat .
 :test :is true .