eyeprolog 1.5.85 → 1.5.87

package/README.md

@@ -84,7 +84,7 @@ The checked [Symbiotic Knowledge Graphs example](examples/symbiotic-knowledge-gr
 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.
 
 ## Benchmarks
-EyeProlog has 21 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, the dynamic database, and bignum arithmetic. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark -- --save .benchmarks/baseline.json`; use `node test/run-benchmark-tests.mjs` for harness checks. For a classic LIPS number, run `node test/lips-benchmark.mjs`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog over the checked [`examples/bench.pl`](examples/bench.pl) naive-reverse workload (the classic Quintus 1984 `nrev/2` benchmark on a 30-element list), subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
+EyeProlog has 21 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, the dynamic database, and bignum arithmetic. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark -- --save .benchmarks/baseline.json`; use `node test/run-benchmark-tests.mjs` for harness checks. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
 For the project policy on post-ISO-standard and WG17 compatibility features such as digit separators, see [ISO/WG17 compatibility extensions](test/conformance/ISO-WG17-EXTENSIONS.md).
 ## Development
 ```sh

package/package.json

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

package/src/quads.js

@@ -82,7 +82,7 @@ function checkDescription(program, quad, description, options, context) {
     if (part.type === ATOM && part.name === 'other_answer_sequence') {
       const previous = alternatives.at(-1);
       if (previous == null || unordered.has(previous)) {
-        return { ok: false, kind: 'malformed', expected: part };
+        return { ok: false, kind: 'malformed', expected: part, alternative: previous ?? undefined };
       }
       unordered.add(previous);
     } else alternatives.push(part);
@@ -93,7 +93,13 @@ function checkDescription(program, quad, description, options, context) {
     Number(alternativeDescribesLoop(right)) - Number(alternativeDescribesLoop(left)));
   for (const alternative of ordered) {
     const malformed = malformedAlternative(quad.query, alternative);
-    if (malformed != null) return { ok: false, kind: 'malformed', expected: malformed };
+    // Carry the whole offending `|`-alternative alongside the narrow
+    // sub-term the check actually tripped on: with several alternatives (the
+    // norm for `sto`-annotated queries -- see issue #112's follow-up),
+    // formatFailure shows this alternative in full and elides its siblings
+    // instead of leaving a reader to guess which branch a bare sub-term like
+    // `_B = [E|_B]` came from.
+    if (malformed != null) return { ok: false, kind: 'malformed', expected: malformed, alternative };
   }
   let unsupported = null;
   let undecided = null;
@@ -111,19 +117,19 @@ function checkAlternative(program, quad, alternative, options, context, unordere
   const requiresSto = leaves.some((leaf) => leaf.sto);
   const unsupported = leaves.find((leaf) => leaf.unsupported != null)?.unsupported;
   if (unsupported != null) {
-    return { ok: false, kind: 'unsupported', expected: unsupported };
+    return { ok: false, kind: 'unsupported', expected: unsupported, alternative };
   }
 
   // A permutation describes a complete sequence, not an arbitrary prefix or
   // a negative assertion. Do not silently weaken those annotations.
   if (unordered && leaves.some((leaf) => leaf.more || leaf.unexpected || leaf.sto ||
       leaf.waits || leaf.input != null || leaf.peek != null)) {
-    return { ok: false, kind: 'unsupported', expected: alternative };
+    return { ok: false, kind: 'unsupported', expected: alternative, alternative };
   }
 
   const ioLeaves = leaves.filter((leaf) => leaf.input != null || leaf.peek != null);
   if (ioLeaves.length > 1 || (ioLeaves.length > 0 && leaves.length !== 1)) {
-    return { ok: false, kind: 'malformed', expected: alternative };
+    return { ok: false, kind: 'malformed', expected: alternative, alternative };
   }
   const hasInputSpec = ioLeaves.length === 1;
   const inputLeaf = ioLeaves[0] ?? null;
@@ -986,6 +992,28 @@ const FAILURE_LABELS = {
   undecided: 'UNDECIDED',
 };
 
+// With several `|`-separated alternatives -- the norm for `sto`-annotated
+// queries -- a bare offending sub-term like `_B = [E|_B]` gives no sense of
+// which alternative it came from (issue #112's follow-up). Show that whole
+// alternative in place, and stand in for its siblings with `...` rather than
+// reproducing them (they were not the problem) or dropping them silently
+// (a reader can no longer tell how many alternatives, or which one, this was).
+// Returns null when the description has only one alternative to begin with:
+// there is then nothing to elide, and the existing plain rendering already
+// shows the whole thing.
+function formatAlternativeContext(program, description, alternative) {
+  const parts = splitOperator(description, '|');
+  if (parts.length <= 1 || !parts.includes(alternative)) return null;
+  return parts.map((part) => (part === alternative ? formatQuadTerm(program, part) : '...')).join(' | ');
+}
+
+// A trailing `...` glued straight to a full stop reads as four dots; the
+// quad answer-description syntax itself always writes a space before the
+// period in that position (see `..., ad_infinitum` vs `... .`), so match it.
+function terminate(text) {
+  return text.endsWith('...') ? `${text} .` : `${text}.`;
+}
+
 function formatFailure(program, quad, result, description = quad.answers[0]) {
   const source = quad.source ?? { filename: '<input>', line: 1 };
   // Point at the failing answer description's own line rather than always the
@@ -995,9 +1023,19 @@ function formatFailure(program, quad, result, description = quad.answers[0]) {
   const label = quad.id == null ? '' : `${formatQuadTerm(program, quad.id)}, `;
   const reason = FAILURE_LABELS[result.kind] ?? 'FAILED';
   const expected = result.expected ?? description;
+  const context = result.alternative != null
+    ? formatAlternativeContext(program, description, result.alternative)
+    : null;
   const detail = result.kind === 'undecided'
     ? `   undecided: ${result.reason}.\n`
-    : `   expected: ${formatQuadTerm(program, expected)}.\n`;
+    // When the offending sub-term already *is* the whole alternative (an
+    // `expected:` line would just repeat the context line), the context line
+    // alone is the full, non-redundant report.
+    : context != null && expected === result.alternative
+      ? `   ${terminate(context)}\n`
+      : context != null
+        ? `   ${terminate(context)}\n   expected: ${formatQuadTerm(program, expected)}.\n`
+        : `   expected: ${formatQuadTerm(program, expected)}.\n`;
   return `quads: ${reason} ${label}${source.filename}:${line}\n` +
     `   ?- ${formatQuadTerm(program, quad.query)}.\n` + detail;
 }

package/test/README.md

@@ -27,7 +27,6 @@ These runners retain their existing options; there is no separate npm alias for
 each one. Focused checks do not replace the full release gate.
 
 For performance measurements, use `npm run benchmark`. Save a local baseline with
-`npm run benchmark -- --save .benchmarks/baseline.json`, or run
-`node test/lips-benchmark.mjs` for the classic LIPS measurement.
+`npm run benchmark -- --save .benchmarks/baseline.json`.
 
 See the [conformance guide](conformance/README.md) for report maintenance.

package/test/fixtures/README.md

@@ -17,21 +17,18 @@ quads for the ISO read and write option `variable_names/1`:
 Retrieved on 2026-08-25. It is vendored so all input, output, waiting, and
 error cases remain release-gated.
 
-`prologue_quad.pl` is an unmodified snapshot of the 72 machine-readable quads
-for the predicates proposed by the Prolog Prologue working draft:
-
-<https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue_quad.pl>
-
-The corresponding working draft is at
-<https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue>.
-The corpus snapshot was retrieved on 2026-09-12; it merges what used to be
-tracked as a separate, narrower `call_nth` corpus (retired -- see git
-history) and updates the `member/2`, `select/3`, `nth0/3`, and `max_integer`
-quads to the working draft's current wording. The regression gate requires
-the entire vendored corpus to pass outright, the same as the live Neumerkel
-gate checks the current upstream bytes on every `npm test` run (see
-[NEUMERKEL-LIVE.md](../conformance/NEUMERKEL-LIVE.md)).
-
-`prologue_quad_runner.pl` loads EyeProlog's `library(prologue)` and includes
-the unmodified corpus, mirroring the draft's requirement that a Prologue be
-included before its examples are run.
+There used to be a `prologue_quad.pl`/`prologue_quad_runner.pl` pair here: an
+unmodified snapshot of the Prolog Prologue working draft's machine-readable
+quads (<https://www.complang.tuwien.ac.at/ulrich/iso-prolog/prologue_quad.pl>),
+plus a runner that loaded `library(prologue)` before including it. It was
+retired (see git history) once its coverage became strictly redundant with
+the *live* Prologue source the Neumerkel gate already fetches and checks on
+every `npm test` run -- the same reason the WG17 syntax matrix has no
+vendored snapshot of its own either (see
+[NEUMERKEL-LIVE.md](../conformance/NEUMERKEL-LIVE.md) and
+[conformance/README.md](../conformance/README.md)). Unlike `phrase_quad.pl`
+and `variable_names_quad.pl` below, the vendored Prologue corpus also
+included two open-ended STO/rational-tree generator quads
+(`member(X,X)`, `select(E,Xs,Xs)`) that made checking it offline
+disproportionately slow, with no coverage benefit over the live gate to
+justify the cost.

package/test/regression/cases-regression.mjs

@@ -2396,41 +2396,6 @@ c4 ?- call((!;1)).
         }
       },
     },
-    {
-      name: 'runQuads passes the complete vendored Prolog Prologue corpus',
-      run: () => {
-        const filename = path.join(testRoot, 'fixtures', 'prologue_quad_runner.pl');
-        const source = fs.readFileSync(filename, 'utf8');
-        const program = Program.parseSources([{
-          text: source,
-          filename,
-          baseDir: path.dirname(filename),
-        }]);
-        assertEqual(program.quads.length, 72, 'vendored quad total');
-        const maxIntegerQuads = program.quads.filter(({ query }) =>
-          termToString(query).includes('current_prolog_flag(max_integer, MI)'));
-        assertEqual(maxIntegerQuads.length, 4, 'max_integer quad count');
-
-        // The full 72-quad corpus, including its rational-tree/occurs-check
-        // STO examples (member(X,X) and select(E,Xs,Xs), both open-ended
-        // native-generator searches -- see the maxInferences accounting added
-        // to generatedLengthAllocationCheckpoint in src/solver.js) is bounded
-        // and takes on the order of several seconds, not the indefinite hang
-        // it used to depend on ambient heap pressure to avoid (see
-        // Solver#reclaimMemory in src/solver.js).
-        const result = publicApi.runQuads(program);
-        // The current upstream max_integer quads already accept EyeProlog's
-        // own bounded=false behavior (no max_integer value, so
-        // current_prolog_flag(max_integer, MI) simply fails); a stale, since
-        // superseded vendored snapshot once needed a documented divergence
-        // for this (see git history), but the current upstream corpus needs
-        // none: the whole vendored corpus passes outright.
-        assertEqual(result.total, 72, 'quad total');
-        assertEqual(result.passed, 72, 'quad passed');
-        assertEqual(result.failed, 0, 'quad failed');
-        assertEqual(result.stdout, 'quads: 72 run, 72 passed, 0 failed.\n', 'quad report');
-      },
-    },
     {
       name: 'CLI passes the complete authoritative length quad corpus',
       run: () => {
@@ -2587,6 +2552,42 @@ c4 ?- call((!;1)).
         assertEqual(result.total, 1, 'quad total');
         assertEqual(result.failed, 1, 'quad failed');
         assertIncludes(result.stdout, 'quads: MALFORMED malformed-quad.pl:2', 'malformed report');
+        // A single `|`-alternative already is the whole answer description --
+        // there is nothing to elide, so the plain, unelided report is
+        // unchanged (contrast the multi-alternative case just below).
+        assertNotIncludes(result.stdout, ' | ', 'single-alternative report stays unelided');
+      },
+    },
+    {
+      name: 'runQuads shows a malformed sub-term in the context of its full sibling-elided alternative (issue #112)',
+      run: () => {
+        // Adapted from the upstream Prologue `select(E, Xs, Xs)` quad
+        // (https://github.com/eyereasoner/eyeprolog/issues/112#issuecomment-5645403025):
+        // a query-unrelated `Ys` stands in for the legitimate forward-reference
+        // idiom so this stays malformed regardless of that fix. With three
+        // `|`-alternatives, a bare `expected: Ys = [E|Ys].` gives no sense of
+        // which one it came from; the report should instead show that whole
+        // alternative in place and stand in for its siblings with `...`.
+        const source = `:- use_module(library(prologue)).
+?- select(E, Xs, Xs).
+   sto,
+   loops
+|  sto,
+   Xs = [E|Xs]
+;  Xs = [_A|_B], Ys = [E|Ys]
+;  ..., ad_infinitum
+|  sto,
+   Xs = [E,E|_A]
+;  Xs = [_A,E,E|_B]
+;  ..., ad_infinitum.
+`;
+        const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'select-quad.pl' }]));
+        assertEqual(result.total, 1, 'quad total');
+        assertEqual(result.failed, 1, 'quad failed');
+        assertIncludes(result.stdout,
+          '   ... | sto, Xs = [E | Xs] ; Xs = [_A | _B], Ys = [E | Ys] ; ..., ad_infinitum | ... .\n',
+          'sibling-elided alternative context');
+        assertIncludes(result.stdout, '   expected: Ys = [E | Ys].\n', 'still-precise offending sub-term');
       },
     },
     {

package/test/run-benchmark-tests.mjs

@@ -70,16 +70,4 @@ ok(adaptive.results[0].batchSize > 1, 'adaptive benchmark smoke test should batc
 ok(adaptive.results[0].sha256 === manifest.find((item) => item.name === 'dcg-expression').expectedSha256,
   'adaptive batching should preserve the semantic checksum');
 
-const classicLips = await spawnJson([
-  path.join(root, 'test', 'lips-benchmark.mjs'),
-  '--count', '20',
-  '--runs', '1',
-  '--warmup', '1',
-  '--json',
-]);
-ok(classicLips.count === 20, 'classic LIPS harness should honor the requested reversal count');
-ok(classicLips.methodology.includes('496 calls/reversal'), 'classic LIPS harness should identify the historical accounting');
-ok(Number.isFinite(classicLips.lips) && classicLips.lips > 0, 'classic LIPS harness should report positive CPU LIPS');
-ok(Number.isFinite(classicLips.netCpuMs) && classicLips.netCpuMs > 0, 'classic LIPS harness should subtract positive CPU time');
-
 process.stdout.write(`Benchmark harness tests: ${passed}/${passed} passed.\n`);

package/the-art-of-eyeprolog.md

@@ -10366,7 +10366,6 @@ and fast:
 ```sh
 npm run benchmark
 npm run benchmark -- --save .benchmarks/baseline.json
-node test/lips-benchmark.mjs
 ```
 
 The benchmark suite contains 21 representative workloads and stores their
@@ -10378,15 +10377,6 @@ with independent `run()` calls until a batch is roughly 400 ms long. After one
 warm-up batch, five measured batches are reported as milliseconds per workload
 execution. Naturally long workloads keep a batch size of one.
 
-The classic `examples/bench.pl` workload also has a dedicated LIPS harness.
-`node test/lips-benchmark.mjs` follows the 1984 Quintus method more closely than the
-generic runner: `dobench/1` and `dodummy/1` execute failure-driven loops inside
-Prolog, the dummy CPU time is subtracted, and the remaining time is converted
-using 496 procedure calls for one reversal of the 30-element list. Node's
-process CPU clock is used for the primary figure, with wall-clock LIPS printed
-as a cross-check. Because LIPS measures a deliberately small recursive kernel,
-it is useful for engine tuning but is not a complete application benchmark.
-
 The report shows the median, per-operation range, chosen batch size, saved
 baseline median, and the percentage change between the current median and baseline
 median. The range remains visible as context, but it does not suppress or reinterpret

package/test/fixtures/prologue_quad.pl

@@ -1,287 +0,0 @@
-% p.p.1 member/2
-
-?- member(X, [1,2]).
-   X = 1
-;  X = 2.
-
-?- member(1, L).
-   L = [1|_A]
-;  L = [_A,1|_B]
-;  L = [_A,_B,1|_C]
-;  ..., ad_infinitum.
-
-?- member(X, [Y,Z|nonlist]).
-   X = Y
-;  X = Z.
-
-?- member(X, nonlist).
-   false.
-
-?- member(X, X).
-   sto, % occurs-check
-   loops
-|  sto, % rational trees
-   X = [X|_A]
-;  X = [_A,X|_B]
-;  X = [_A,_B,X|_C]
-;  ..., ad_infinitum
-|  sto, % literal substitutions
-   X = [_A|_B]
-;  X = [_A,[_A,[_A|_B]|_C]|_C]
-;  X = [_A,_B,[_A,_B,[_A,_B|_C]|_D]|_D]
-;  ..., ad_infinitum.
-
-% p.p.2 append/3
-
-?- append([a,b],[c,d], Xs).
-   Xs = [a,b,c,d].
-
-?- append([a], nonlist, Xs).
-   Xs = [a|nonlist].
-
-?- append([a], Ys, Zs).
-   Zs = [a|Ys].
-
-?- append(Xs, Ys, [a,b,c]).
-   Xs = [], Ys = [a,b,c]
-;  Xs = [a], Ys = [b,c]
-;  Xs = [a,b], Ys = [c]
-;  Xs = [a,b,c], Ys = [].
-
-% p.p.3 length/2
-
-?- length([a,b,c], Length).
-   Length = 3.
-
-?- length(List, 5).
-   List = [_,_,_,_,_].
-
-?- length(List, Length).
-   List = [], Length = 0
-;  List = [_], Length = 1
-;  List = [_,_], Length = 2
-;  ... . % Ad infinitum.
-
-% p.p.4 between/3
-
-?- between(1, 2, 0).
-   false.
-
-?- between(1, 2, I).
-   I = 1
-;  I = 2.
-
-?- between(2, 1, I).
-   false.
-
-?- between(I, I, 0).
-   instantiation_error.
-
-?- between(1, I, 0).
-   instantiation_error.
-
-?- between(I, -1, 0).
-   instantiation_error.
-
-?- between(1, c, 0).
-   type_error(integer,c).
-
-?- between(1+1,2,I).
-   type_error(integer,1+1).
-
-% p.p.5 select/3
-
-?- select(X, [1,2], Xs).
-   X = 1, Xs = [2]
-;  X = 2, Xs = [1].
-
-?- select(X, [Y|nonlist], Xs).
-   X = Y, Xs = nonlist.
-
-?- select(E, Xs, Xs).
-   sto, % occurs-check
-   loops
-|  sto, % rational trees
-   Xs = [E|Xs]
-;  Xs = [_A|_B], _B = [E|_B]
-;  ..., ad_infinitum
-|  sto, % literal substitutions
-   Xs = [E,E|_A]
-;  Xs = [_A,E,E|_B]
-;  ..., ad_infinitum.
-
-% p.p.6 succ/2
-
-?- succ(X, S).
-   instantiation_error.
-
-?- succ(X, X).
-   instantiation_error.
-
-?- succ(0, S).
-   S = 1.
-
-?- succ(1, 1+1).
-   type_error(integer, 1+1).
-
-?- succ(X, 0).
-   false.
-
-?- succ(-1, S).
-   domain_error(not_less_than_zero, -1).
-
-?- current_prolog_flag(max_integer, MI), succ(MI, 0).
-   false.
-
-?- current_prolog_flag(max_integer, MI), succ(MI, 1).
-   false.
-
-?- current_prolog_flag(max_integer, MI), succ(MI, MI).
-   false.
-
-?- current_prolog_flag(max_integer, MI), succ(MI, S).
-   false
-|  evaluation_error(int_overflow)
-|  representation_error(max_integer).
-
-% p.p.7
-
-?- maplist(>(3), [1, 2]).
-   true.
-
-?- maplist(>(3), [1, 2, 3]).
-   false.
-
-?- maplist(=(X), Xs).
-   Xs = []
-;  Xs = [X]
-;  Xs = [X, X]
-;  Xs = [X, X, X]
-;  ... . % Ad infinitum.
-
-% p.p.8
-
-?- nth0(1, [a,b,c], E).
-   E = b.
-
-?- nth0(N, [a,b,c], E).
-   N = 0, E = a
-;  N = 1, E = b
-;  N = 2, E = c.
-
-?- nth0(0, [A,B|non_list], E).
-   A = E.
-
-?- nth0(2, Es, E).
-   Es = [_A,_B,E|_C].
-
-?- nth0(N, Es, E).
-   N = 0, Es = [E|_A]
-;  N = 1, Es = [_A,E|_B]
-;  N = 2, Es = [_A,_B,E|_C]
-;  N = 3, Es = [_A,_B,_C,E|_D]
-;  ..., ad_infinitum.
-
-?- nth0(non_integer, Es, E).
-   type_error(integer, non_integer).
-
-?- nth0(-1, Es, E).
-   domain_error(not_less_than_zero, -1).
-
-?- nth0(N, [[]|Es], Es).
-   N = 0, Es = []
-;  sto, % occurs-check
-   loops
-|  N = 0, Es = []
-;  sto, % rational trees
-   N = 1, Es = [Es|_A]
-;  N = 2, Es = [_A,Es|_B]
-;  ..., ad_infinitum.
-
-?- nth1(0, Es, E).
-   false.
-
-% p.p.9
-
-?- call_nth(true, Nth).
-   Nth = 1.
-
-?- call_nth(false, Nth).
-   false.
-
-?- call_nth(repeat, Nth).
-   Nth = 1
-;  Nth = 2
-;  Nth = 3
-;  Nth = 4
-;  Nth = 5
-;  ... .
-
-?- call_nth(( N = 1 ; N = 2 ), Nth).
-   N = 1, Nth = 1
-;  N = 2, Nth = 2.
-
-?- call_nth(true, non_integer).
-   type_error(integer,non_integer).
-
-?- call_nth(true, 1.0).
-   type_error(integer,1.0).
-
-?- call_nth(true, 0).
-   false.
-
-?- call_nth(repeat, 0).
-   false.
-
-?- call_nth(repeat, -1).
-   domain_error(not_less_than_zero,-1).
-
-?- call_nth(length(L,N), 3).
-   L = [_A,_B], N = 2.
-
-?- call_nth(inex, 0).
-   false. % thus not existence_error(procedure,inex/0)
-
-?- call_nth(inex, 0).
-   existence_error(procedure,...), unexpected.
-
-?- call_nth(1, 0).
-   false.
-
-?- call_nth(V, 0).
-   false.
-
-?- call_nth(N = 1, N).
-   N = 1.
-
-?- call_nth(N = -1, N).
-   false.
-
-?- call_nth(repeat,1+1).
-   type_error(integer,1+1).
-
-% p.p.10
-
-?- foldl(append, [[1,2],[3],[4,5]], [],Xs).
-   Xs = [4,5,3,1,2].
-
-% p.p.11
-
-?- countall((X=1;X=2), N).
-   N = 2.
-?- countall((true;true), N).
-   N = 2.
-?- countall(G_0, N).
-   instantiation_error.
-?- countall((length(L,5),nth0(_,L,_),nth0(_,L,_)), N).
-   N = 25.
-?- countall(N = 1, N).
-   N = 1.
-?- countall(N = non_integer, N).
-   N = 1.
-?- countall(false, 1).
-   false.
-?- countall(false, -1).
-   domain_error(not_less_than_zero,-1).
-?- countall(false, non_integer).
-   type_error(integer,non_integer).

package/test/fixtures/prologue_quad_runner.pl

@@ -1,2 +0,0 @@
-:- use_module(library(prologue)).
-:- include('prologue_quad.pl').

package/test/lips-benchmark.mjs

@@ -1,93 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import process from 'node:process';
-import { performance } from 'node:perf_hooks';
-import { fileURLToPath } from 'node:url';
-import { Program, parseGoalText, run } from '../index.js';
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-
-function integer(value, name, minimum) {
-  const n = Number(value);
-  if (!Number.isInteger(n) || n < minimum) throw new Error(`${name} must be an integer >= ${minimum}`);
-  return n;
-}
-
-const options = { count: 50, runs: 5, warmup: 2, json: false };
-for (let i = 2; i < process.argv.length; i++) {
-  const arg = process.argv[i];
-  if (arg === '--count') options.count = integer(process.argv[++i], '--count', 1);
-  else if (arg === '--runs') options.runs = integer(process.argv[++i], '--runs', 1);
-  else if (arg === '--warmup') options.warmup = integer(process.argv[++i], '--warmup', 0);
-  else if (arg === '--json') options.json = true;
-  else if (arg === '-h' || arg === '--help') {
-    process.stdout.write('Usage: node test/lips-benchmark.mjs [--count N] [--runs N] [--warmup N] [--json]\n');
-    process.exit(0);
-  } else throw new Error(`unknown option: ${arg}`);
-}
-
-const source = await fs.readFile(path.join(root, 'examples', 'bench.pl'), 'utf8');
-const program = Program.parse(source);
-const dobench = parseGoalText(`dobench(${options.count})`);
-const dodummy = parseGoalText(`dodummy(${options.count})`);
-
-function execute(goal) {
-  const cpuStart = process.cpuUsage();
-  const wallStart = performance.now();
-  const result = run(program, { goals: [goal] });
-  const wallMs = performance.now() - wallStart;
-  const cpu = process.cpuUsage(cpuStart);
-  if (result.haltCode != null) throw new Error(`benchmark halted with code ${result.haltCode}`);
-  if (!result.stdout) throw new Error('benchmark goal produced no success answer');
-  return { cpuMs: (cpu.user + cpu.system) / 1000, wallMs };
-}
-
-for (let i = 0; i < options.warmup; i++) {
-  execute(dodummy);
-  execute(dobench);
-}
-
-const samples = [];
-for (let i = 0; i < options.runs; i++) {
-  const dummy = execute(dodummy);
-  const bench = execute(dobench);
-  const netCpuMs = bench.cpuMs - dummy.cpuMs;
-  const netWallMs = bench.wallMs - dummy.wallMs;
-  if (netCpuMs <= 0) throw new Error(`non-positive control-subtracted CPU time (${netCpuMs.toFixed(3)} ms); increase --count`);
-  samples.push({
-    dummyCpuMs: dummy.cpuMs,
-    benchCpuMs: bench.cpuMs,
-    netCpuMs,
-    netWallMs,
-    lips: 496 * options.count * 1000 / netCpuMs,
-    wallLips: netWallMs > 0 ? 496 * options.count * 1000 / netWallMs : null,
-  });
-}
-
-function median(values) {
-  const sorted = [...values].sort((a, b) => a - b);
-  const middle = Math.floor(sorted.length / 2);
-  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-}
-
-const result = {
-  methodology: 'Quintus 1984 naive reverse; dobench minus dodummy; 496 calls/reversal',
-  count: options.count,
-  runs: options.runs,
-  warmup: options.warmup,
-  lips: median(samples.map((sample) => sample.lips)),
-  wallLips: median(samples.map((sample) => sample.wallLips).filter(Number.isFinite)),
-  netCpuMs: median(samples.map((sample) => sample.netCpuMs)),
-  samples,
-};
-
-if (options.json) {
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-} else {
-  process.stdout.write(`EyeProlog classic nrev: ${Math.round(result.lips).toLocaleString('en-US')} LIPS\n`);
-  process.stdout.write(`  ${options.count} reversals/run, ${options.runs} measured runs, ${options.warmup} warmups\n`);
-  process.stdout.write(`  median control-subtracted CPU: ${result.netCpuMs.toFixed(1)} ms\n`);
-  if (Number.isFinite(result.wallLips)) {
-    process.stdout.write(`  wall-clock cross-check: ${Math.round(result.wallLips).toLocaleString('en-US')} LIPS\n`);
-  }
-}