eyeleng 1.0.11 → 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)
 }
 
@@ -202,7 +204,7 @@ Important options:
 --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
+--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

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 .

package/examples/path-discovery.srl

@@ -96485,7 +96485,7 @@ WHERE {
   ?query a :RouteQuery ;
     :source ?source .
   ?source nepo:hasOutboundRouteTo ?next .
-  FILTER(!sameTerm(?source, ?next)) .
+  FILTER(!sameTerm(?source, ?next))
   ?source rdfs:label ?sourceName .
   ?next rdfs:label ?nextName .
   SET(?pathKey := CONCAT("|", STR(?source), "|", STR(?next), "|"))
@@ -96514,12 +96514,12 @@ WHERE {
     :routeLabel ?routeLabel .
   ?query :destination ?destination ;
     :maxStopOvers ?maxStopOvers .
-  FILTER(!sameTerm(?airport, ?destination)) .
-  FILTER(?stopovers < ?maxStopOvers) .
+  FILTER(!sameTerm(?airport, ?destination))
+  FILTER(?stopovers < ?maxStopOvers)
   ?airport nepo:hasOutboundRouteTo ?next .
-  FILTER(!sameTerm(?airport, ?next)) .
+  FILTER(!sameTerm(?airport, ?next))
   SET(?nextNeedle := CONCAT("|", STR(?next), "|"))
-  FILTER(!CONTAINS(?pathKey, ?nextNeedle)) .
+  FILTER(!CONTAINS(?pathKey, ?nextNeedle))
   ?next rdfs:label ?nextName .
   SET(?nextStopovers := ?stopovers + 1)
   SET(?nextPathKey := CONCAT(?pathKey, STR(?next), "|"))

package/eyeleng.js

@@ -40,7 +40,7 @@
       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\n  --deps                Print rule dependency edges during --check\n  --query TEXT          Run a raw SRL body pattern over the closure\n  --query-file FILE     Read a raw SRL body pattern from a file\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  --stream-messages     Replay RDF Message Log envelopes\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\n  --query-file FILE     Read a raw SRL body pattern from a file\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  --stream-messages     Replay RDF Message Log envelopes\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) {
@@ -148,7 +148,7 @@
         for (const edge of edges) {
           const from = formatRuleName(analysis.dependency.rules[edge.from].name, prefixes);
           const to = formatRuleName(analysis.dependency.rules[edge.to].name, prefixes);
-          const kind = edge.negative ? 'NOT' : 'uses';
+          const kind = edge.negated ? 'NOT' : (edge.termGeneration ? 'generates' : 'uses');
           stderr.write(`eyeleng: deps: ${from} --${kind} ${edge.predicate ? compactIRI(edge.predicate, prefixes) : '*'}--> ${to}\n`);
         }
         if (analysis.dependency.layers && analysis.dependency.layers.length > 0) {
@@ -4278,8 +4278,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');
       
@@ -4299,7 +4299,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('; ')}`);
         }
@@ -4310,6 +4310,9 @@
           layerIndexes,
           analysis.dependency ? analysis.dependency.edges : [],
         );
+        const relaxedRecursiveRunOnce = options.relaxedRecursion === false
+          ? new Set()
+          : recursiveTermGenerationRuleIndexes(analysis);
         const baseContext = {
           ...evalOptions,
           maxIterations,
@@ -4325,8 +4328,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;
@@ -4426,6 +4429,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, {})
@@ -4440,8 +4444,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;
@@ -4463,6 +4469,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();
@@ -4819,8 +4913,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);
@@ -4852,12 +4946,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)`,
             });
           }
       
@@ -4904,34 +4999,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));
             }
           }
         }
@@ -4947,7 +5055,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)];
@@ -4970,7 +5078,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)),
@@ -5140,7 +5251,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;
@@ -5151,9 +5269,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;
       }
@@ -5426,7 +5544,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/package.json

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

package/src/analyze.js

@@ -6,8 +6,8 @@ const { tripleHasBlankNode } = require('./assignments.js');
 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);
@@ -39,12 +39,13 @@ function analyze(program, options = {}) {
 
     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)`,
       });
     }
 
@@ -91,34 +92,47 @@ function dependencyGraph(program, options = {}) {
       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));
       }
     }
   }
@@ -134,7 +148,7 @@ function dependencyGraph(program, options = {}) {
   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)];
@@ -157,7 +171,10 @@ function dependencyGraph(program, options = {}) {
       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)),
@@ -327,7 +344,14 @@ function componentMin(component) {
 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;
@@ -338,9 +362,9 @@ function recursiveRuleIndexes(dependency) {
   }
 
   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;
 }
@@ -613,7 +637,26 @@ function substituteAssignedConstant(term, constants) {
 }
 
 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/src/cli.js

@@ -34,7 +34,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\n  --deps                Print rule dependency edges during --check\n  --query TEXT          Run a raw SRL body pattern over the closure\n  --query-file FILE     Read a raw SRL body pattern from a file\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  --stream-messages     Replay RDF Message Log envelopes\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\n  --query-file FILE     Read a raw SRL body pattern from a file\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  --stream-messages     Replay RDF Message Log envelopes\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) {
@@ -142,7 +142,7 @@ function printDependencies(analysis, prefixes, stderr) {
   for (const edge of edges) {
     const from = formatRuleName(analysis.dependency.rules[edge.from].name, prefixes);
     const to = formatRuleName(analysis.dependency.rules[edge.to].name, prefixes);
-    const kind = edge.negative ? 'NOT' : 'uses';
+    const kind = edge.negated ? 'NOT' : (edge.termGeneration ? 'generates' : 'uses');
     stderr.write(`eyeleng: deps: ${from} --${kind} ${edge.predicate ? compactIRI(edge.predicate, prefixes) : '*'}--> ${to}\n`);
   }
   if (analysis.dependency.layers && analysis.dependency.layers.length > 0) {

package/src/engine.js

@@ -1,7 +1,7 @@
 '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');
 
@@ -21,7 +21,7 @@ function evaluate(program, options = {}) {
     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('; ')}`);
   }
@@ -32,6 +32,9 @@ function evaluate(program, options = {}) {
     layerIndexes,
     analysis.dependency ? analysis.dependency.edges : [],
   );
+  const relaxedRecursiveRunOnce = options.relaxedRecursion === false
+    ? new Set()
+    : recursiveTermGenerationRuleIndexes(analysis);
   const baseContext = {
     ...evalOptions,
     maxIterations,
@@ -47,8 +50,8 @@ function evaluate(program, options = {}) {
 
   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;
@@ -148,6 +151,7 @@ function applyRuleOnce(program, store, ruleIndex, context) {
   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, {})
@@ -162,8 +166,10 @@ function applyRuleOnce(program, store, ruleIndex, context) {
     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;
@@ -185,6 +191,94 @@ function applyRuleOnce(program, store, ruleIndex, context) {
   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();

package/src/shacl12RulesManifest.js

@@ -139,6 +139,10 @@ async function runSyntaxOrWellformedTest(test, options = {}) {
     filename: test.actionUrl,
     baseIRI: test.actionUrl,
     shacl12Conformance: true,
+    // The W3C manifest defines the strict, guaranteed-terminating conformance profile.
+    // Eyeleng's relaxed mode remains available through the normal API/CLI, but
+    // negative well-formedness tests for recursive term generation must fail here.
+    strict: true,
   };
 
   if (test.type.includes('Syntax')) {
@@ -176,6 +180,7 @@ async function runEvalTest(test, options = {}) {
     filename: test.rulesetUrl,
     baseIRI: test.rulesetUrl,
     shacl12Conformance: true,
+    strict: true,
   };
   const compiled = eyeleng.compile(rulesSource, compileOptions);
   const program = { ...compiled.program, data: [...compiled.program.data, ...dataTriples] };

package/test/api.test.js

@@ -3,6 +3,7 @@
 const { test, main } = require('./harness.js').createHarness('API');
 const assert = require('node:assert/strict');
 const { parse, compile, run, runToString } = require('../src/index.js');
+const { tripleKey } = require('../src/term.js');
 
 test('parse reads prefixes, data, and rules', () => {
   const program = parse(`
@@ -455,7 +456,70 @@ RULE { :s :p ?x } WHERE { :s :q ?x SET(?z := STR(?x)) }
 `, options));
 });
 
-main();
+
+test('relaxed mode permits recursive deterministic assignments with max-iteration safety', () => {
+  const source = `
+PREFIX : <http://example/>
+DATA { :counter :value 0 . :limit :max 3 . }
+RULE { :counter :value ?next } WHERE {
+  :counter :value ?value .
+  :limit :max ?max .
+  FILTER(?value < ?max)
+  SET(?next := ?value + 1)
+}
+`;
+  const compiled = compile(source, { shacl12Conformance: true, throwOnDiagnostics: false });
+  assert.equal(compiled.analysis.warnings[0].code, 'recursive-assignment-rule');
+  assert.throws(() => compile(source, { shacl12Conformance: true, strict: true }), /termination is not guaranteed/);
+  const output = runToString(source, { shacl12Conformance: true, maxIterations: 20 });
+  assert.match(output, /:counter :value 1 \./);
+  assert.match(output, /:counter :value 2 \./);
+  assert.match(output, /:counter :value 3 \./);
+});
+
+test('head blank nodes are deterministically skolemized with all universal bindings', () => {
+  const source = `
+PREFIX : <http://example/>
+DATA { :a :p :o . :b :p :o . }
+RULE { [] :source ?s ; :value :o } WHERE { ?s :p :o }
+`;
+  const first = run(source);
+  const second = run(source);
+  assert.deepEqual(first.inferred.map(tripleKey).sort(), second.inferred.map(tripleKey).sort());
+  const sourcePredicate = 'http://example/source';
+  const witnessSubjects = first.inferred
+    .filter((triple) => triple.p.type === 'iri' && triple.p.value === sourcePredicate)
+    .map((triple) => triple.s.value);
+  assert.equal(witnessSubjects.length, 2);
+  assert.equal(new Set(witnessSubjects).size, 2);
+});
+
+
+test('head blank skolemization is a standard function of all universals', () => {
+  const source = `
+PREFIX : <http://example.org/#>
+DATA { :s1 :p :o . :s2 :p :o . }
+RULE { [] :witnessFor ?s } WHERE { ?s :p :o }
+`;
+  const result = run(source, { maxIterations: 20, throwOnDiagnostics: false });
+  const witnessSubjects = result.inferred
+    .filter((triple) => triple.p.value === 'http://example.org/#witnessFor')
+    .map((triple) => triple.s.value);
+  assert.equal(witnessSubjects.length, 2);
+  assert.equal(new Set(witnessSubjects).size, 2);
+});
+
+test('recursive existential rules may not terminate with all-universal skolemization', () => {
+  const source = `
+PREFIX : <http://example.org/#>
+DATA { :s :p :o . }
+RULE { [] :p :o } WHERE { ?s :p :o }
+`;
+  assert.throws(
+    () => run(source, { maxIterations: 5, throwOnDiagnostics: false }),
+    /Reached maxIterations=5/,
+  );
+});
 
 test('RDF Message Logs expose Eyeling-style envelopes and payload triples', () => {
   const messages = `VERSION "1.2-messages"
@@ -519,3 +583,20 @@ RULE { :test :annotation ?source } WHERE {
   assert.match(output, /:root :first 1 \./);
   assert.match(output, /:test :annotation :witness \./);
 });
+
+
+test('strict conformance allows recursive constant BIND aliases', () => {
+  assert.doesNotThrow(() => compile(`
+PREFIX : <http://example.org/#>
+RULE { ?s ?p ?o } WHERE { ?s :p ?o . BIND(:p AS ?p) }
+`, { shacl12Conformance: true, strict: true }));
+});
+
+test('strict conformance rejects recursive computed assignments', () => {
+  assert.throws(() => compile(`
+PREFIX : <http://example.org/#>
+RULE { ?x :p ?v1 } WHERE { ?x :p ?v . SET(?v1 := ?v + 1) }
+`, { shacl12Conformance: true, strict: true }), /creates terms in a recursive dependency cycle/);
+});
+
+main();