eyeprolog 1.4.2 → 1.4.4

package/README.md

@@ -65,6 +65,7 @@ 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
+- [Introduction to EyeProlog](examples/deck/introduction-to-eyeprolog.md) — short presentation deck for first-time audiences
 - [Symbiotic Knowledge Graphs](examples/deck/symbiotic-knowledge-graphs.md) — 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

package/examples/deck/README.md

@@ -2,6 +2,7 @@
 
 Wide-audience companion explanations for selected runnable examples.
 
+- [Introduction to EyeProlog](introduction-to-eyeprolog.md) — a short slide deck introducing facts, rules, answers, proofs, ISO conformance, JavaScript embedding, and RDF roundtrips.
 - [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.

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 [`README.md`](../../README.md) for setup and links.
+- Read [`why-eyeprolog.md`](../../why-eyeprolog.md) for the design motivation.
+- Open [`playground.html`](../../playground.html) to run examples in a browser.
+- Explore [`examples/`](../) for runnable programs.
+- Read [`the-art-of-eyeprolog.md`](../../the-art-of-eyeprolog.md) for the full reference.

package/package.json

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

package/src/iso.js

@@ -2623,10 +2623,53 @@ function validateControlCallable(term, culprit, env) {
     }
   }
 }
+function convertMetaCallBodyTerm(term, env, module) {
+  // ISO term-to-body conversion is applied when call/1 begins, before any
+  // goal in the converted body is executed. An unbound variable occurring as
+  // a body goal therefore becomes call(Var) at that point. If an earlier goal
+  // later binds Var to !, the resulting call(!) has its own opaque cut scope
+  // instead of turning into a textual cut in the enclosing meta-call.
+  //
+  // Build the converted control tree iteratively so a deeply nested sequence
+  // of conjunctions/disjunctions cannot consume the JavaScript call stack.
+  const convertNode = (input, inheritedModule) => {
+    const resolved = deref(input, env);
+    const effectiveModule = resolved.module ?? inheritedModule;
+    if (resolved.type === VAR) {
+      const wrapped = compound('call', [resolved]);
+      wrapped.module = effectiveModule;
+      return { term: wrapped, source: null, module: effectiveModule };
+    }
+    if (resolved.type !== ATOM && resolved.type !== COMPOUND) {
+      throw new PrologError('type_error(callable)', term);
+    }
+    if (resolved.type === COMPOUND && [',', ';', '->'].includes(resolved.name) && resolved.arity === 2) {
+      const converted = compound(resolved.name, [...resolved.args]);
+      converted.module = effectiveModule;
+      return { term: converted, source: resolved, module: effectiveModule };
+    }
+    return { term: resolved, source: null, module: effectiveModule };
+  };
+
+  const root = convertNode(term, module);
+  const pending = root.source == null ? [] : [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (let index = 0; index < 2; index++) {
+      const child = convertNode(current.source.args[index], current.module);
+      current.term.args[index] = child.term;
+      if (child.source != null) pending.push(child);
+    }
+  }
+  return root.term;
+}
+
 function expandCallGoal({ goal, env }) {
   const invoked = callable(goal.args[0], env);
-  if (invoked.module == null) invoked.module = goal.module ?? 'user';
-  return invoked;
+  const module = invoked.module ?? goal.module ?? 'user';
+  const converted = convertMetaCallBodyTerm(invoked, env, module);
+  if (converted.module == null) converted.module = module;
+  return converted;
 }
 function* callBuiltin(context) {
   const { solver, env } = context;

package/test/conformance/ISO-COMPLIANCE.md

@@ -36,7 +36,7 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | 7.4 — Prolog text and directives | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes the preparation/directive rows: declaration semantics, source clauses, cross-text operators/character conversion/flags, initialization order/lifetime, `include/1`, and one-time `ensure_loaded/1`, with implementation-defined cross-text choices indexed under 5.4. |
 | 7.5-7.6 — database and term/clause conversion | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes static/dynamic and private/public procedure semantics, clause order, logical-update visibility, empty/unknown lifetime, and term/body/clause conversion. Source and runtime assertion conversion recurse through `,/2`, `;/2`, and `->/2`, preserve variable identity, and protect standardized static/control procedures. |
 | 7.7 — execution and backtracking | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes ordinary clause selection/backtracking, source/database order, empty-versus-unknown procedures, logical-update visibility, and strict dispatch. EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts remain disabled in the strict profile. |
-| 7.8 — control constructs and exceptions | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes `true/0`, `fail/0`, `call/1`, cut, conjunction, disjunction, if-then(-else), and `catch/3`/`throw/1`, including Corrigendum 2 catchability of errors arising from the protected goal and Corrigendum 3 term-to-body conversion. The 8.15 built-in additions remain independently row-audited. |
+| 7.8 — control constructs and exceptions | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes `true/0`, `fail/0`, `call/1`, cut, conjunction, disjunction, if-then(-else), and `catch/3`/`throw/1`, including Corrigendum 2 catchability of errors arising from the protected goal and Corrigendum 3 term-to-body conversion at `call/1` entry; the regression suite pins the resulting cut scope when an initially unbound variable goal later becomes `!`. The 8.15 built-in additions remain independently row-audited. |
 | 7.9 — expression evaluation | covered | [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) closes recursive evaluation, direct-variable precedence, corrected non-evaluable `F/N` errors (including STC #69), operand template/type rules, mixed arithmetic-comparison conversion, exceptional values, and finite-host resource normalization. The audit also fixes float-only `float_integer_part/1` and `float_fractional_part/1` so even huge valid integers reach `type_error(float,...)` before any I->F overflow. |
 | 7.10 — input/output concepts | covered | Higher-level stream semantics are pinned for non-atom ground stream terms, alias lifetime, current/target stream selection and fallback, write truncation, append positioning, contradictory stream options, exact binary round-tripping, flushing, standard-stream close behavior, and repositioned overwrite. Term-output spelling is also checked lexically where ISO distinguishes token forms: Corrigendum 2 bar operators are written with bare `|`, ordinary atom/functor `|` remains quoted, and the semicolon name token is emitted bare by canonical output. The complete 8.11-8.14 built-in mode/error family remains row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md), while all implementation-defined stream choices are indexed in [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md). |
 | 7.11 — flags | covered | The complete Part 1 flag set, selected defaults, standard value domains, changeability, `current_prolog_flag/2`, and `set_prolog_flag/2` error behavior have dedicated strict tests. EyeProlog selects `bounded=false` and `integer_rounding_function=toward_zero`; valid alternative values of those fixed flags reach `permission_error(modify,flag,...)`, while `max_integer` and `min_integer` have no current value. STC #70 is recorded explicitly: EyeProlog has no separate finite procedure-arity ceiling, so the optional `max_procedure_arity` flag is absent while `max_arity` remains `unbounded`. Strict mode excludes the EyeProlog `occurs_check` extension. |

package/test/conformance/ISO-PROLOG-TEXT-EXECUTION-MATRIX.md

@@ -55,8 +55,12 @@ The complete 8.8-8.9 database built-in modes/errors remain covered by
 | 7.6.3 clause-to-term observation | covered | `clause/2` returns fresh renamed clause observations with the required sharing between head and body. |
 | 7.6.4 update conversion | covered | `asserta/1`, `assertz/1`, `retract/1`, and prepared source clauses use the same strict body-conversion rules and reject malformed bodies before database mutation. |
 
-Corrigendum 3's explicit `call/1` term-to-body wording is covered by the source
-and asserted-body conversion regressions.
+Corrigendum 3's explicit `call/1` term-to-body wording is covered by the source,
+asserted-body, and meta-call conversion regressions. In particular, `call/1`
+converts an initially unbound variable goal to `call(Var)` before execution; if
+an earlier goal later binds that variable to `!`, the resulting `call(!)` keeps
+its own opaque cut boundary instead of becoming a textual cut in the enclosing
+converted body.
 
 ## 7.7 - execution and backtracking
 
@@ -74,8 +78,8 @@ and asserted-body conversion regressions.
 | --- | --- | --- |
 | 7.8.1 `true/0` | covered | succeeds once |
 | 7.8.2 `fail/0` | covered | fails |
-| 7.8.3 `call/1` | covered | executes the converted goal; variables can become callable after earlier bindings; Corrigendum 3 term-to-body conversion is used |
-| 7.8.4 cut | covered | cut commits within its defined invocation scope; callee-local cuts do not incorrectly prune caller alternatives |
+| 7.8.3 `call/1` | covered | executes the converted goal; variables that are unbound at meta-call entry become `call(Var)` before execution, so a later binding to `!` remains an opaque `call(!)`; variables already bound at entry are dereferenced during conversion |
+| 7.8.4 cut | covered | cut commits within its defined invocation scope; callee-local cuts and cuts reached through a converted variable goal do not incorrectly prune alternatives outside that invocation |
 | 7.8.5 conjunction | covered | left-to-right execution and backtracking; nested malformed converted goals retain the whole control-term culprit |
 | 7.8.6 disjunction | covered | left branch is tried before the right and failure backtracks into the right branch |
 | 7.8.7 if-then | covered | successful condition commits to the selected condition solution before the then branch |

package/test/run-iso-strict.mjs

@@ -1214,6 +1214,21 @@ export function runIsoStrict(reporter = new TestReporter()) {
       isoStrict: true,
       goal: 'catch(throw(ball(X)),ball(Y),X=Y)',
     }).stats.completed_goal_lists > 0, true, 'throw/1 and catch/3 unify through a renamed thrown term');
+
+    const answerCount = (text) => {
+      const program = Program.parse('', { isoStrict: true });
+      const solver = new Solver(program, { isoStrict: true });
+      return [...solver.solve([parseGoalText(text, {
+        isoStrict: true,
+        operatorDefinitions: [...program.operators.values()],
+      })], new Env(), 0)].length;
+    };
+    equal(answerCount('call((Z=!, (X=1;X=2), Z)) ; T=end'), 3,
+      'call/1 converts an initially unbound variable goal before it can become a cut (issue #86)');
+    equal(answerCount('call((Z=!, (X=1;X=2), Z, X=2))'), 1,
+      'call(Var) cut remains opaque to choices made earlier in the converted body');
+    equal(answerCount('Z=!, (call(((X=1;X=2),Z)) ; T=end)'), 2,
+      'a variable already bound before call/1 conversion is dereferenced as a direct cut');
   });
 
   reporter.test('rejects EyeProlog module directives', () => {

package/test/run-regression.mjs

@@ -1116,6 +1116,31 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 22 run, 22 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'call/1 converts variable goals before execution so later cuts stay opaque (issue #86)',
+      run: () => {
+        const quad = publicApi.runQuads(`?- call((Z = !,(X=1;X=2), Z)) ; T=end.\n` +
+          `   Z = !, X = 1\n` +
+          `;  Z = !, X = 2\n` +
+          `;  T = end.\n`);
+        assertEqual(quad.total, 1, 'issue #86 quad total');
+        assertEqual(quad.passed, 1, 'issue #86 exact answer sequence');
+        assertEqual(quad.failed, 0, 'issue #86 quad failures');
+
+        const program = Program.parse('');
+        const answerCount = (text) => {
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          return [...solver.solve([parseGoalText(text)], new Env(), 0)].length;
+        };
+
+        assertEqual(answerCount('call((Z=!, (X=1;X=2), Z)) ; T=end'), 3,
+          'issue #86 outer answer count');
+        assertEqual(answerCount('call((Z=!, (X=1;X=2), Z, X=2))'), 1,
+          'later call(!) does not prune the X=2 alternative');
+        assertEqual(answerCount('Z=!, (call(((X=1;X=2),Z)) ; T=end)'), 2,
+          'pre-bound cut stays direct inside the meta-call');
+      },
+    },
     {
       name: 'negation observes disjunction through direct and call/1 execution',
       run: () => {