eyeleng 1.0.11 → 1.0.13

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.13",
   "description": "The EYE Logic Engine: a JavaScript implementation of SHACL Rules, including SRL and RDF Rules syntax front-ends.",
   "keywords": [
     "SRL",
@@ -36,16 +36,17 @@
     "build": "node tools/bundle.js",
     "pretest": "node tools/bundle.js",
     "test": "node test/run.js",
+    "test:api": "node test/api.test.js",
+    "test:examples": "node test/examples.test.js",
     "preversion": "npm test",
     "version": "node tools/bundle.js",
     "postversion": "git push origin HEAD --follow-tags",
     "w3c:rules": "node tools/w3c-shacl12-rules.js",
+    "w3c:rules:json": "node tools/w3c-shacl12-rules.js --json",
+    "w3c:rules:earl": "node tools/w3c-shacl12-rules.js --earl",
     "w3c:rdf": "node tools/w3c-rdf.js",
     "w3c:rdf:json": "node tools/w3c-rdf.js --json",
     "w3c:rdf:earl": "node tools/w3c-rdf.js --earl",
-    "w3c:all": "npm run w3c:rules && npm run w3c:rdf",
-    "w3c:rules:json": "node tools/w3c-shacl12-rules.js --json",
-    "w3c:rules:earl": "node tools/w3c-shacl12-rules.js --earl",
     "bench": "node tools/perf-bench.js --check",
     "bench:report": "node tools/perf-bench.js --report",
     "bench:update": "node tools/perf-bench.js --update"