eyeprolog 1.4.3 → 1.4.5

package/README.md

@@ -65,7 +65,8 @@ printf 'human(socrates).\nmortal(X) :- human(X).\n' |
 - [Playground](https://eyereasoner.github.io/eyeprolog/playground) — run EyeProlog in a browser
 - [Examples](examples) — runnable programs and checked output
 - [Example decks](examples/deck/README.md) — explainable RDF/Prolog scenarios with reproducible roundtrips
-- [Symbiotic Knowledge Graphs](examples/deck/symbiotic-knowledge-graphs.md) — RDF ↔ Prolog heatwave-response demo for human/AI/KG co-evolution
+- [Introduction to EyeProlog](https://eyereasoner.github.io/eyeprolog/examples/deck/introduction-to-eyeprolog) — short presentation deck for first-time audiences
+- [Symbiotic Knowledge Graphs](https://eyereasoner.github.io/eyeprolog/examples/deck/symbiotic-knowledge-graphs) — RDF ↔ Prolog heatwave-response demo for human/AI/KG co-evolution
 - [rdf-prolog-roundtrip](https://github.com/eyereasoner/rdf-prolog-roundtrip) — standalone RDF 1.2 ↔ ISO Prolog bridge used by the RDF examples
 - [ISO conformance audit](test/conformance/ISO-COMPLIANCE.md) — supported Part 1 profile
 - [Conformance report](conformance-report.md) — generated executable conformance status and corpus summary
@@ -75,9 +76,9 @@ printf 'human(socrates).\nmortal(X) :- human(X).\n' |
 
 EyeProlog can sit behind an RDF knowledge graph without inventing a private graph representation. [`rdf-prolog-roundtrip`](https://github.com/eyereasoner/rdf-prolog-roundtrip) converts RDF 1.2 datasets to ordinary `rdf(Subject, Predicate, Object, Graph)` facts, EyeProlog applies portable rules, and ground `rdf/4` results can be converted back to RDF.
 
-The checked [Symbiotic Knowledge Graphs example](examples/symbiotic-knowledge-graph.pl) uses named graphs and RDF 1.2 triple terms to distinguish trusted knowledge, AI-proposed statements, and human review. Its [wide-audience companion](examples/deck/symbiotic-knowledge-graphs.md) explains why this is a useful present-day software model for human/AI/KG co-evolution: RDF supplies shared semantic memory, Prolog supplies explicit deliberation, AI supplies new hypotheses, and people remain participants in meaning and judgment.
+The checked [Symbiotic Knowledge Graphs example](examples/symbiotic-knowledge-graph.pl) uses named graphs and RDF 1.2 triple terms to distinguish trusted knowledge, AI-proposed statements, and human review. Its [wide-audience companion](https://eyereasoner.github.io/eyeprolog/examples/deck/symbiotic-knowledge-graphs) explains why this is a useful present-day software model for human/AI/KG co-evolution: RDF supplies shared semantic memory, Prolog supplies explicit deliberation, AI supplies new hypotheses, and people remain participants in meaning and judgment.
 
-The same RDF → Prolog → RDF boundary is exercised by five additional checked scenarios: [cross-organization data sharing](examples/deck/cross-organization-data-sharing.md), [explainable EV-depot configuration](examples/deck/explainable-ev-depot-configuration.md), [operational incident response](examples/deck/operational-incident-response.md), [software supply-chain vulnerability response](examples/deck/sbom-vulnerability-response.md), and a [scientific evidence graph](examples/deck/scientific-evidence-graph.md). Together they cover policy decisions, reversible configuration reasoning, dependency-graph diagnosis, transitive SBOM exposure, and evidence aggregation with explicit disagreement.
+The same RDF → Prolog → RDF boundary is exercised by five additional checked scenarios: [cross-organization data sharing](https://eyereasoner.github.io/eyeprolog/examples/deck/cross-organization-data-sharing), [explainable EV-depot configuration](https://eyereasoner.github.io/eyeprolog/examples/deck/explainable-ev-depot-configuration), [operational incident response](https://eyereasoner.github.io/eyeprolog/examples/deck/operational-incident-response), [software supply-chain vulnerability response](https://eyereasoner.github.io/eyeprolog/examples/deck/sbom-vulnerability-response), and a [scientific evidence graph](https://eyereasoner.github.io/eyeprolog/examples/deck/scientific-evidence-graph). Together they cover policy decisions, reversible configuration reasoning, dependency-graph diagnosis, transitive SBOM exposure, and evidence aggregation with explicit disagreement.
 
 ## Development
 

package/examples/deck/README.md

@@ -2,10 +2,11 @@
 
 Wide-audience companion explanations for selected runnable examples.
 
-- [Cross-organization data sharing](cross-organization-data-sharing.md) — ODRL/DPV sharing decisions with permit, deny, review, safeguards, and obligations.
-- [Explainable EV-depot configuration](explainable-ev-depot-configuration.md) — reversible configuration rules that select a charger, explain blockers, and derive required changes.
-- [ODRL policy reasoning](odrl-policy-reasoning.md) — permissions, prohibitions, duties, conflicts, and defaults.
-- [Operational incident response](operational-incident-response.md) — topology-aware root-cause, impact, evidence-chain, and safe-mitigation reasoning.
-- [SBOM vulnerability response](sbom-vulnerability-response.md) — transitive exposure paths, severity policy, waivers, deployment decisions, and upgrade actions.
-- [Scientific evidence graph](scientific-evidence-graph.md) — RDF 1.2 claims, provenance, evidence quality, corroboration, and explicit disagreement.
-- [Symbiotic Knowledge Graphs](symbiotic-knowledge-graphs.md) — a real-world RDF → Prolog → RDF heatwave-response loop in which AI proposes, explicit rules govern, people review, and accepted knowledge improves later decisions.
+- [Introduction to EyeProlog](https://eyereasoner.github.io/eyeprolog/examples/deck/introduction-to-eyeprolog) — a short slide deck introducing facts, rules, answers, proofs, ISO conformance, JavaScript embedding, and RDF roundtrips.
+- [Cross-organization data sharing](https://eyereasoner.github.io/eyeprolog/examples/deck/cross-organization-data-sharing) — ODRL/DPV sharing decisions with permit, deny, review, safeguards, and obligations.
+- [Explainable EV-depot configuration](https://eyereasoner.github.io/eyeprolog/examples/deck/explainable-ev-depot-configuration) — reversible configuration rules that select a charger, explain blockers, and derive required changes.
+- [ODRL policy reasoning](https://eyereasoner.github.io/eyeprolog/examples/deck/odrl-policy-reasoning) — permissions, prohibitions, duties, conflicts, and defaults.
+- [Operational incident response](https://eyereasoner.github.io/eyeprolog/examples/deck/operational-incident-response) — topology-aware root-cause, impact, evidence-chain, and safe-mitigation reasoning.
+- [SBOM vulnerability response](https://eyereasoner.github.io/eyeprolog/examples/deck/sbom-vulnerability-response) — transitive exposure paths, severity policy, waivers, deployment decisions, and upgrade actions.
+- [Scientific evidence graph](https://eyereasoner.github.io/eyeprolog/examples/deck/scientific-evidence-graph) — RDF 1.2 claims, provenance, evidence quality, corroboration, and explicit disagreement.
+- [Symbiotic Knowledge Graphs](https://eyereasoner.github.io/eyeprolog/examples/deck/symbiotic-knowledge-graphs) — a real-world RDF → Prolog → RDF heatwave-response loop in which AI proposes, explicit rules govern, people review, and accepted knowledge improves later decisions.

package/examples/deck/introduction-to-eyeprolog.md

@@ -0,0 +1,209 @@
+---
+marp: true
+title: Introduction to EyeProlog
+description: A short presentation introducing EyeProlog as a portable, inspectable ISO Prolog engine for answers, proofs, and RDF-backed reasoning.
+---
+
+# Introduction to EyeProlog
+
+Portable Prolog reasoning for answers, proofs, and knowledge graphs
+
+---
+
+## What is EyeProlog?
+
+EyeProlog is a small ISO Prolog implementation for JavaScript.
+
+It turns explicit facts and rules into:
+
+- answers;
+- variable bindings;
+- checked example output;
+- optional proof traces;
+- embeddable reasoning in Node.js and browsers.
+
+---
+
+## Why Prolog?
+
+Prolog is a language for relations.
+
+Instead of spelling out every control step, you describe what must hold:
+
+```prolog
+human(socrates).
+mortal(X) :- human(X).
+```
+
+Then you ask questions:
+
+```prolog
+?- mortal(socrates).
+   true.
+```
+
+---
+
+## The core idea
+
+```text
+facts + rules + query
+        |
+        v
+  search by unification
+        |
+        v
+answers with reasons
+```
+
+The same rule can answer a yes/no question, enumerate solutions, or participate in a larger proof.
+
+---
+
+## Quick start
+
+Run EyeProlog without a global install:
+
+```sh
+npx --yes eyeprolog
+```
+
+Try a list query:
+
+```prolog
+?- use_module(library(lists)).
+   true.
+?- member(X, [prolog, logic]).
+   X = prolog
+;  X = logic.
+```
+
+---
+
+## Programs are ordinary text
+
+A file can contain facts, rules, and goals:
+
+```prolog
+human(socrates).
+mortal(X) :- human(X).
+
+?- mortal(X).
+```
+
+Run it:
+
+```sh
+eyeprolog examples/socrates.pl
+```
+
+---
+
+## Proofs are first-class
+
+EyeProlog can show not only *what* was concluded, but *why*.
+
+```sh
+eyeprolog --proof examples/socrates.pl
+```
+
+Proof output is useful for:
+
+- debugging rules;
+- explaining decisions;
+- regression tests;
+- audit trails.
+
+---
+
+## ISO first, extensions visible
+
+EyeProlog starts from ISO/IEC 13211-1 Prolog.
+
+That matters because facts, rules, terms, control, errors, streams, arithmetic, and meta-calls have an external reference point.
+
+Normal mode adds practical libraries and embedding features. Strict ISO mode keeps the standardized core separate and testable.
+
+---
+
+## Why JavaScript?
+
+EyeProlog runs where modern applications already run:
+
+- command-line tools;
+- npm packages;
+- browser playgrounds;
+- web workers;
+- JavaScript APIs.
+
+The aim is not to replace every Prolog system. It is to make portable Prolog reasoning easy to embed and inspect.
+
+---
+
+## RDF and knowledge graphs
+
+EyeProlog pairs naturally with RDF through `rdf-prolog-roundtrip`:
+
+```text
+RDF dataset
+  -> rdf(S, P, O, Graph) facts
+  -> EyeProlog rules
+  -> result_rdf/4 facts
+  -> RDF dataset
+```
+
+RDF remains the interchange layer. Prolog remains the transparent reasoning layer.
+
+---
+
+## What this enables
+
+The example suite uses the same pattern for:
+
+- policy decisions;
+- incident response;
+- software supply-chain risk;
+- scientific evidence assessment;
+- EV-depot configuration;
+- symbiotic human/AI/knowledge-graph workflows.
+
+Each scenario keeps data, rules, answers, and materialized results as separate inspectable artifacts.
+
+---
+
+## Testing and conformance
+
+EyeProlog’s release gate includes:
+
+- file-based conformance cases;
+- strict ISO tests;
+- WG17 syntax cases;
+- regression tests;
+- runnable examples;
+- proof examples;
+- documentation synchronization checks.
+
+The point is simple: behavior should be reproducible, not anecdotal.
+
+---
+
+## When EyeProlog fits
+
+EyeProlog is a good fit when a project needs:
+
+- explicit rules;
+- inspectable conclusions;
+- portable Prolog syntax;
+- embeddable JavaScript runtime;
+- checked examples and proofs;
+- a clean boundary between data, rules, and results.
+
+---
+
+## Where to go next
+
+- Read [project README](https://github.com/eyereasoner/eyeprolog#readme) for setup and links.
+- Read [Why EyeProlog?](https://eyereasoner.github.io/eyeprolog/why-eyeprolog) for the design motivation.
+- Open [EyeProlog playground](https://eyereasoner.github.io/eyeprolog/playground) to run examples in a browser.
+- Explore [runnable examples](https://github.com/eyereasoner/eyeprolog/tree/main/examples) for runnable programs.
+- Read [The Art of EyeProlog](https://eyereasoner.github.io/eyeprolog/the-art-of-eyeprolog) for the full reference.

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",