eyeling 1.7.7 → 1.7.9

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/examples/log-pan-rt-soe.n3

@@ -0,0 +1,29 @@
+# =======================================================
+# log:parsedAsN3 log:rawType log:semanticsOrError example
+# =======================================================
+
+@prefix :    <http://example.org/> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+:Let :param """
+@prefix : <http://example.org/> .
+:s :p :o .
+""" .
+
+{
+  :Let :param ?txt .
+  ?txt log:parsedAsN3 ?f .
+  ?f   log:rawType ?tParsed .
+
+  <https://www.w3.org/2000/10/swap/test/s2.n3> log:semanticsOrError ?x .
+  ?x log:rawType ?tRemote .
+}
+=>
+{
+  :parsedFormula :is ?f .
+  :parsedType    :is ?tParsed .
+  :remoteValue   :is ?x .
+  :remoteType    :is ?tRemote .
+} .
+

package/examples/output/log-pan-rt-soe.n3

@@ -0,0 +1,9 @@
+@prefix : <http://example.org/> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+:parsedFormula :is {
+    :s :p :o .
+} .
+:parsedType :is log:Formula .
+:remoteValue :is "error(dereference_failed,https://www.w3.org/2000/10/swap/test/s2.n3)" .
+:remoteType :is log:Literal .

package/eyeling.js

@@ -89,6 +89,7 @@ const jsonPointerCache = new Map();
 // Key is the dereferenced document IRI *without* fragment.
 const __logContentCache = new Map(); // iri -> string | null (null means fetch/read failed)
 const __logSemanticsCache = new Map(); // iri -> GraphTerm | null (null means parse failed)
+const __logSemanticsOrErrorCache = new Map(); // iri -> Term (GraphTerm | Literal) for log:semanticsOrError
 const __logConclusionCache = new WeakMap(); // GraphTerm -> GraphTerm (deductive closure)
 
 // Environment detection (Node vs Browser/Worker).
@@ -2971,6 +2972,23 @@ function stripQuotes(lex) {
   return lex;
 }
 
+function termToJsXsdStringNoLang(t) {
+  // Strict xsd:string extraction *without* language tags.
+  // Accept:
+  //   - plain string literals ("...")
+  //   - "..."^^xsd:string
+  // Reject:
+  //   - language-tagged strings ("..."@en)
+  //   - any other datatype
+  if (!(t instanceof Literal)) return null;
+  if (literalHasLangTag(t.value)) return null;
+
+  const [lex, dt] = literalParts(t.value);
+  if (!isQuotedLexical(lex)) return null;
+  if (dt !== null && dt !== XSD_NS + 'string' && dt !== 'xsd:string') return null;
+  return decodeN3StringEscapes(stripQuotes(lex));
+}
+
 function termToJsString(t) {
   // Strict string extraction for SWAP/N3 string builtins:
   //   - accept plain string literals ("...") and language-tagged ones ("..."@en)
@@ -5074,6 +5092,110 @@ if (pv === LOG_NS + 'conclusion') {
     return s2 !== null ? [s2] : [];
   }
 
+  // log:semanticsOrError
+  // Schema: $s+ log:semanticsOrError $o?
+  // Like log:semantics, but yields an xsd:string error message on failure.
+  if (pv === LOG_NS + 'semanticsOrError') {
+    const iri = iriValue(g.s);
+    if (iri === null) return [];
+
+    const docIri = __stripFragment(iri);
+    const norm = __normalizeDerefIri(docIri);
+    const key = typeof norm === 'string' && norm ? norm : docIri;
+
+    let term = null;
+
+    if (__logSemanticsOrErrorCache.has(key)) {
+      term = __logSemanticsOrErrorCache.get(key);
+    } else {
+      // If we already successfully computed log:semantics, reuse it.
+      const formula = __derefSemanticsSync(docIri);
+
+      if (formula instanceof GraphTerm) {
+        term = formula;
+      } else {
+        // Try to get an informative error.
+        const txt = __derefTextSync(docIri);
+        if (typeof txt !== 'string') {
+          term = makeStringLiteral(`error(dereference_failed,${docIri})`);
+        } else {
+          try {
+            const baseIri = typeof key === 'string' && key ? key : docIri;
+            term = __parseSemanticsToFormula(txt, baseIri);
+            // Keep the semantics cache consistent.
+            __logSemanticsCache.set(key, term);
+          } catch (e) {
+            const msg = e && e.message ? e.message : String(e);
+            term = makeStringLiteral(`error(parse_error,${msg})`);
+          }
+        }
+      }
+
+      __logSemanticsOrErrorCache.set(key, term);
+    }
+
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = term;
+      return [s2];
+    }
+    if (g.o instanceof Blank) return [{ ...subst }];
+
+    const s2 = unifyTerm(g.o, term, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // log:parsedAsN3
+  // Schema: $s+ log:parsedAsN3 $o-
+  // Parses the subject xsd:string as N3 and returns it as a formula.
+  if (pv === LOG_NS + 'parsedAsN3') {
+    const txt = termToJsXsdStringNoLang(g.s);
+    if (txt === null) return [];
+
+    let formula;
+    try {
+      // No external base is specified in the builtin definition; the parsed
+      // string may contain its own @base / @prefix directives.
+      formula = __parseSemanticsToFormula(txt, '');
+    } catch {
+      return [];
+    }
+
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = formula;
+      return [s2];
+    }
+    if (g.o instanceof Blank) return [{ ...subst }];
+
+    const s2 = unifyTerm(g.o, formula, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // log:rawType
+  // Schema: $s+ log:rawType $o-
+  // Returns one of log:Formula, log:Literal, rdf:List, or log:Other.
+  if (pv === LOG_NS + 'rawType') {
+    if (g.s instanceof Var) return [];
+
+    let ty;
+    if (g.s instanceof GraphTerm) ty = internIri(LOG_NS + 'Formula');
+    else if (g.s instanceof Literal) ty = internIri(LOG_NS + 'Literal');
+    else if (g.s instanceof ListTerm || g.s instanceof OpenListTerm) ty = internIri(RDF_NS + 'List');
+    else ty = internIri(LOG_NS + 'Other');
+
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = ty;
+      return [s2];
+    }
+    if (g.o instanceof Blank) return [{ ...subst }];
+
+    const s2 = unifyTerm(g.o, ty, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+
 
   // log:dtlit
   // Schema: ( $s.1? $s.2? )? log:dtlit $o?
@@ -5300,6 +5422,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 [];
@@ -6348,6 +6485,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);
@@ -6364,7 +6592,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);
   }
 
@@ -6385,6 +6614,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;
@@ -6460,6 +6691,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.7",
+  "version": "1.7.9",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [