eyeprolog 1.5.56 → 1.5.58

package/package.json

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

package/src/cli.js

@@ -335,6 +335,7 @@ Options:
   --proof-detail mode   Use abstract or expanded proof detail (implies --proof).
   --verify-proof file   Verify why/2 proof certificates against the input program.
   -q, --quads           Run embedded quad tests and fail if any do not hold.
+                        Note: -q is quads, not quiet; --quiet has no short form.
   --quiet               Suppress answer terms while preserving Prolog output.
   -s, --stats           Print solver and memory statistics to stderr after execution.
   --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;

package/src/errors.js

@@ -2,7 +2,7 @@
 // Keep these independent of the ISO builtin registry so syntax, DCG, program,
 // and solver layers can report Prolog errors without importing the whole ISO
 // implementation (and without creating semantic-layer import cycles).
-import { termToString } from './term.js';
+import { atom, compound, numberTerm, termToString } from './term.js';
 
 export class PrologError extends Error {
   constructor(formal, culprit = null) {
@@ -21,3 +21,28 @@ export class HaltSignal extends Error {
     this.code = code;
   }
 }
+
+// ISO 7.12.2 leaves the second argument of error/2 implementation defined.
+// Reporting which built-in raised the error is far more useful than a constant,
+// so built-in call sites attach the predicate indicator when the raising code
+// did not supply a context of its own. The indicator term is built once per
+// registry entry and reused, so the error path allocates nothing extra.
+function builtinErrorContext(def, goal) {
+  let context = def._errorContextTerm;
+  if (context === undefined) {
+    context = compound('/', [atom(goal.name), numberTerm(goal.arity)]);
+    def._errorContextTerm = context;
+  }
+  return context;
+}
+
+// Shared, pre-built error instances are thrown many times from different
+// built-ins, so tagging one with a context would leak the first thrower's
+// indicator into every later report. They keep the default context, which also
+// preserves the ground-error-term cache in formalErrorTerm.
+export function attachBuiltinErrorContext(error, def, goal) {
+  if (!(error instanceof PrologError)) return error;
+  if (error.contextTerm != null || error._sharedInstance === true) return error;
+  error.contextTerm = builtinErrorContext(def, goal);
+  return error;
+}

package/src/iso.js

@@ -22,7 +22,7 @@ import {
 let isoFresh = 0;
 
 export { PrologError, HaltSignal } from './errors.js';
-import { PrologError, HaltSignal } from './errors.js';
+import { HaltSignal, PrologError, attachBuiltinErrorContext } from './errors.js';
 
 class ThrownTerm extends Error {
   constructor(term) {
@@ -2452,6 +2452,7 @@ function numberListText(list, env, kind, valueIsBound, solver = null) {
 }
 
 const numberSyntaxError = new PrologError('syntax_error(number)');
+numberSyntaxError._sharedInstance = true;
 
 function numberListBuiltin(kind) {
   return function* ({ solver, goal, env }) {
@@ -3161,8 +3162,17 @@ function* catchSolutions({ solver, goal, env }, state) {
       // isolated in a child solver. Running it directly avoids constructing a
       // complete Solver for hot caught failures such as number_chars/2 syntax
       // probes, while the cloned environment keeps catch/3's rollback boundary.
-      const iterator = direct.handler({ solver, goal: invoked, env: env.clone() });
-      const result = iterator.next();
+      let iterator;
+      let result;
+      try {
+        iterator = direct.handler({ solver, goal: invoked, env: env.clone() });
+        result = iterator.next();
+      } catch (caught) {
+        // This fast path bypasses the solver's builtin frame, so it has to
+        // attach the raising predicate's indicator itself (see
+        // attachBuiltinErrorContext in solver.js).
+        throw attachBuiltinErrorContext(caught, direct, invoked);
+      }
       if (result.done) solver.stats.deterministic_builtin_failures++;
       else {
         solver.stats.deterministic_builtin_successes++;

package/src/parser.js

@@ -1138,7 +1138,7 @@ class Parser {
         }
         const operator = this.applyOperatorDirective(directive, line);
         if (!coreDirective && !extensionDirective && !operator) {
-          throw new Error(`parse line ${line}: bad term`);
+          throw new Error(`parse line ${line}: ${unsupportedDirectiveMessage(directive, this.strictIso)}`);
         }
         this.expect(TOK.DOT, '.');
         this.applyParserFlagDirective(directive, line);
@@ -1911,3 +1911,76 @@ export function parseGoalText(text, options = {}) {
   }
   return head.args[0];
 }
+
+// Directives are accepted from a fixed list, so an unrecognized one is a
+// different mistake from unparseable input and deserves a different message.
+// The three cases below cover what people actually write: a bare goal that
+// belongs in initialization/1, a misspelt directive name, and a term that is
+// not a directive at all.
+const CORE_DIRECTIVE_INDICATORS = [
+  'dynamic/1', 'multifile/1', 'discontiguous/1', 'initialization/1', 'include/1',
+  'ensure_loaded/1', 'char_conversion/2', 'set_prolog_flag/2', 'op/3',
+];
+const EXTENSION_DIRECTIVE_INDICATORS = [
+  'use_module/1', 'use_module/2', 'meta_predicate/1', 'attribute/1', 'table/1',
+  'public/1', 'module/2',
+];
+
+function directiveNameDistance(a, b) {
+  // Small Levenshtein distance, used only to suggest a near-miss spelling.
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  let previous = Array.from({ length: cols }, (_, i) => i);
+  for (let i = 1; i < rows; i++) {
+    const current = [i];
+    for (let j = 1; j < cols; j++) {
+      current[j] = Math.min(
+        previous[j] + 1,
+        current[j - 1] + 1,
+        previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
+      );
+    }
+    previous = current;
+  }
+  return previous[cols - 1];
+}
+
+function nearestDirectiveName(name, available) {
+  let best = null;
+  let bestDistance = Infinity;
+  for (const indicator of available) {
+    const candidate = indicator.slice(0, indicator.lastIndexOf('/'));
+    const distance = directiveNameDistance(name, candidate);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  // Only suggest a genuinely close spelling, not the alphabetically nearest.
+  return bestDistance <= Math.max(1, Math.floor(name.length / 3)) ? best : null;
+}
+
+function unsupportedDirectiveMessage(directive, strictIso) {
+  const available = strictIso
+    ? CORE_DIRECTIVE_INDICATORS
+    : [...CORE_DIRECTIVE_INDICATORS, ...EXTENSION_DIRECTIVE_INDICATORS];
+  if (directive.type !== COMPOUND && directive.type !== ATOM) {
+    return 'a directive must be a callable term';
+  }
+  const name = directive.name;
+  const arity = directive.type === COMPOUND ? directive.arity : 0;
+  const indicator = `${name}/${arity}`;
+  const known = available.filter((entry) => entry.slice(0, entry.lastIndexOf('/')) === name);
+  if (known.length > 0) {
+    return `directive ${indicator} has the wrong arity; expected ${known.join(' or ')}`;
+  }
+  const suggestion = nearestDirectiveName(name, available);
+  if (suggestion != null) {
+    return `unknown directive ${indicator}; did you mean ${suggestion}?`;
+  }
+  // A goal such as `:- write(hello), nl.` is well-formed but is not one of the
+  // recognized declarations, so point at initialization/1 rather than reporting
+  // a syntax error.
+  return `unknown directive ${indicator}; to run a goal at load time use ` +
+    ':- initialization(Goal).';
+}

package/src/program.js

@@ -1439,8 +1439,13 @@ function analyzeInteropPortability(program, extraGoals = []) {
 // this only affects user code, but within user code it acts at a distance
 // across included files.
 //
-// How strictly this is treated depends on how explicit the program was, which
-// follows the graded scheme SWI-Prolog uses for the same situation:
+// How strictly this is treated depends on how explicit the program was. The
+// first two tiers match what Trealla and Scryer do for the same program
+// (`:- use_module(library(lists)).` followed by clauses for append/3): both
+// warn and continue, Trealla with `overwriting user:'append'/3` and Scryer with
+// `overwriting append/3 because the clauses are discontiguous`. SWI-Prolog
+// treats imported predicates as weak symbols and warns likewise. No system
+// raises an error there, so neither does EyeProlog:
 //
 //   implicit autoload                          -> warning
 //   use_module(library(L))                     -> warning
@@ -1448,9 +1453,9 @@ function analyzeInteropPortability(program, extraGoals = []) {
 //
 // Only the last case is an outright contradiction: the program asked for that
 // exact predicate to be imported and then supplied clauses for it. The first
-// two stay warnings so that flat, module-free programs -- which load unchanged
-// on Scryer and Trealla, where the library is simply never imported -- keep
-// working. Note that ISO reserves permission_error(modify, static_procedure)
+// two stay warnings so that flat, module-free programs keep loading here
+// exactly as they do on Scryer and Trealla, which was checked directly rather
+// than inferred. Note that ISO reserves permission_error(modify, static_procedure)
 // for built-in predicates (7.5.3); library predicates are not built-ins, so
 // this error is raised only where the program's own import list demands it.
 function analyzeLibraryShadowing(program) {

package/src/solver.js

@@ -6,6 +6,7 @@ import {
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
+import { attachBuiltinErrorContext } from './errors.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
@@ -757,8 +758,14 @@ export class Solver {
         if (builtinReady) {
           const deterministic = def.deterministic ||
             def.deterministicWhen?.({ solver: this, goal, env }) === true;
-          const iterator = def.handler({ solver: this, goal, env });
-          const firstResult = iterator.next();
+          let iterator;
+          let firstResult;
+          try {
+            iterator = def.handler({ solver: this, goal, env });
+            firstResult = iterator.next();
+          } catch (caught) {
+            throw attachBuiltinErrorContext(caught, def, goal);
+          }
           if (deterministic) {
             if (!firstResult.done) this.stats.deterministic_builtin_successes++;
             else this.stats.deterministic_builtin_failures++;

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -67,7 +67,7 @@ Status values are:
 | 7.11.2.2 | Effect when `debug=on` | The flag is accepted and stored; it does not change goal semantics or enable a debugger. | **defined** — `src/solver.js`; no semantic branch depends on `debug`. |
 | 7.11.2.3 | Default `max_arity` | `unbounded`: EyeProlog imposes no fixed semantic ceiling on compound-term arity. Practical host allocation exhaustion is a resource condition. This flag is distinct from any potential implementation-specific procedure-arity limit; EyeProlog currently declares no separate finite procedure limit. | **defined** — `src/iso-limits.js`, `src/solver.js`, `src/parser.js`, `src/iso.js`; strict regression coverage. |
 | 7.11.2.5 | Default `double_quotes` | `chars`. | **defined** — `src/solver.js`, parser flag state. |
-| 7.12.1 | Second argument of `error/2` | The default context term is the atom `eyeprolog`. A few implementation-specific diagnostics may deliberately supply a more specific context term. | **defined** — `formalErrorTerm()` in `src/iso.js`. |
+| 7.12.1 | Second argument of `error/2` | Built-in predicates report the predicate indicator of the predicate that raised the error, for example `error(type_error(atom, 1.0), atom_length/2)`. Errors raised outside a built-in frame, and errors thrown from shared pre-built instances that several built-ins reuse, fall back to the atom `eyeprolog`. A few implementation-specific diagnostics deliberately supply their own context term. | **defined** — `attachBuiltinErrorContext()` in `src/errors.js`, `formalErrorTerm()` in `src/iso.js`. |
 | 7.12.2(f) | Implementation-defined representation limits | Character and character-code operations are limited to Unicode scalar values; surrogates and values above U+10FFFF are representation errors. Arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |
 | 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` and `default_procedure_access` flags. With `bounded=false`, `max_integer` and `min_integer` have no current or selectable value and their `current_prolog_flag/2` queries fail. Valid alternative values of fixed standard flags are distinguished from invalid values so `set_prolog_flag/2` reports permission versus domain errors as prescribed. | **defined** — strict registry/flag filtering in `src/solver.js`; strict flag tests. |
 | 8.17.3 | Other effects of `halt/0` | Terminates EyeProlog execution and returns host/process status `0`; it produces no Prolog solution. | **defined** — `HaltSignal`, `haltBuiltin()`, CLI/runner handling. |

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

@@ -23,7 +23,7 @@ chosen behavior is also indexed by `ISO-IMPLEMENTATION-DEFINED.md`.
 | 7.4.2.7 `include/1` | covered | The included text is prepared at the directive position and shares operator/character/flag preparation state with its parent. |
 | 7.4.2.8 `ensure_loaded/1` | covered | A source is prepared at most once in the current load graph, including repeated references and self/top-level references. |
 | 7.4.2.9 `set_prolog_flag/2` | covered | Preparation-time flag changes affect subsequent text and are replayed into execution state; strict flag names/values/changeability remain governed by the closed 7.11 review. |
-| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins, so ISO does not protect them. They stay redefinable when they reach the program implicitly, through autoloading or a whole-module `use_module(library(L))`, but the redefinition is reported as a shadowing warning because it replaces the library predicate for all user code in the program. Naming a predicate in an explicit import list, `use_module(library(L), [Name/Arity])`, and then supplying clauses for it is a contradiction and reports `permission_error(modify, static_procedure)`. Bundled library modules keep resolving their own internal calls, so a user redefinition never changes library behaviour. Corpus: `error/iso/consult_redefines_builtin`. |
+| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins, so ISO does not protect them. They stay redefinable when they reach the program implicitly, through autoloading or a whole-module `use_module(library(L))`, but the redefinition is reported as a shadowing warning because it replaces the library predicate for all user code in the program. Naming a predicate in an explicit import list, `use_module(library(L), [Name/Arity])`, and then supplying clauses for it is a contradiction and reports `permission_error(modify, static_procedure)`. Bundled library modules keep resolving their own internal calls, so a user redefinition never changes library behaviour. Trealla and Scryer also warn and continue for the whole-module case rather than raising an error, so the warning tiers match those systems. Corpus: `error/iso/consult_redefines_builtin`. |
 
 The strict release test `closes ISO 7.4 Prolog-text preparation and directive
 rows` exercises the cross-text operator/character/flag state, include and

package/test/conformance/expected/iso/exceptions_and_flags.pl

@@ -1,3 +1,3 @@
-answer(7, red, caught(eyeprolog), first, caught(eyeprolog)).
-answer(7, red, caught(eyeprolog), second, caught(eyeprolog)).
+answer(7, red, caught(atom_length / 2), first, caught(eyeprolog)).
+answer(7, red, caught(atom_length / 2), second, caught(eyeprolog)).
 flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true), pair(default_procedure_access, private)]).

package/test/conformance/expected-errors/syntax/extra_missing_head_rejected.txt

@@ -1 +1 @@
-parse line 1: bad term
+parse line 1: unknown directive q/1; to run a goal at load time use :- initialization(Goal).

package/test/regression/cases-regression.mjs

@@ -1891,7 +1891,7 @@ c4 ?- call((!;1)).
         assertIncludes(repl.stdout, 'T = ./*. .', 'REPL dotted graphic atom answer');
         assertNotIncludes(repl.stdout, "T = './*.'", 'REPL dotted graphic atom has no spurious quotes');
         assertIncludes(repl.stdout, 'T = ok.', 'REPL following read answer');
-        assertIncludes(repl.stdout, 'error(syntax_error(read_term), eyeprolog)', 'REPL syntax error');
+        assertIncludes(repl.stdout, 'error(syntax_error(read_term), read / 1)', 'REPL syntax error');
         assertEqual(repl.stderr, '', 'REPL stderr');
 
         const continuedGraphic = runCli([], {
@@ -2719,8 +2719,8 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    error(type_error(list, [1, [], _A | 2]), eyeprolog).\n' +
-          '?-    error(type_error(list, [1, [], _A | 2]), eyeprolog).\n' +
+          '?-    error(type_error(list, [1, [], _A | 2]), number_chars / 2).\n' +
+          '?-    error(type_error(list, [1, [], _A | 2]), number_chars / 2).\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -2734,8 +2734,8 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    error(instantiation_error, eyeprolog).\n' +
-          '?-    Error = instantiation_error, Imp_def = eyeprolog.\n' +
+          '?-    error(instantiation_error, (is) / 2).\n' +
+          '?-    Error = instantiation_error, Imp_def = (is)/2.\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -4044,7 +4044,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         const result = runCli([], { input: 'statistics(nonsense, Value).\nhalt.\n' });
         assertEqual(result.status, 0, 'exit status');
         assertIncludes(result.stdout,
-          'error(domain_error(statistics_key, nonsense), eyeprolog).',
+          'error(domain_error(statistics_key, nonsense), statistics / 2).',
           'statistics key error');
         assertEqual(result.stderr, '', 'stderr');
       },
@@ -4427,6 +4427,42 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
         assertIncludes(result.stdout, 'answer([1, 2, 3])', 'library append/2 still uses the library append/3');
       },
     },
+    {
+      // Directives come from a fixed list, so an unrecognized one is a
+      // different mistake from unparseable input and gets its own message
+      // instead of the generic parser 'bad term'.
+      name: 'unsupported directives report why they were rejected',
+      run: () => {
+        const goalDirective = runCli(['-'], { input: ':- write(hello), nl.\n' });
+        assertEqual(goalDirective.status, 1, 'goal directive status');
+        assertIncludes(goalDirective.stderr, 'unknown directive write/1', 'goal directive indicator');
+        assertIncludes(goalDirective.stderr, 'initialization(Goal)', 'goal directive remedy');
+        assertNotIncludes(goalDirective.stderr, 'bad term', 'no generic parser message');
+
+        const misspelt = runCli(['-'], { input: ':- dynamc(foo/1).\n' });
+        assertEqual(misspelt.status, 1, 'misspelt status');
+        assertIncludes(misspelt.stderr, 'did you mean dynamic?', 'near-miss suggestion');
+
+        const wrongArity = runCli(['-'], { input: ':- dynamic(foo/1, bar).\n' });
+        assertEqual(wrongArity.status, 1, 'wrong arity status');
+        assertIncludes(wrongArity.stderr, 'expected dynamic/1', 'arity guidance');
+
+        const notCallable = runCli(['-'], { input: ':- 42.\n' });
+        assertEqual(notCallable.status, 1, 'non-callable status');
+        assertIncludes(notCallable.stderr, 'must be a callable term', 'callable guidance');
+      },
+    },
+    {
+      // Genuinely malformed input must keep reporting a syntax error rather
+      // than being misreported as a directive problem.
+      name: 'malformed terms still report a parse error',
+      run: () => {
+        const result = runCli(['-'], { input: 'foo(1). bar(\n' });
+        assertEqual(result.status, 1, 'exit status');
+        assertIncludes(result.stderr, 'parse line', 'parse error');
+        assertNotIncludes(result.stderr, 'unknown directive', 'not a directive message');
+      },
+    },
     {
       name: 'double dash permits option-shaped file names',
       run: () => {
@@ -5046,7 +5082,7 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
             goal: 'answer(T)',
             ioOptions: { input: invalidOctal },
           }).stdout,
-          'answer(error(syntax_error(read_term), eyeprolog)).\n',
+          'answer(error(syntax_error(read_term), read / 1)).\n',
           'read/1 rejects non-octal numeric escape',
         );
       },

package/test/run-iso-strict.mjs

@@ -649,7 +649,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
           'close(tmp_in)',
           'current_input(C)',
           'stream_property(C,alias(user_input))',
-          'catch(set_input(tmp_in),error(existence_error(stream,tmp_in),eyeprolog),true)',
+          'catch(set_input(tmp_in),error(existence_error(stream,tmp_in),set_input/1),true)',
         ].join(','),
       }).stats.completed_goal_lists, 1, 'stream-term, alias lifetime, target/current input, and close fallback');
 
@@ -856,14 +856,14 @@ export function runIsoStrict(reporter = new TestReporter()) {
 
   reporter.test('closes the ISO 7.12 processor error envelope and classification rows', () => {
     const caught = [
-      "catch(atom_length(X,N),error(instantiation_error,eyeprolog),true)",
-      "catch(atom_length(1,N),error(type_error(atom,1),eyeprolog),true)",
-      "catch(op(1300,xfx,foo),error(domain_error(operator_priority,1300),eyeprolog),true)",
+      "catch(atom_length(X,N),error(instantiation_error,atom_length/2),true)",
+      "catch(atom_length(1,N),error(type_error(atom,1),atom_length/2),true)",
+      "catch(op(1300,xfx,foo),error(domain_error(operator_priority,1300),op/3),true)",
       "catch(call(no_such_predicate),error(existence_error(procedure,no_such_predicate/0),eyeprolog),true)",
-      "catch(abolish(atom/1),error(permission_error(modify,static_procedure,atom/1),eyeprolog),true)",
-      "catch(char_code(C,1114112),error(representation_error(character_code),eyeprolog),true)",
-      "catch(X is 1/0,error(evaluation_error(zero_divisor),eyeprolog),true)",
-      "catch(X is 1<<4294967296,error(resource_error(memory),eyeprolog),true)",
+      "catch(abolish(atom/1),error(permission_error(modify,static_procedure,atom/1),abolish/1),true)",
+      "catch(char_code(C,1114112),error(representation_error(character_code),char_code/2),true)",
+      "catch(X is 1/0,error(evaluation_error(zero_divisor),(is)/2),true)",
+      "catch(X is 1<<4294967296,error(resource_error(memory),(is)/2),true)",
     ];
     for (const goal of caught) {
       equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
@@ -871,14 +871,14 @@ export function runIsoStrict(reporter = new TestReporter()) {
 
     equal(run('', {
       isoStrict: true,
-      goal: "catch(read_term(T,[]),error(syntax_error(read_term),eyeprolog),true)",
+      goal: "catch(read_term(T,[]),error(syntax_error(read_term),read_term/2),true)",
       ioOptions: { input: "'unterminated." },
     }).stats.completed_goal_lists, 1, 'syntax error uses error/2 envelope and implementation-defined context');
 
     const systemSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
     systemSolver.io.flush = () => { throw new Error('simulated host I/O failure'); };
     equal([...systemSolver.solve([
-      parseGoalText('catch(flush_output(user_output),error(system_error,eyeprolog),true)', { isoStrict: true }),
+      parseGoalText('catch(flush_output(user_output),error(system_error,flush_output/1),true)', { isoStrict: true }),
     ], new Env(), 0)].length, 1, 'system error uses error/2 envelope and implementation-defined context');
 
     // ISO 7.12 deliberately leaves the choice implementation-dependent when