eyeprolog 1.2.2 → 1.2.4

package/examples/access-control-policy.pl

@@ -53,3 +53,5 @@ status(test1, policy_passed) :-
 
 reason(test1, "all required claims are present, one allowed claim is present, and no forbidden claim is present") :-
   passes_policy(test1, policy_x).
+
+:- set_prolog_flag(unknown, fail).

package/examples/d3-group.pl

@@ -102,3 +102,5 @@ subgroupCount(d3_group, Count) :-
   length(Groups, Count).
 
 reason(d3_group, "findall enumerates candidate subgroups and sort gives canonical subgroup order").
+
+:- set_prolog_flag(unknown, fail).

package/examples/fast-fourier-transform.pl

@@ -53,3 +53,4 @@ node(n(A1, N1), [n(A, N)|T]-[n(A1, N1), n(A, N)|T]) :-
 % query
 %% goal: fft([0, 1, 2, 3, 4, 5, 6, 7], _)
 
+:- set_prolog_flag(unknown, fail).

package/examples/map-four-color-search.pl

@@ -66,3 +66,5 @@ four_color_answer(european_union, Coloring) :-
   place_order(Places),
   place_pairs(Places, Coloring),
   once(color_places(Coloring)).
+
+:- set_prolog_flag(unknown, fail).

package/examples/partial-evaluator.pl

@@ -72,3 +72,5 @@ residual_program(Name, Residual) :- program(Name, Expr, Env), pe(Env, Expr, Resi
 
 partialEvalAnswer(residual(Name), Residual) :- residual_program(Name, Residual).
 partialEvalAnswer(note, "static inputs are folded while dynamic variables remain as residual code") :- residual_program(poly_y, _).
+
+:- set_prolog_flag(unknown, fail).

package/examples/weighted-interval-scheduling.pl

@@ -82,3 +82,5 @@ weighted_interval_answer(chosen_interval, interval(I, Start, Finish, Value)) :-
   chosen_from(1, I),
   interval(I, Start, Finish, Value).
 weighted_interval_answer(candidate_count, Count) :- countall(interval(_i, _start, _finish, _value), Count).
+
+:- set_prolog_flag(unknown, fail).

package/package.json

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

package/src/repl.js

@@ -34,7 +34,7 @@ export async function runRepl(engine, options = {}) {
         const goal = parseGoal(engine, state, text);
         if (!options.isoStrict && isUseModuleGoal(goal)) {
           sources.push({ text: `:- ${text}.\n`, filename: '<repl>' });
-          state = makeState(engine, sources, output, options);
+          state = makeState(engine, sources, output, options, state);
           state.solver.runInitializations();
           output.write('   true.\n');
           continue;
@@ -42,16 +42,22 @@ export async function runRepl(engine, options = {}) {
         const consultFiles = options.isoStrict ? null : consultDesignations(engine, goal);
         if (consultFiles != null) {
           for (const filename of consultFiles) sources.push(await readSource(filename));
-          state = makeState(engine, sources, output, options);
+          state = makeState(engine, sources, output, options, state);
           state.solver.runInitializations();
           output.write('   true.\n');
           continue;
         }
 
-        const result = await solveQuery(engine, state, goal, reader, output);
-        if (result?.halted) {
-          exitCode = result.code;
-          break;
+        const flagsBefore = snapshotFlagValues(state.solver);
+        try {
+          await prepareInteractiveTermInput(state, goal, reader);
+          const result = await solveQuery(engine, state, goal, reader, output);
+          if (result?.halted) {
+            exitCode = result.code;
+            break;
+          }
+        } finally {
+          rememberFlagOverrides(state, flagsBefore);
         }
       } catch (error) {
         if (error?.name === 'HaltSignal') {
@@ -142,7 +148,7 @@ class LineReader {
   }
 }
 
-function makeState(engine, sources, output, options = {}) {
+function makeState(engine, sources, output, options = {}, previousState = null) {
   const strictIso = options.isoStrict === true;
   const program = engine.Program.parseSources(sources, { strictIso, sourceMetadata: strictIso });
   const solver = new engine.Solver(program, {
@@ -150,7 +156,25 @@ function makeState(engine, sources, output, options = {}) {
     isoStrict: strictIso,
     ioOptions: { write: (text) => output.write(String(text)) },
   });
-  return { program: solver.program, solver, strictIso };
+  const flagOverrides = new Map(previousState?.flagOverrides ?? []);
+  for (const [name, value] of flagOverrides) {
+    const definition = solver.prologFlags.get(name);
+    if (definition?.changeable && definition.allowed.includes(value)) {
+      definition.value = engine.atom(value);
+    }
+  }
+  return { program: solver.program, solver, strictIso, flagOverrides };
+}
+
+function snapshotFlagValues(solver) {
+  return new Map([...solver.prologFlags].map(([name, definition]) => [name, definition.value?.name]));
+}
+
+function rememberFlagOverrides(state, before) {
+  for (const [name, definition] of state.solver.prologFlags) {
+    const value = definition.value?.name;
+    if (before.get(name) !== value) state.flagOverrides.set(name, value);
+  }
 }
 
 async function readQuery(reader) {
@@ -166,6 +190,57 @@ async function readQuery(reader) {
   }
 }
 
+async function prepareInteractiveTermInput(state, goal, reader) {
+  const stream = interactiveTermInputStream(state, goal);
+  if (stream == null || terminalFullStop(String(stream.content).slice(stream.position)) >= 0) return;
+
+  const text = await readInteractiveTerm(reader);
+  if (text == null) return;
+  stream.content += text;
+  stream.pastEnd = false;
+}
+
+function interactiveTermInputStream(state, goal) {
+  if (goal.type !== 'compound') return null;
+  let reference = null;
+  if (goal.name === 'read' && goal.arity === 1) {
+    reference = state.solver.io.currentInput;
+  } else if (goal.name === 'read' && goal.arity === 2) {
+    reference = explicitInputReference(goal.args[0]);
+  } else if (goal.name === 'read_term' && goal.arity === 2) {
+    reference = state.solver.io.currentInput;
+  } else if (goal.name === 'read_term' && goal.arity === 3) {
+    reference = explicitInputReference(goal.args[0]);
+  } else {
+    return null;
+  }
+
+  const stream = reference == null ? null : state.solver.io.resolve(reference);
+  return stream?.standard && stream.alias === 'user_input' && stream.mode === 'read' ? stream : null;
+}
+
+function explicitInputReference(term) {
+  if (term.type === 'atom') return term.name;
+  if (term.type === 'compound' && term.name === '$stream' && term.arity === 1 &&
+      term.args[0].type === 'number' && /^\d+$/.test(term.args[0].name)) {
+    return Number(term.args[0].name);
+  }
+  return null;
+}
+
+async function readInteractiveTerm(reader) {
+  let source = '';
+  let prompt = '|: ';
+  while (true) {
+    const line = await reader.read(prompt);
+    if (line == null) return source.trim() ? source : null;
+    source += `${line}\n`;
+    const end = terminalFullStop(source);
+    if (end >= 0) return source.slice(0, end + 1) + '\n';
+    prompt = '|    ';
+  }
+}
+
 function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;

package/src/solver.js

@@ -49,7 +49,7 @@ export class Solver {
     this.inferenceLimitExceeded = false;
     this.solutionLimit = options.solutionLimit ?? 10000000;
     this.solutionsSeen = 0;
-    this.prologFlags = options.prologFlags ?? defaultPrologFlags(this.registry?.eyePrologLibrary ? 'fail' : 'error', this.isoStrict);
+    this.prologFlags = options.prologFlags ?? defaultPrologFlags('error', this.isoStrict);
     if (this.isoStrict) {
       for (const name of [...this.prologFlags.keys()]) {
         if (!ISO_CORE_FLAG_NAMES.has(name)) this.prologFlags.delete(name);

package/test/conformance/ISO-COMPLIANCE.md

@@ -38,7 +38,7 @@ error-ordering alternative to an individual executable assertion.
 | 7.8 — control constructs and exceptions | audit | call, cut, conjunction, disjunction, if-then, catch/throw, renamed-copy tests. |
 | 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Exceptional-value/error-precedence matrix remains to be exhaustively enumerated. |
 | 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, Corrigendum 3 writer cases. Full option cross-product remains open. |
-| 7.11 — flags | audit | Required Part 1 flags implemented. Strict mode excludes the EyeProlog `occurs_check` extension and uses ISO `unknown=error`. |
+| 7.11 — flags | audit | Required Part 1 flags implemented. Normal and strict modes use the ISO `unknown=error` default; strict mode excludes the EyeProlog `occurs_check` extension. |
 | 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Complete prescribed-error ordering remains open. |
 | 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. Mode/error matrix is not yet one-row-per-standard-row. |
 | Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Host floating-point representation choices remain documented implementation-defined behavior. |

package/test/conformance/ISO-MATRIX.md

@@ -31,9 +31,9 @@ integer powers (Cor.3).
 Implementation-defined choices are documented in *The Art of EyeProlog*:
 integers and arity are unbounded by the Prolog model (subject to host memory),
 ordinary unification performs an occurs check, `double_quotes` defaults to
-`chars`, strict core mode uses ISO `unknown=error` while normal EyeProlog
-defaults `unknown` to `fail`, `//` rounds toward zero, floating-point operations
-use finite ECMAScript numbers, and character codes use Unicode scalar values.
+`chars`, both strict core mode and normal EyeProlog use the ISO
+`unknown=error` default, `//` rounds toward zero, floating-point operations use
+finite ECMAScript numbers, and character codes use Unicode scalar values.
 
 This is an executable conformance matrix, not a certification issued by an
 independent standards body. Release gating runs the ISO cases and the dedicated

package/test/conformance/cases/aggregation/057_countall_empty_and_nonempty.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 item(a).
 item(b).
 answer(counts, counts(C, Z)) :- countall(item(X), C), countall(missing(X), Z).

package/test/conformance/cases/aggregation/075_aggregation_edges.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 % Reference 9.1: aggregation handles empty result sets, structured templates, and ordered best answers.
 %% goal: answer(X0, X1)
 

package/test/conformance/cases/aggregation/aggregate_max_no_answers_fails.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(ok) :- \+ aggregate_max(Key, Value, missing(Value), BestKey, BestValue).

package/test/conformance/cases/aggregation/countall_zero.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(N) :- countall(missing(X), N).

package/test/conformance/cases/aggregation/findall_empty_bag.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(Bag) :- findall(X, missing(X), Bag).

package/test/conformance/cases/aggregation/sumall_empty_zero.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(N) :- sumall(X, missing(X), N).

package/test/conformance/cases/control/074_forall_edges.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 % Reference 9.1: forall/2 succeeds for every generated binding, including the empty generator case.
 %% goal: answer(X0, X1)
 

package/test/conformance/cases/control/extra_not_unbound_unknown_goal_succeeds.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(not_unbound_unknown_goal_succeeds) :- \+ missing(X).

package/test/conformance/cases/control/extra_once_empty_fails.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(once_empty_fails) :- once(missing).

package/test/conformance/cases/control/forall_empty_generator_true.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(ok) :- \+ empty_counterexample.

package/test/conformance/cases/negation/not_unknown_goal_succeeds.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 % Negation succeeds when its inner goal has no solution.
 %% goal: answer(X0)
 

package/test/conformance/warnings/negation/extra_stratified_multiple_negations_quiet.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 p(a).

package/test/conformance/warnings/negation/extra_warning_preserves_empty_stdout.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 p(a) :- \+ q(a).

package/test/conformance/warnings/negation/negative_unknown_group_quiet.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 answer(ok) :- \+ missing(ok).

package/test/conformance/warnings/negation/stratified_negative_unknown_after_positive_quiet.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 %% goal: answer(X0)
 
 item(a).

package/test/conformance/warnings/negation/stratified_quiet.pl

@@ -1,3 +1,5 @@
+:- set_prolog_flag(unknown, fail).
+
 % Stratified negation emits no portability warning.
 %% goal: answer(X0)
 

package/test/run-regression.mjs

@@ -671,6 +671,29 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL read predicates consume following interactive term input',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'read(X).\n' +
+            'foo.\n' +
+            'read_term(Y, []).\n' +
+            "'\\7\\'.\n" +
+            'read(user_input, Z).\n' +
+            'bar.\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?- |:    X = foo.\n' +
+          "?- |:    Y = '\\a'.\n" +
+          '?- |:    Z = bar.\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL accepts multiline period-terminated queries',
       run: () => {
@@ -693,6 +716,36 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL preserves runtime unknown flag across consultation',
+      run: () => {
+        const filename = path.join(tmp, `repl-empty-${++tmpCounter}.pl`);
+        fs.writeFileSync(filename, '');
+        const result = runCli([], {
+          input:
+            'current_prolog_flag(unknown, V).\n' +
+            'set_prolog_flag(unknown, fail).\n' +
+            `[${sourceAtom(filename)}].\n` +
+            'current_prolog_flag(unknown, V).\n' +
+            'set_prolog_flag(unknown, error).\n' +
+            `[${sourceAtom(filename)}].\n` +
+            'missing_after_consult.\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    V = error.\n' +
+          '?-    true.\n' +
+          '?-    true.\n' +
+          '?-    V = fail.\n' +
+          '?-    true.\n' +
+          '?-    true.\n' +
+          '?-    error(existence_error(procedure, missing_after_consult / 0), eyeprolog).\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL use_module imports Part 2 library predicates',
       run: () => {
@@ -700,7 +753,11 @@ c4 ?- call((!;1)).
           input: 'append(X, Y, [1, 2, 3, 4]).\nuse_module(library(lists)).\nappend(X, Y, [1, 2, 3, 4]).\n\nhalt.\n',
         });
         assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, '?-    false.\n?-    true.\n?-    X = [], Y = [1, 2, 3, 4]\n;  ... .\n?- ', 'stdout');
+        assertEqual(result.stdout,
+          '?-    error(existence_error(procedure, append / 3), eyeprolog).\n' +
+          '?-    true.\n' +
+          '?-    X = [], Y = [1, 2, 3, 4]\n;  ... .\n?- ',
+          'stdout');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
@@ -1097,6 +1154,19 @@ c4 ?- call((!;1)).
         assertEqual(infix.arity, 2, 'quad query arity');
       },
     },
+    {
+      name: 'normal EyeProlog uses the ISO unknown=error default',
+      run: () => {
+        const program = Program.parse('');
+        const solver = new Solver(program, { registry: getEyePrologRegistry() });
+        assertEqual(solver.prologFlags.get('unknown')?.value?.name, 'error', 'normal unknown default');
+        assertEqual(
+          run('', { goal: 'current_prolog_flag(unknown, V)' }).stdout,
+          'current_prolog_flag(unknown, error).\n',
+          'public runner unknown default',
+        );
+      },
+    },
     {
       name: 'strict ISO core mode exposes only the Part 1 registry and flag surface',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5667,18 +5667,23 @@ silently changing a static program.
 | `max_integer` | `unbounded` | `unbounded` | no |
 | `min_integer` | `unbounded` | `unbounded` | no |
 | `max_arity` | `unbounded` | `unbounded` | no |
-| `unknown` | `fail` | `error`, `fail`, `warning` | yes |
+| `unknown` | `error` | `error`, `fail`, `warning` | yes |
 | `double_quotes` | `chars` | `chars`, `codes`, `atom` | yes |
 | `occurs_check` | `true` | `true`, `error` | yes |
 
-Strict ISO core mode defaults `unknown` to `error`; the normal EyeProlog
-environment defaults it to `fail`. The `occurs_check` flag is an EyeProlog
-diagnostic extension rather than an ISO-defined core flag: it is absent in
-strict mode, while normal mode keeps its `true` default and optional `error`
-diagnostic for STO attempts. Operator and flag directives are processed per
-program rather than changing global JavaScript state. The `double_quotes`
-setting affects subsequent source text, included files, command-line and API
-goal text, and terms read by `read_term/*`:
+Both normal EyeProlog and strict ISO core mode use the ISO `unknown=error`
+default. Interactive `set_prolog_flag/2` changes are retained when the REPL
+consults another file or imports a module instead of being reset by the host
+rebuild of the program. Programs that intentionally treat an undefined
+predicate as failure must opt in with `set_prolog_flag(unknown, fail)`; bundled
+examples and non-ISO corpus cases that depend on that policy do so explicitly.
+The `occurs_check` flag is an EyeProlog diagnostic
+extension rather than an ISO-defined core flag: it is absent in strict mode,
+while normal mode keeps its `true` default and optional `error` diagnostic for
+STO attempts. Operator and flag directives are processed per program rather
+than changing global JavaScript state. The `double_quotes` setting affects
+subsequent source text, included files, command-line and API goal text, and
+terms read by `read_term/*`:
 
 ```text
 % Default: a list of one-character atoms.
@@ -6216,8 +6221,21 @@ not be a valid right operand of the displayed `=/2`, EyeProlog adds parentheses,
 for example `T = (a = b).` rather than the invalid `T = a = b.`. Use `[file].`
 or `['file.pl'].` to
 consult local source, and `halt.` or `halt(Status).` to leave the top level.
-Up and Down recall queries from the current session. Explicit `eyeprolog -h`
-displays command-line help.
+A direct top-level `read/1-2` or `read_term/2-3` from `user_input` requests the
+next full-stop-terminated Prolog term with a `|: ` input prompt instead of
+treating the interactive input stream as already exhausted. For example:
+
+```text
+?- read(X).
+|: hello.
+   X = hello.
+```
+
+The top-level prompt itself is a host-interface convention rather than part of
+ISO/IEC 13211-1; the term that follows it is parsed by the same ISO term-input
+machinery as `read/1-2` and `read_term/2-3` on other text streams. Up and Down
+recall queries from the current session. Explicit `eyeprolog -h` displays
+command-line help.
 
 ### Selecting goals