eyeleng 1.0.11 → 1.0.13

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();

package/test/run.js

@@ -18,7 +18,6 @@ const preferred = [
   'browser-bundle.test.js',
   'examples.test.js',
   'shacl12-rules.test.js',
-  'w3c-rdf.test.js',
 ];
 const files = preferred.filter((name) => fs.existsSync(path.join(__dirname, name)));
 

package/tools/w3c-rdf.js

@@ -8,7 +8,6 @@ const {
   runW3cRdfManifests,
   formatW3cRdfProgressLine,
   formatW3cRdfManifestsResult,
-  rdfManifestsToEarl,
   writeRdfEarlReport,
   defaultRdfReportPath,
 } = require('../src/rdfManifest.js');
@@ -19,12 +18,18 @@ function argValue(argv, name) {
   return argv[index + 1] || null;
 }
 
+function loggerForMode({ json, earl }) {
+  // Keep stdout machine-readable or empty in output modes. Progress still stays visible.
+  return json || earl ? console.error : console.log;
+}
+
 async function main(argv = process.argv.slice(2)) {
   const json = argv.includes('--json');
   const earl = argv.includes('--earl');
   const noReport = argv.includes('--no-report');
-  const quiet = json || earl || argv.includes('--quiet');
+  const quiet = argv.includes('--quiet');
   const output = argValue(argv, '--output') || defaultRdfReportPath();
+  const log = loggerForMode({ json, earl });
   const manifests = argv.filter((arg, index) => {
     if (arg.startsWith('--')) return false;
     if (argv[index - 1] === '--output') return false;
@@ -33,19 +38,18 @@ async function main(argv = process.argv.slice(2)) {
   const resources = manifests.length ? manifests : defaultW3cRdfManifestUrls;
   const result = await runW3cRdfManifests(resources, {
     onManifestStart(resource, index, total) {
-      if (!quiet) console.log(`${C.y}==${C.n} W3C RDF manifest ${index + 1}/${total}: ${resource}`);
+      if (!quiet) log(`${C.y}==${C.n} W3C RDF manifest ${index + 1}/${total}: ${resource}`);
     },
     onProgress(item, index) {
-      if (!quiet) console.log(formatW3cRdfProgressLine(item, index, { colors: C }));
+      if (!quiet) log(formatW3cRdfProgressLine(item, index, { colors: C }));
     },
   });
   if (!noReport) {
     const reportPath = writeRdfEarlReport(result, output, { assertedBy: '<https://github.com/eyereasoner/eyeleng>' });
-    if (!quiet) console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
+    if (!quiet) log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
   }
   if (json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  else if (earl) process.stdout.write(`${rdfManifestsToEarl(result, { assertedBy: '<https://github.com/eyereasoner/eyeleng>' })}\n`);
-  else process.stdout.write(`${formatW3cRdfManifestsResult(result, { colors: C })}\n`);
+  else if (!earl) process.stdout.write(`${formatW3cRdfManifestsResult(result, { colors: C })}\n`);
   return result.counts.fail === 0 ? 0 : 1;
 }
 

package/tools/w3c-shacl12-rules.js

@@ -8,7 +8,6 @@ const {
   runShacl12RulesManifest,
   formatShacl12RulesProgressLine,
   formatShacl12RulesManifestResult,
-  shacl12RulesManifestToEarl,
   writeShacl12RulesEarlReport,
   defaultReportPath,
 } = require('../src/shacl12RulesManifest.js');
@@ -19,12 +18,18 @@ function argValue(argv, name) {
   return argv[index + 1] || null;
 }
 
+function loggerForMode({ json, earl }) {
+  // Keep stdout machine-readable or empty in output modes. Progress still stays visible.
+  return json || earl ? console.error : console.log;
+}
+
 async function main(argv = process.argv.slice(2)) {
   const json = argv.includes('--json');
   const earl = argv.includes('--earl');
   const noReport = argv.includes('--no-report');
-  const quiet = json || earl || argv.includes('--quiet');
+  const quiet = argv.includes('--quiet');
   const output = argValue(argv, '--output') || defaultReportPath();
+  const log = loggerForMode({ json, earl });
   const manifests = argv.filter((arg, index) => {
     if (arg.startsWith('--')) return false;
     if (argv[index - 1] === '--output') return false;
@@ -32,20 +37,20 @@ async function main(argv = process.argv.slice(2)) {
   });
   const manifest = manifests[0] || process.env.EYELENG_SHACL12_RULES_MANIFEST || defaultShacl12RulesManifestUrl;
 
+  if (!quiet) log(`${C.y}==${C.n} W3C SHACL 1.2 Rules manifest: ${manifest}`);
   const result = await runShacl12RulesManifest(manifest, {
     onProgress(item, index) {
-      if (!quiet) console.log(formatShacl12RulesProgressLine(item, index, { colors: C }));
+      if (!quiet) log(formatShacl12RulesProgressLine(item, index, { colors: C }));
     },
   });
 
   if (!noReport) {
     const reportPath = writeShacl12RulesEarlReport(result, output);
-    if (!quiet) console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
+    if (!quiet) log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
   }
 
   if (json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  else if (earl) process.stdout.write(`${shacl12RulesManifestToEarl(result)}\n`);
-  else process.stdout.write(`${formatShacl12RulesManifestResult(result, { colors: C })}\n`);
+  else if (!earl) process.stdout.write(`${formatShacl12RulesManifestResult(result, { colors: C })}\n`);
   return result.counts.fail === 0 ? 0 : 1;
 }