eyeling 1.7.6 → 1.7.8

package/README.md

@@ -108,6 +108,7 @@ Options:
   -n, --no-proof-comments Disable proof explanations (default).
   -s, --super-restricted  Disable all builtins except => and <=.
   -a, --ast               Print parsed AST as JSON and exit.
+  --strings               Print log:outputString strings (ordered by key) instead of N3 output.
 ```
 
 By default, `eyeling`:

package/eyeling.js

@@ -91,6 +91,61 @@ const __logContentCache = new Map(); // iri -> string | null (null means fetch/r
 const __logSemanticsCache = new Map(); // iri -> GraphTerm | null (null means parse failed)
 const __logConclusionCache = new WeakMap(); // GraphTerm -> GraphTerm (deductive closure)
 
+// Environment detection (Node vs Browser/Worker).
+// Eyeling is primarily synchronous, so we use sync XHR in browsers for log:content/log:semantics.
+// Note: Browser fetches are subject to CORS; use CORS-enabled resources or a proxy.
+const __IS_NODE =
+  typeof process !== 'undefined' &&
+  !!(process.versions && process.versions.node);
+
+function __hasXmlHttpRequest() {
+  return typeof XMLHttpRequest !== 'undefined';
+}
+
+function __resolveBrowserUrl(ref) {
+  if (!ref) return ref;
+  // If already absolute, keep as-is.
+  if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(ref)) return ref;
+  const base =
+    (typeof document !== 'undefined' && document.baseURI) ||
+    (typeof location !== 'undefined' && location.href) ||
+    '';
+  try {
+    return new URL(ref, base).toString();
+  } catch {
+    return ref;
+  }
+}
+
+function __fetchHttpTextSyncBrowser(url) {
+  if (!__hasXmlHttpRequest()) return null;
+  try {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, false); // synchronous
+    try {
+      xhr.setRequestHeader(
+        'Accept',
+        'text/n3, text/turtle, application/n-triples, application/n-quads, text/plain;q=0.1, */*;q=0.01'
+      );
+    } catch {
+      // Some environments restrict setting headers (ignore).
+    }
+    xhr.send(null);
+    const sc = xhr.status || 0;
+    if (sc < 200 || sc >= 300) return null;
+    return xhr.responseText;
+  } catch {
+    return null;
+  }
+}
+
+function __normalizeDerefIri(iriNoFrag) {
+  // In Node, treat non-http as local path; leave as-is.
+  if (__IS_NODE) return iriNoFrag;
+  // In browsers/workers, resolve relative references against the page URL.
+  return __resolveBrowserUrl(iriNoFrag);
+}
+
 function __stripFragment(iri) {
   const i = iri.indexOf('#');
   return i >= 0 ? iri.slice(0, i) : iri;
@@ -115,6 +170,7 @@ function __fileIriToPath(fileIri) {
 }
 
 function __readFileText(pathOrFileIri) {
+  if (!__IS_NODE) return null;
   const fs = require('fs');
   let path = pathOrFileIri;
   if (__isFileIri(pathOrFileIri)) path = __fileIriToPath(pathOrFileIri);
@@ -126,6 +182,7 @@ function __readFileText(pathOrFileIri) {
 }
 
 function __fetchHttpTextViaSubprocess(url) {
+  if (!__IS_NODE) return null;
   const cp = require('child_process');
   // Use a subprocess so this code remains synchronous without rewriting the whole reasoner to async.
   const script = `
@@ -181,16 +238,27 @@ function __fetchHttpTextViaSubprocess(url) {
 }
 
 function __derefTextSync(iriNoFrag) {
-  if (__logContentCache.has(iriNoFrag)) return __logContentCache.get(iriNoFrag);
+  const norm = __normalizeDerefIri(iriNoFrag);
+  const key = typeof norm === 'string' && norm ? norm : iriNoFrag;
+
+  if (__logContentCache.has(key)) return __logContentCache.get(key);
 
   let text = null;
-  if (__isHttpIri(iriNoFrag)) {
-    text = __fetchHttpTextViaSubprocess(iriNoFrag);
+
+  if (__IS_NODE) {
+    if (__isHttpIri(key)) {
+      text = __fetchHttpTextViaSubprocess(key);
+    } else {
+      // Treat any non-http(s) IRI as a local path (including file://), for basic usability.
+      text = __readFileText(key);
+    }
   } else {
-    // Treat any non-http(s) IRI as a local path (including file://), for basic usability.
-    text = __readFileText(iriNoFrag);
+    // Browser / Worker: we can only dereference over HTTP(S), and it must pass CORS.
+    const url = typeof norm === 'string' && norm ? norm : key;
+    if (__isHttpIri(url)) text = __fetchHttpTextSyncBrowser(url);
   }
-  __logContentCache.set(iriNoFrag, text);
+
+  __logContentCache.set(key, text);
   return text;
 }
 
@@ -218,19 +286,22 @@ function __parseSemanticsToFormula(text, baseIri) {
 }
 
 function __derefSemanticsSync(iriNoFrag) {
-  if (__logSemanticsCache.has(iriNoFrag)) return __logSemanticsCache.get(iriNoFrag);
+  const norm = __normalizeDerefIri(iriNoFrag);
+  const key = typeof norm === 'string' && norm ? norm : iriNoFrag;
+  if (__logSemanticsCache.has(key)) return __logSemanticsCache.get(key);
 
   const text = __derefTextSync(iriNoFrag);
   if (typeof text !== 'string') {
-    __logSemanticsCache.set(iriNoFrag, null);
+    __logSemanticsCache.set(key, null);
     return null;
   }
   try {
-    const formula = __parseSemanticsToFormula(text, iriNoFrag);
-    __logSemanticsCache.set(iriNoFrag, formula);
+    const baseIri = (typeof key === 'string' && key) ? key : iriNoFrag;
+      const formula = __parseSemanticsToFormula(text, baseIri);
+    __logSemanticsCache.set(key, formula);
     return formula;
   } catch {
-    __logSemanticsCache.set(iriNoFrag, null);
+    __logSemanticsCache.set(key, null);
     return null;
   }
 }
@@ -5229,6 +5300,21 @@ if (pv === LOG_NS + 'conclusion') {
     return sols.length ? [] : [{ ...subst }];
   }
 
+  // log:outputString
+  // Schema: $s+ log:outputString $o+
+  // Side-effecting output directive. As a builtin goal, we simply succeed
+  // when both sides are bound and the object is a string literal.
+  // Actual printing is handled at the end of a reasoning run (see --strings).
+  if (pv === LOG_NS + 'outputString') {
+    // Require subject to be bound (not a variable) and object to be a concrete string literal.
+    if (g.s instanceof Var) return [];
+    if (g.o instanceof Var) return [];
+    const s = termToJsString(g.o);
+    if (s === null) return [];
+    return [{ ...subst }];
+  }
+
+
   // log:collectAllIn (scoped)
   if (pv === LOG_NS + 'collectAllIn') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 3) return [];
@@ -6277,6 +6363,97 @@ function formatN3SyntaxError(err, text, path) {
 // ===========================================================================
 // CLI entry point
 // ===========================================================================
+// ===========================================================================
+// log:outputString support
+// ===========================================================================
+
+function __compareOutputStringKeys(a, b, prefixes) {
+  // Deterministic ordering of keys. The spec only requires "order of the subject keys"
+  // and leaves concrete term ordering reasoner-dependent. We implement:
+  //   1) numeric literals (numeric value)
+  //   2) plain literals (lexical form)
+  //   3) IRIs
+  //   4) blank nodes (label)
+  //   5) fallback: skolemKeyFromTerm
+  const aNum = parseNumericLiteralInfo(a);
+  const bNum = parseNumericLiteralInfo(b);
+  if (aNum && bNum) {
+    // bigint or number
+    if (aNum.kind === 'bigint' && bNum.kind === 'bigint') {
+      if (aNum.value < bNum.value) return -1;
+      if (aNum.value > bNum.value) return 1;
+      return 0;
+    }
+    const av = Number(aNum.value);
+    const bv = Number(bNum.value);
+    if (av < bv) return -1;
+    if (av > bv) return 1;
+    return 0;
+  }
+  if (aNum && !bNum) return -1;
+  if (!aNum && bNum) return 1;
+
+  // Plain literal ordering (lexical)
+  if (a instanceof Literal && b instanceof Literal) {
+    const [alex] = literalParts(a.value);
+    const [blex] = literalParts(b.value);
+    if (alex < blex) return -1;
+    if (alex > blex) return 1;
+    return 0;
+  }
+  if (a instanceof Literal && !(b instanceof Literal)) return -1;
+  if (!(a instanceof Literal) && b instanceof Literal) return 1;
+
+  // IRIs
+  if (a instanceof Iri && b instanceof Iri) {
+    if (a.value < b.value) return -1;
+    if (a.value > b.value) return 1;
+    return 0;
+  }
+  if (a instanceof Iri && !(b instanceof Iri)) return -1;
+  if (!(a instanceof Iri) && b instanceof Iri) return 1;
+
+  // Blank nodes
+  if (a instanceof Blank && b instanceof Blank) {
+    if (a.label < b.label) return -1;
+    if (a.label > b.label) return 1;
+    return 0;
+  }
+  if (a instanceof Blank && !(b instanceof Blank)) return -1;
+  if (!(a instanceof Blank) && b instanceof Blank) return 1;
+
+  // Fallback
+  const ak = skolemKeyFromTerm(a);
+  const bk = skolemKeyFromTerm(b);
+  if (ak < bk) return -1;
+  if (ak > bk) return 1;
+  return 0;
+}
+
+function __collectOutputStringsFromFacts(facts, prefixes) {
+  // Gather all (key, string) pairs from the saturated fact store.
+  const pairs = [];
+  for (const tr of facts) {
+    if (!(tr && tr.p instanceof Iri)) continue;
+    if (tr.p.value !== LOG_NS + 'outputString') continue;
+    if (!(tr.o instanceof Literal)) continue;
+
+    const s = termToJsString(tr.o);
+    if (s === null) continue;
+
+    pairs.push({ key: tr.s, text: s, idx: pairs.length });
+  }
+
+  pairs.sort((a, b) => {
+    const c = __compareOutputStringKeys(a.key, b.key, prefixes);
+    if (c !== 0) return c;
+    return a.idx - b.idx; // stable tie-breaker
+  });
+
+  return pairs.map((p) => p.text).join('');
+}
+
+
 function main() {
   // Drop "node" and script name; keep only user-provided args
   const argv = process.argv.slice(2);
@@ -6293,7 +6470,8 @@ function main() {
       `  -p, --proof-comments    Enable proof explanations.\n` +
       `  -n, --no-proof-comments Disable proof explanations (default).\n` +
       `  -s, --super-restricted  Disable all builtins except => and <=.\n` +
-      `  -a, --ast               Print parsed AST as JSON and exit.\n`;
+      `  -a, --ast               Print parsed AST as JSON and exit.\n` +
+      `  --strings               Print log:outputString strings (ordered by key) instead of N3 output.\n`;
     (toStderr ? console.error : console.log)(msg);
   }
 
@@ -6314,6 +6492,8 @@ function main() {
 
   const showAst = argv.includes('--ast') || argv.includes('-a');
 
+  const outputStringsMode = argv.includes('--strings');
+
   // --proof-comments / -p: enable proof explanations
   if (argv.includes('--proof-comments') || argv.includes('-p')) {
     proofCommentsEnabled = true;
@@ -6389,6 +6569,12 @@ function main() {
 
   const facts = triples.filter((tr) => isGroundTriple(tr));
   const derived = forwardChain(facts, frules, brules);
+  // If requested, print log:outputString values (ordered by subject key) and exit.
+  if (outputStringsMode) {
+    const out = __collectOutputStringsFromFacts(facts, prefixes);
+    if (out) process.stdout.write(out);
+    process.exit(0);
+  }
   const derivedTriples = derived.map((df) => df.fact);
   const usedPrefixes = prefixes.prefixesUsedForOutput(derivedTriples);
 

package/package.json

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