eyeprolog 1.2.15 → 1.2.16

package/package.json

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

package/src/solver.js

@@ -490,10 +490,11 @@ function normalizeHostResourceError(error) {
   const message = String(error?.message ?? '');
   // V8 reports exhausted Map/Set capacity as a host RangeError.  ISO 7.12.2 h
   // requires processor resource exhaustion to surface as resource_error/1,
-  // with the resource atom implementation dependent.  EyeProlog uses the
-  // finite_memory spelling already accepted by its ISO conformance corpus.
+  // with the resource atom implementation dependent.  A finite host capacity
+  // ceiling is reported as `memory`; reserve `finite_memory` for the separate
+  // convention where no finite amount of memory can complete the computation.
   if (/^(?:Map|Set) maximum size exceeded$/.test(message)) {
-    return new PrologError('resource_error(finite_memory)');
+    return new PrologError('resource_error(memory)');
   }
   return error;
 }

package/test/run-regression.mjs

@@ -2221,22 +2221,27 @@ open(X) :- candidate(X), \\+ closed(X).
       },
     },
     {
-      name: 'host Map capacity errors become ISO resource errors',
+      name: 'host Map/Set capacity errors become resource_error(memory)',
       run: () => {
-        const registry = new BuiltinRegistry();
-        registry.add('exhaust_map', 0, function* () {
-          throw new RangeError('Map maximum size exceeded');
-        });
-        const solver = new Solver(Program.parse(''), { registry });
-        const goal = parseGoalText('exhaust_map');
-        let caught = null;
-        try {
-          [...solver.solve([goal], new Env(), 0)];
-        } catch (error) {
-          caught = error;
+        for (const [predicate, message] of [
+          ['exhaust_map', 'Map maximum size exceeded'],
+          ['exhaust_set', 'Set maximum size exceeded'],
+        ]) {
+          const registry = new BuiltinRegistry();
+          registry.add(predicate, 0, function* () {
+            throw new RangeError(message);
+          });
+          const solver = new Solver(Program.parse(''), { registry });
+          const goal = parseGoalText(predicate);
+          let caught = null;
+          try {
+            [...solver.solve([goal], new Env(), 0)];
+          } catch (error) {
+            caught = error;
+          }
+          assertEqual(caught?.name, 'PrologError', `${predicate} normalized error type`);
+          assertEqual(caught?.formal, 'resource_error(memory)', `${predicate} normalized resource error`);
         }
-        assertEqual(caught?.name, 'PrologError', 'normalized error type');
-        assertEqual(caught?.formal, 'resource_error(finite_memory)', 'normalized resource error');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1823,8 +1823,12 @@ sorted-list operation. No process-global variable registry or creation ordinal
 is retained or exposed through later comparisons.
 
 Host capacity failures that V8 reports as `Map maximum size exceeded` or `Set`
-`maximum size exceeded` are normalized at the solver boundary to the ISO error
-`resource_error(finite_memory)` instead of leaking a JavaScript `RangeError`.
+`maximum size exceeded` are normalized at the solver boundary to
+`resource_error(memory)` instead of leaking a JavaScript `RangeError`. ISO
+13211-1 leaves the resource atom implementation dependent. EyeProlog uses
+`memory` for a finite host allocation/capacity ceiling and reserves the
+`finite_memory` spelling for the distinct convention where no finite amount of
+memory could complete the computation.
 
 ### Implementation boundary