eyeprolog 1.5.29 → 1.5.31

package/package.json

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

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

@@ -115,7 +115,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 +219,7 @@ export class Solver {
       maxInferences: this.maxInferences,
       maxMemoryBytes: this.maxMemoryBytes,
       memoryRecovery: this.memoryRecovery,
+      memoryCheckState: this.memoryCheckState,
       solutionLimit,
       isoStrict: this.isoStrict,
       prologFlags: this.prologFlags,
@@ -848,15 +853,15 @@ export class Solver {
             if (!entry.computing) {
               if (!this.tableCoordinator) {
                 this.tableCoordinator = { entry, cycleSeen: false, entries: new Set([entry]) };
-                scheduleTableFixpointRound(stack, this, { entry, group, goal, rest, env, depth, active });
+                scheduleTableFixpointRound(stack, this, { entry, group, goal, rest, env, depth, active, mapKey });
               } else {
                 entry.computing = true;
                 stack.push({ kind: 'completeMemo', entry, revision: this.programRevision });
-                pushUserGoalUncachedFrames(stack, this, group, goal, [{ kind: 'memoStore', entry, goal, revision: this.programRevision }, ...rest], env, depth, active);
+                pushUserGoalUncachedFrames(stack, this, group, goal, [{ kind: 'memoStore', entry, goal, revision: this.programRevision }, ...rest], env, depth, active, mapKey);
               }
               break;
             }
-            if (this.tableCoordinator && (usingBroadTable || activeVariantIn(goal, env, active))) {
+            if (this.tableCoordinator && (usingBroadTable || activeTableKeyIn(mapKey, active))) {
               this.tableCoordinator.cycleSeen = true;
             }
             pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, this);
@@ -1005,8 +1010,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();
@@ -1252,6 +1258,7 @@ function scheduleTableFixpointRound(stack, solver, frame) {
     frame.env,
     frame.depth,
     frame.active,
+    frame.mapKey,
   );
 }
 
@@ -1289,13 +1296,13 @@ function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solv
   for (let answerIndex = entry.answers.length - 1; answerIndex >= 0; answerIndex--) pushReplay(answerIndex);
 }
 
-function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active) {
+function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active, tableMapKey = null) {
   if (group.fastPi && pushFastPiFrames(stack, goal, rest, env, depth, active)) return;
   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 frames = [];
-  const invocation = { goal, env: env._snapshotForSolverRead() };
+  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
@@ -3015,6 +3022,13 @@ function rememberMemoAnswer(entry, goal, env) {
   }
 }
 
+function activeTableKeyIn(mapKey, active) {
+  for (let index = active.length - 1; index >= 0; index--) {
+    if (active[index]?.tableMapKey === mapKey) return true;
+  }
+  return false;
+}
+
 function activeVariantIn(goal, env, active) {
   if (active.length === 0) return false;
   let goalShape = null;