eyeling 1.32.1 → 1.33.0

package/eyeling.js

@@ -6493,6 +6493,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
+      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/index.d.ts

@@ -80,6 +80,38 @@ export interface N3SourceListInput {
   scopeBlankNodes?: boolean;
 }
 
+export type EngineName = 'n3' | 'eyeling' | 'eyelang' | 'prolog' | 'horn';
+
+export type EyelangSource = string | { eyelang?: string; prolog?: string; text?: string; label?: string };
+
+export interface EyelangSourceListInput {
+  sources: EyelangSource[];
+}
+
+export interface EyelangStats {
+  [key: string]: number;
+}
+
+export interface EyelangRunOptions {
+  engine?: EngineName;
+  proof?: boolean;
+  why?: boolean;
+  explain?: boolean;
+  stats?: boolean;
+  rdf?: boolean;
+  rdf12?: boolean;
+  n3?: boolean;
+  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
+  args?: string[];
+  maxBuffer?: number;
+  [key: string]: unknown;
+}
+
+export interface EyelangRunResult {
+  stdout: string;
+  stats: EyelangStats;
+}
+
 export interface RdfJsReasonInput {
   n3?: string;
   quads?: Iterable<import('@rdfjs/types').Quad> | AsyncIterable<import('@rdfjs/types').Quad>;
@@ -112,10 +144,17 @@ export interface StoreOptions {
 }
 
 export interface ReasonOptions {
+  engine?: EngineName;
   proof?: boolean;
   proofComments?: boolean;
   noProofComments?: boolean;
+  why?: boolean;
+  explain?: boolean;
+  stats?: boolean;
   rdf?: boolean;
+  rdf12?: boolean;
+  n3?: boolean;
+  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
   args?: string[];
   maxBuffer?: number;
   builtinModules?: string | string[];
@@ -139,6 +178,7 @@ export interface BuiltinRegistrationContext {
 export type BuiltinHandler = (ctx: BuiltinRegistrationContext) => Array<Record<string, EyelingTerm>>;
 
 export interface ReasonStreamOptions {
+  engine?: EngineName;
   baseIri?: string | null;
   proof?: boolean;
   includeInputFactsInClosure?: boolean;
@@ -199,12 +239,18 @@ export class PersistentFactStore implements FactStore {
 
 export function reason(
   opts: ReasonOptions,
-  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput | EyelangSourceListInput,
 ): string;
+export function runAsync(
+  input: string,
+  opts: ReasonStreamOptions & { engine: 'eyelang' | 'prolog' | 'horn' },
+): Promise<EyelangRunResult>;
 export function runAsync(
   input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-  opts?: ReasonStreamOptions,
+  opts?: ReasonStreamOptions & { engine?: 'n3' | 'eyeling' },
 ): Promise<ReasonStreamResult & { store?: FactStore }>;
+export function runEyelang(input: string, opts?: EyelangRunOptions): Promise<EyelangRunResult>;
+export function reasonEyelang(input: string, opts?: EyelangRunOptions): Promise<string>;
 export function reasonStream(
   input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
   opts?: ReasonStreamOptions,
@@ -227,6 +273,8 @@ export interface EyelingModule {
   readonly version: string;
   reason: typeof reason;
   runAsync: typeof runAsync;
+  runEyelang: typeof runEyelang;
+  reasonEyelang: typeof reasonEyelang;
   reasonStream: typeof reasonStream;
   reasonRdfJs: typeof reasonRdfJs;
   readonly INFERENCE_FUSE_EXIT_CODE: typeof INFERENCE_FUSE_EXIT_CODE;

package/index.js

@@ -4,12 +4,100 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const cp = require('node:child_process');
+const { pathToFileURL } = require('node:url');
 
 const bundleApi = require('./eyeling.js');
 const { dataFactory, normalizeReasonerInputSync } = require('./lib/rdfjs');
 const { isN3SourceListInput } = require('./lib/multisource');
 const engine = require('./lib/engine');
 
+
+function normalizeEngineName(value) {
+  if (value == null || value === '') return 'n3';
+  const name = String(value).toLowerCase();
+  if (name === 'n3' || name === 'eyeling') return 'n3';
+  if (name === 'eyelang' || name === 'prolog' || name === 'horn') return 'eyelang';
+  throw new TypeError(`unknown Eyeling engine: ${value}`);
+}
+
+function normalizeEyelangSourceForTempFile(source) {
+  if (typeof source === 'string') return source;
+  if (source && typeof source === 'object' && !Array.isArray(source)) {
+    const text =
+      typeof source.eyelang === 'string' ? source.eyelang
+        : typeof source.prolog === 'string' ? source.prolog
+          : typeof source.text === 'string' ? source.text
+            : typeof source.n3 === 'string' ? source.n3
+              : null;
+    if (text !== null) return text;
+  }
+  throw new TypeError('reason({ engine: "eyelang" }, input): each source must be a string or an object with an eyelang/prolog/text field');
+}
+
+function normalizeEyelangInput(input) {
+  if (typeof input === 'string') return [input];
+  if (input == null) return [''];
+  if (input && typeof input === 'object' && !Array.isArray(input)) {
+    if (Array.isArray(input.sources)) return input.sources.map(normalizeEyelangSourceForTempFile);
+    return [normalizeEyelangSourceForTempFile(input)];
+  }
+  throw new TypeError('reason({ engine: "eyelang" }, input): input must be a string, source object, or { sources } list');
+}
+
+function reasonEyelangSync(opt = {}, input = '') {
+  const args = [];
+
+  if (opt.proof || opt.why || opt.explain) args.push('--proof');
+  if (opt.stats) args.push('--stats');
+  if (opt.rdf || opt.rdf12) args.push('--rdf');
+  if (opt.n3) args.push('--n3');
+  if (typeof opt.inputFormat === 'string' && opt.inputFormat) args.push('--input-format', opt.inputFormat);
+  if (Array.isArray(opt.args)) args.push(...opt.args);
+
+  const maxBuffer = Number.isFinite(opt.maxBuffer) ? opt.maxBuffer : 50 * 1024 * 1024;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-eyelang-'));
+
+  try {
+    const inputFiles = normalizeEyelangInput(input).map((text, index) => {
+      const inputFile = path.join(dir, `input-${index + 1}.pl`);
+      fs.writeFileSync(inputFile, text, 'utf8');
+      return inputFile;
+    });
+
+    const eyelangCliPath = path.join(__dirname, 'lib', 'eyelang', 'bin.js');
+    const res = cp.spawnSync(process.execPath, [eyelangCliPath, ...args, ...inputFiles], { encoding: 'utf8', maxBuffer });
+
+    if (res.error) throw res.error;
+    if (res.stderr) process.stderr.write(res.stderr);
+
+    if (res.status !== 0) {
+      const err = new Error(res.stderr || `eyelang exited with code ${res.status}`);
+      err.code = res.status;
+      err.stdout = res.stdout;
+      err.stderr = res.stderr;
+      throw err;
+    }
+
+    return res.stdout;
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+async function loadEyelangModule() {
+  return import(pathToFileURL(path.join(__dirname, 'lib', 'eyelang', 'index.mjs')).href);
+}
+
+async function runEyelang(input = '', opt = {}) {
+  const eyelang = await loadEyelangModule();
+  return eyelang.run(input, opt || {});
+}
+
+async function reasonEyelang(input = '', opt = {}) {
+  const result = await runEyelang(input, opt || {});
+  return result.stdout;
+}
+
 function reason(opt = {}, input = '') {
   if (input == null) input = '';
 
@@ -17,6 +105,8 @@ function reason(opt = {}, input = '') {
   if (Array.isArray(opt)) opt = { args: opt };
   if (opt == null || typeof opt !== 'object') opt = {};
 
+  if (normalizeEngineName(opt.engine) === 'eyelang') return reasonEyelangSync(opt, input);
+
   const args = [];
 
   // default: proof output OFF for API output (machine-friendly)
@@ -116,12 +206,16 @@ function reason(opt = {}, input = '') {
 }
 
 async function runAsync(input = '', opt = {}) {
-  return engine.runAsync(input, opt || {});
+  const options = opt || {};
+  if (normalizeEngineName(options.engine) === 'eyelang') return runEyelang(input, options);
+  return engine.runAsync(input, options);
 }
 
 module.exports = {
   reason,
   runAsync,
+  runEyelang,
+  reasonEyelang,
   reasonStream: bundleApi.reasonStream,
   reasonRdfJs: bundleApi.reasonRdfJs,
   rdfjs: dataFactory,

package/lib/cli.js

@@ -805,6 +805,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
+      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/lib/eyelang/bin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+'use strict';
+
+import('./cli.mjs').then(({ main }) => main(process.argv.slice(2))).catch((error) => {
+  console.error(`eyelang: ${error && error.message ? error.message : String(error)}`);
+  process.exit(1);
+});

package/lib/eyelang/builtins/aggregation.mjs

@@ -0,0 +1,81 @@
+// Aggregation builtins that run a inner goal and collect, count, sum, or select the best answers.
+// Each handler clones the solver so the inner goal can enumerate independently of the outer goal.
+import { compareTerms, copyResolved, isDecimalInteger, lexicalValue, listFromItems, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.mjs';
+
+export const aggregationBuiltins = {
+  register(registry) {
+    registry.add('findall', 3, findall);
+    registry.add('countall', 2, countall);
+    registry.add('sumall', 3, sumall);
+    registry.add('aggregate_min', 5, aggregateBest(true));
+    registry.add('aggregate_max', 5, aggregateBest(false));
+  }
+};
+
+function* findall({ solver, goal, env }) {
+  const [template, innerGoal, bag] = goal.args;
+  const collector = solver.cloneForInnerGoal(10000000);
+  const collected = [];
+  for (const answerEnv of collector.solve([innerGoal], env.clone(), 0)) collected.push(copyResolved(template, answerEnv));
+  const next = env.clone();
+  if (unify(bag, listFromItems(collected), next)) yield next;
+}
+
+function* countall({ solver, goal, env }) {
+  const [innerGoal, count] = goal.args;
+  const collector = solver.cloneForInnerGoal(10000000);
+  let n = 0;
+  for (const _ of collector.solve([innerGoal], env.clone(), 0)) n++;
+  const next = env.clone();
+  if (unify(count, numberTerm(n), next)) yield next;
+}
+
+function* sumall({ solver, goal, env }) {
+  const [template, innerGoal, sum] = goal.args;
+  const collector = solver.cloneForInnerGoal(10000000);
+  let intSum = 0n;
+  let floatMode = false;
+  let floatSum = 0;
+  for (const answerEnv of collector.solve([innerGoal], env.clone(), 0)) {
+    const text = lexicalValue(template, answerEnv);
+    if (text == null) return;
+    if (!floatMode && isDecimalInteger(text)) intSum += BigInt(text);
+    else {
+      const value = parseFiniteNumber(text);
+      if (value == null) return;
+      if (!floatMode) { floatSum = Number(intSum); floatMode = true; }
+      floatSum += value;
+    }
+  }
+  const result = floatMode ? numberTextFromDouble(floatSum) : intSum.toString();
+  const next = env.clone();
+  if (unify(sum, numberTerm(result), next)) yield next;
+}
+
+function aggregateBest(wantMin) {
+  return function* ({ solver, goal, env }) {
+    const [keyTemplate, valueTemplate, innerGoal, bestKey, bestValue] = goal.args;
+    const collector = solver.cloneForInnerGoal(10000000);
+    let has = false;
+    let key = null;
+    let value = null;
+    for (const answerEnv of collector.solve([innerGoal], env.clone(), 0)) {
+      const candidateKey = copyResolved(keyTemplate, answerEnv);
+      const candidateValue = copyResolved(valueTemplate, answerEnv);
+      if (!has) {
+        has = true;
+        key = candidateKey;
+        value = candidateValue;
+      } else {
+        const cmp = compareTerms(candidateKey, key);
+        if ((wantMin && cmp < 0) || (!wantMin && cmp > 0)) {
+          key = candidateKey;
+          value = candidateValue;
+        }
+      }
+    }
+    if (!has) return;
+    const next = env.clone();
+    if (unify(bestKey, key, next) && unify(bestValue, value, next)) yield next;
+  };
+}

package/lib/eyelang/builtins/alphametic.mjs

@@ -0,0 +1,144 @@
+// Reusable alphametic addition solver.
+// It evaluates column constraints right-to-left, so examples such as
+// SEND+MORE=MONEY and DONALD+GERALD=ROBERT do not need to express digit search
+// with many relational select/3 and arithmetic goals.
+import { atom, deref, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
+
+export const alphameticBuiltins = {
+  register(registry) {
+    registry.add('alphametic_sum', 5, alphameticSum, {
+      fallbackWhenNotReady: true,
+      ready: alphameticReady,
+    });
+  }
+};
+
+function alphameticReady(goal, env) {
+  return atomList(goal.args[0], env) !== null && wordList(goal.args[1], env) !== null && atomList(goal.args[2], env) !== null;
+}
+
+function* alphameticSum({ goal, env }) {
+  const letters = atomList(goal.args[0], env);
+  const addends = wordList(goal.args[1], env);
+  const result = atomList(goal.args[2], env);
+  if (!letters || !addends || !result || letters.length > 10 || addends.length === 0) return;
+
+  const letterSet = new Set(letters);
+  for (const word of [...addends, result]) for (const letter of word) if (!letterSet.has(letter)) return;
+
+  const leading = new Set();
+  for (const word of [...addends, result]) if (word.length > 1) leading.add(word[0]);
+  const maxLen = Math.max(result.length, ...addends.map((word) => word.length));
+  const assignment = new Map();
+  const used = Array(10).fill(false);
+
+  function canUse(letter, digit) {
+    return !used[digit] && !(digit === 0 && leading.has(letter));
+  }
+
+  function assignDigit(letter, digit) {
+    assignment.set(letter, digit);
+    used[digit] = true;
+  }
+
+  function unassignDigit(letter, digit) {
+    assignment.delete(letter);
+    used[digit] = false;
+  }
+
+  function* assignAddends(column, carry, index, sum) {
+    if (index >= addends.length) {
+      yield* finishColumn(column, sum);
+      return;
+    }
+    const word = addends[index];
+    const letter = word[word.length - 1 - column];
+    if (letter === undefined) {
+      yield* assignAddends(column, carry, index + 1, sum);
+      return;
+    }
+    const assigned = assignment.get(letter);
+    if (assigned !== undefined) {
+      yield* assignAddends(column, carry, index + 1, sum + assigned);
+      return;
+    }
+    for (let digit = 0; digit <= 9; digit++) {
+      if (!canUse(letter, digit)) continue;
+      assignDigit(letter, digit);
+      yield* assignAddends(column, carry, index + 1, sum + digit);
+      unassignDigit(letter, digit);
+    }
+  }
+
+  function* finishColumn(column, sum) {
+    const resultLetter = result[result.length - 1 - column];
+    const digit = sum % 10;
+    const nextCarry = Math.floor(sum / 10);
+    if (resultLetter === undefined) {
+      if (digit === 0) yield* solveColumn(column + 1, nextCarry);
+      return;
+    }
+    const assigned = assignment.get(resultLetter);
+    if (assigned !== undefined) {
+      if (assigned === digit) yield* solveColumn(column + 1, nextCarry);
+      return;
+    }
+    if (!canUse(resultLetter, digit)) return;
+    assignDigit(resultLetter, digit);
+    yield* solveColumn(column + 1, nextCarry);
+    unassignDigit(resultLetter, digit);
+  }
+
+  function* solveColumn(column, carry) {
+    if (column >= maxLen) {
+      if (carry !== 0) return;
+      if (assignment.size !== letters.length) return;
+      yield new Map(assignment);
+      return;
+    }
+    yield* assignAddends(column, carry, 0, carry);
+  }
+
+  for (const solution of solveColumn(0, 0)) {
+    const digitTerms = letters.map((letter) => numberTerm(String(solution.get(letter))));
+    const values = [...addends, result].map((word) => wordValue(word, solution));
+    const valueTerms = values.map((value) => numberTerm(String(value)));
+    const next = env.clone();
+    if (unify(goal.args[3], listFromItems(digitTerms), next) && unify(goal.args[4], listFromItems(valueTerms), next)) yield next;
+  }
+}
+
+function wordValue(word, assignment) {
+  let value = 0;
+  for (const letter of word) value = value * 10 + assignment.get(letter);
+  return value;
+}
+
+function atomList(term, env) {
+  const items = properListItems(term, env);
+  if (!items) return null;
+  const out = [];
+  for (const item of items) {
+    const text = atomKey(deref(item, env));
+    if (text == null) return null;
+    out.push(text);
+  }
+  return out;
+}
+
+function wordList(term, env) {
+  const items = properListItems(term, env);
+  if (!items) return null;
+  const out = [];
+  for (const item of items) {
+    const word = atomList(item, env);
+    if (!word) return null;
+    out.push(word);
+  }
+  return out;
+}
+
+function atomKey(term) {
+  if (term.type === 'atom' || term.type === 'string' || term.type === 'number') return term.name;
+  return null;
+}

package/lib/eyelang/builtins/arithmetic.mjs

@@ -0,0 +1,197 @@
+// Numeric builtins for integer-preserving arithmetic, floating point functions, comparisons, and ranges.
+// The code keeps BigInt paths where possible so large eyelang integers remain exact.
+import { compareIntegerText, deref, isDecimalInteger, lexicalValue, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.mjs';
+
+const unaryNames = ['neg', 'abs', 'sin', 'cos', 'asin', 'acos', 'rounded', 'log'];
+const binaryNames = ['add', 'sub', 'mul', 'div', 'mod', 'max', 'min', 'pow'];
+const compareNames = ['lt', 'gt', 'le', 'ge'];
+
+export const arithmeticBuiltins = {
+  register(registry) {
+    for (const name of unaryNames) registry.add(name, 2, unary(name), { deterministic: true });
+    for (const name of binaryNames) registry.add(name, 3, binary(name), { deterministic: true });
+    for (const name of compareNames) registry.add(name, 2, compare(name), { deterministic: true });
+    registry.add('between', 3, between);
+    registry.add('smallest_divisor_from', 3, smallestDivisorFrom, { deterministic: true });
+  }
+};
+
+
+function unary(name) {
+  return function* ({ goal, env }) {
+    const text = lexicalValue(goal.args[0], env);
+    if (text == null) return;
+    let out = null;
+    if ((name === 'neg' || name === 'abs') && isDecimalInteger(text)) {
+      const value = BigInt(text);
+      out = (name === 'neg' ? -value : value < 0n ? -value : value).toString();
+    } else {
+      const input = parseFiniteNumber(text);
+      if (input == null) return;
+      let value;
+      if (name === 'neg') value = -input;
+      else if (name === 'abs') value = Math.abs(input);
+      else if (name === 'sin') value = Math.sin(input);
+      else if (name === 'cos') value = Math.cos(input);
+      else if (name === 'asin') value = Math.asin(input);
+      else if (name === 'acos') value = Math.acos(input);
+      else if (name === 'rounded') value = Math.round(input);
+      else if (name === 'log') {
+        if (input <= 0) return;
+        value = logCompat(input);
+      }
+      out = name === 'rounded' ? String(Math.trunc(value)) : numberTextFromDouble(value);
+    }
+    const next = env.clone();
+    if (out != null && unify(goal.args[1], numberTerm(out), next)) yield next;
+  };
+}
+
+function binary(name) {
+  return function* ({ goal, env }) {
+    const leftText = lexicalValue(goal.args[0], env);
+    const rightText = lexicalValue(goal.args[1], env);
+    if (leftText == null || rightText == null) return;
+    let out = null;
+    if (isDecimalInteger(leftText) && isDecimalInteger(rightText) && name !== 'mod') {
+      const a = BigInt(leftText);
+      const b = BigInt(rightText);
+      if (name === 'add') out = (a + b).toString();
+      else if (name === 'sub') out = (a - b).toString();
+      else if (name === 'mul') out = (a * b).toString();
+      else if (name === 'div') { if (b === 0n) return; out = (a / b).toString(); }
+      else if (name === 'max') out = (a >= b ? a : b).toString();
+      else if (name === 'min') out = (a <= b ? a : b).toString();
+      else if (name === 'pow') { if (b < 0n) return; out = (a ** b).toString(); }
+    } else if (name === 'mod') {
+      if (!isDecimalInteger(leftText) || !isDecimalInteger(rightText)) return;
+      const a = BigInt(leftText), b = BigInt(rightText);
+      if (b === 0n) return;
+      out = (a % b).toString();
+    } else {
+      const a = parseFiniteNumber(leftText), b = parseFiniteNumber(rightText);
+      if (a == null || b == null) return;
+      let value;
+      if (name === 'add') value = a + b;
+      else if (name === 'sub') value = a - b;
+      else if (name === 'mul') value = a * b;
+      else if (name === 'div') { if (b === 0) return; value = a / b; }
+      else if (name === 'pow') value = Math.pow(a, b);
+      else if (name === 'max') value = Math.max(a, b);
+      else if (name === 'min') value = Math.min(a, b);
+      out = numberTextFromDouble(value);
+    }
+    const next = env.clone();
+    if (out != null && unify(goal.args[2], numberTerm(out), next)) yield next;
+  };
+}
+
+function compare(name) {
+  return function* ({ goal, env }) {
+    const left = lexicalValue(goal.args[0], env);
+    const right = lexicalValue(goal.args[1], env);
+    if (left == null || right == null) return;
+    const cmp = compareLexicalOrNumeric(left, right);
+    const pass = name === 'lt' ? cmp < 0 : name === 'gt' ? cmp > 0 : name === 'le' ? cmp <= 0 : cmp >= 0;
+    if (pass) yield env;
+  };
+}
+
+export function compareLexicalOrNumeric(left, right) {
+  if (isDecimalInteger(left) && isDecimalInteger(right)) return compareIntegerText(left, right);
+  const dur = compareDuration(left, right);
+  if (dur != null) return dur;
+  const a = parseFiniteNumber(left), b = parseFiniteNumber(right);
+  if (a != null && b != null) return a < b ? -1 : a > b ? 1 : 0;
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function compareDuration(a, b) {
+  const pa = parseDuration(a), pb = parseDuration(b);
+  if (!pa || !pb) return null;
+  for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  return 0;
+}
+function parseDuration(text) {
+  const m = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?$/.exec(text);
+  if (!m || (!m[1] && !m[2] && !m[3])) return null;
+  return [Number(m[1] ?? 0), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+}
+
+function* between({ goal, env }) {
+  const lowText = lexicalValue(goal.args[0], env), highText = lexicalValue(goal.args[1], env);
+  if (!isDecimalInteger(lowText) || !isDecimalInteger(highText)) return;
+  const lowNumber = Number(lowText), highNumber = Number(highText);
+  const output = deref(goal.args[2], env);
+  if (Number.isSafeInteger(lowNumber) && Number.isSafeInteger(highNumber)) {
+    if (output.type === 'var') {
+      for (let value = lowNumber; value <= highNumber; value++) {
+        const next = env.clone();
+        next.bind(output.name, numberTerm(String(value)));
+        yield next;
+      }
+      return;
+    }
+    for (let value = lowNumber; value <= highNumber; value++) {
+      const next = env.clone();
+      if (unify(goal.args[2], numberTerm(String(value)), next)) yield next;
+    }
+    return;
+  }
+  const low = BigInt(lowText), high = BigInt(highText);
+  if (output.type === 'var') {
+    for (let value = low; value <= high; value++) {
+      const next = env.clone();
+      next.bind(output.name, numberTerm(value.toString()));
+      yield next;
+    }
+    return;
+  }
+  for (let value = low; value <= high; value++) {
+    const next = env.clone();
+    if (unify(goal.args[2], numberTerm(value.toString()), next)) yield next;
+  }
+}
+
+function* smallestDivisorFrom({ goal, env }) {
+  const nText = lexicalValue(goal.args[0], env), dText = lexicalValue(goal.args[1], env);
+  if (!isDecimalInteger(nText) || !isDecimalInteger(dText)) return;
+  const n = BigInt(nText), start = BigInt(dText);
+  if (n < 0n || start <= 0n) return;
+  let result = n;
+  for (let c = start; c > 0n && c <= n / c; c++) {
+    if (n % c === 0n) { result = c; break; }
+  }
+  const next = env.clone();
+  if (unify(goal.args[2], numberTerm(result.toString()), next)) yield next;
+}
+
+
+const f64 = new Float64Array(1);
+const u64 = new BigUint64Array(f64.buffer);
+
+function nextUp(value) {
+  if (!Number.isFinite(value)) return value;
+  if (value === 0) return Number.MIN_VALUE;
+  f64[0] = value;
+  u64[0] += value > 0 ? 1n : -1n;
+  return f64[0];
+}
+
+function nextDown(value) {
+  if (!Number.isFinite(value)) return value;
+  if (value === 0) return -Number.MIN_VALUE;
+  f64[0] = value;
+  u64[0] += value > 0 ? -1n : 1n;
+  return f64[0];
+}
+
+function logCompat(input) {
+  const value = Math.log(input);
+  // V8 and glibc libm differ by one ulp for a few values reached by the
+  // Newton-Raphson example. Align this pure-JS port with the native eyelang
+  // reference while leaving ordinary log(1), log(2), log(10), and log(e) alone.
+  if (input > 2.5 && input < 2.7182818 && value > 0.95 && value < 1.0) return nextUp(value);
+  if (input > 2.7182818 && input < 2.718281828459 && value > 0.999999999999 && value < 1.0) return nextDown(value);
+  return value;
+}