eyeling 1.7.17 → 1.7.18

package/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-### Copyright 2021-2026 Jos De Roo, KNoWS office of IDLab, Ghent University - imec
+### Copyright 2025-2026 Jos De Roo, KNoWS office of IDLab, Ghent University - imec
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -17,13 +17,14 @@ A [Notation3 (N3)](https://notation3.org/) reasoner in **JavaScript**.
 Try it here:
 
 - [Eyeling playground](https://eyereasoner.github.io/eyeling/demo)
-- [Eyeling streaming playground](https://eyereasoner.github.io/eyeling/stream)
-
-The playground runs `eyeling` client-side. You can:
+  - Edit an N3 program directly.
+  - Load an N3 program from a URL (in the "Load N3 from URL" box or as ?url=...).
+  - Share a link with the program encoded in the URL fragment (`#...`).
 
-- edit an N3 program directly
-- load an N3 program from a URL (in the "Load N3 from URL" box or as ?url=...)
-- share a link with the program encoded in the URL fragment (`#...`)
+- [Eyeling streaming playground](https://eyereasoner.github.io/eyeling/stream)
+  - Browse a Wikidata entity, load its facts, and see Eyeling’s **deductive closure appear incrementally** as triples are derived.
+  - Edit **N3 rules live** and re-run to watch how different inference rules change what gets derived.
+  - Demo **CORS-safe dynamic fetching**: derived “fetch requests” can trigger extra facts (e.g., Wikiquote extracts) that are injected and re-reasoned.
 
 ## Quick start
 
@@ -120,6 +121,7 @@ Options:
   -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.
+  --enforce-https         Rewrite http:// IRIs to https:// for log dereferencing builtins.
 ```
 
 By default, `eyeling`:
@@ -165,6 +167,7 @@ The CLI prints only newly derived forward facts.
 - backward rules are indexed by head predicate
 - the backward prover is **iterative** (explicit stack), so deep chains won’t blow the JS call stack
 - for very deep backward chains, substitutions may be compactified (semantics-preserving) to avoid quadratic “copy a growing substitution object” behavior
+- if the head is **structurally ground** and has no head blanks, one body proof suffices—and if the head triples are already known, we can skip the body proof.
 
 ## Blank nodes and quantification
 
@@ -202,7 +205,7 @@ Rules whose conclusion is `false` are treated as hard failures:
 
 As soon as the premise is provable, `eyeling` exits with status code `2`.
 
-## Syntax + built-ins
+## Syntax
 
 `eyeling`’s parser targets (nearly) the full *Notation3 Language* grammar from the [W3C N3 Community Group spec](https://w3c.github.io/N3/spec/).
 
@@ -223,14 +226,9 @@ Commonly used N3/Turtle features:
 - Resource paths (`!` and `^`)
 - `#` line comments
 
-`eyeling` implements a pragmatic subset of common N3 builtin families and evaluates them during backward goal proving:
+## Builtins
 
-- **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
-- **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:rest` `list:reverse` `list:sort`
-- **log**: `log:collectAllIn` `log:content` `log:dtlit` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:includes` `log:langlit` `log:notEqualTo` `log:notIncludes` `log:outputString` `log:parsedAsN3` `log:rawType` `log:semantics` `log:semanticsOrError` `log:skolem` `log:trace` `log:uri`
-- **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:integerQuotient` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
-- **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:jsonPointer` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
-- **time**: `time:day` `time:hour` `time:localTime` `time:minute` `time:month` `time:second` `time:timeZone` `time:year`
+`eyeling` implements the builtins described in [eyeling-builtins](https://github.com/eyereasoner/eyeling/blob/main/eyeling-builtins.ttl).
 
 ## License
 

package/eyeling.js

@@ -104,6 +104,17 @@ const __logSemanticsCache = new Map(); // iri -> GraphTerm | null (null means pa
 const __logSemanticsOrErrorCache = new Map(); // iri -> Term (GraphTerm | Literal) for log:semanticsOrError
 const __logConclusionCache = new WeakMap(); // GraphTerm -> GraphTerm (deductive closure)
 
+// When enabled, force http:// IRIs to be dereferenced as https://
+// (CLI: --enforce-https, API: reasonStream({ enforceHttps: true })).
+let enforceHttpsEnabled = false;
+
+function __maybeEnforceHttps(iri) {
+  if (!enforceHttpsEnabled) return iri;
+  return typeof iri === 'string' && iri.startsWith('http://')
+    ? 'https://' + iri.slice('http://'.length)
+    : iri;
+}
+
 // 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.
@@ -150,9 +161,9 @@ function __fetchHttpTextSyncBrowser(url) {
 
 function __normalizeDerefIri(iriNoFrag) {
   // In Node, treat non-http as local path; leave as-is.
-  if (__IS_NODE) return iriNoFrag;
+  if (__IS_NODE) return __maybeEnforceHttps(iriNoFrag);
   // In browsers/workers, resolve relative references against the page URL.
-  return __resolveBrowserUrl(iriNoFrag);
+  return __maybeEnforceHttps(__resolveBrowserUrl(iriNoFrag));
 }
 
 function __stripFragment(iri) {
@@ -195,9 +206,17 @@ function __fetchHttpTextViaSubprocess(url) {
   const cp = require('child_process');
   // Use a subprocess so this code remains synchronous without rewriting the whole reasoner to async.
   const script = `
+    const enforceHttps = ${enforceHttpsEnabled ? 'true' : 'false'};
     const url = process.argv[1];
     const maxRedirects = 10;
+    function norm(u) {
+      if (enforceHttps && typeof u === 'string' && u.startsWith('http://')) {
+        return 'https://' + u.slice('http://'.length);
+      }
+      return u;
+    }
     function get(u, n) {
+      u = norm(u);
       if (n > maxRedirects) { console.error('Too many redirects'); process.exit(3); }
       let mod;
       if (u.startsWith('https://')) mod = require('https');
@@ -219,7 +238,8 @@ function __fetchHttpTextViaSubprocess(url) {
       const req = mod.request(opts, (res) => {
         const sc = res.statusCode || 0;
         if (sc >= 300 && sc < 400 && res.headers && res.headers.location) {
-          const next = new URL(res.headers.location, u).toString();
+          let next = new URL(res.headers.location, u).toString();
+          next = norm(next);
           res.resume();
           return get(next, n + 1);
         }
@@ -6991,8 +7011,16 @@ function __collectOutputStringsFromFacts(facts, prefixes) {
 }
 
 function reasonStream(n3Text, opts = {}) {
-  const { baseIri = null, proof = false, onDerived = null, includeInputFactsInClosure = true } = opts;
-
+  const {
+    baseIri = null,
+    proof = false,
+    onDerived = null,
+    includeInputFactsInClosure = true,
+    enforceHttps = false,
+  } = opts;
+
+  const __oldEnforceHttps = enforceHttpsEnabled;
+  enforceHttpsEnabled = !!enforceHttps;
   proofCommentsEnabled = !!proof;
 
   const toks = lex(n3Text);
@@ -7020,12 +7048,14 @@ function reasonStream(n3Text, opts = {}) {
 
   const closureTriples = includeInputFactsInClosure ? facts : derived.map((d) => d.fact);
 
-  return {
+  const __out = {
     prefixes,
     facts, // saturated closure (Triple[])
     derived, // DerivedFact[]
     closureN3: closureTriples.map((t) => tripleToN3(t, prefixes)).join('\n'),
   };
+  enforceHttpsEnabled = __oldEnforceHttps;
+  return __out;
 }
 
 // Minimal export surface for Node + browser/worker
@@ -7056,7 +7086,8 @@ function main() {
       `  -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` +
-      `  --strings               Print log:outputString strings (ordered by key) instead of N3 output.\n`;
+      `  --strings               Print log:outputString strings (ordered by key) instead of N3 output.\n` +
+      `  --enforce-https         Rewrite http:// IRIs to https:// for log dereferencing builtins.\n`;
     (toStderr ? console.error : console.log)(msg);
   }
 
@@ -7079,6 +7110,11 @@ function main() {
 
   const outputStringsMode = argv.includes('--strings');
 
+  // --enforce-https: rewrite http:// -> https:// for log dereferencing builtins
+  if (argv.includes('--enforce-https')) {
+    enforceHttpsEnabled = true;
+  }
+
   // --proof-comments / -p: enable proof explanations
   if (argv.includes('--proof-comments') || argv.includes('-p')) {
     proofCommentsEnabled = true;

package/package.json

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