eyeprolog 1.5.30 → 1.5.32

package/README.md

@@ -86,9 +86,9 @@ 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 20 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, and rewriting. 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:baseline`; use `npm run test:benchmark` for harness checks. 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, and the classic Prolog naive-reverse workload. 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:baseline`; use `npm run test:benchmark` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `npm run benchmark:lips`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `benchmark:lips` is the canonical engine-speed measurement. 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).
+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
 git clone https://github.com/eyereasoner/eyeprolog.git
 cd eyeprolog

package/examples/bench.pl

@@ -0,0 +1,57 @@
+% Classic Prolog "naive reverse" benchmark (Quintus, 1984), adapted as a
+% deterministic EyeProlog example.  The traditional workload reverses a
+% 30-element list with nrev/2 and concatenate/3.  It takes 496 Prolog
+% procedure calls per reversal in the original LIPS accounting.
+%
+% `npm run benchmark:lips` uses the classic dobench/dodummy control subtraction
+% with Node's process CPU clock, avoiding a dependency on a Prolog-specific
+% statistics/2 clock while preserving the benchmark methodology. See README.md.
+%
+% Source/history:
+% https://gerrit.googlesource.com/prolog-cafe/+/73b5ce4f5fbef086a22de3292a53e1ffe2947fab/examples/benchmarks/src/bench.pl
+
+%% goal: bench_result(X0)
+
+nrev([], []).
+nrev([X|Rest], Ans) :-
+    nrev(Rest, L),
+    concatenate(L, [X], Ans).
+
+concatenate([], L, L).
+concatenate([X|L1], L2, [X|L3]) :-
+    concatenate(L1, L2, L3).
+
+data([1,2,3,4,5,6,7,8,9,10,
+      11,12,13,14,15,16,17,18,19,20,
+      21,22,23,24,25,26,27,28,29,30]).
+
+bench_result(Reversed) :-
+    data(List),
+    nrev(List, Reversed).
+
+% Supporting predicates from the classic benchmark harness.  The JavaScript
+% benchmark driver times dodummy/1 and dobench/1 separately and subtracts the
+% dummy time, matching the Quintus methodology without requiring a particular
+% Prolog statistics/2 clock implementation.
+
+dobench(Count) :-
+    data(List),
+    bench_repeat(Count),
+    nrev(List, _),
+    fail.
+dobench(_).
+
+dodummy(Count) :-
+    data(List),
+    bench_repeat(Count),
+    dummy(List, _),
+    fail.
+dodummy(_).
+
+dummy(_, _).
+
+bench_repeat(_N).
+bench_repeat(N) :-
+    N > 1,
+    N1 is N - 1,
+    bench_repeat(N1).

package/examples/output/bench.pl

@@ -0,0 +1 @@
+bench_result([30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.30",
+  "version": "1.5.32",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -70,6 +70,7 @@
     "benchmark": "node test/benchmark.mjs",
     "benchmark:baseline": "node test/benchmark.mjs --save .benchmarks/baseline.json",
     "test:benchmark": "node test/run-benchmark-tests.mjs",
-    "generate:reference": "node tools/generate-predicate-reference.mjs"
+    "generate:reference": "node tools/generate-predicate-reference.mjs",
+    "benchmark:lips": "node test/lips-benchmark.mjs"
   }
 }

package/playground.html

@@ -453,6 +453,7 @@
           "bayes-diagnosis",
           "bayes-therapy",
           "beam-deflection",
+          "bench",
           "binomial-vandermonde",
           "blocks-world-planning",
           "bmi",

package/src/parser.js

@@ -1382,10 +1382,14 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     return atom(text);
   };
 
-  const trimRange = (text, start, end) => {
+  const trimRangeStart = (text, start, end) => {
     while (start < end && isWhitespaceCode(text.charCodeAt(start))) start++;
+    return start;
+  };
+
+  const trimRangeEnd = (text, start, end) => {
     while (end > start && isWhitespaceCode(text.charCodeAt(end - 1))) end--;
-    return [start, end];
+    return end;
   };
 
   const tokenKindInRange = (text, start, end) => {
@@ -1427,7 +1431,8 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   };
 
   const scalarOrVariableRange = (text, start, end) => {
-    [start, end] = trimRange(text, start, end);
+    start = trimRangeStart(text, start, end);
+    end = trimRangeEnd(text, start, end);
     const kind = tokenKindInRange(text, start, end);
     const value = text.slice(start, end);
     if (kind === 'var') {
@@ -1447,20 +1452,27 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   const rawBody = {};
 
   const scalarTokenRange = (text, start, end, out, slot) => {
-    [start, end] = trimRange(text, start, end);
+    start = trimRangeStart(text, start, end);
+    end = trimRangeEnd(text, start, end);
     const kind = tokenKindInRange(text, start, end);
     let type = kind;
     if (kind == null && simpleNumberInRange(text, start, end)) type = 'number';
     if (type == null) return false;
     let name = text.slice(start, end);
     if (type === 'var' && name === '_') name = `__anon${anonymous++}`;
-    out[`arg${slot}Type`] = type;
-    out[`arg${slot}Name`] = name;
+    if (slot === 0) {
+      out.arg0Type = type;
+      out.arg0Name = name;
+    } else {
+      out.arg1Type = type;
+      out.arg1Name = name;
+    }
     return true;
   };
 
   const parseBinaryRawRange = (text, start, end, out) => {
-    [start, end] = trimRange(text, start, end);
+    start = trimRangeStart(text, start, end);
+    end = trimRangeEnd(text, start, end);
     let i = start;
     const first = text.charCodeAt(i);
     if (!(first >= 97 && first <= 122)) return false;
@@ -1487,7 +1499,8 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   };
 
   const parseBinaryCompoundRange = (text, start = 0, end = text.length) => {
-    [start, end] = trimRange(text, start, end);
+    start = trimRangeStart(text, start, end);
+    end = trimRangeEnd(text, start, end);
     let i = start;
     const first = text.charCodeAt(i);
     if (!(first >= 97 && first <= 122)) return null;
@@ -1680,7 +1693,8 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     let contentStart = lineStart;
     let contentEnd = lineEnd;
     if (contentEnd > contentStart && source.charCodeAt(contentEnd - 1) === 13) contentEnd--;
-    [contentStart, contentEnd] = trimRange(source, contentStart, contentEnd);
+    contentStart = trimRangeStart(source, contentStart, contentEnd);
+    contentEnd = trimRangeEnd(source, contentStart, contentEnd);
     if (contentStart < contentEnd && source.charCodeAt(contentStart) !== 37) {
       if (!chunk && source.charCodeAt(contentEnd - 1) === 46 && !preparationConversionActive()) {
         if (emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {

package/src/program.js

@@ -36,6 +36,11 @@ const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
 const PROGRAM_BUILD_BATCH_SIZE = 16384;
 const preparedBundledLibraryCache = new Map();
+const NORMAL_OPERATOR_DEFINITIONS = [
+  ...ISO_OPERATOR_DEFINITIONS,
+  ...PART3_OPERATOR_DEFINITIONS,
+  ...QUAD_OPERATOR_DEFINITIONS,
+];
 
 function collectMultiplicitySensitiveDependencies(goal, out = []) {
   if (goal?.type !== COMPOUND) return out;
@@ -151,13 +156,12 @@ export class Program {
     // recursive predicates retain standard depth-first Prolog control.
     this.tabledPredicates = new Set();
     this.operators = new Map();
-    const predefinedOperatorSets = this.strictIso
-      ? [ISO_OPERATOR_DEFINITIONS]
-      : [ISO_OPERATOR_DEFINITIONS, PART3_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS];
-    for (const definitions of predefinedOperatorSets) {
-      for (const [priority, specifier, name] of definitions) {
-        this.defineOperator(priority, specifier, name);
-      }
+    const predefinedOperators = this.strictIso ? ISO_OPERATOR_DEFINITIONS : NORMAL_OPERATOR_DEFINITIONS;
+    // The predefined lists contain no competing declarations in the same
+    // prefix, infix, or postfix class. Populate them directly; defineOperator
+    // still performs replacement semantics for source-level op/3 directives.
+    for (const [priority, specifier, name] of predefinedOperators) {
+      this.operators.set(`${specifier}\u0000${name}`, { priority, specifier, name });
     }
     this.initializations = [];
     // Track how many initialization/1 directives have run so a REPL can
@@ -251,12 +255,15 @@ export class Program {
   }
   findGroup(name, arity, module = 'user') {
     const indicator = `${name}/${arity}`;
-    const visited = new Set();
-    let current = module;
+    const direct = this.groups.get(module === 'user' ? indicator : `${module}:${indicator}`);
+    if (direct) return direct;
+    let current = this.moduleImports.get(module)?.get(indicator);
+    if (current == null) return null;
+    const visited = new Set([module]);
     while (!visited.has(current)) {
       visited.add(current);
-      const direct = this.groups.get(modulePredicateKey(current, name, arity));
-      if (direct) return direct;
+      const imported = this.groups.get(current === 'user' ? indicator : `${current}:${indicator}`);
+      if (imported) return imported;
       const importedModule = this.moduleImports.get(current)?.get(indicator);
       if (importedModule == null) return null;
       current = importedModule;

package/src/solver.js

@@ -1,7 +1,7 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -18,6 +18,7 @@ import { evaluatePositiveDatalog, relationForDatalogGroup, datalogCandidateIndex
 let freshCounter = 0;
 const DEFAULT_INNER_TABLE_SCOPE_LIMIT = 1024;
 const GOAL_CONTINUATION_THRESHOLD = 64;
+const NO_CALL_TARGET = Symbol('no-call-target');
 // Conservative live-storage estimate for one generated length/2 list cell
 // (cons object, argument vector, fresh variable, and its generated name).
 const GENERATED_LENGTH_CELL_RESERVE_BYTES = 256;
@@ -90,6 +91,9 @@ export class Solver {
     // implementation-specific predicates.  Use the Part 1 + corrigenda
     // registry even when an embedder supplied the normal EyeProlog registry.
     this.registry = this.isoStrict ? getStrictIsoRegistry() : (options.registry ?? getEyePrologRegistry());
+    this.userGroupCache = Object.create(null);
+    this.moduleGroupCache = new Map();
+    this.builtinCache = Object.create(null);
     this.mutableProgram = program.mutable === true;
     this.programRevision = this.program.revision ?? 0;
     // Normal Prolog execution must not silently acquire a semantic depth
@@ -115,7 +119,11 @@ export class Solver {
       reservationBytes: 0,
       checks: 0,
     };
-    this.nextMemoryCheck = 0;
+    // Nested meta-call solvers contribute to one execution and inspect the
+    // same process heap. Share their sampling deadline so each short-lived
+    // child does not repeat an expensive host memory query before the parent
+    // has advanced the guard interval.
+    this.memoryCheckState = options.memoryCheckState ?? { nextObservation: 0 };
     // Do not impose an implicit answer cap. Infinite and very large searches are
     // part of normal Prolog semantics; callers that need a resource bound can
     // still supply solutionLimit explicitly.
@@ -215,6 +223,7 @@ export class Solver {
       maxInferences: this.maxInferences,
       maxMemoryBytes: this.maxMemoryBytes,
       memoryRecovery: this.memoryRecovery,
+      memoryCheckState: this.memoryCheckState,
       solutionLimit,
       isoStrict: this.isoStrict,
       prologFlags: this.prologFlags,
@@ -290,6 +299,37 @@ export class Solver {
     }
   }
 
+  lookupGroup(name, arity, module = 'user') {
+    if (module === 'user') {
+      let slots = this.userGroupCache[name];
+      if (slots === undefined) this.userGroupCache[name] = slots = [];
+      const cached = slots[arity];
+      if (cached !== undefined) return cached === NO_CALL_TARGET ? null : cached;
+      const group = this.program.findGroup(name, arity, module);
+      slots[arity] = group ?? NO_CALL_TARGET;
+      return group;
+    }
+    let byName = this.moduleGroupCache.get(module);
+    if (byName == null) this.moduleGroupCache.set(module, byName = new Map());
+    let byArity = byName.get(name);
+    if (byArity == null) byName.set(name, byArity = []);
+    const cached = byArity[arity];
+    if (cached !== undefined) return cached === NO_CALL_TARGET ? null : cached;
+    const group = this.program.findGroup(name, arity, module);
+    byArity[arity] = group ?? NO_CALL_TARGET;
+    return group;
+  }
+
+  lookupBuiltin(name, arity) {
+    let slots = this.builtinCache[name];
+    if (slots === undefined) this.builtinCache[name] = slots = [];
+    const cached = slots[arity];
+    if (cached !== undefined) return cached === NO_CALL_TARGET ? null : cached;
+    const def = this.registry.get(name, arity);
+    slots[arity] = def ?? NO_CALL_TARGET;
+    return def;
+  }
+
   syncProgramRevision() {
     if (!this.mutableProgram) {
       if (this.program.mutable !== true) return;
@@ -298,6 +338,9 @@ export class Solver {
     const revision = this.program.revision ?? 0;
     if (revision === this.programRevision) return;
     this.programRevision = revision;
+    this.userGroupCache = Object.create(null);
+    this.moduleGroupCache.clear();
+    this.builtinCache = Object.create(null);
     this.memo.clear();
     this.subsumptiveMemo.clear();
     this.wfsModels.clear();
@@ -507,13 +550,7 @@ export class Solver {
           });
           continue;
         }
-        const id = nextFreshId();
-        const freshVariables = new Map();
-        const freshHead = freshTerm(clause.head, id, freshVariables);
-        const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
-        const localFreshPlan = clauseLocalFreshPlan(clause);
-        const headLocalFresh = freshVariableSet(localFreshPlan.head, freshVariables);
-        attachBodyLocalFreshVariables(freshBody, localFreshPlan.body, freshVariables);
+        const { freshHead, freshBody, headLocalFresh } = instantiateClause(clause, nextFreshId());
         next = clauseEnv.clone();
         this.stats.unify_calls++;
         if (!unify(clauseGoal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) continue;
@@ -649,7 +686,7 @@ export class Solver {
         // EyeProlog normally solves left-to-right, but ready deterministic builtins can
         // be run early as pure filters. Stop at internal sentinels so rule-body
         // active guards are released before the caller's remaining goals are seen.
-        const selectedIndex = selectReadyDeterministicBuiltin(goals, env, this.registry);
+        const selectedIndex = 0;
         const goal = deref(goals[selectedIndex], env);
         const rest = selectedIndex === 0 ? goals.slice(1) : [...goals.slice(0, selectedIndex), ...goals.slice(selectedIndex + 1)];
         prepareLocalVariablesForGoal(goal, env);
@@ -701,7 +738,7 @@ export class Solver {
           }
         }
 
-        const def = callable ? this.registry.get(goal.name, goal.arity) : null;
+        const def = callable ? this.lookupBuiltin(goal.name, goal.arity) : null;
         this.active = active;
         const builtinReady = def && builtinIsReadyOrAuthoritative(def, this, goal, env);
         if (builtinReady && typeof def.expandGoal === 'function') {
@@ -735,7 +772,7 @@ export class Solver {
         }
 
         this.stats.solve_one_goal_calls++;
-        const group = this.program.findGroup(goal.name, goal.arity, goal.module ?? 'user');
+        const group = this.lookupGroup(goal.name, goal.arity, goal.module ?? 'user');
         if (!group) {
           if (goal.name === '-->' && goal.arity === 2) {
             throw new PrologError(
@@ -865,6 +902,35 @@ export class Solver {
         }
 
         if (!group.tabled && tryPushScalarFactRunFrames(stack, this, [goal, ...rest], env, depth, active)) break;
+        // When indexing leaves exactly one cut-free clause, enter it directly
+        // instead of allocating a resumable clause-choice frame. This keeps
+        // ordinary deterministic recursion on the interpreter's tight loop.
+        if (!group.tabled && groupNeedsActiveFrame(group) === false) {
+          const candidates = selectClauseCandidates(group, goal, env);
+          const candidateCount = clauseCandidateLength(candidates.primary) +
+            clauseCandidateLength(candidates.fallback);
+          if (candidateCount === 1) {
+            const clause = clauseCandidateLength(candidates.primary) === 1
+              ? clauseCandidateAt(candidates.primary, 0)
+              : clauseCandidateAt(candidates.fallback, 0);
+            const { freshHead, freshBody, headLocalFresh } = instantiateClause(clause, nextFreshId());
+            const next = env.clone();
+            this.stats.unify_calls++;
+            if (!unify(goal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) break;
+            if (freshBody.length === 0) {
+              goals = rest;
+            } else if (rest.length >= GOAL_CONTINUATION_THRESHOLD ||
+                rest.some((pending) => pending?.kind === 'continueGoals')) {
+              next.compactForDeepContinuation?.();
+              goals = [...freshBody, { kind: 'continueGoals', goals: rest, depth, releaseActive: false }];
+            } else {
+              goals = [...freshBody, ...rest];
+            }
+            env = next;
+            depth++;
+            continue;
+          }
+        }
         pushUserGoalUncachedFrames(stack, this, group, goal, rest, env, depth, active);
         break;
       }
@@ -1005,8 +1071,9 @@ export class Solver {
   }
 
   checkMemoryLimit(force = false) {
-    if (!force && this.inferences < this.nextMemoryCheck) return;
-    this.nextMemoryCheck = this.inferences + 256;
+    const observation = this.inferenceObservation.value;
+    if (!force && observation < this.memoryCheckState.nextObservation) return;
+    this.memoryCheckState.nextObservation = observation + 256;
     if (!Number.isFinite(this.maxMemoryBytes)) return;
     const used = usedHeapSize();
     if (used != null && used < this.maxMemoryBytes) this.finishMemoryRecovery();
@@ -1104,13 +1171,7 @@ export class Solver {
           continue;
         }
         if (headCannotMatch(goal, clause.head, env)) continue;
-        const id = nextFreshId();
-        const freshVariables = new Map();
-        const freshHead = freshTerm(clause.head, id, freshVariables);
-        const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
-        const localFreshPlan = clauseLocalFreshPlan(clause);
-        const headLocalFresh = freshVariableSet(localFreshPlan.head, freshVariables);
-        attachBodyLocalFreshVariables(freshBody, localFreshPlan.body, freshVariables);
+        const { freshHead, freshBody, headLocalFresh } = instantiateClause(clause, nextFreshId());
         const next = env.clone();
         this.stats.unify_calls++;
         if (!unify(goal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) continue;
@@ -1295,16 +1356,15 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   if (tryPushGroundScalarRuleFrame(stack, solver, group, goal, rest, env, depth, active)) return;
   if (tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active)) return;
   const candidates = selectClauseCandidates(group, goal, env);
+  const candidateCount = clauseCandidateLength(candidates.primary) + clauseCandidateLength(candidates.fallback);
   const frames = [];
-  const invocation = { goal, env: env._snapshotForSolverRead(), tableMapKey };
   // Active frames serve two purposes: they delimit cut and detect variants in
-  // recursive user predicates. Cut-free, non-recursive library helpers need
-  // neither. Copying their full active stack at every recursive step made
-  // otherwise linear relations such as length/2 retain O(depth^2) references.
+  // recursive user predicates. Delay the invocation snapshot until a reachable
+  // cut/guard actually needs one; ordinary cut-free recursion avoids it.
   for (const pass of [candidates.primary, candidates.fallback]) {
     for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
       const clause = clauseCandidateAt(pass, candidateIndex);
-      if (headCannotMatch(goal, clause.head, env)) continue;
+      if (candidateCount > 1 && headCannotMatch(goal, clause.head, env)) continue;
       // Do not speculatively unify alternative heads. With attributed variables,
       // head unification can run verify_attributes/3, queue wakeups, fail, or
       // throw. Those effects are observable and must occur only if Prolog search
@@ -1325,10 +1385,12 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   // recursive clause; do not copy the whole active path at every such layer.
   const traditionalDepthFirst = !group.tabled;
   const guarded = traditionalDepthFirst
-    ? frames.some((frame) => clauseHasCutForTailRelease(frame.clause))
+    ? (group.hasCut === true && frames.some((frame) => clauseHasCutForTailRelease(frame.clause)))
     : groupNeedsActiveFrame(group);
   const release = guarded ? [{ kind: 'releaseActive' }] : [];
-  const nextActive = guarded ? [...active, invocation] : active;
+  const nextActive = guarded
+    ? [...active, { goal, env: env._snapshotForSolverRead(), tableMapKey }]
+    : active;
   for (const frame of frames) {
     frame.active = nextActive;
     frame.release = release;
@@ -1341,6 +1403,104 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
 }
 
 
+function instantiatePlanNode(node, variables) {
+  if (node.variableSlot != null) return variables[node.variableSlot];
+  const args = new Array(node.args.length);
+  for (let index = 0; index < args.length; index++) {
+    args[index] = instantiatePlanNode(node.args[index], variables);
+  }
+  const term = new Term(node.type, node.name, args);
+  if (node.module != null) term.module = node.module;
+  return term;
+}
+
+function freshSetForVariableSlots(slots, variables) {
+  if (slots.length === 0) return null;
+  const names = new Array(slots.length);
+  for (let index = 0; index < slots.length; index++) names[index] = variables[slots[index]].name;
+  return names.length <= 4 ? new SmallFreshVariableSet(names) : new Set(names);
+}
+
+function instantiateClause(clause, id) {
+  let plan = clause._instantiationPlan;
+  if (plan == null) {
+    const variableSlots = new Map();
+    const variableNames = [];
+    const compile = (term) => {
+      if (term.type === VAR) {
+        let slot = variableSlots.get(term.name);
+        if (slot == null) {
+          slot = variableNames.length;
+          variableSlots.set(term.name, slot);
+          variableNames.push(term.name);
+        }
+        return { variableSlot: slot };
+      }
+      return {
+        type: term.type,
+        name: term.name,
+        module: term.module,
+        args: term.args.map(compile),
+      };
+    };
+    const localFreshPlan = clauseLocalFreshPlan(clause);
+    const head = compile(clause.head);
+    const body = clause.body.map(compile);
+    const slotsFor = (names) => names.map((name) => variableSlots.get(name)).filter((slot) => slot != null);
+    const bodyProofIndexes = [];
+    for (let index = 0; index < clause.body.length; index++) {
+      if (goalUsesFirstUseProof(clause.body[index])) bodyProofIndexes.push(index);
+    }
+    plan = clause._instantiationPlan = {
+      head,
+      body,
+      variableNames,
+      headLocalSlots: slotsFor(localFreshPlan.head),
+      bodyLocalSlots: localFreshPlan.body.map(slotsFor),
+      bodyProofIndexes,
+    };
+  }
+
+  const variables = new Array(plan.variableNames.length);
+  for (let index = 0; index < variables.length; index++) {
+    variables[index] = variable(`${plan.variableNames[index]}#${id}`);
+  }
+  const freshHead = instantiatePlanNode(plan.head, variables);
+  const freshBody = new Array(plan.body.length);
+  for (let index = 0; index < freshBody.length; index++) {
+    freshBody[index] = instantiatePlanNode(plan.body[index], variables);
+  }
+  const headLocalFresh = freshSetForVariableSlots(plan.headLocalSlots, variables);
+  for (let proofIndex = 0; proofIndex < plan.bodyProofIndexes.length; proofIndex++) {
+    const index = plan.bodyProofIndexes[proofIndex];
+    const goal = freshBody[index];
+    const knownNonoccurringVariables = freshSetForVariableSlots(plan.bodyLocalSlots[index] ?? [], variables);
+    if (knownNonoccurringVariables == null || goal?.type !== COMPOUND) continue;
+    attachKnownNonoccurringVariables(goal, knownNonoccurringVariables);
+  }
+  return { freshHead, freshBody, headLocalFresh };
+}
+
+function attachKnownNonoccurringVariables(term, knownNonoccurringVariables) {
+  if (term?.type !== COMPOUND) return;
+  if (term.name === '=' && term.arity === 2) {
+    term._knownNonoccurringVariables = knownNonoccurringVariables;
+  } else if ((term.name === 'get_atts' && term.arity === 2)
+    || (term.name === 'get_attr' && term.arity === 3)
+    || (term.name === '$get_attr_list' && term.arity === 2)
+    || (term.name === '$get_from_attr_list' && term.arity === 3)) {
+    term._firstUseVariables = knownNonoccurringVariables;
+  }
+  if ((term.name === ',' || term.name === ';' || term.name === '->') && term.arity === 2) {
+    attachKnownNonoccurringVariables(term.args[0], knownNonoccurringVariables);
+    attachKnownNonoccurringVariables(term.args[1], knownNonoccurringVariables);
+  } else if (term.name === '\\+' && term.arity === 1) {
+    attachKnownNonoccurringVariables(term.args[0], knownNonoccurringVariables);
+  } else if (term.name === ':' && term.arity === 2) {
+    attachKnownNonoccurringVariables(term.args[1], knownNonoccurringVariables);
+  }
+}
+
 function clauseLocalFreshPlan(clause) {
   if (clause._localFreshPlan != null) return clause._localFreshPlan;
   const seen = new Set();
@@ -2326,9 +2486,9 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
     const goal = goals[runLength];
     if (!goal || goal.kind === 'releaseActive' || goal.kind === 'memoStore' || goal.kind === 'continueGoals') break;
     if (goal.type !== COMPOUND) break;
-    const def = solver.registry.get(goal.name, goal.arity);
+    const def = solver.lookupBuiltin(goal.name, goal.arity);
     if (def) break;
-    const group = solver.program.findGroup(goal.name, goal.arity, goal.module ?? 'user');
+    const group = solver.lookupGroup(goal.name, goal.arity, goal.module ?? 'user');
     if (!group || group.tabled || !group.scalarFactsOnly) break;
     groups.push(group);
     runLength++;

package/src/term.js

@@ -682,12 +682,10 @@ class SolverBindingStore {
     this.baseValues = [];
     this.slotLastTrail = [];
     this.freeSlots = [];
-    this.trailNames = [];
     this.trailSlots = [];
     this.trailOldValues = [];
     this.trailNewValues = [];
     this.trailPreviousForSlot = [];
-    this.trailCreated = [];
     if (bindings != null) {
       for (const [name, value] of bindings) {
         const slot = this.names.length;
@@ -709,15 +707,13 @@ class SolverBindingStore {
       throw new Error('stale solver binding mark');
     }
     while (this.trailSlots.length > mark) {
-      const created = this.trailCreated.pop();
       const previousForSlot = this.trailPreviousForSlot.pop();
       this.trailNewValues.pop();
       const oldValue = this.trailOldValues.pop();
       const slot = this.trailSlots.pop();
-      const name = this.trailNames.pop();
       this.slotLastTrail[slot] = previousForSlot;
-      if (created) {
-        this.slots.delete(name);
+      if (oldValue === ENV_UNBOUND) {
+        this.slots.delete(this.names[slot]);
         this.values[slot] = ENV_UNBOUND;
         this.baseValues[slot] = ENV_UNBOUND;
         this.names[slot] = null;
@@ -740,12 +736,10 @@ class SolverBindingStore {
       this.slotLastTrail[slot] = -1;
     }
     const entry = this.trailSlots.length;
-    this.trailNames.push(name);
     this.trailSlots.push(slot);
     this.trailOldValues.push(this.values[slot]);
     this.trailNewValues.push(value);
     this.trailPreviousForSlot.push(this.slotLastTrail[slot] ?? -1);
-    this.trailCreated.push(created);
     this.slotLastTrail[slot] = entry;
     this.values[slot] = value;
   }
@@ -862,7 +856,9 @@ class SolverEnv extends Env {
   }
 
   get(name) {
-    this._activateBindings();
+    if (this._solverBindingMark !== this._solverBindings.trailSlots.length) {
+      this._solverBindings.rollback(this._solverBindingMark);
+    }
     const slot = this._solverBindings.slots.get(name);
     if (slot === undefined) return undefined;
     const value = this._solverBindings.values[slot];
@@ -878,9 +874,11 @@ class SolverEnv extends Env {
   }
 
   bind(name, term) {
-    this._activateBindings();
+    if (this._solverBindingMark !== this._solverBindings.trailSlots.length) {
+      this._solverBindings.rollback(this._solverBindingMark);
+    }
     this._solverBindings.bind(name, term);
-    this._solverBindingMark = this._solverBindings.mark();
+    this._solverBindingMark = this._solverBindings.trailSlots.length;
   }
 
   compactForDeepContinuation() {
@@ -933,6 +931,21 @@ function structuralVariableNames(term) {
   if (term?.type === VAR) return [term.name];
   if (term?.type !== COMPOUND) return EMPTY_ARGS;
 
+  if (!isCompactList(term) && term.arity === 2) {
+    const left = term.args[0];
+    const right = term.args[1];
+    const leftSimple = left?.type === VAR || isScalar(left);
+    const rightSimple = right?.type === VAR || isScalar(right);
+    if (leftSimple && rightSimple) {
+      if (left?.type === VAR) {
+        if (right?.type === VAR) return left.name === right.name ? [left.name] : [left.name, right.name];
+        return [left.name];
+      }
+      if (right?.type === VAR) return [right.name];
+      return EMPTY_ARGS;
+    }
+  }
+
   const cached = structuralVariableCache.get(term);
   if (cached !== undefined) return cached;
 
@@ -1013,12 +1026,17 @@ function occurs(variableName, term, env) {
   }
 
   const pending = initial.slice();
-  const seenVariables = new Set();
+  const seenSmall = [];
+  let seenLarge = null;
   for (let index = 0; index < pending.length; index++) {
     const name = pending[index];
     if (name === variableName) return true;
-    if (seenVariables.has(name)) continue;
-    seenVariables.add(name);
+    let alreadySeen = false;
+    if (seenLarge != null) alreadySeen = seenLarge.has(name);
+    else for (let j = 0; j < seenSmall.length; j++) { if (seenSmall[j] === name) { alreadySeen = true; break; } }
+    if (alreadySeen) continue;
+    if (seenLarge != null) seenLarge.add(name);
+    else { seenSmall.push(name); if (seenSmall.length === 8) seenLarge = new Set(seenSmall); }
     const binding = env?.get(name);
     if (binding === undefined) continue;
     const names = structuralVariableNames(binding);
@@ -1040,9 +1058,10 @@ export function unify(left, right, env, options = {}) {
   // construction fast paths share this internal proof; ordinary unification
   // remains fully occurs-checked.
   const knownNonoccurringVariables = options.knownNonoccurringVariables ?? null;
-  const stack = [[left, right]];
+  const stack = [left, right];
   while (stack.length) {
-    let [a, b] = stack.pop();
+    let b = stack.pop();
+    let a = stack.pop();
     a = deref(a, env);
     b = deref(b, env);
 
@@ -1053,7 +1072,7 @@ export function unify(left, right, env, options = {}) {
         a = deref(a, env);
         b = deref(b, env);
         if (a.type !== VAR || b.type !== VAR || a.name === b.name) {
-          stack.push([a, b]);
+          stack.push(a, b);
           continue;
         }
       }
@@ -1083,7 +1102,7 @@ export function unify(left, right, env, options = {}) {
         if (!env.preparePrologAttributeUnification(a, b)) return false;
         a = deref(a, env);
         b = deref(b, env);
-        if (a.type !== VAR) { stack.push([a, b]); continue; }
+        if (a.type !== VAR) { stack.push(a, b); continue; }
       }
       markCompactVariableBound(a, b, env);
       env?.dropPrologAttributes?.(a.name);
@@ -1101,7 +1120,7 @@ export function unify(left, right, env, options = {}) {
         if (!env.preparePrologAttributeUnification(b, a)) return false;
         b = deref(b, env);
         a = deref(a, env);
-        if (b.type !== VAR) { stack.push([a, b]); continue; }
+        if (b.type !== VAR) { stack.push(a, b); continue; }
       }
       markCompactVariableBound(b, a, env);
       env?.dropPrologAttributes?.(b.name);
@@ -1121,7 +1140,7 @@ export function unify(left, right, env, options = {}) {
 
     if (a.type === COMPOUND) {
       if (a.name !== b.name || a.arity !== b.arity) return false;
-      for (let i = a.arity - 1; i >= 0; i--) stack.push([a.args[i], b.args[i]]);
+      for (let i = a.arity - 1; i >= 0; i--) stack.push(a.args[i], b.args[i]);
       continue;
     }
 

package/test/bench/benchmarks.json

@@ -8,6 +8,16 @@
     ],
     "expectedSha256": "a0aa24fcbc87c394a4da789ac861b8e18cabad5e0d73b25ddc02df5dd4376c1b"
   },
+  {
+    "name": "classic-nrev",
+    "group": "recursion/lips",
+    "file": "examples/bench.pl",
+    "goals": [
+      "bench_result(X0)"
+    ],
+    "expectedSha256": "8045dc0730e4996a7b01fb2348311fb175ed53f4c49d14f82e01a3d470602255",
+    "logicalInferences": 496
+  },
   {
     "name": "clpz-sudoku",
     "group": "clpz",

package/test/benchmark.mjs

@@ -69,6 +69,9 @@ for (const item of manifest) {
   if (!/^[0-9a-f]{64}$/.test(item.expectedSha256)) {
     throw new Error(`invalid expectedSha256 for benchmark ${item.name}`);
   }
+  if (item.logicalInferences != null && (!Number.isInteger(item.logicalInferences) || item.logicalInferences <= 0)) {
+    throw new Error(`invalid logicalInferences for benchmark ${item.name}`);
+  }
 }
 
 const selected = manifest.filter((item) => {
@@ -115,6 +118,16 @@ function formatMs(value) {
   return `${value.toFixed(1)} ms`;
 }
 
+function lipsFor(logicalInferences, medianMs) {
+  if (!Number.isFinite(logicalInferences) || !Number.isFinite(medianMs) || medianMs <= 0) return null;
+  return logicalInferences * 1000 / medianMs;
+}
+
+function formatLips(value) {
+  if (value == null) return '—';
+  return Math.round(value).toLocaleString('en-US');
+}
+
 function changePercent(medianMs, baselineMs) {
   if (baselineMs == null || baselineMs === 0) return null;
   return ((medianMs - baselineMs) / baselineMs) * 100;
@@ -213,6 +226,8 @@ for (const item of selected) {
     answerLines: worker.answerLines,
     outputBytes: worker.outputBytes,
     sha256: worker.digest,
+    logicalInferences: item.logicalInferences ?? null,
+    lips: lipsFor(item.logicalInferences, medianMs),
     baselineMs: baselineItem?.medianMs ?? null,
     changePercent: changePercent(medianMs, baselineItem?.medianMs ?? null),
   });
@@ -250,10 +265,11 @@ if (options.json) {
     results,
   }, null, 2)}\n`);
 } else {
-  const headers = ['Benchmark', 'Median/op', 'Range/op', 'Batch', 'Baseline', 'Change', 'Answers'];
+  const headers = ['Benchmark', 'Median/op', 'LIPS', 'Range/op', 'Batch', 'Baseline', 'Change', 'Answers'];
   const rows = results.map((item) => [
     item.name,
     formatMs(item.medianMs),
+    formatLips(item.lips),
     `${formatMs(item.minMs)}–${formatMs(item.maxMs)}`,
     String(item.batchSize),
     formatMs(item.baselineMs),
@@ -283,6 +299,7 @@ if (options.json) {
   if (baselinePath == null && !baselineWarning) process.stdout.write('No timing baseline found; run npm run benchmark:baseline to create .benchmarks/baseline.json.\n');
   if (options.save != null) process.stdout.write(`Saved timing baseline: ${path.relative(root, options.save)}\n`);
   process.stdout.write('Change compares the current median/op directly with the saved baseline median/op; the measured range is shown separately.\n');
+  process.stdout.write('The classic-nrev LIPS column is a quick wall-clock estimate. Use npm run benchmark:lips for the Quintus-style dummy-subtracted CPU measurement.\n');
   if (summary.comparable > 0) {
     process.stdout.write('Suite score is the geometric mean of current/baseline ratios, so every benchmark has equal relative weight; Time-weighted total compares summed medians and is dominated by longer workloads.\n');
   }

package/test/conformance/ISO-COMPLIANCE.md

@@ -254,7 +254,7 @@ not interpret the following as core-language features:
 - Part 3 grammar-rule expansion and `phrase/2-3`;
 - explicit tabling, EyeProlog well-founded evaluation via `tnot/1` and
   `wfs_truth/2`, WFS runtime statistics, and recursive numeric execution shortcuts;
-- normal-profile integer digit separators and Trealla-compatible
+- normal-profile integer digit separators (the accepted WG17 single-underscore/layout form documented at <https://www.complang.tuwien.ac.at/ulrich/iso-prolog/digit_separators>) and Trealla-compatible
   `"text"||Tail` double-quoted-list splicing;
 - the JavaScript API `stringTerm(Text)` additional term type (normal mode only).
 

package/test/conformance/ISO-WG17-EXTENSIONS.md

@@ -0,0 +1,68 @@
+# ISO/WG17 compatibility extensions
+
+EyeProlog separates its strict ISO core from carefully selected compatibility
+extensions. `isoStrict: true` targets ISO/IEC 13211-1:1995 plus Corrigenda 1-3;
+newer or non-core features belong in the normal profile until they are part of
+the claimed strict baseline.
+
+## Selection rule
+
+A proposed extension is a good candidate when it has all of these properties:
+
+1. it solves a concrete portability or usability problem;
+2. its syntax/semantics are precise enough to test independently;
+3. it has clear WG17 momentum, a published ISO technical specification, or
+   established interoperable implementation practice; and
+4. it does not silently change strict ISO behavior.
+
+This intentionally excludes adopting every discussion item on the ISO Prolog
+working-notes pages. Draft/editorial proposals can change, and controversial
+changes are more valuable as tracked tests/documentation than as premature
+language behavior.
+
+## Implemented high-value items
+
+- **Digit separators (normal profile).** Decimal, binary, octal, and hexadecimal
+  integer constants accept a single underscore between digit groups. Layout,
+  line comments, and block comments may follow the underscore before the next
+  digit, matching the accepted WG17 options described at
+  <https://www.complang.tuwien.ac.at/ulrich/iso-prolog/digit_separators>.
+  Consecutive/trailing separators and separators inside floats/exponents are
+  rejected. Strict ISO mode rejects the extension.
+- **Corrigenda 1-3.** The strict suite explicitly covers the published
+  corrections, including `variable_names/1` write behavior.
+- **Cleanup.** `setup_call_cleanup/3` and `call_cleanup/2` are available in the
+  normal compatibility/library surface and are regression tested.
+- **DCGs.** EyeProlog supports grammar-rule expansion and `phrase/2-3` in the
+  normal profile, aligned with ISO/IEC TS 13211-3:2025. These remain outside
+  the Part 1 strict-core claim.
+- **Prologue/library portability.** The normal profile includes a portable
+  standard-library surface and autoloading rather than treating those
+  predicates as Part 1 core built-ins.
+
+## What should be considered next?
+
+The best next work is evidence-driven rather than feature-count driven:
+
+- keep running the public WG17 syntax/conformance corpora and close concrete
+  interoperability gaps they expose;
+- prefer published specifications (for example additional fully testable parts
+  of the DCG TS) over draft syntax experiments;
+- evaluate Prolog-prologue predicates when they materially improve source
+  portability and can be implemented with compatible errors/modes;
+- keep module conformance as a separate Part 2 effort instead of mixing it into
+  the Part 1 strict claim; and
+- track draft STC/WG17 proposals in tests/status documents until their intended
+  behavior is stable enough to adopt explicitly.
+
+In particular, the digit-separator page currently leaves float separator forms
+such as `1_1.25`, `11.2_5`, and `1.0e1_0` unresolved. EyeProlog therefore does
+**not** generalize integer separators into float syntax.
+
+## Regression expectations
+
+Every accepted compatibility extension should have tests for positive syntax,
+negative/boundary syntax, stream or conversion entry points where applicable,
+and an explicit strict-mode rejection when the feature is not in the strict
+baseline. This keeps the normal profile useful without weakening the meaning of
+`isoStrict: true`.

package/test/lips-benchmark.mjs

@@ -0,0 +1,93 @@
+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`);
+  }
+}

package/test/run-benchmark-tests.mjs

@@ -42,8 +42,10 @@ function runWorker(item) {
   ]);
 }
 
-ok(Array.isArray(manifest) && manifest.length === 20, 'benchmark manifest should contain exactly 20 representative workloads');
+ok(Array.isArray(manifest) && manifest.length === 21, 'benchmark manifest should contain exactly 21 representative workloads');
 ok(new Set(manifest.map((item) => item.name)).size === manifest.length, 'benchmark names should be unique');
+const classicNrev = manifest.find((item) => item.name === 'classic-nrev');
+ok(classicNrev?.logicalInferences === 496, 'classic nrev should retain the traditional 496-call LIPS accounting');
 
 for (const item of manifest) {
   ok(/^[0-9a-f]{64}$/.test(item.expectedSha256), `${item.name} should have a committed semantic checksum`);
@@ -70,4 +72,28 @@ ok(adaptive.results[0].batchSize > 1, 'adaptive benchmark smoke test should batc
 ok(adaptive.results[0].sha256 === manifest.find((item) => item.name === 'dcg-command').expectedSha256,
   'adaptive batching should preserve the semantic checksum');
 
+const nrev = await spawnJson([
+  path.join(root, 'test', 'benchmark.mjs'),
+  '--filter', 'classic-nrev',
+  '--runs', '1',
+  '--warmup', '0',
+  '--target-ms', '0',
+  '--json',
+]);
+ok(nrev.results.length === 1, 'classic nrev benchmark should be selectable');
+ok(nrev.results[0].logicalInferences === 496, 'classic nrev JSON should expose its logical-inference count');
+ok(Number.isFinite(nrev.results[0].lips) && nrev.results[0].lips > 0, 'classic nrev JSON should report positive LIPS');
+
+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/test/run-regression.mjs

@@ -7330,11 +7330,19 @@ function whiteBoxCases() {
           'program radix literal');
         assertEqual(parseNumberTokenText('1_ /* group */ 000').name, '1000',
           'number-token conversion with layout');
+        assertEqual(parseNumberTokenText('0b1010_0101').name, '165', 'binary number-token conversion');
+        assertEqual(parseNumberTokenText('0o7_% group\n7').name, '63', 'octal number-token conversion with line comment');
+        assertEqual(parseNumberTokenText('0xCA_/* group */FE').name, '51966', 'hex number-token conversion with block comment');
         assertEqual(
           run('', { goal: 'number_chars(N,"1_000")' }).stdout,
           'number_chars(1000, "1_000").\n',
           'normal number_chars input',
         );
+        assertEqual(
+          run('', { goal: 'number_codes(N,[48,120,67,65,95,70,69])' }).stdout,
+          'number_codes(51966, [48, 120, 67, 65, 95, 70, 69]).\n',
+          'normal number_codes radix input',
+        );
         assertEqual(
           run('', { goal: 'read_term(N, [])', ioOptions: { input: '1_ /* group */ 000. ' } }).stdout,
           'read_term(1000, []).\n',

package/the-art-of-eyeprolog.md

@@ -9743,7 +9743,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **224 self-contained runnable programs**. Every
+top-level directory contains **225 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic lists link every top-level program and open the program
@@ -10173,9 +10173,10 @@ and fast:
 ```sh
 npm run benchmark
 npm run benchmark:baseline
+npm run benchmark:lips
 ```
 
-The benchmark suite contains 20 representative workloads and stores their
+The benchmark suite contains 21 representative workloads and stores their
 semantic output digests in the repository, while wall-clock baselines remain
 machine-local under `.benchmarks/` because absolute timings are machine-specific.
 Each benchmark runs in its own fresh Node worker. Inside that worker, one untimed
@@ -10184,6 +10185,15 @@ 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.
+`npm run benchmark:lips` 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