eyeling 1.32.1 → 1.33.1

package/README.md

@@ -23,6 +23,7 @@ Eyeling is characterized by:
 - **Streaming RDF Messages** — supports RDF Messages streams, enabling Eyeling to fit into streaming RDF pipelines.
 - **Node.js, npm, and browser use** — run it from the command line, call it from JavaScript, or use the browser-oriented bundle.
 - **RDF-JS interoperability** — use N3 text, RDF-JS quads, datasets, or Eyeling’s own AST-level API, with TypeScript declarations grounded in `@rdfjs/types`.
+- **Experimental eyelang engine** — run compact Prolog-style Horn clause programs alongside the N3 engine, giving Eyeling a second reasoning engine without mixing the internals.
 
 
 This README is the primary guide to using, extending, and maintaining Eyeling.
@@ -53,20 +54,21 @@ Eyeling is designed for people who want a small, inspectable reasoner that can r
 4. [Command-line interface](#command-line-interface)
 5. [JavaScript API](#javascript-api)
 6. [RDF-JS integration](#rdf-js-integration)
-7. [RDF compatibility mode and RDF 1.2](#rdf-compatibility-mode-and-rdf-12)
-8. [RDF Message Logs](#rdf-message-logs)
-9. [Built-ins](#built-ins)
-10. [Custom built-ins](#custom-built-ins)
-11. [Reasoning model](#reasoning-model)
-12. [Architecture](#architecture)
-13. [Repository layout](#repository-layout)
-14. [Examples guide](#examples-guide)
-15. [Testing and quality checks](#testing-and-quality-checks)
-16. [Development workflow](#development-workflow)
-17. [Publishing and release notes](#publishing-and-release-notes)
-18. [Troubleshooting](#troubleshooting)
-19. [Security and operational notes](#security-and-operational-notes)
-20. [Glossary](#glossary)
+7. [Eyelang second engine](#eyelang-second-engine)
+8. [RDF compatibility mode and RDF 1.2](#rdf-compatibility-mode-and-rdf-12)
+9. [RDF Message Logs](#rdf-message-logs)
+10. [Built-ins](#built-ins)
+11. [Custom built-ins](#custom-built-ins)
+12. [Reasoning model](#reasoning-model)
+13. [Architecture](#architecture)
+14. [Repository layout](#repository-layout)
+15. [Examples guide](#examples-guide)
+16. [Testing and quality checks](#testing-and-quality-checks)
+17. [Development workflow](#development-workflow)
+18. [Publishing and release notes](#publishing-and-release-notes)
+19. [Troubleshooting](#troubleshooting)
+20. [Security and operational notes](#security-and-operational-notes)
+21. [Glossary](#glossary)
 
 ---
 
@@ -80,7 +82,8 @@ It accepts facts and rules written in N3-style syntax, computes the logical cons
 - a CommonJS API from Node.js through `require('eyeling')`;
 - a browser/worker API through `eyeling/browser`;
 - an RDF-JS adapter for applications that work with quads and data factories;
-- a streaming tool for RDF Message Logs.
+- a streaming tool for RDF Message Logs;
+- an experimental host for the `eyelang` Prolog-style Horn clause engine.
 
 Eyeling is intentionally small and dependency-light. The source tree is organized as a miniature compiler and inference engine: lexer, parser, term model, rule normalization, built-ins, forward chaining, backward proving, printing, RDF-JS adapters, and CLI wiring.
 
@@ -143,6 +146,26 @@ For proof output:
 node eyeling.js --proof examples/socrates.n3
 ```
 
+Run an eyelang program through the second engine:
+
+```bash
+eyeling --engine eyelang examples/eyelang/ancestor.pl
+```
+
+Or from JavaScript:
+
+```js
+const { reason } = require('eyeling');
+
+const output = reason({ engine: 'eyelang' }, `
+  materialize(out, 1).
+  in(done).
+  out(X) :- in(X).
+`);
+
+console.log(output);
+```
+
 ---
 
 ## Core concepts
@@ -595,6 +618,54 @@ Use RDF-JS when you want Eyeling to sit inside a JavaScript RDF pipeline. Use ra
 
 ---
 
+## Eyelang second engine
+
+Eyeling can also host the experimental `eyelang` engine. This is deliberately a second engine, not a rewrite of the N3 engine. The package therefore has two eyes:
+
+- the default **N3 engine** for RDF/Notation3 reasoning;
+- the **eyelang engine** for compact Prolog-style Horn clause programs.
+
+Use the CLI option when running `.pl` programs:
+
+```bash
+eyeling --engine eyelang examples/eyelang/ancestor.pl
+```
+
+Use the CommonJS convenience API when the rest of your application already imports `eyeling`:
+
+```js
+const { reason, reasonEyelang } = require('eyeling');
+
+const program = `
+  materialize(out, 1).
+  in(done).
+  out(X) :- in(X).
+`;
+
+console.log(reason({ engine: 'eyelang' }, program));
+console.log(await reasonEyelang(program));
+```
+
+Use the subpath export for the full eyelang module API:
+
+```js
+import { run, Program, Solver } from 'eyeling/eyelang';
+
+const result = run(program);
+console.log(result.stdout);
+```
+
+The two engines intentionally keep separate parsers, term models, solvers, and built-ins. Shared package entry points, examples, documentation, and CLI routing make them convenient to use together while keeping their execution models inspectable.
+
+Eyelang examples and language notes live under `examples/eyelang/`. The embedded engine runtime stays under `lib/eyelang/`, while the conformance corpus and test runners live under `test/eyelang/` so runtime code and test assets stay separate:
+
+```bash
+npm run test:eyelang        # integration check plus eyelang corpus
+npm run test:eyelang:corpus # eyelang corpus only
+```
+
+---
+
 ## RDF compatibility mode and RDF 1.2
 
 RDF compatibility mode is enabled with `--rdf` on the CLI or `{ rdf: true }` in the API.
@@ -720,7 +791,7 @@ Eyeling provides datatype built-ins in the namespace `https://eyereasoner.github
 
 Supported operations include:
 
-- `dt:datatype`, `dt:lexicalForm`, and `dt:language` for literal inspection;
+- `dt:datatype`, `dt:lexicalForm`, and `dt:language` for literal inspection. `dt:datatype` returns the literal's actual datatype IRI only, so RDF string literals return `xsd:string`; it does not return `rdfs:Literal`, which is a class of literals rather than a datatype IRI;
 - `dt:validForDatatype` and `dt:invalidForDatatype` for lexical validity and datatype membership checks, either as `?literal dt:validForDatatype ?datatype` tests or as tuple-to-boolean checks like `(?literal ?datatype) dt:validForDatatype true`;
 - `dt:sameValueAs` and `dt:differentValueFrom` for value-space equality and inequality;
 - `dt:canonicalLiteral` for canonical literal production.

package/bin/eyeling.cjs

@@ -1,10 +1,62 @@
 #!/usr/bin/env node
 'use strict';
 
-const bundle = require('../eyeling.js');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
 
-if (!bundle || typeof bundle.main !== 'function') {
-  throw new Error('Eyeling CLI bundle did not expose main()');
+function extractEngineArg(argv) {
+  const filtered = [];
+  let engine = null;
+  let endOptions = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (!endOptions && arg === '--') {
+      endOptions = true;
+      filtered.push(arg);
+    } else if (!endOptions && arg === '--engine') {
+      engine = argv[++i];
+      if (!engine) throw new Error('--engine needs a value');
+    } else if (!endOptions && arg.startsWith('--engine=')) {
+      engine = arg.slice('--engine='.length);
+    } else {
+      filtered.push(arg);
+    }
+  }
+
+  return { engine, argv: filtered };
 }
 
-bundle.main();
+function normalizeEngineName(value) {
+  if (value == null || value === '') return 'n3';
+  const name = String(value).toLowerCase();
+  if (name === 'n3' || name === 'eyeling') return 'n3';
+  if (name === 'eyelang' || name === 'prolog' || name === 'horn') return 'eyelang';
+  throw new Error(`unknown Eyeling engine: ${value}`);
+}
+
+async function runEyelangCli(argv) {
+  const cliUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'eyelang', 'cli.mjs')).href;
+  const cli = await import(cliUrl);
+  await cli.main(argv);
+}
+
+const parsed = extractEngineArg(process.argv.slice(2));
+const engine = normalizeEngineName(parsed.engine);
+
+if (engine === 'eyelang') {
+  runEyelangCli(parsed.argv).catch((error) => {
+    console.error(`eyeling: ${error && error.message ? error.message : String(error)}`);
+    process.exit(1);
+  });
+} else {
+  const bundle = require('../eyeling.js');
+
+  if (!bundle || typeof bundle.main !== 'function') {
+    throw new Error('Eyeling CLI bundle did not expose main()');
+  }
+
+  process.argv = [process.argv[0], process.argv[1], ...parsed.argv];
+  bundle.main();
+}

package/dist/browser/eyeling.browser.js

@@ -1888,17 +1888,7 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
-    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
-
-    // OWL 2 RL datatype rules often need common string literals to also
-    // participate in generic literal comparisons, while application rules still
-    // ask for their precise datatype explicitly.  When the datatype output is
-    // unbound, expose rdfs:Literal as an additional super-datatype answer for
-    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
-    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
-      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
-    }
-    return out;
+    return evalBindBuiltinObject(g.o, valueTerm, subst);
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {
@@ -6493,6 +6483,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
+      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/examples/eyelang/INTEGRATION.md

@@ -0,0 +1,13 @@
+# Eyelang examples inside Eyeling
+
+This directory contains eyelang examples that can be exercised through Eyeling's experimental second engine:
+
+```bash
+eyeling --engine eyelang examples/eyelang/ancestor.pl
+```
+
+The eyelang conformance corpus is kept under `test/eyelang/` and can be run with:
+
+```bash
+npm run test:eyelang:corpus
+```