eyeprolog 1.5.31 → 1.5.33

package/README.md

@@ -74,9 +74,9 @@ All 33 bundled modules that overlap Scryer's current `src/lib/` surface cover Sc
 - [Symbiotic Knowledge Graphs](https://eyereasoner.github.io/eyeprolog/examples/deck/symbiotic-knowledge-graphs) — RDF ↔ Prolog heatwave-response demo for human/AI/KG co-evolution
 - [rdf-prolog-roundtrip](https://github.com/eyereasoner/rdf-prolog-roundtrip) — standalone RDF 1.2 ↔ ISO Prolog bridge used by the RDF examples
 - [ISO conformance audit](test/conformance/ISO-COMPLIANCE.md) — supported Part 1 profile
-- [Conformance report](conformance-report.md) — generated executable conformance status and corpus summary
+- [Latest Neumerkel conformity](test/conformance/NEUMERKEL-LATEST.md) — tracked result from the current live upstream inventory
+- [Conformance report](conformance-report.md) — generated executable conformance status and local corpus summary
 - [OpenRuleBench](openrulebench/README.md) — portable benchmark profile
-
 ## RDF, Prolog, and symbiotic knowledge graphs
 
 EyeProlog can sit behind an RDF knowledge graph without inventing a private graph representation. [`rdf-prolog-roundtrip`](https://github.com/eyereasoner/rdf-prolog-roundtrip) converts RDF 1.2 datasets to ordinary `rdf(Subject, Predicate, Object, Graph)` facts, EyeProlog applies portable rules, and ground `rdf/4` results can be converted back to RDF.
@@ -86,14 +86,14 @@ 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
 npm install
 npm test
 ```
-
+`npm test` is the release gate and fetches the latest seven Neumerkel conformity sources before the local gates; use `npm run test:offline` for a network-free pass, `npm run test:conformance` for all conformance layers, `npm run test:neumerkel` for live upstream only, and `npm run test:neumerkel:cached` only to reproduce the last fetch. Upstream counts are discovered dynamically and verified against the tracked [latest Neumerkel report](test/conformance/NEUMERKEL-LATEST.md). Exact bytes/hashes stay under Git-ignored `.cache/neumerkel/`; refresh the tracked report with `npm run conformance:update:neumerkel` when upstream changes. Benchmarks remain `npm run benchmark` and `npm run benchmark:lips`.
 EyeProlog is released under the [MIT License](LICENSE.md).

package/conformance-report.md

@@ -4,6 +4,12 @@ This report combines an executable external conformance gate with the file-based
 conformance corpus under `test/conformance/`. The executable result is measured
 when this report is generated; it is not inferred from fixture counts.
 
+## Latest Neumerkel evidence
+
+See the tracked [latest Neumerkel conformity report](test/conformance/NEUMERKEL-LATEST.md).
+The live release gate fetches all seven TU Wien sources again and verifies that tracked
+report still matches the discovered upstream inventory.
+
 ## Executable conformance status
 
 | Gate | Passed | Total | Status |

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.31",
+  "version": "1.5.33",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -46,30 +46,32 @@
   },
   "scripts": {
     "test": "node test/run-all.mjs",
-    "generate": "node tools/generate-library-autoload-index.mjs && node tools/generate-predicate-reference.mjs && node tools/extract-book-examples.mjs",
-    "generate:autoload": "node tools/generate-library-autoload-index.mjs",
-    "test:eyeprolog": "node test/run-all.mjs",
-    "test:conformance": "node test/run-conformance.mjs",
-    "test:iso-strict": "node test/run-iso-strict.mjs",
-    "test:interop": "node test/run-interop.mjs",
-    "test:openrulebench": "node test/run-openrulebench.mjs",
+    "test:offline": "node test/run-all.mjs --offline",
+    "test:conformance": "node test/run-conformance-all.mjs",
+    "test:conformance:offline": "node test/run-conformance-all.mjs --offline",
+    "test:neumerkel": "node test/run-neumerkel.mjs",
+    "test:neumerkel:cached": "node test/run-neumerkel.mjs --cached --no-verify-report",
+    "test:neumerkel:harness": "node test/run-neumerkel-tests.mjs",
+    "test:iso": "node test/run-iso-strict.mjs",
     "test:wg17": "node test/run-wg17.mjs",
-    "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",
-    "test:regression:api": "node test/run-regression.mjs api",
-    "test:regression:core": "node test/run-regression.mjs regression",
-    "test:regression:docs": "node test/run-regression.mjs docs",
-    "test:regression:white-box": "node test/run-regression.mjs white-box",
+    "test:examples": "node test/run-examples.mjs",
+    "test:interop": "node test/run-interop.mjs",
     "test:playground": "node test/run-playground.mjs",
-    "wg17:upgrade": "node tools/upgrade-wg17.mjs",
-    "report:wg17": "node tools/report-wg17-syntax-coverage.mjs",
-    "report:wg17-syntax": "node tools/report-wg17-syntax-coverage.mjs",
-    "preversion": "npm test && node test/run-conformance-report.mjs conformance-report.md",
-    "postversion": "git push origin HEAD --follow-tags",
     "test:architecture": "node test/run-architecture.mjs",
+    "test:openrulebench": "node test/run-openrulebench.mjs",
+    "test:benchmark": "node test/run-benchmark-tests.mjs",
     "benchmark": "node test/benchmark.mjs",
+    "benchmark:lips": "node test/lips-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"
+    "conformance:update": "npm run conformance:update:wg17 && npm run conformance:update:neumerkel",
+    "conformance:report": "node test/run-conformance-report.mjs conformance-report.md",
+    "generate": "node tools/generate-library-autoload-index.mjs && node tools/generate-predicate-reference.mjs && node tools/extract-book-examples.mjs",
+    "generate:autoload": "node tools/generate-library-autoload-index.mjs",
+    "generate:reference": "node tools/generate-predicate-reference.mjs",
+    "preversion": "npm test && npm run conformance:report",
+    "postversion": "git push origin HEAD --follow-tags",
+    "conformance:update:wg17": "node tools/upgrade-wg17.mjs",
+    "conformance:update:neumerkel": "node test/run-neumerkel.mjs --update-report"
   }
 }

package/playground.html

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

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
@@ -295,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;
@@ -303,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();
@@ -512,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;
@@ -654,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);
@@ -706,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') {
@@ -740,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(
@@ -870,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;
       }
@@ -1110,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;
@@ -1301,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
@@ -1331,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;
@@ -1347,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();
@@ -2332,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;
     }