eyeprolog 1.2.27 → 1.2.28

package/package.json

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

package/src/platform.js

@@ -15,6 +15,8 @@ if (isNode) {
   BufferCtor = globalThis.Buffer ?? null;
 }
 
+const configuredOldSpaceLimit = configuredOldSpaceBytes();
+
 export { fs, path, BufferCtor, isNode };
 
 export function currentWorkingDirectory() {
@@ -23,6 +25,17 @@ export function currentWorkingDirectory() {
 
 export function usedHeapSize() {
   if (isNode && typeof process.memoryUsage === 'function') {
+    // --max-old-space-size constrains V8's old generation, not the complete
+    // heap reported by process.memoryUsage().heapUsed. Comparing that limit
+    // with total heap use makes bursts of collectible new-space objects look
+    // like retained memory. Measure the corresponding non-young spaces when
+    // an old-space limit was supplied.
+    if (configuredOldSpaceLimit != null && typeof v8?.getHeapSpaceStatistics === 'function') {
+      const spaces = v8.getHeapSpaceStatistics();
+      return spaces
+        .filter(({ space_name: name }) => name !== 'read_only_space' && !name.startsWith('new_'))
+        .reduce((total, { space_used_size: size }) => total + size, 0);
+    }
     return process.memoryUsage().heapUsed;
   }
   const memory = globalThis.performance?.memory;
@@ -33,8 +46,7 @@ export function softHeapLimit() {
   let limit = null;
   if (isNode) {
     limit = v8?.getHeapStatistics?.().heap_size_limit ?? null;
-    const configuredOldSpace = configuredOldSpaceBytes();
-    if (configuredOldSpace != null) limit = Math.min(limit ?? Infinity, configuredOldSpace);
+    if (configuredOldSpaceLimit != null) limit = Math.min(limit ?? Infinity, configuredOldSpaceLimit);
   } else {
     const memory = globalThis.performance?.memory;
     if (Number.isFinite(memory?.jsHeapSizeLimit)) limit = memory.jsHeapSizeLimit;

package/test/run-regression.mjs

@@ -2586,6 +2586,42 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(result.stdout, '300000', 'fresh-variable answer count');
       },
     },
+    {
+      name: 'caught number syntax errors do not exhaust memory on distinct inputs',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = `
+          :- use_module(library(lists)).
+          alphabet(['0','1','2','3','4','5','6','7','8','9','.']).
+          trial([A,B,C,D,E]) :-
+            alphabet(Chars),
+            member(A, Chars), member(B, Chars), member(C, Chars),
+            member(D, Chars), member(E, Chars),
+            catch(number_chars(_, [A,B,C,D,E]), error(syntax_error(number), _), true).
+        `;
+        const script = `
+          import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(programText)});
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          const goal = parseGoalText('trial(Chars)');
+          let count = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) {
+            if (++count === 150000) break;
+          }
+          if (count !== 150000) throw new Error('unexpected answer count: ' + count);
+          process.stdout.write(String(count));
+        `;
+        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, '150000', 'distinct number syntax attempts');
+      },
+    },
     {
       name: 'host Map/Set capacity errors become resource_error(memory)',
       run: () => {