eyeprolog 1.2.22 → 1.2.24

package/package.json

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

package/src/iso.js

@@ -5,7 +5,8 @@ import {
   isDecimalInteger, listFromItems, numberTerm, numberTextFromDouble,
   properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
-import { createParserOperatorState, parseClauses, parseGoalText } from './parser.js';
+import { sameNumberValue } from './number-value.js';
+import { createParserOperatorState, parseClauses, parseGoalText, parseNumberTokenText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 
@@ -220,7 +221,8 @@ function subsumesTerm(general, specific, env) {
       }
       continue;
     }
-    if (left.type !== right.type || left.name !== right.name || left.arity !== right.arity) return false;
+    if (left.type !== right.type || left.arity !== right.arity) return false;
+    if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
     for (let i = left.arity - 1; i >= 0; i--) pending.push([left.args[i], right.args[i]]);
   }
   return true;
@@ -239,7 +241,8 @@ function* nonIdentity({ goal, env }) {
 function identical(left, right, env) {
   left = deref(left, env);
   right = deref(right, env);
-  if (left.type !== right.type || left.name !== right.name || left.arity !== right.arity) return false;
+  if (left.type !== right.type || left.arity !== right.arity) return false;
+  if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
   if (left.type === VAR) return left.name === right.name;
   for (let i = 0; i < left.arity; i++) if (!identical(left.args[i], right.args[i], env)) return false;
   return true;
@@ -1549,9 +1552,7 @@ function quotedNumberSign(text, start) {
 }
 
 function parseIsoNumber(text) {
-  // number_chars/2 accepts leading layout, but its character list must end
-  // with the numeric token itself rather than trailing layout text.
-  if (text.length === 0 || /[\u0009-\u000d\u0020]$/.test(text)) return null;
+  if (text.length === 0) return null;
   let position = skipNumberLayout(text, 0);
   let sign = '';
 
@@ -1587,10 +1588,7 @@ function parseIsoNumber(text) {
   // ISO floating-point syntax requires a decimal fraction before an exponent.
   if (/^-?\d+[eE][+-]?\d+$/.test(numericText)) return null;
   try {
-    const parsed = parseGoalText(`number_chars_value(${numericText})`);
-    if (parsed.type !== COMPOUND || parsed.name !== 'number_chars_value' ||
-        parsed.arity !== 1 || parsed.args[0].type !== NUMBER) return null;
-    const value = parsed.args[0];
+    const value = parseNumberTokenText(numericText);
     if (isDecimalInteger(value.name)) return numberTerm(BigInt(value.name).toString());
     const finite = Number(value.name);
     if (!Number.isFinite(finite)) return null;
@@ -1601,14 +1599,18 @@ function parseIsoNumber(text) {
 }
 
 function sameNumber(left, right) {
-  const leftInteger = isDecimalInteger(left.name);
-  const rightInteger = isDecimalInteger(right.name);
-  if (leftInteger || rightInteger) {
-    return leftInteger && rightInteger && BigInt(left.name) === BigInt(right.name);
+  return sameNumberValue(left.name, right.name);
+}
+
+function canonicalNumberText(value) {
+  if (isDecimalInteger(value.name)) return BigInt(value.name).toString();
+  const finite = Number(value.name);
+  if (Number.isFinite(finite) && /^-?\d+\.\d+(?:[eE][+-]?\d+)?$/.test(value.name)) {
+    return value.name;
   }
-  const leftValue = Number(left.name);
-  const rightValue = Number(right.name);
-  return Number.isFinite(leftValue) && Number.isFinite(rightValue) && leftValue === rightValue;
+  const text = numberTextFromDouble(finite);
+  if (text == null) throw new PrologError('representation_error(max_float)');
+  return text;
 }
 
 function numberListText(list, env, kind, valueIsBound) {
@@ -1650,7 +1652,7 @@ function numberListBuiltin(kind) {
         if (sameNumber(value, parsed)) yield next;
         return;
       }
-      const items = characters(value.name).map((ch) =>
+      const items = characters(canonicalNumberText(value)).map((ch) =>
         kind === 'chars' ? atom(ch) : numberTerm(ch.codePointAt(0)));
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;

package/src/number-value.js

@@ -0,0 +1,28 @@
+// Numeric value identity shared by term semantics and scalar indexes. Keep
+// integer and float terms distinct while ignoring insignificant spelling
+// differences within either ISO numeric type.
+const decimalInteger = (text) => /^-?\d+$/.test(text ?? '');
+
+const finiteFloat = (text) => {
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(text ?? '')) return null;
+  const value = Number(text);
+  return Number.isFinite(value) ? value : null;
+};
+
+export function sameNumberValue(left, right) {
+  const leftInteger = decimalInteger(left);
+  const rightInteger = decimalInteger(right);
+  if (leftInteger || rightInteger) {
+    return leftInteger && rightInteger && BigInt(left) === BigInt(right);
+  }
+  const leftValue = finiteFloat(left);
+  const rightValue = finiteFloat(right);
+  return leftValue != null && rightValue != null && leftValue === rightValue;
+}
+
+export function numberValueKey(text) {
+  if (decimalInteger(text)) return `integer:${BigInt(text)}`;
+  const value = finiteFloat(text);
+  if (value == null) return `invalid:${text}`;
+  return `float:${Object.is(value, -0) ? 0 : value}`;
+}

package/src/parser.js

@@ -433,6 +433,18 @@ class Parser {
         this.take();
         this.take();
         let value = this.take();
+        if (value) {
+          const firstCode = value.charCodeAt(0);
+          if (firstCode >= 0xd800 && firstCode <= 0xdbff) {
+            const secondCode = this.peek().charCodeAt(0);
+            if (secondCode < 0xdc00 || secondCode > 0xdfff) {
+              throw new Error(`parse line ${line}: bad character code constant`);
+            }
+            value += this.take();
+          } else if (firstCode >= 0xdc00 && firstCode <= 0xdfff) {
+            throw new Error(`parse line ${line}: bad character code constant`);
+          }
+        }
         if (!value || (value !== ' ' && isWhitespaceCode(value.charCodeAt(0)))) {
           throw new Error(`parse line ${line}: bad character code constant`);
         }
@@ -1294,6 +1306,22 @@ export function parseProgramText(source, options = {}) {
   return parseClauses(source, options);
 }
 
+export function parseNumberTokenText(text) {
+  const source = String(text ?? '');
+  const parser = new Parser(source, {
+    includeDefaultOperators: false,
+    sourceMetadata: false,
+  });
+  // Inspect the tokenizer position before requesting another token: advancing
+  // would skip trailing layout and make `3 ` or `3/**/` look complete. A
+  // literal space consumed by the character-code token `0' ` is already part
+  // of parser.pos and is therefore correctly accepted.
+  if (parser.token.type !== TOK.NUMBER || parser.pos !== source.length) {
+    throw new Error('not exactly one number token');
+  }
+  return numberTerm(parser.token.text);
+}
+
 export function parseGoalText(text, options = {}) {
   const clauses = parseClauses(`zz_goal((${text})).`, options);
   const head = clauses[0]?.head;

package/src/program.js

@@ -1,6 +1,7 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
 import { ATOM, COMPOUND, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
+import { numberValueKey } from './number-value.js';
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
@@ -158,6 +159,9 @@ export class Program {
       scalarFactsOnly: true,
       dynamic: this.dynamicPredicates.has(modulePredicateKey(module, name, arity)),
       negationStratum: null,
+      hasCut: false,
+      cutReachable: null,
+      bundledLibrary: false,
     };
     return group;
   }
@@ -185,6 +189,7 @@ export class Program {
       group.rejectedDemandIndexes.clear();
     }
     group.clauses.push(clause);
+    if (clauseHasCut(clause)) group.hasCut = true;
     const clausePosition = group.clauses.length - 1;
     for (let i = 0; i < head.arity; i++) indexOne(group.argIndexes[i], head.args[i], clause, group.clauses, clausePosition);
   }
@@ -291,6 +296,7 @@ export class Program {
     const groups = [...this.groups.values()];
     const indexByGroup = new Map(groups.map((group, i) => [group, i]));
     const deps = groups.map(() => new Set());
+    const cutDeps = groups.map(() => new Set());
     const negativeEdges = [];
     for (const group of groups) {
       const groupIndex = indexByGroup.get(group);
@@ -298,11 +304,18 @@ export class Program {
         if (isCompactBinaryClause(clause)) {
           if (clause.bodyName != null) {
             const dep = this.findGroup(clause.bodyName, 2, group.module);
-            if (dep) deps[groupIndex].add(indexByGroup.get(dep));
+            if (dep) {
+              deps[groupIndex].add(indexByGroup.get(dep));
+              cutDeps[groupIndex].add(indexByGroup.get(dep));
+            }
           }
           continue;
         }
         for (const goal of clause.body) {
+          for (const dependency of collectGoalDependencies(goal, false, true)) {
+            const dep = this.findGroup(dependency.name, dependency.arity, dependency.module ?? group.module);
+            if (dep) cutDeps[groupIndex].add(indexByGroup.get(dep));
+          }
           const directKey = directGoalDependencyKey(goal);
           if (directKey) {
             const dep = this.findGroup(goal.name, goal.arity, goal.module ?? group.module);
@@ -324,6 +337,8 @@ export class Program {
       const start = indexByGroup.get(group);
       const standardLibraryModule = group.module !== 'user' &&
         this.modules.get(group.module)?.filename?.startsWith('src/lib/');
+      group.bundledLibrary = standardLibraryModule === true;
+      group.cutReachable = [...reachableIndexes(start, cutDeps)].some((index) => groups[index].hasCut);
       const seen = new Set();
       const stack = [start];
       let recursive = false;
@@ -532,6 +547,7 @@ class ProgramBuilder {
         group.clauses.push(clause);
         clause.groundHead = termHasNoVariables(head);
         clause.scalarHead = head.type === COMPOUND && head.args.every(isScalar);
+        if (clauseHasCut(clause)) group.hasCut = true;
         if (clause.body.length !== 0 || !clause.scalarHead) group.scalarFactsOnly = false;
         for (let i = 0; i < head.arity; i++) {
           indexOne(group.argIndexes[i], head.args[i], clause, group.clauses, clausePosition);
@@ -1113,33 +1129,41 @@ function directGoalDependencyKey(goal) {
   return `${goal.name}/${goal.arity}`;
 }
 
-function collectGoalDependencies(goal, negated) {
+function collectGoalDependencies(goal, negated, traverseConditionals = false) {
   if (goal.type === ATOM) return [{ key: `${goal.name}/0`, name: goal.name, arity: 0, module: goal.module, negative: negated }];
   if (goal.type !== COMPOUND) return [];
   if (goal.name === ',' && goal.arity === 2) {
     return [
-      ...collectGoalDependencies(goal.args[0], negated),
-      ...collectGoalDependencies(goal.args[1], negated),
+      ...collectGoalDependencies(goal.args[0], negated, traverseConditionals),
+      ...collectGoalDependencies(goal.args[1], negated, traverseConditionals),
+    ];
+  }
+  if (traverseConditionals && (goal.name === ';' || goal.name === '->') && goal.arity === 2) {
+    return [
+      ...collectGoalDependencies(goal.args[0], negated, true),
+      ...collectGoalDependencies(goal.args[1], negated, true),
     ];
   }
   if ((goal.name === '\\+' || goal.name === 'not') && goal.arity === 1) {
-    return collectGoalDependencies(goal.args[0], !negated);
+    return collectGoalDependencies(goal.args[0], !negated, traverseConditionals);
   }
   if (goal.name === 'once' && goal.arity === 1) {
-    return collectGoalDependencies(goal.args[0], negated);
+    return collectGoalDependencies(goal.args[0], negated, traverseConditionals);
   }
   if (goal.name === 'forall' && goal.arity === 2) {
     return [
-      ...collectGoalDependencies(goal.args[0], negated),
-      ...collectGoalDependencies(goal.args[1], negated),
+      ...collectGoalDependencies(goal.args[0], negated, traverseConditionals),
+      ...collectGoalDependencies(goal.args[1], negated, traverseConditionals),
     ];
   }
   if ((goal.name === 'findall' || goal.name === 'sumall') && goal.arity === 3) {
-    return collectGoalDependencies(goal.args[1], negated);
+    return collectGoalDependencies(goal.args[1], negated, traverseConditionals);
+  }
+  if (goal.name === 'countall' && goal.arity === 2) {
+    return collectGoalDependencies(goal.args[0], negated, traverseConditionals);
   }
-  if (goal.name === 'countall' && goal.arity === 2) return collectGoalDependencies(goal.args[0], negated);
   if ((goal.name === 'aggregate_min' || goal.name === 'aggregate_max') && goal.arity === 5) {
-    return collectGoalDependencies(goal.args[2], negated);
+    return collectGoalDependencies(goal.args[2], negated, traverseConditionals);
   }
   return [{ key: `${goal.name}/${goal.arity}`, name: goal.name, arity: goal.arity, module: goal.module, negative: negated }];
 }
@@ -1238,15 +1262,19 @@ function scalarBuckets(index, term) {
 }
 
 function argumentBucket(index, term) {
-  return scalarBuckets(index, term).get(term.name) ?? null;
+  return scalarBuckets(index, term).get(scalarBucketKey(term.type, term.name)) ?? null;
 }
 
 function addArgumentBucket(index, term, clause) {
-  addClauseBucket(scalarBuckets(index, term), term.name, clause);
+  addClauseBucket(scalarBuckets(index, term), scalarBucketKey(term.type, term.name), clause);
 }
 
 function scalarIndexKey(term) {
-  return `${term.type}\u0000${term.name}`;
+  return `${term.type}\u0000${scalarBucketKey(term.type, term.name)}`;
+}
+
+function scalarBucketKey(type, name) {
+  return type === 'number' ? numberValueKey(name) : name;
 }
 
 function addClauseBucket(buckets, key, clause) {
@@ -1276,7 +1304,7 @@ function indexCompactOne(index, type, name, clause, clauses = null, clausePositi
       index.sawScalar = true;
       if (clauses && clausePosition > 0) index.fallback = clauses.slice(0, clausePosition);
     }
-    addClauseBucket(compactScalarBuckets(index, type), name, clause);
+    addClauseBucket(compactScalarBuckets(index, type), scalarBucketKey(type, name), clause);
   } else if (index.sawScalar) {
     index.fallback.push(clause);
   }
@@ -1303,6 +1331,7 @@ function rebuildGroupIndexes(group) {
   group.demandIndexes.clear();
   group.rejectedDemandIndexes.clear();
   group.scalarFactsOnly = true;
+  group.hasCut = false;
   for (let clausePosition = 0; clausePosition < group.clauses.length; clausePosition++) {
     const clause = group.clauses[clausePosition];
     if (isCompactBinaryClause(clause)) {
@@ -1315,6 +1344,7 @@ function rebuildGroupIndexes(group) {
     }
     clause.groundHead = termHasNoVariables(clause.head);
     clause.scalarHead = clause.head.type === COMPOUND && clause.head.args.every(isScalar);
+    if (clauseHasCut(clause)) group.hasCut = true;
     if (clause.body.length !== 0 || !clause.scalarHead) group.scalarFactsOnly = false;
     for (let i = 0; i < group.arity; i++) indexOne(group.argIndexes[i], clause.head.args[i], clause, group.clauses, clausePosition);
   }

package/src/solver.js

@@ -1,9 +1,11 @@
 // 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 {
-  COMPOUND, Env, compound, copyResolved, deref, emptyList, flattenConjunction, freshTerm,
-  numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variantTerms,
+  COMPOUND, NUMBER, VAR, Env, compound, cons, copyResolved, deref, emptyList,
+  flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
+  numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
+import { sameNumberValue } from './number-value.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program.js';
@@ -366,6 +368,23 @@ export class Solver {
         }
         qualifyMetaArguments(goal, group);
 
+        const lengthIterator = prologueLengthIterator(this, group, goal, env);
+        if (lengthIterator != null) {
+          const firstResult = lengthIterator.next();
+          if (firstResult.done) break;
+          stack.push({
+            kind: 'resumeBuiltin',
+            iterator: lengthIterator,
+            goals: rest,
+            depth: depth + 1,
+            active,
+          });
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
         if (group.tabled) {
           const key = memoKey(goal, env, group);
           if (key.hasBound) {
@@ -417,8 +436,8 @@ export class Solver {
     return activeVariantIn(goal, env, this.active);
   }
 
-  checkMemoryLimit() {
-    if (this.inferences < this.nextMemoryCheck) return;
+  checkMemoryLimit(force = false) {
+    if (!force && this.inferences < this.nextMemoryCheck) return;
     this.nextMemoryCheck = this.inferences + 256;
     if (!Number.isFinite(this.maxMemoryBytes)) return;
     const used = usedHeapSize();
@@ -476,6 +495,12 @@ export class Solver {
         if (!unify(goal, freshHead, next)) continue;
         if (freshBody.length === 0) {
           yield* this.solve(rest, next, depth + 1);
+        } else if (!groupNeedsActiveFrame(group)) {
+          for (const bodyEnv of this.solve(freshBody, next, depth + 1)) {
+            if (this.solutionsSeen > 0) this.solutionsSeen--;
+            yield* this.solve(rest, bodyEnv, depth + 1);
+            if (this.solutionsSeen >= this.solutionLimit) break;
+          }
         } else {
           yield* this.solveRuleBodyThenRest(goal, env, freshBody, rest, next, depth);
         }
@@ -612,7 +637,11 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   const candidates = selectClauseCandidates(group, goal, env);
   const frames = [];
   const invocation = { goal, env };
-  const guarded = !group.linearNumeric;
+  // 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.
+  const guarded = groupNeedsActiveFrame(group);
   const release = guarded ? [{ kind: 'releaseActive' }] : [];
   const nextActive = guarded ? [...active, invocation] : active;
   for (const pass of [candidates.primary, candidates.fallback]) {
@@ -662,6 +691,141 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   for (let i = frames.length - 1; i >= 0; i--) stack.push(frames[i]);
 }
 
+function groupNeedsActiveFrame(group) {
+  // User code may observe the surrounding control context through later cuts,
+  // so only apply this planning shortcut to the fixed bundled-library graph.
+  if (group.bundledLibrary !== true) return true;
+  // A frame is also required above a cut-bearing callee. The disjunction
+  // builtin uses the caller marker to distinguish a callee-local cut from a
+  // cut in its own branch. null means dependency analysis was intentionally
+  // disabled (strict mode or a newly mutated group), so remain conservative.
+  return group.cutReachable !== false || (group.recursive && !group.linearNumeric);
+}
+
+function prologueLengthIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true ||
+      group.module !== 'prologue' || group.name !== 'length' || group.arity !== 2 ||
+      group.bundledLibrary !== true || group.clauses.length !== 2) {
+    return null;
+  }
+
+  // Delayed and constrained variables need the ordinary solver's wake-up
+  // points. The fast path is deliberately limited to plain finite-tree terms.
+  if (env._clpz != null) return null;
+  const length = deref(goal.args[1], env);
+  if (length.type === VAR && env._delays?.has(length.name)) return null;
+
+  let cursor = deref(goal.args[0], env);
+  while (isCons(cursor)) {
+    cursor = deref(cursor.args[1], env);
+  }
+  if (cursor.type === VAR) {
+    if (env._delays?.has(cursor.name)) return null;
+    if (length.type === VAR && cursor.name === length.name) return null;
+  }
+  return prologueLengthSolutions(solver, goal, env);
+}
+
+function* prologueLengthSolutions(solver, goal, env) {
+  const requestedLength = deref(goal.args[1], env);
+  if (requestedLength.type !== VAR) {
+    if (requestedLength.type !== NUMBER || !isDecimalInteger(requestedLength.name)) {
+      throw new PrologError('type_error(integer)', requestedLength);
+    }
+    const length = BigInt(requestedLength.name);
+    if (length < 0n) throw new PrologError('domain_error(not_less_than_zero)', requestedLength);
+    yield* fixedLengthSolutions(solver, goal.args[0], length, env);
+    return;
+  }
+
+  yield* generatedLengthSolutions(solver, goal.args[0], goal.args[1], env);
+}
+
+function* fixedLengthSolutions(solver, list, length, env) {
+  let cursor = deref(list, env);
+  let remaining = length;
+  let steps = 0n;
+  while (isCons(cursor)) {
+    if (remaining === 0n) return;
+    remaining--;
+    cursor = deref(cursor.args[1], env);
+    lengthAllocationCheckpoint(solver, ++steps);
+  }
+  if (isEmptyList(cursor)) {
+    if (remaining === 0n) yield env;
+    return;
+  }
+  if (cursor.type !== VAR) return;
+
+  // A source-level anonymous variable occurs nowhere else, so materializing
+  // its list cannot affect any subsequent goal or answer substitution.
+  if (isAnonymousVariable(cursor)) {
+    yield env;
+    return;
+  }
+
+  const id = nextFreshId();
+  let suffix = emptyList();
+  for (let index = 0n; index < remaining; index++) {
+    suffix = cons(variable(`__length${id}_${index}`), suffix);
+    lengthAllocationCheckpoint(solver, ++steps);
+  }
+  const next = env.clone();
+  solver.stats.unify_calls++;
+  if (unify(cursor, suffix, next)) yield next;
+}
+
+function* generatedLengthSolutions(solver, list, length, env) {
+  let cursor = deref(list, env);
+  let count = 0n;
+  let steps = 0n;
+  while (isCons(cursor)) {
+    count++;
+    cursor = deref(cursor.args[1], env);
+    lengthAllocationCheckpoint(solver, ++steps);
+  }
+  if (isEmptyList(cursor)) {
+    const next = bindGeneratedLength(solver, length, count, env);
+    if (next != null) yield next;
+    return;
+  }
+  if (cursor.type !== VAR) return;
+
+  if (isAnonymousVariable(cursor)) {
+    for (let value = count; ; value++) {
+      const next = bindGeneratedLength(solver, length, value, env);
+      if (next != null) yield next;
+    }
+  }
+
+  const id = nextFreshId();
+  let suffix = emptyList();
+  for (let extra = 0n; ; extra++) {
+    const next = env.clone();
+    solver.stats.unify_calls++;
+    if (unify(cursor, suffix, next)) {
+      const answer = bindGeneratedLength(solver, length, count + extra, next);
+      if (answer != null) yield answer;
+    }
+    suffix = cons(variable(`__length${id}_${extra}`), suffix);
+    lengthAllocationCheckpoint(solver, ++steps);
+  }
+}
+
+function bindGeneratedLength(solver, length, value, env) {
+  const next = env.clone();
+  solver.stats.unify_calls++;
+  return unify(length, numberTerm(value), next) ? next : null;
+}
+
+function isAnonymousVariable(term) {
+  return term.type === VAR && term.name.startsWith('__anon');
+}
+
+function lengthAllocationCheckpoint(solver, steps) {
+  if ((steps & 255n) === 0n) solver.checkMemoryLimit(true);
+}
+
 function pushFastPiFrames(stack, goal, rest, env, depth, active) {
   const values = goal.args.map((arg) => deref(arg, env));
   if ([0, 1, 2, 4].some((index) => values[index].type !== 'number')) return false;
@@ -1089,11 +1253,13 @@ function isScalarTerm(term) {
 }
 
 function sameScalarTerm(left, right) {
-  return isScalarTerm(left) && isScalarTerm(right) && left.type === right.type && left.name === right.name;
+  return isScalarTerm(left) && isScalarTerm(right) && left.type === right.type &&
+    (left.type === 'number' ? sameNumberValue(left.name, right.name) : left.name === right.name);
 }
 
 function sameGroundTerm(left, right) {
-  if (left?.type !== right?.type || left?.name !== right?.name) return false;
+  if (left?.type !== right?.type) return false;
+  if (left?.type === 'number' ? !sameNumberValue(left.name, right.name) : left?.name !== right?.name) return false;
   const arity = left.args?.length ?? 0;
   if (arity !== (right.args?.length ?? 0)) return false;
   for (let i = 0; i < arity; i++) if (!sameGroundTerm(left.args[i], right.args[i])) return false;

package/src/term.js

@@ -1,5 +1,7 @@
 // Term model, environments, unification, readback, and ordering helpers.
-// This file is intentionally dependency-free because nearly every other module imports it.
+// Keep dependencies minimal because nearly every other module imports this file.
+import { sameNumberValue } from './number-value.js';
+
 export const VAR = 'var';
 export const ATOM = 'atom';
 export const STRING = 'string';
@@ -247,7 +249,7 @@ export function unify(left, right, env, options = {}) {
     }
 
     if (isScalar(a)) {
-      if (a.name !== b.name) return false;
+      if (a.type === NUMBER ? !sameNumberValue(a.name, b.name) : a.name !== b.name) return false;
       continue;
     }
 
@@ -497,7 +499,8 @@ export function variantTerms(left, leftEnv, right, rightEnv, pairs = new Map(),
     reverse.set(right.name, left.name);
     return true;
   }
-  if (left.type !== right.type || left.name !== right.name || left.arity !== right.arity) return false;
+  if (left.type !== right.type || left.arity !== right.arity) return false;
+  if (left.type === NUMBER ? !sameNumberValue(left.name, right.name) : left.name !== right.name) return false;
   for (let i = 0; i < left.arity; i++) {
     if (!variantTerms(left.args[i], leftEnv, right.args[i], rightEnv, pairs, reverse)) return false;
   }

package/test/run-regression.mjs

@@ -567,6 +567,63 @@ c4 ?- call((!;1)).
         }
       },
     },
+    {
+      name: 'number conversion accepts ISO space and Unicode character-code constants exactly',
+      run: () => {
+        const source = String.raw`
+?- N = 0' .
+   N = 32.
+?- number_chars(N,"0' ").
+   N = 32.
+?- number_codes(N,[48,39,32]).
+   N = 32.
+?- N = 0'😀.
+   N = 128512.
+?- number_chars(N,"0'😀").
+   N = 128512.
+?- number_codes(N,[48,39,128512]).
+   N = 128512.
+?- number_codes(N,[48,39,34]).
+   N = 34.
+?- number_codes(N,[48,39,96]).
+   N = 96.
+?- number_codes(N,[48,39,92,92]).
+   N = 92.
+?- number_chars(01,Chars).
+   Chars = "1".
+?- number_codes(01,Codes).
+   Codes = [49].
+?- 1.2 = 1.20.
+   true.
+?- 1.2 == 1.20.
+   true.
+?- 1 = 1.0.
+   false.
+?- number_chars(1.20,C), number_chars(Y,C), 1.20 == Y.
+   C = "1.20", Y = 1.2.
+`;
+        const result = publicApi.runQuads(source);
+        assertEqual(result.total, 15, 'quad total');
+        assertEqual(result.passed, 15, 'quad passed');
+        assertEqual(result.stdout, 'quads: 15 run, 15 passed, 0 failed.\n', 'quad report');
+
+        for (const goal of [
+          'number_chars(N,"3/**/")',
+          'number_codes(N,[51,47,42,42,47])',
+          'number_chars(N,"0\'  ")',
+          'number_codes(N,[48,39,32,32])',
+        ]) {
+          let caught = null;
+          try {
+            publicApi.run('', { goal });
+          } catch (error) {
+            caught = error;
+          }
+          if (caught == null) throw new Error(`${goal} should reject trailing layout`);
+          assertIncludes(String(caught?.message ?? caught), 'syntax_error(number)', goal);
+        }
+      },
+    },
     {
       name: 'number conversion rejects parenthesized numeric terms',
       run: () => {
@@ -624,6 +681,21 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'quad stderr');
       },
     },
+    {
+      name: 'REPL advances anonymous Prologue length checks through I = 28',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'use_module(library(prologue)).\n' +
+            'length(_,I),I>9,N is 2^I,\\+ \\+ length(_,N).\n' +
+            'f\nf\nf\n;\n;\n;\n;\n\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stdout, ';  I = 28, N = 268435456\n;  ... .\n?- ', 'large anonymous length answer');
+        assertNotIncludes(result.stdout, 'resource_error(memory)', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'Prologue freeze wakes delayed goals with their bindings',
       run: () => {
@@ -2415,14 +2487,14 @@ open(X) :- candidate(X), \\+ closed(X).
       },
     },
     {
-      name: 'list allocation heap pressure becomes resource_error(memory)',
+      name: 'named list allocation heap pressure becomes resource_error(memory)',
       run: () => {
         const engineUrl = new URL('../src/index.js', import.meta.url).href;
         const programText = ':- use_module(library(prologue)).\n';
-        const goalText = 'length(_, I), I > 9, N is 2^I, \\+ \\+ length(_, N)';
+        const goalText = '\\+ \\+ length(List, 1000000)';
         const script = `
           import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
-          const program = Program.parse(${JSON.stringify(programText)});
+          const program = Program.parse(${JSON.stringify(programText)}, { sourceMetadata: false });
           const solver = new Solver(program, { registry: getEyePrologRegistry() });
           const goal = parseGoalText(${JSON.stringify(goalText)}, {
             operatorDefinitions: [...program.operators.values()],
@@ -2443,6 +2515,37 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(result.stdout, 'resource_error(memory)', 'heap pressure resource error');
       },
     },
+    {
+      name: 'anonymous Prologue length checks avoid materializing discarded lists',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = ':- use_module(library(prologue)).\n';
+        const goalText = 'length(_, I), I > 9, N is 2^I, \\+ \\+ length(_, N)';
+        const script = `
+          import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(programText)}, { sourceMetadata: false });
+          const solver = new Solver(program, {
+            registry: getEyePrologRegistry(),
+            solutionLimit: 19,
+          });
+          const goal = parseGoalText(${JSON.stringify(goalText)}, {
+            operatorDefinitions: [...program.operators.values()],
+          });
+          let answers = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) answers++;
+          process.stdout.write(String(answers));
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=64',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, '19', 'answers through I = 28');
+      },
+    },
     {
       name: 'solver honors solution limits',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1843,6 +1843,17 @@ ISO 13211-1 leaves the resource atom implementation dependent. EyeProlog uses
 `finite_memory` spelling for the distinct convention where no finite amount of
 memory could complete the computation.
 
+The iterative solver keeps active-call frames only where they are semantically
+needed for cut scope or recursive variant guards. Bundled-library helpers whose
+callable dependency region is cut-free and which need no recursive variant
+guard therefore do not copy a growing active-call sequence at every step.
+Under the normal EyeProlog registry, the bundled Prologue `length/2` also has a
+scoped iterative execution path: named lists are counted or constructed without
+recursive interpreter frames, and an anonymous list is not materialized because
+its binding cannot be observed. The ordinary clauses remain the authoritative
+module definition and are used unchanged by the ISO-only registry and whenever
+delays or finite-domain constraints require their normal wake-up points.
+
 ### Implementation boundary
 
 The source layout mirrors the language boundary. `src/iso.js` contains the
@@ -5777,7 +5788,13 @@ therefore follow `-` directly because `%` cannot continue a graphic token; an
 adjacent bracketed comment in `-/**/1` remains a syntax error under the eager
 token-consumer rule. Decimal fractions and decimal exponents are supported;
 the apostrophe character code is written with a doubled apostrophe as `0'''`
-and has value 39. Trailing material and non-finite values are rejected. The
+and has value 39, while a literal space character code is `0' ` and has value
+32. Character-code constants consume one Unicode scalar, including a
+non-BMP character. Trailing layout, comments, and other material are rejected;
+bound integers are converted to their canonical decimal spelling, and
+non-finite values are rejected. Equivalent spellings of the same numeric type
+compare by value, preserving the standard conversion round trip, while integer
+and floating-point terms remain distinct. The
 regression gate vendors all 74 numbered cases from Ulrich Neumerkel's contemporary
 `number_chars/2` comparison, including the Cor.2 error-precedence cases;
 `number_codes/2` shares the same numeric parser and has mirrored coverage for
@@ -5912,8 +5929,8 @@ so side effects occur in Prolog execution order.
 ### The EyeProlog library
 
 EyeProlog exposes **99 library predicate indicators** in addition to the 129
-indicators in its isolated ISO profile. **60 are implemented entirely as
-ordinary Prolog clauses** in focused modules under `src/lib/`. The remaining 39
+indicators in its isolated ISO profile. **60 are defined as ordinary Prolog
+clauses** in focused modules under `src/lib/`. The remaining 39
 are public wrappers around backtrackable host support: Prologue `call_nth/2` and
 `freeze/2`, plus the 37-predicate finite-domain `library(clpz)` kernel. The
 resulting normal EyeProlog language surface is therefore **228 public predicate