eyeling 1.19.4 → 1.19.6

package/eyeling.js

@@ -8133,6 +8133,18 @@ function __printTriggeredFuse(rule, prefixes, subst /* optional */, extraNote /*
   }
 }
 
+function __exitReasoning(code, message /* optional */) {
+  if (typeof process !== 'undefined' && process && typeof process.exit === 'function') {
+    process.exit(code);
+    return;
+  }
+
+  const err = new Error(message || `Process exited with code ${code}`);
+  err.__eyelingExit = true;
+  err.code = code;
+  throw err;
+}
+
 function forwardChain(facts, forwardRules, backRules, onDerived /* optional */, opts = {}) {
   enterReasoningRun();
   try {
@@ -8272,7 +8284,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         // Allow dynamic fuses: ... => ?X. where ?X becomes false
         if (dynTerm instanceof Literal && dynTerm.value === 'false') {
           __printTriggeredFuse(r, opts && opts.prefixes, s, 'Dynamic head resolved to false.');
-          process.exit(2);
+          __exitReasoning(2, 'Inference fuse triggered.');
         }
 
         const dynTriples = __graphTriplesOrTrue(dynTerm);
@@ -8300,10 +8312,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         const objIsGraph = obj instanceof GraphTerm;
         const subjIsTrue = subj instanceof Literal && subj.value === 'true';
         const objIsTrue = obj instanceof Literal && obj.value === 'true';
+        const objIsFalse = obj instanceof Literal && obj.value === 'false';
 
         const isFwRuleTriple =
-          isLogImplies(instantiated.p) &&
-          ((subjIsGraph && objIsGraph) || (subjIsTrue && objIsGraph) || (subjIsGraph && objIsTrue));
+          isLogImplies(instantiated.p) && (subjIsGraph || subjIsTrue) && (objIsGraph || objIsTrue || objIsFalse);
 
         const isBwRuleTriple =
           isLogImpliedBy(instantiated.p) &&
@@ -8318,47 +8330,39 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
             changedHere = true;
           }
 
-          // Promote rule-producing triples to live rules, treating literal true as {}.
-          const left = __graphTriplesOrTrue(subj);
-          const right = __graphTriplesOrTrue(obj);
-
-          if (left !== null && right !== null) {
-            if (isFwRuleTriple) {
-              const [premise, conclusion] = liftBlankRuleVars(left, right);
-              const headBlankLabels = collectBlankLabelsInTriples(conclusion);
-              const newRule = new Rule(premise, conclusion, true, false, headBlankLabels);
-              __prepareForwardRule(newRule);
-
-              const key = __ruleKey(
-                newRule.isForward,
-                newRule.isFuse,
-                newRule.premise,
-                newRule.conclusion,
-                newRule.__dynamicConclusionTerm || null,
-              );
-              if (!forwardRules.__ruleKeySet.has(key)) {
-                forwardRules.__ruleKeySet.add(key);
-                forwardRules.push(newRule);
-                rulesChanged = true;
-              }
-            } else if (isBwRuleTriple) {
-              const [premise, conclusion] = liftBlankRuleVars(right, left);
-              const headBlankLabels = collectBlankLabelsInTriples(conclusion);
-              const newRule = new Rule(premise, conclusion, false, false, headBlankLabels);
-
-              const key = __ruleKey(
-                newRule.isForward,
-                newRule.isFuse,
-                newRule.premise,
-                newRule.conclusion,
-                newRule.__dynamicConclusionTerm || null,
-              );
-              if (!backRules.__ruleKeySet.has(key)) {
-                backRules.__ruleKeySet.add(key);
-                backRules.push(newRule);
-                indexBackRule(backRules, newRule);
-                rulesChanged = true;
-              }
+          // 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);
+            __prepareForwardRule(newRule);
+
+            const key = __ruleKey(
+              newRule.isForward,
+              newRule.isFuse,
+              newRule.premise,
+              newRule.conclusion,
+              newRule.__dynamicConclusionTerm || null,
+            );
+            if (!forwardRules.__ruleKeySet.has(key)) {
+              forwardRules.__ruleKeySet.add(key);
+              forwardRules.push(newRule);
+              rulesChanged = true;
+            }
+          } else if (isBwRuleTriple) {
+            const newRule = __makeRuleFromTerms(subj, obj, false);
+
+            const key = __ruleKey(
+              newRule.isForward,
+              newRule.isFuse,
+              newRule.premise,
+              newRule.conclusion,
+              newRule.__dynamicConclusionTerm || null,
+            );
+            if (!backRules.__ruleKeySet.has(key)) {
+              backRules.__ruleKeySet.add(key);
+              backRules.push(newRule);
+              indexBackRule(backRules, newRule);
+              rulesChanged = true;
             }
           }
 
@@ -8441,7 +8445,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           // Inference fuse
           if (r.isFuse && sols.length) {
             __printTriggeredFuse(r, opts && opts.prefixes, sols[0]);
-            process.exit(2);
+            __exitReasoning(2, 'Inference fuse triggered.');
           }
 
           for (const s of sols) {

package/lib/engine.js

@@ -2651,6 +2651,18 @@ function __printTriggeredFuse(rule, prefixes, subst /* optional */, extraNote /*
   }
 }
 
+function __exitReasoning(code, message /* optional */) {
+  if (typeof process !== 'undefined' && process && typeof process.exit === 'function') {
+    process.exit(code);
+    return;
+  }
+
+  const err = new Error(message || `Process exited with code ${code}`);
+  err.__eyelingExit = true;
+  err.code = code;
+  throw err;
+}
+
 function forwardChain(facts, forwardRules, backRules, onDerived /* optional */, opts = {}) {
   enterReasoningRun();
   try {
@@ -2790,7 +2802,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         // Allow dynamic fuses: ... => ?X. where ?X becomes false
         if (dynTerm instanceof Literal && dynTerm.value === 'false') {
           __printTriggeredFuse(r, opts && opts.prefixes, s, 'Dynamic head resolved to false.');
-          process.exit(2);
+          __exitReasoning(2, 'Inference fuse triggered.');
         }
 
         const dynTriples = __graphTriplesOrTrue(dynTerm);
@@ -2818,10 +2830,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         const objIsGraph = obj instanceof GraphTerm;
         const subjIsTrue = subj instanceof Literal && subj.value === 'true';
         const objIsTrue = obj instanceof Literal && obj.value === 'true';
+        const objIsFalse = obj instanceof Literal && obj.value === 'false';
 
         const isFwRuleTriple =
-          isLogImplies(instantiated.p) &&
-          ((subjIsGraph && objIsGraph) || (subjIsTrue && objIsGraph) || (subjIsGraph && objIsTrue));
+          isLogImplies(instantiated.p) && (subjIsGraph || subjIsTrue) && (objIsGraph || objIsTrue || objIsFalse);
 
         const isBwRuleTriple =
           isLogImpliedBy(instantiated.p) &&
@@ -2836,47 +2848,39 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
             changedHere = true;
           }
 
-          // Promote rule-producing triples to live rules, treating literal true as {}.
-          const left = __graphTriplesOrTrue(subj);
-          const right = __graphTriplesOrTrue(obj);
-
-          if (left !== null && right !== null) {
-            if (isFwRuleTriple) {
-              const [premise, conclusion] = liftBlankRuleVars(left, right);
-              const headBlankLabels = collectBlankLabelsInTriples(conclusion);
-              const newRule = new Rule(premise, conclusion, true, false, headBlankLabels);
-              __prepareForwardRule(newRule);
-
-              const key = __ruleKey(
-                newRule.isForward,
-                newRule.isFuse,
-                newRule.premise,
-                newRule.conclusion,
-                newRule.__dynamicConclusionTerm || null,
-              );
-              if (!forwardRules.__ruleKeySet.has(key)) {
-                forwardRules.__ruleKeySet.add(key);
-                forwardRules.push(newRule);
-                rulesChanged = true;
-              }
-            } else if (isBwRuleTriple) {
-              const [premise, conclusion] = liftBlankRuleVars(right, left);
-              const headBlankLabels = collectBlankLabelsInTriples(conclusion);
-              const newRule = new Rule(premise, conclusion, false, false, headBlankLabels);
-
-              const key = __ruleKey(
-                newRule.isForward,
-                newRule.isFuse,
-                newRule.premise,
-                newRule.conclusion,
-                newRule.__dynamicConclusionTerm || null,
-              );
-              if (!backRules.__ruleKeySet.has(key)) {
-                backRules.__ruleKeySet.add(key);
-                backRules.push(newRule);
-                indexBackRule(backRules, newRule);
-                rulesChanged = true;
-              }
+          // 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);
+            __prepareForwardRule(newRule);
+
+            const key = __ruleKey(
+              newRule.isForward,
+              newRule.isFuse,
+              newRule.premise,
+              newRule.conclusion,
+              newRule.__dynamicConclusionTerm || null,
+            );
+            if (!forwardRules.__ruleKeySet.has(key)) {
+              forwardRules.__ruleKeySet.add(key);
+              forwardRules.push(newRule);
+              rulesChanged = true;
+            }
+          } else if (isBwRuleTriple) {
+            const newRule = __makeRuleFromTerms(subj, obj, false);
+
+            const key = __ruleKey(
+              newRule.isForward,
+              newRule.isFuse,
+              newRule.premise,
+              newRule.conclusion,
+              newRule.__dynamicConclusionTerm || null,
+            );
+            if (!backRules.__ruleKeySet.has(key)) {
+              backRules.__ruleKeySet.add(key);
+              backRules.push(newRule);
+              indexBackRule(backRules, newRule);
+              rulesChanged = true;
             }
           }
 
@@ -2959,7 +2963,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           // Inference fuse
           if (r.isFuse && sols.length) {
             __printTriggeredFuse(r, opts && opts.prefixes, sols[0]);
-            process.exit(2);
+            __exitReasoning(2, 'Inference fuse triggered.');
           }
 
           for (const s of sols) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.19.4",
+  "version": "1.19.6",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -43,10 +43,11 @@
     "test:builtin-contract": "node test/builtin-contract.test.js",
     "test:n3gen": "node test/n3gen.test.js",
     "test:examples": "node test/examples.test.js",
+    "test:extra": "node test/extra.test.js",
     "test:manifest": "node test/manifest.test.js",
     "test:playground": "node test/playground.test.js",
     "test:package": "node test/package.test.js",
-    "test:all": "npm run test:api && npm run test:builtin-contract && npm run test:n3gen && npm run test:examples && npm run test:manifest && npm run test:playground",
+    "test:all": "npm run test:api && npm run test:builtin-contract && npm run test:n3gen && npm run test:examples && npm run test:extra && npm run test:manifest && npm run test:playground",
     "pretest": "npm run build && npm run test:packlist",
     "test": "npm run test:all",
     "posttest": "npm run test:package",

package/test/extra.test.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const TTY = process.stdout.isTTY;
+const C = TTY
+  ? { g: '\x1b[32m', r: '\x1b[31m', y: '\x1b[33m', dim: '\x1b[2m', n: '\x1b[0m' }
+  : { g: '', r: '', y: '', dim: '', n: '' };
+const msTag = (ms) => `${C.dim}(${ms} ms)${C.n}`;
+
+function ok(msg) {
+  console.log(`${C.g}OK${C.n}  ${msg}`);
+}
+function fail(msg) {
+  console.error(`${C.r}FAIL${C.n} ${msg}`);
+}
+function info(msg) {
+  console.log(`${C.y}==${C.n} ${msg}`);
+}
+
+function main() {
+  const suiteStart = Date.now();
+  const root = path.resolve(__dirname, '..');
+  const extraDir = path.join(root, 'examples', 'extra');
+  const outputDir = path.join(extraDir, 'output');
+  const nodePath = process.execPath;
+
+  if (!fs.existsSync(extraDir)) {
+    fail(`Cannot find examples/extra directory: ${extraDir}`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const files = fs
+    .readdirSync(extraDir)
+    .filter((f) => f.endsWith('.js'))
+    .sort((a, b) => a.localeCompare(b));
+
+  info(`Running ${files.length} extra examples`);
+  console.log(`${C.dim}node ${process.version}${C.n}`);
+
+  if (files.length === 0) {
+    ok('No .js files found in examples/extra/');
+    process.exit(0);
+  }
+
+  let passed = 0;
+  let failed = 0;
+  const idxWidth = String(files.length).length;
+
+  for (let i = 0; i < files.length; i += 1) {
+    const idx = String(i + 1).padStart(idxWidth, '0');
+    const file = files[i];
+    const start = Date.now();
+
+    const inputPath = path.join(extraDir, file);
+    const outputPath = path.join(outputDir, file.replace(/\.js$/i, '.txt'));
+
+    const r = cp.spawnSync(nodePath, [inputPath], {
+      cwd: extraDir,
+      encoding: 'utf8',
+      maxBuffer: 200 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const stdout = r.stdout || '';
+    fs.writeFileSync(outputPath, stdout, 'utf8');
+
+    const rc = r.status == null ? 1 : r.status;
+    const ms = Date.now() - start;
+
+    if (rc === 0) {
+      ok(`${idx} ${file} -> output/${path.basename(outputPath)} ${msTag(ms)}`);
+      passed += 1;
+    } else {
+      fail(`${idx} ${file} ${msTag(ms)}`);
+      fail(`Exit code ${rc}`);
+      if (r.stderr) process.stderr.write(r.stderr);
+      failed += 1;
+    }
+  }
+
+  console.log('');
+  const suiteMs = Date.now() - suiteStart;
+  info(`Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
+
+  if (failed === 0) {
+    ok(`All extra examples passed (${passed}/${files.length})`);
+    process.exit(0);
+  }
+
+  fail(`Some extra examples failed (${passed}/${files.length})`);
+  process.exit(2);
+}
+
+main();