eyeprolog 1.3.35 → 1.3.37

package/README.md

@@ -312,4 +312,10 @@ The GitHub test workflow runs the complete suite and an npm package dry-run on
 both the minimum supported Node.js 18 release line and Node.js 24. Publishing
 repeats those release checks before uploading the package.
 
+The runtime JavaScript modules stay flat under `src/`; the existing `src/lib/`
+directory contains the portable Prolog library modules. See
+[`src/ARCHITECTURE.md`](src/ARCHITECTURE.md) for the source-layer boundaries,
+facade modules, dependency rule, and the requirement that architectural cleanup
+must preserve the existing solver hot paths and benchmark performance.
+
 EyeProlog is released under the [MIT License](LICENSE.md).

package/index.d.ts

@@ -77,8 +77,9 @@ export interface EyePrologQuad {
 
 export interface EyePrologQuadResult {
   ok: boolean;
-  kind?: 'failed' | 'malformed' | 'bad_identifier' | 'unsupported';
+  kind?: 'failed' | 'malformed' | 'bad_identifier' | 'unsupported' | 'undecided';
   expected?: EyePrologTerm;
+  reason?: string;
 }
 
 export interface EyePrologQuadRunResult {
@@ -86,9 +87,20 @@ export interface EyePrologQuadRunResult {
   total: number;
   passed: number;
   failed: number;
+  undecided: number;
   results: EyePrologQuadResult[];
 }
 
+export interface EyePrologQuadRunOptions extends EyePrologRunOptions {
+  initialize?: boolean;
+  /** Search budget for ordinary quad descriptions before reporting an undecided result. */
+  quadMaxInferences?: number;
+  /** Depth bound used when a quad explicitly expects loops. */
+  loopMaxDepth?: number;
+  /** Inference bound used when a quad explicitly expects loops. */
+  loopMaxInferences?: number;
+}
+
 export interface EyePrologPredicateGroup {
   name: string;
   arity: number;
@@ -271,7 +283,7 @@ export class HaltSignal extends Error {
   constructor(code?: number);
 }
 export function run(source: string | Program, options?: EyePrologRunOptions): EyePrologRunResult;
-export function runQuads(source: string | Program, options?: EyePrologRunOptions & { initialize?: boolean }): EyePrologQuadRunResult;
+export function runQuads(source: string | Program, options?: EyePrologQuadRunOptions): EyePrologQuadRunResult;
 export function whyProof(program: Program, goal: EyePrologTerm, options?: EyePrologRunOptions): { ok: boolean; text: string };
 export function whyNoProof(goal: EyePrologTerm): string;
 export function explainProof(program: Program, goal: EyePrologTerm, options?: EyePrologRunOptions): { ok: boolean; text: string };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.35",
+  "version": "1.3.37",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -64,6 +64,7 @@
     "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"
+    "postversion": "git push origin HEAD --follow-tags",
+    "test:architecture": "node test/run-architecture.mjs"
   }
 }

package/src/ARCHITECTURE.md

@@ -0,0 +1,44 @@
+# EyeProlog source architecture
+
+The runtime is intentionally layered so semantic modules do not depend back on
+higher-level frontends.
+
+## Layers
+
+1. **Kernel representation and syntax** — `term.js`, `number-value.js`,
+   `syntax-scan.js`, `parser.js`, `write.js`, `errors.js`.
+2. **Program preparation** — `program.js` plus `program-analysis.js` and
+   `program-indexing.js`. Static recursion/Datalog/WFS classification lives in
+   `program-analysis.js`; compact clauses and candidate indexes live in
+   `program-indexing.js`.
+3. **Execution** — `solver.js`, `io.js`, `datalog.js`, `wfs.js`, `clpz.js`.
+4. **Language services** — `iso.js`, `iso-arithmetic.js`, `dcg.js`,
+   `standard-library.js`, and `src/lib/`.
+5. **Frontends/tools** — `execute.js`, `repl.js`, `cli.js`, `quads.js`,
+   `explain.js`, and the playground worker.
+
+`iso.js` and `program.js` remain facade modules for their existing exports, so
+this refactor does not change the public JavaScript API.
+
+## Dependency rule
+
+Dependencies should point down or sideways within a layer, never back from a
+kernel component into the ISO registry or a frontend.  In particular,
+`errors.js` owns `PrologError` and `HaltSignal`; DCG expansion can therefore
+report processor errors without importing `iso.js` and creating an
+`iso.js <-> dcg.js` cycle.
+
+The JavaScript runtime stays flat directly under `src/`; the existing `src/lib/`
+contains Prolog library sources rather than JavaScript runtime modules. The architecture
+test rejects JavaScript import cycles under `src/`.
+
+## Performance rule
+
+Architecture changes must not add runtime strategy objects, callbacks, or
+extra dispatch in solver hot paths.  Existing scalar/indexed solver paths stay
+as direct function calls.  Candidate indexing is separated physically but
+retains the same data structures and selection functions.
+
+Large solver fast paths deliberately remain co-located in `solver.js` until a
+split can demonstrate benchmark parity.  A cleaner file layout is not worth a
+runtime regression.

package/src/cli.js

@@ -168,6 +168,7 @@ export async function main(argv) {
     const result = engine.runQuads(program, { initialize: options.goals.length === 0 });
     process.stdout.write(result.stdout);
     if (result.failed > 0) process.exitCode = 1;
+    else if (result.undecided > 0) process.exitCode = 2;
   }
 }
 

package/src/dcg.js

@@ -5,7 +5,7 @@ import {
   ATOM, COMPOUND, VAR, Env, atom, compactListLength, compound, deref, emptyList,
   flattenConjunction, variable,
 } from './term.js';
-import { PrologError } from './iso.js';
+import { PrologError } from './errors.js';
 
 let dcgFresh = 0;
 

package/src/errors.js

@@ -0,0 +1,23 @@
+// Runtime control and ISO processor error types shared across subsystems.
+// Keep these independent of the ISO builtin registry so syntax, DCG, program,
+// and solver layers can report Prolog errors without importing the whole ISO
+// implementation (and without creating semantic-layer import cycles).
+import { termToString } from './term.js';
+
+export class PrologError extends Error {
+  constructor(formal, culprit = null) {
+    const detail = culprit == null ? formal : `${formal}, ${termToString(culprit)}`;
+    super(`error(${detail})`);
+    this.name = 'PrologError';
+    this.formal = formal;
+    this.culprit = culprit;
+  }
+}
+
+export class HaltSignal extends Error {
+  constructor(code = 0) {
+    super(`halt(${code})`);
+    this.name = 'HaltSignal';
+    this.code = code;
+  }
+}

package/src/iso-arithmetic.js

@@ -0,0 +1,166 @@
+// ISO arithmetic evaluation and comparison semantics.
+import {
+  ATOM, COMPOUND, NUMBER, VAR, atom, compound, deref, isDecimalInteger,
+  numberTerm, numberTextFromDouble, unify,
+} from './term.js';
+import { PrologError } from './errors.js';
+
+function evaluate(term, env) {
+  term = deref(term, env);
+  if (term.type === VAR) throw new PrologError('instantiation_error');
+  if (term.type === NUMBER) {
+    if (isDecimalInteger(term.name)) return { integer: true, value: BigInt(term.name) };
+    const value = Number(term.name);
+    if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
+    return { integer: false, value };
+  }
+  if (term.type === ATOM) {
+    if (term.name === 'pi') return { integer: false, value: Math.PI };
+    if (term.name === 'e') return { integer: false, value: Math.E };
+  }
+  if (term.type !== COMPOUND) throw new PrologError('type_error(evaluable)', term);
+  const args = term.args.map((arg) => evaluate(arg, env));
+  return evaluateOperation(term, args);
+}
+function evaluateOperation(term, args) {
+  const name = term.name;
+  const arity = term.arity;
+  if (arity === 1 && (name === '+' || name === '-')) {
+    return name === '+' ? args[0] : args[0].integer
+      ? { integer: true, value: -args[0].value }
+      : { integer: false, value: -args[0].value };
+  }
+  if (arity === 1 && name === '\\') {
+    if (!args[0].integer) throw new PrologError('type_error(integer)', numericTerm(args[0]));
+    return { integer: true, value: ~args[0].value };
+  }
+  if (arity === 1 && ['abs', 'sign', 'float', 'truncate', 'round', 'ceiling', 'floor',
+    'float_integer_part', 'float_fractional_part',
+    'sin', 'cos', 'atan', 'asin', 'acos', 'tan', 'exp', 'log', 'sqrt'].includes(name)) {
+    const a = Number(args[0].value);
+    if (name === 'abs' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -args[0].value : args[0].value };
+    if (name === 'sign' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -1n : args[0].value > 0n ? 1n : 0n };
+    if (name === 'truncate' || name === 'round' || name === 'ceiling' || name === 'floor') {
+      const fn = name === 'truncate' ? Math.trunc : name === 'round' ? Math.round : name === 'ceiling' ? Math.ceil : Math.floor;
+      return { integer: true, value: BigInt(fn(a)) };
+    }
+    if (name === 'float_integer_part' || name === 'float_fractional_part') {
+      if (args[0].integer) throw new PrologError('type_error(float)', numericTerm(args[0]));
+      const value = name === 'float_integer_part' ? Math.trunc(a) : a - Math.trunc(a);
+      return { integer: false, value };
+    }
+    const fn = name === 'float' ? (x) => x : name === 'abs' ? Math.abs : name === 'sign' ? Math.sign : Math[name];
+    const value = fn(a);
+    if (Number.isNaN(value) || (name === 'log' && a === 0)) throw new PrologError('evaluation_error(undefined)');
+    if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
+    return { integer: false, value };
+  }
+  if (arity !== 2) throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
+  const bothInteger = args[0].integer && args[1].integer;
+  const a = args[0].value, b = args[1].value;
+  if (['//', 'div', 'mod', 'rem', '/\\', '\\/', 'xor', '<<', '>>'].includes(name) && !bothInteger) {
+    const invalid = !args[0].integer ? args[0] : args[1];
+    throw new PrologError('type_error(integer)', numericTerm(invalid));
+  }
+  if (bothInteger && name === '^') {
+    if (b >= 0n) return { integer: true, value: a ** b };
+    if (a === 0n) throw new PrologError('evaluation_error(undefined)');
+    if (a === 1n) return { integer: true, value: 1n };
+    if (a === -1n) return { integer: true, value: (-b) % 2n === 0n ? 1n : -1n };
+    // Corrigendum 3: the defined real result needs a floating-point base.
+    throw new PrologError('type_error(float)', numericTerm(args[0]));
+  }
+  if (bothInteger && ['+', '-', '*', '//', 'div', 'mod', 'rem', '/\\', '\\/', 'xor', '<<', '>>'].includes(name)) {
+    if ((name === '//' || name === 'div' || name === 'mod' || name === 'rem') && b === 0n) throw new PrologError('evaluation_error(zero_divisor)');
+    if (name === '+') return { integer: true, value: a + b };
+    if (name === '-') return { integer: true, value: a - b };
+    if (name === '*') return { integer: true, value: a * b };
+    if (name === '//') return { integer: true, value: a / b };
+    if (name === 'div') {
+      const quotient = a / b;
+      const remainder = a % b;
+      return { integer: true, value: remainder !== 0n && ((a < 0n) !== (b < 0n)) ? quotient - 1n : quotient };
+    }
+    if (name === 'rem') return { integer: true, value: a % b };
+    if (name === 'mod') return { integer: true, value: ((a % b) + b) % b };
+    if (name === '/\\') return { integer: true, value: a & b };
+    if (name === '\\/') return { integer: true, value: a | b };
+    if (name === 'xor') return { integer: true, value: a ^ b };
+    if (name === '<<') return { integer: true, value: a << b };
+    if (name === '>>') return { integer: true, value: a >> b };
+  }
+  const x = Number(a), y = Number(b);
+  if ((!Number.isFinite(x) || !Number.isFinite(y)) && name !== 'max' && name !== 'min') {
+    throw new PrologError('evaluation_error(float_overflow)');
+  }
+  if (name === '/' && y === 0) throw new PrologError('evaluation_error(zero_divisor)');
+  let value;
+  if (name === 'max' || name === 'min') {
+    const cmp = compareArithmeticValues(args[0], args[1]);
+    const chooseLeft = name === 'max' ? cmp >= 0 : cmp <= 0;
+    return chooseLeft ? args[0] : args[1];
+  }
+  if (name === 'atan2') {
+    if (x === 0 && y === 0) throw new PrologError('evaluation_error(undefined)');
+    value = Math.atan2(x, y);
+  }
+  else if (name === '+') value = x + y;
+  else if (name === '-') value = x - y;
+  else if (name === '*') value = x * y;
+  else if (name === '/') value = x / y;
+  else if (name === '**' || name === '^') value = Math.pow(x, y);
+  else throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
+  if (Number.isNaN(value)) throw new PrologError('evaluation_error(undefined)');
+  if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
+  return { integer: false, value };
+}
+export function arithmeticValueTerm(value) {
+  return value.integer ? numberTerm(value.value.toString()) : numberTerm(numberTextFromDouble(value.value));
+}
+function numericTerm(value) {
+  return arithmeticValueTerm(value);
+}
+export function evaluateArithmetic(term, env) {
+  return evaluate(term, env);
+}
+function compareIntegerToFloat(integerValue, floatValue) {
+  if (!Number.isFinite(floatValue)) throw new PrologError('evaluation_error(float_overflow)');
+
+  // Do not round an unbounded integer through JavaScript Number before a
+  // mixed arithmetic comparison.  Every integral IEEE-754 double can be
+  // converted back to the exact integer value it represents; fractional
+  // doubles necessarily have magnitude below 2^53, so their truncation is
+  // also exact.  This preserves mathematical ordering across the I/F boundary
+  // (STC #50), e.g. 9007199254740993 > 9007199254740992.0.
+  if (Number.isInteger(floatValue)) {
+    const floatInteger = BigInt(floatValue);
+    return integerValue < floatInteger ? -1 : integerValue > floatInteger ? 1 : 0;
+  }
+
+  const truncated = BigInt(Math.trunc(floatValue));
+  if (integerValue < truncated) return -1;
+  if (integerValue > truncated) return 1;
+  return floatValue > 0 ? -1 : 1;
+}
+
+export function compareArithmeticValues(left, right) {
+  const a = left.value;
+  const b = right.value;
+  if (left.integer && right.integer) return a < b ? -1 : a > b ? 1 : 0;
+  if (left.integer) return compareIntegerToFloat(a, b);
+  if (right.integer) return -compareIntegerToFloat(b, a);
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+export function* isBuiltin({ goal, env }) {
+  const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env));
+  const next = env.clone();
+  if (unify(goal.args[0], result, next)) yield next;
+}
+export function arithmeticComparison(test) {
+  return function* ({ goal, env }) {
+    const left = evaluateArithmetic(goal.args[0], env);
+    const right = evaluateArithmetic(goal.args[1], env);
+    const cmp = compareArithmeticValues(left, right);
+    if (test(cmp)) yield env;
+  };
+}

package/src/iso.js

@@ -18,23 +18,8 @@ import {
 
 let isoFresh = 0;
 
-export class PrologError extends Error {
-  constructor(formal, culprit = null) {
-    const detail = culprit == null ? formal : `${formal}, ${termToString(culprit)}`;
-    super(`error(${detail})`);
-    this.name = 'PrologError';
-    this.formal = formal;
-    this.culprit = culprit;
-  }
-}
-
-export class HaltSignal extends Error {
-  constructor(code = 0) {
-    super(`halt(${code})`);
-    this.name = 'HaltSignal';
-    this.code = code;
-  }
-}
+export { PrologError, HaltSignal } from './errors.js';
+import { PrologError, HaltSignal } from './errors.js';
 
 class ThrownTerm extends Error {
   constructor(term) {
@@ -2318,165 +2303,8 @@ function* ifThenBuiltin({ solver, goal, env }) {
   }
 }
 
-function evaluate(term, env) {
-  term = deref(term, env);
-  if (term.type === VAR) throw new PrologError('instantiation_error');
-  if (term.type === NUMBER) {
-    if (isDecimalInteger(term.name)) return { integer: true, value: BigInt(term.name) };
-    const value = Number(term.name);
-    if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
-    return { integer: false, value };
-  }
-  if (term.type === ATOM) {
-    if (term.name === 'pi') return { integer: false, value: Math.PI };
-    if (term.name === 'e') return { integer: false, value: Math.E };
-  }
-  if (term.type !== COMPOUND) throw new PrologError('type_error(evaluable)', term);
-  const args = term.args.map((arg) => evaluate(arg, env));
-  return evaluateOperation(term, args);
-}
-function evaluateOperation(term, args) {
-  const name = term.name;
-  const arity = term.arity;
-  if (arity === 1 && (name === '+' || name === '-')) {
-    return name === '+' ? args[0] : args[0].integer
-      ? { integer: true, value: -args[0].value }
-      : { integer: false, value: -args[0].value };
-  }
-  if (arity === 1 && name === '\\') {
-    if (!args[0].integer) throw new PrologError('type_error(integer)', numericTerm(args[0]));
-    return { integer: true, value: ~args[0].value };
-  }
-  if (arity === 1 && ['abs', 'sign', 'float', 'truncate', 'round', 'ceiling', 'floor',
-    'float_integer_part', 'float_fractional_part',
-    'sin', 'cos', 'atan', 'asin', 'acos', 'tan', 'exp', 'log', 'sqrt'].includes(name)) {
-    const a = Number(args[0].value);
-    if (name === 'abs' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -args[0].value : args[0].value };
-    if (name === 'sign' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -1n : args[0].value > 0n ? 1n : 0n };
-    if (name === 'truncate' || name === 'round' || name === 'ceiling' || name === 'floor') {
-      const fn = name === 'truncate' ? Math.trunc : name === 'round' ? Math.round : name === 'ceiling' ? Math.ceil : Math.floor;
-      return { integer: true, value: BigInt(fn(a)) };
-    }
-    if (name === 'float_integer_part' || name === 'float_fractional_part') {
-      if (args[0].integer) throw new PrologError('type_error(float)', numericTerm(args[0]));
-      const value = name === 'float_integer_part' ? Math.trunc(a) : a - Math.trunc(a);
-      return { integer: false, value };
-    }
-    const fn = name === 'float' ? (x) => x : name === 'abs' ? Math.abs : name === 'sign' ? Math.sign : Math[name];
-    const value = fn(a);
-    if (Number.isNaN(value) || (name === 'log' && a === 0)) throw new PrologError('evaluation_error(undefined)');
-    if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
-    return { integer: false, value };
-  }
-  if (arity !== 2) throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
-  const bothInteger = args[0].integer && args[1].integer;
-  const a = args[0].value, b = args[1].value;
-  if (['//', 'div', 'mod', 'rem', '/\\', '\\/', 'xor', '<<', '>>'].includes(name) && !bothInteger) {
-    const invalid = !args[0].integer ? args[0] : args[1];
-    throw new PrologError('type_error(integer)', numericTerm(invalid));
-  }
-  if (bothInteger && name === '^') {
-    if (b >= 0n) return { integer: true, value: a ** b };
-    if (a === 0n) throw new PrologError('evaluation_error(undefined)');
-    if (a === 1n) return { integer: true, value: 1n };
-    if (a === -1n) return { integer: true, value: (-b) % 2n === 0n ? 1n : -1n };
-    // Corrigendum 3: the defined real result needs a floating-point base.
-    throw new PrologError('type_error(float)', numericTerm(args[0]));
-  }
-  if (bothInteger && ['+', '-', '*', '//', 'div', 'mod', 'rem', '/\\', '\\/', 'xor', '<<', '>>'].includes(name)) {
-    if ((name === '//' || name === 'div' || name === 'mod' || name === 'rem') && b === 0n) throw new PrologError('evaluation_error(zero_divisor)');
-    if (name === '+') return { integer: true, value: a + b };
-    if (name === '-') return { integer: true, value: a - b };
-    if (name === '*') return { integer: true, value: a * b };
-    if (name === '//') return { integer: true, value: a / b };
-    if (name === 'div') {
-      const quotient = a / b;
-      const remainder = a % b;
-      return { integer: true, value: remainder !== 0n && ((a < 0n) !== (b < 0n)) ? quotient - 1n : quotient };
-    }
-    if (name === 'rem') return { integer: true, value: a % b };
-    if (name === 'mod') return { integer: true, value: ((a % b) + b) % b };
-    if (name === '/\\') return { integer: true, value: a & b };
-    if (name === '\\/') return { integer: true, value: a | b };
-    if (name === 'xor') return { integer: true, value: a ^ b };
-    if (name === '<<') return { integer: true, value: a << b };
-    if (name === '>>') return { integer: true, value: a >> b };
-  }
-  const x = Number(a), y = Number(b);
-  if ((!Number.isFinite(x) || !Number.isFinite(y)) && name !== 'max' && name !== 'min') {
-    throw new PrologError('evaluation_error(float_overflow)');
-  }
-  if (name === '/' && y === 0) throw new PrologError('evaluation_error(zero_divisor)');
-  let value;
-  if (name === 'max' || name === 'min') {
-    const cmp = compareArithmeticValues(args[0], args[1]);
-    const chooseLeft = name === 'max' ? cmp >= 0 : cmp <= 0;
-    return chooseLeft ? args[0] : args[1];
-  }
-  if (name === 'atan2') {
-    if (x === 0 && y === 0) throw new PrologError('evaluation_error(undefined)');
-    value = Math.atan2(x, y);
-  }
-  else if (name === '+') value = x + y;
-  else if (name === '-') value = x - y;
-  else if (name === '*') value = x * y;
-  else if (name === '/') value = x / y;
-  else if (name === '**' || name === '^') value = Math.pow(x, y);
-  else throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
-  if (Number.isNaN(value)) throw new PrologError('evaluation_error(undefined)');
-  if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
-  return { integer: false, value };
-}
-export function arithmeticValueTerm(value) {
-  return value.integer ? numberTerm(value.value.toString()) : numberTerm(numberTextFromDouble(value.value));
-}
-function numericTerm(value) {
-  return arithmeticValueTerm(value);
-}
-export function evaluateArithmetic(term, env) {
-  return evaluate(term, env);
-}
-function compareIntegerToFloat(integerValue, floatValue) {
-  if (!Number.isFinite(floatValue)) throw new PrologError('evaluation_error(float_overflow)');
-
-  // Do not round an unbounded integer through JavaScript Number before a
-  // mixed arithmetic comparison.  Every integral IEEE-754 double can be
-  // converted back to the exact integer value it represents; fractional
-  // doubles necessarily have magnitude below 2^53, so their truncation is
-  // also exact.  This preserves mathematical ordering across the I/F boundary
-  // (STC #50), e.g. 9007199254740993 > 9007199254740992.0.
-  if (Number.isInteger(floatValue)) {
-    const floatInteger = BigInt(floatValue);
-    return integerValue < floatInteger ? -1 : integerValue > floatInteger ? 1 : 0;
-  }
-
-  const truncated = BigInt(Math.trunc(floatValue));
-  if (integerValue < truncated) return -1;
-  if (integerValue > truncated) return 1;
-  return floatValue > 0 ? -1 : 1;
-}
-
-export function compareArithmeticValues(left, right) {
-  const a = left.value;
-  const b = right.value;
-  if (left.integer && right.integer) return a < b ? -1 : a > b ? 1 : 0;
-  if (left.integer) return compareIntegerToFloat(a, b);
-  if (right.integer) return -compareIntegerToFloat(b, a);
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function* isBuiltin({ goal, env }) {
-  const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env));
-  const next = env.clone();
-  if (unify(goal.args[0], result, next)) yield next;
-}
-function arithmeticComparison(test) {
-  return function* ({ goal, env }) {
-    const left = evaluateArithmetic(goal.args[0], env);
-    const right = evaluateArithmetic(goal.args[1], env);
-    const cmp = compareArithmeticValues(left, right);
-    if (test(cmp)) yield env;
-  };
-}
+export { arithmeticValueTerm, evaluateArithmetic, compareArithmeticValues } from './iso-arithmetic.js';
+import { isBuiltin, arithmeticComparison } from './iso-arithmetic.js';
 
 
 export class BuiltinRegistry {