eyeling 1.26.4 → 1.26.6

package/examples/proof/log-not-includes.n3

@@ -0,0 +1,55 @@
+@prefix : <http://example.org/#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix math: <http://www.w3.org/2000/10/swap/math#> .
+@prefix pe: <https://eyereasoner.github.io/pe#> .
+
+:x :y 1 .
+{
+    :x :y 1 .
+} => {
+    :a :b :c .
+} .
+:a :b :c .
+
+{ :x :y 1 . } pe:why {
+  { :x :y 1 . }
+    pe:by [ pe:rule "log-not-includes.n3"; pe:line 10 ];
+    pe:uses { 1 math:equalTo 1 . }.
+
+  { 1 math:equalTo 1 . }
+    pe:by [ pe:builtin math:equalTo ].
+}.
+
+{
+    {
+        :x :y 1 .
+    } => {
+        :a :b :c .
+    } .
+} pe:why {
+  {
+    {
+        :x :y 1 .
+    } => {
+        :a :b :c .
+    } .
+}
+    pe:by [ pe:rule "log-not-includes.n3"; pe:line 10 ];
+    pe:uses { 1 math:equalTo 1 . }.
+
+  { 1 math:equalTo 1 . }
+    pe:by [ pe:builtin math:equalTo ].
+}.
+
+{ :a :b :c . } pe:why {
+  { :a :b :c . }
+    pe:by [ pe:rule "log-not-includes.n3"; pe:line 10 ];
+    pe:uses { :x :y 1 . }.
+
+  { :x :y 1 . }
+    pe:by [ pe:rule "log-not-includes.n3"; pe:line 10 ];
+    pe:uses { 1 math:equalTo 1 . }.
+
+  { 1 math:equalTo 1 . }
+    pe:by [ pe:builtin math:equalTo ].
+}.

package/examples/proof/log-uri.n3

@@ -0,0 +1,34 @@
+@prefix : <http://example.org/#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix pe: <https://eyereasoner.github.io/pe#> .
+
+:uriString :is "https://www.w3.org" .
+:uriResource :is <https://www.w3.org> .
+
+{ :uriString :is "https://www.w3.org" . } pe:why {
+  { :uriString :is "https://www.w3.org" . }
+    pe:by [ pe:rule "log-uri.n3"; pe:line 8 ];
+    pe:binding
+      [ pe:var "r"; pe:value <https://www.w3.org> ],
+      [ pe:var "s"; pe:value "https://www.w3.org" ];
+    pe:uses
+      { <https://www.w3.org> log:uri "https://www.w3.org" . },
+      { <https://www.w3.org> log:uri "https://www.w3.org" . }.
+
+  { <https://www.w3.org> log:uri "https://www.w3.org" . }
+    pe:by [ pe:builtin log:uri ].
+}.
+
+{ :uriResource :is <https://www.w3.org> . } pe:why {
+  { :uriResource :is <https://www.w3.org> . }
+    pe:by [ pe:rule "log-uri.n3"; pe:line 8 ];
+    pe:binding
+      [ pe:var "r"; pe:value <https://www.w3.org> ],
+      [ pe:var "s"; pe:value "https://www.w3.org" ];
+    pe:uses
+      { <https://www.w3.org> log:uri "https://www.w3.org" . },
+      { <https://www.w3.org> log:uri "https://www.w3.org" . }.
+
+  { <https://www.w3.org> log:uri "https://www.w3.org" . }
+    pe:by [ pe:builtin log:uri ].
+}.

package/examples/proof/rule-matching.n3

@@ -0,0 +1,34 @@
+@prefix : <https://eyereasoner.github.io/ns#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix pe: <https://eyereasoner.github.io/pe#> .
+
+:result :is true .
+
+{ :result :is true . } pe:why {
+  { :result :is true . }
+    pe:by [ pe:rule "rule-matching.n3"; pe:line 8 ];
+    pe:binding
+      [ pe:var "A"; pe:value {
+          ?A__0 => ?B__1 .
+      } ],
+      [ pe:var "B"; pe:value {
+          :result :is true .
+      } ];
+    pe:uses
+      {
+          {
+              ?A__0 => ?B__1 .
+          } => {
+              :result :is true .
+          } .
+      }.
+
+  {
+    {
+        ?A__0 => ?B__1 .
+    } => {
+        :result :is true .
+    } .
+}
+    pe:by [ pe:builtin log:implies ].
+}.

package/eyeling.js

@@ -6212,16 +6212,16 @@ function __computeConclusionFromFormula(formula) {
   for (const tr of formula.triples) {
     // Treat {A} => {B} as a forward rule.
     if (isLogImplies(tr.p)) {
-      fw.push(__makeRuleFromTerms(tr.s, tr.o, true));
+      fw.push(__copyProofSource(tr, __makeRuleFromTerms(tr.s, tr.o, true)));
       continue;
     }
 
     // Treat {A} <= {B} as the same rule in the other direction, i.e., {B} => {A},
     // so it participates in deductive closure even if only <= is used.
     if (isLogImpliedBy(tr.p)) {
-      fw.push(__makeRuleFromTerms(tr.o, tr.s, true));
+      fw.push(__copyProofSource(tr, __makeRuleFromTerms(tr.o, tr.s, true)));
       // Also index it as a backward rule for completeness (helps proveGoals in some cases).
-      bw.push(__makeRuleFromTerms(tr.s, tr.o, false));
+      bw.push(__copyProofSource(tr, __makeRuleFromTerms(tr.s, tr.o, false)));
       continue;
     }
   }
@@ -8735,7 +8735,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           // Promote rule-producing triples to live rules, treating literal true as {}
           // and literal false as a fuse head.
           if (isFwRuleTriple) {
-            const newRule = __makeRuleFromTerms(subj, obj, true);
+            const newRule = __copyProofSource(r, __makeRuleFromTerms(subj, obj, true));
             __prepareForwardRule(newRule);
 
             const key = __ruleKey(
@@ -8752,7 +8752,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
               rulesChanged = true;
             }
           } else if (isBwRuleTriple) {
-            const newRule = __makeRuleFromTerms(subj, obj, false);
+            const newRule = __copyProofSource(r, __makeRuleFromTerms(subj, obj, false));
 
             const key = __ruleKey(
               newRule.isForward,

package/lib/engine.js

@@ -717,16 +717,16 @@ function __computeConclusionFromFormula(formula) {
   for (const tr of formula.triples) {
     // Treat {A} => {B} as a forward rule.
     if (isLogImplies(tr.p)) {
-      fw.push(__makeRuleFromTerms(tr.s, tr.o, true));
+      fw.push(__copyProofSource(tr, __makeRuleFromTerms(tr.s, tr.o, true)));
       continue;
     }
 
     // Treat {A} <= {B} as the same rule in the other direction, i.e., {B} => {A},
     // so it participates in deductive closure even if only <= is used.
     if (isLogImpliedBy(tr.p)) {
-      fw.push(__makeRuleFromTerms(tr.o, tr.s, true));
+      fw.push(__copyProofSource(tr, __makeRuleFromTerms(tr.o, tr.s, true)));
       // Also index it as a backward rule for completeness (helps proveGoals in some cases).
-      bw.push(__makeRuleFromTerms(tr.s, tr.o, false));
+      bw.push(__copyProofSource(tr, __makeRuleFromTerms(tr.s, tr.o, false)));
       continue;
     }
   }
@@ -3240,7 +3240,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           // Promote rule-producing triples to live rules, treating literal true as {}
           // and literal false as a fuse head.
           if (isFwRuleTriple) {
-            const newRule = __makeRuleFromTerms(subj, obj, true);
+            const newRule = __copyProofSource(r, __makeRuleFromTerms(subj, obj, true));
             __prepareForwardRule(newRule);
 
             const key = __ruleKey(
@@ -3257,7 +3257,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
               rulesChanged = true;
             }
           } else if (isBwRuleTriple) {
-            const newRule = __makeRuleFromTerms(subj, obj, false);
+            const newRule = __copyProofSource(r, __makeRuleFromTerms(subj, obj, false));
 
             const key = __ruleKey(
               newRule.isForward,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.26.4",
+  "version": "1.26.6",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/examples.test.js

@@ -52,20 +52,53 @@ function normalizeMarkdownForCompare(text) {
 // Normalize N3 output for comparison.
 // Eyeling (and other N3 tools) may emit the same closure with different
 // triple ordering. Examples tests should verify content, not presentation.
-function normalizeN3ForCompare(n3Text) {
-  return stripTrailingWhitespace(n3Text)
+function normalizeN3ForCompare(n3Text, sourceText = '', expectedPath = '') {
+  let value = stripTrailingWhitespace(n3Text);
+
+  // get-uuid.n3 intentionally uses log:skolem and relative IRIs, so its
+  // output depends on the checkout path and generated skolem seed. Compare the
+  // shape of the generated triples rather than those environment-specific bits.
+  if (/\blog:skolem\b/.test(sourceText) || path.basename(expectedPath) === 'get-uuid.n3') {
+    value = value
+      .replace(/<urn:uuid:[^>]+>/g, '<urn:uuid:__UUID__>')
+      .replace(/<file:\/\/[^>\s]*\/examples\/([^/>]+)>/g, '<file://__EXAMPLES__/$1>');
+  }
+
+  return value
     .split('\n')
     .filter((l) => l.length > 0)
     .sort((a, b) => a.localeCompare(b))
     .join('\n');
 }
 
-function normalizeForCompare(text, expectedPath) {
+function normalizeForCompare(text, expectedPath, sourceText = '') {
   const ext = path.extname(expectedPath);
   const value = text;
   if (ext === '.md') return normalizeMarkdownForCompare(value);
   if (ext === '.txt') return normalizeTextForCompare(value);
-  return normalizeN3ForCompare(value);
+  return normalizeN3ForCompare(value, sourceText, expectedPath);
+}
+
+function normalizeProofForCompare(text, expectedPath, sourceText) {
+  let value = normalizeForCompare(text, expectedPath, sourceText);
+
+  // Some proof goldens intentionally cover volatile builtins such as
+  // time:localTime. Keep those examples useful by comparing proof structure
+  // while masking only the volatile literal values.
+  if (/\btime:localTime\b/.test(sourceText)) {
+    value = value
+      .replace(/"[^"\n]*"\^\^xsd:dateTime/g, '"__DATETIME__"^^xsd:dateTime')
+      .replace(/"PT[0-9]+(?:\.[0-9]+)?S"\^\^xsd:duration/g, '"__DURATION__"^^xsd:duration');
+  }
+
+  return value;
+}
+
+function compareGeneratedOutput({ expectedPath, generatedPath, sourceText, proof }) {
+  const expectedText = fs.readFileSync(expectedPath, 'utf8');
+  const generatedText = fs.readFileSync(generatedPath, 'utf8');
+  const normalize = proof ? normalizeProofForCompare : normalizeForCompare;
+  return normalize(expectedText, expectedPath, sourceText) === normalize(generatedText, expectedPath, sourceText);
 }
 
 // Expectation logic (robust, long-term):
@@ -141,6 +174,42 @@ function resolveExampleBuiltinPath(root, inputFile) {
   return { abs, rel };
 }
 
+function runExampleToFile({ root, examplesDir, eyelingJsPath, nodePath, file, generatedPath, proof = false }) {
+  const builtin = resolveExampleBuiltinPath(root, file);
+  const trigInput = resolveExampleTrigInput(root, file);
+  const rdfMode = !!trigInput;
+  const modeFlag = proof ? '-p' : '-d';
+  const outFd = fs.openSync(generatedPath, 'w');
+
+  try {
+    if (builtin) {
+      const args = [eyelingJsPath, modeFlag];
+      if (rdfMode) args.push('-r');
+      args.push('--builtin', builtin.rel, path.join('examples', file));
+      if (trigInput) args.push(path.join('examples', trigInput.rel));
+      return cp.spawnSync(nodePath, args, {
+        cwd: root,
+        stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
+        maxBuffer: 200 * 1024 * 1024,
+        encoding: 'utf8',
+      });
+    }
+
+    const args = [eyelingJsPath, modeFlag];
+    if (rdfMode) args.push('-r');
+    args.push(file);
+    if (trigInput) args.push(trigInput.rel);
+    return cp.spawnSync(nodePath, args, {
+      cwd: examplesDir,
+      stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
+      maxBuffer: 200 * 1024 * 1024,
+      encoding: 'utf8',
+    });
+  } finally {
+    fs.closeSync(outFd);
+  }
+}
+
 function main() {
   const suiteStart = Date.now();
 
@@ -148,6 +217,7 @@ function main() {
   const root = path.resolve(__dirname, '..');
   const examplesDir = path.join(root, 'examples');
   const outputDir = path.join(examplesDir, 'output');
+  const proofDir = path.join(examplesDir, 'proof');
   const eyelingJsPath = path.join(root, 'eyeling.js');
   const nodePath = process.execPath;
 
@@ -164,8 +234,15 @@ function main() {
     .readdirSync(examplesDir)
     .filter((f) => f.endsWith('.n3'))
     .sort((a, b) => a.localeCompare(b));
-
-  info(`Running ${files.length} examples tests`);
+  const proofFiles = fs.existsSync(proofDir)
+    ? fs
+        .readdirSync(proofDir)
+        .filter((f) => f.endsWith('.n3') && fs.existsSync(path.join(examplesDir, f)))
+        .sort((a, b) => a.localeCompare(b))
+    : [];
+  const totalTests = files.length + proofFiles.length;
+
+  info(`Running ${files.length} examples tests and ${proofFiles.length} proof golden tests`);
   console.log(`${C.dim}${getEyelingVersion(nodePath, eyelingJsPath, root)}; node ${process.version}${C.n}`);
 
   if (files.length === 0) {
@@ -178,6 +255,7 @@ function main() {
 
   // Pretty, stable numbering (e.g., 001..100 when running 100 tests)
   const idxWidth = String(files.length).length;
+  const proofIdxWidth = String(Math.max(proofFiles.length, 1)).length;
 
   for (let i = 0; i < files.length; i++) {
     const idx = String(i + 1).padStart(idxWidth, '0');
@@ -221,38 +299,7 @@ function main() {
     //   node eyeling.js --builtin examples/builtin/foo.js examples/foo.n3
     // A matching examples/input/<stem>.trig sidecar is external RDF/TriG
     // evidence for this example, so include it and run in -r mode automatically.
-    const builtin = resolveExampleBuiltinPath(root, file);
-    const trigInput = resolveExampleTrigInput(root, file);
-    const rdfMode = !!trigInput;
-    const outFd = fs.openSync(generatedPath, 'w');
-    let r;
-    try {
-      if (builtin) {
-        const args = [eyelingJsPath, '-d'];
-        if (rdfMode) args.push('-r');
-        args.push('--builtin', builtin.rel, path.join('examples', file));
-        if (trigInput) args.push(path.join('examples', trigInput.rel));
-        r = cp.spawnSync(nodePath, args, {
-          cwd: root,
-          stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
-          maxBuffer: 200 * 1024 * 1024,
-          encoding: 'utf8',
-        });
-      } else {
-        const args = [eyelingJsPath, '-d'];
-        if (rdfMode) args.push('-r');
-        args.push(file);
-        if (trigInput) args.push(trigInput.rel);
-        r = cp.spawnSync(nodePath, args, {
-          cwd: examplesDir,
-          stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
-          maxBuffer: 200 * 1024 * 1024,
-          encoding: 'utf8',
-        });
-      }
-    } finally {
-      fs.closeSync(outFd);
-    }
+    const r = runExampleToFile({ root, examplesDir, eyelingJsPath, nodePath, file, generatedPath });
 
     const rc = r.status == null ? 1 : r.status;
 
@@ -261,12 +308,7 @@ function main() {
     // Compare output. N3 outputs are order-insensitive; Markdown outputs are order-sensitive.
     let diffOk = false;
     try {
-      const expectedText = fs.readFileSync(expectedPath, 'utf8');
-      const generatedText = fs.readFileSync(generatedPath, 'utf8');
-      if (expectedText == null) throw new Error('missing expected output');
-      diffOk =
-        normalizeForCompare(expectedText, expectedPath) ===
-        normalizeForCompare(generatedText, expectedPath);
+      diffOk = compareGeneratedOutput({ expectedPath, generatedPath, sourceText: n3Text, proof: false });
     } catch {
       diffOk = false;
     }
@@ -302,15 +344,76 @@ function main() {
     if (tmpDir) rmrf(tmpDir);
   }
 
+
+  for (let i = 0; i < proofFiles.length; i++) {
+    const idx = String(i + 1).padStart(proofIdxWidth, '0');
+    const file = proofFiles[i];
+    const start = Date.now();
+    const filePath = path.join(examplesDir, file);
+    const expectedPath = path.join(proofDir, file);
+
+    let n3Text;
+    try {
+      n3Text = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      const ms = Date.now() - start;
+      fail(`proof ${idx} ${file} ${msTag(ms)}`);
+      fail(`Cannot read proof input: ${e.message}`);
+      failed++;
+      continue;
+    }
+
+    const expectedRc = expectedExitCode(n3Text);
+    const tmpDir = mkTmpDir();
+    const generatedPath = path.join(tmpDir, 'generated.n3');
+    const r = runExampleToFile({ root, examplesDir, eyelingJsPath, nodePath, file, generatedPath, proof: true });
+    const rc = r.status == null ? 1 : r.status;
+    const ms = Date.now() - start;
+
+    let diffOk = false;
+    try {
+      diffOk = compareGeneratedOutput({ expectedPath, generatedPath, sourceText: n3Text, proof: true });
+    } catch {
+      diffOk = false;
+    }
+
+    const rcOk = rc === expectedRc;
+
+    if (diffOk && rcOk) {
+      if (expectedRc === 0) {
+        ok(`proof ${idx} ${file} ${msTag(ms)}`);
+      } else {
+        ok(`proof ${idx} ${file} (expected exit ${expectedRc}) ${msTag(ms)}`);
+      }
+      passed++;
+    } else {
+      fail(`proof ${idx} ${file} ${msTag(ms)}`);
+      if (!rcOk) {
+        fail(`Exit code ${rc}, expected ${expectedRc}`);
+      }
+      if (!diffOk) {
+        fail('Proof output differs');
+      }
+      showDiff({
+        examplesDir,
+        expectedPath,
+        generatedPath,
+      });
+      failed++;
+    }
+
+    if (tmpDir) rmrf(tmpDir);
+  }
+
   console.log('');
   const suiteMs = Date.now() - suiteStart;
   info(`Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
 
   if (failed === 0) {
-    ok(`All examples tests passed (${passed}/${files.length})`);
+    ok(`All examples tests passed (${passed}/${totalTests})`);
     process.exit(0);
   } else {
-    fail(`Some examples tests failed (${passed}/${files.length})`);
+    fail(`Some examples tests failed (${passed}/${totalTests})`);
     // keep exit code 2 (matches historical behavior of examples/test)
     process.exit(2);
   }